/******************************************************************* leaktracker.h: Resource leak tracker for memory leaks, file handles, Win32 HANDLE's, and Win32 Sys-Memory ********************************************************** By David Maisonave (Axter) Phone# 609-346-1007 ********************************************************** Description: The leaktracker program detects memory leaks and file handle leaks. It detects both ANSI C file handle leaks and Windows file HANDLE leaks. Leaks are reported with source file name, line number, and function used to create the leak (malloc, new, new[], fopen) On VC++ 7.1 and GNU 3.x, the function name is also included in the report. This function name is the function that called the allocator. Example: ------------------------------------------------------------------------- fooappprj\somecode.cpp(145): FuncName{InitObj} resource leak caused by malloc ------------------------------------------------------------------------- Although this particular version is designed for WIN32, it can easily be modified to be used in other platforms. The implementation for the leaktracker program is contained in a DLL (leaktracker.dll). The DLL should be stored in the Windows\system32 directory, along with the leaktracker.lib file. To add the leaktracker to an exiting project, just include the leaktracker.h header file to the *.cpp|*.c file. There are pragma commands in this header file that will pull in the leaktracker.lib file for VC++ compilers and the Borland compiler. ********************************************************** Important: Both the leaktracker.dll and the leaktracker.lib file must be stored in the 'C:\WINDOWS\system32' directory. ********************************************************** Very Important: This header file MUST be the last file included in any source code (*.c,*.cpp) file. It should NOT be included in any header file. MFC-Usage: This header file must be included after IMPLEMENT_DYNCREATE macro or related macros ********************************************************** License Copyright (C) 2005-2005 by David Maisonave (Axter) This software library is free. Permission to use, copy, modify, distribute this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies. David Maisonave (Axter) makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. ********************************************************** Details Usage: The leaktracker.lib needs to be stored in the C:\WINDOWS\system32 directory in order to compile the code. The leaktracker.dll needs to be stored in the C:\WINDOWS\system32 directory in order to run the code. By default, when the executable exits, leaks are reported in the following file name and path: C:\zz_David_Maisonave_DefaultLeakTrackerLogFile.log The default path can be changed by calling function _leaktracker61_EnableReportLeakOnApplication_Exit("c:\\MyAppName.leaktracker.log", 1); If there are no memory leaks, nothing is added to the file. A memory leak report can be created at any time while the code is running. To report leaks, call _leaktracker61_DumpAllLeaks function. If this function is called with a NULL value, the memory leak is displayed on the screen. Example: _leaktracker61_DumpAllLeaks(NULL, 0); If this function is called with a file containing a valid path, then the leaks are posted to the file. By default both memory leaks and file handle leaks are reported. To change this default behavior, call _leaktracker61_SetLeakTrackerOptions with desired enum value. (See Below enum type _leaktracker61_eLeakTrackerOptions) leaktracker.dll source code: The build version of the leaktracker.dll can be downloaded from the following link: http://code.axter.com/leaktracker.zip The source code for the leaktracker.dll can be downloaded from the following link: http://code.axter.com/leaktracker_dll_source_code.zip *******************************************************************/ /******************************************************************* *******************************************************************/ #ifndef LEAKTRACKER_H_ #define LEAKTRACKER_H_ //To exclude leaktracker logic from the build, comment out the following three macros #define INCLUDE_C_LEAKTRACKER_IMPL__ #define INCLUDE_CPLUSPLUS_LEAKTRACKER_IMPL__ #define DEBUG_VERSION_ #if (defined(DEBUG) || defined (_DEBUG)) #define DEBUG_VERSION_ #endif #if !defined(__FUNCTION__) && !defined(__GNUC__) //The GNU compiler and VC++ 7.x supports this macro #define __FUNCTION__ "" //If compiler does not support it, then use empty string #endif //!defined(__FUNCTION__) && !defined(__GNUC__) #if defined(DEBUG_VERSION_) && defined(INCLUDE_C_LEAKTRACKER_IMPL__) //For Win32 debugging using a DLL, keep both leaktracker.lib file and leaktracker.dll in directory C:\WINDOWS\system32 #if defined(_MSC_VER) #pragma message( "**************************************************************************************") #pragma message( "Note: Including leaktracker implementation... DO NOT USE THIS BUILD FOR PRODUCTION!!!") #pragma message( "**************************************************************************************") #pragma comment(lib, "C:\\WINDOWS\\system32\\leaktracker.lib") #elif defined(__BORLANDC__) #pragma link "C:\\WINDOWS\\system32\\leaktracker_bcc.lib" #elif defined(__GNUC__) // No current method for adding lib file to GNU compiler via header #else // This is a place holder for other compilers #endif //_MSC_VER #ifdef __cplusplus extern "C" { #endif //__cplusplus int _leaktracker61_DumpAllLeaks(const char*FileName, int iAppendToExistingFile); void _leaktracker61_EnableReportLeakOnApplication_Exit(const char*FileName, int iAppendToExistingFile); void _leaktracker61_SaveMe(const char* FileName, int LineNo, const char* FuncName); void _leaktracker61_log_last_alloc_pointer(const char* FileName, int LineNo, const char* FuncName); typedef enum { _leaktracker61_eReportMemleaksAndHandleLeaks = 3, _leaktracker61_eReportMemLeaksOnly = 1, _leaktracker61_eReportHandleLeaksOnly = 2, _leaktracker61_eSoundDisabled = 4, _leaktracker61_eSoundEnabled = 4+8, _leaktracker61_LeakCheckDisabled = 16, _leaktracker61_LeakCheckEnabled = 16 + 32, _leaktracker61_TrackFailedAllocationsDisabled = 64, _leaktracker61_TrackFailedAllocationEnabled = 64+128, _leaktracker61_ClearLeakList = 256 }_leaktracker61_eLeakTrackerOptions; int _leaktracker61_SetLeakTrackerOptions(int option); #ifdef _WIN64 typedef __int64 _leaktracker61_intptr_t; #else #ifdef _W64 typedef _W64 int _leaktracker61_intptr_t; #else //_W64 typedef long _leaktracker61_intptr_t; #endif //_W64 #endif void _leaktracker61_free(void *memblock, const char* FileName, int LineNo, const char* FuncName); void* _leaktracker61_realloc(void *new_memblock, void *old_memblock, const char* FileName, int LineNo, const char* FuncName ); void _leaktracker61_log_delete_obj_mem(void *memblock, int IsArray); void* _leaktracker61_log_alloc_obj_mem(void *memblock, int IsArray); void* _leaktracker61_log_new_obj_mem(void *memblock, int IsArray, const char* FileName, int LineNo, const char* FuncName); char* _leaktracker61_strdup(char * memblock, const char* FileName, int LineNo, const char* FuncName ); void _leaktracker61_SetPointerToNullValueIfOptionSet(void** ptr); void _leaktracker61_EnableSetPointerToNullValueWhenFree(); void* _leaktracker61_GenericResourceAllocatorWithVoidReturn(void* h, const char* FileName__, int LineNo__, const char* FuncName__, const char*ResourceAllocatorName, int AllocArgumentBitMask, const char*StrAllocArgument, long NumberAllocArgument, unsigned long uNumberAllocArgument, size_t sNumberAllocArgument1, size_t sNumberAllocArgument2); int _leaktracker61_GenericResourceAllocatorWithIntReturn(int h, const char* FileName__, int LineNo__, const char* FuncName__, const char*ResourceAllocatorName); void* _leaktracker61_GenericResourceAllocatorAndDeallocateWithVoidReturn(void* h, void* old, const char* FileName__, int LineNo__, const char* FuncName__, const char*ResourceAllocatorName); void* _leaktracker61_GenericResourceAllocatorAndDeallocateWithVoidReturn2(void* h, int old, const char* FileName__, int LineNo__, const char* FuncName__, const char*ResourceAllocatorName); int _leaktracker61_GenericResourceAllocatorAndDeallocateWithIntReturn(int h, int old, const char* FileName__, int LineNo__, const char* FuncName__, const char*ResourceAllocatorName); void* _leaktracker61_GenericResourceDeAllocatorWithVoidReturn(void* ReturnValue, void* h, const char* FileName__, int LineNo__, const char* FuncName__, const char*ResourceAllocatorName); int _leaktracker61_GenericResourceDeAllocatorWithIntReturn(int ReturnValue, void* h, const char* FileName__, int LineNo__, const char* FuncName__, const char*ResourceAllocatorName); #ifdef __cplusplus } #endif //__cplusplus #if defined(__cplusplus) && defined(INCLUDE_CPLUSPLUS_LEAKTRACKER_IMPL__) #if defined(_MSC_VER) && (_MSC_VER > 1200) #include #else #include #endif //defined(_MSC_VER) && (_MSC_VER > 1200) #ifdef new #undef new #endif //new inline void operator delete(void* memblock) { free(memblock); _leaktracker61_log_delete_obj_mem(memblock, 0); } inline void operator delete[](void* memblock) { free(memblock); _leaktracker61_log_delete_obj_mem(memblock, 1); } inline void * operator new(size_t bytes, const char *file, int line, const char* FunctionName){ return _leaktracker61_log_new_obj_mem(malloc(bytes), 0, file, line, FunctionName); } inline void * operator new[](size_t bytes, const char *file, int line, const char* FunctionName){ return _leaktracker61_log_new_obj_mem(malloc(bytes), 1, file, line, FunctionName); } #ifndef __BORLANDC__ inline void operator delete(void* memblock, const char *file, int line, const char* FunctionName) { free(memblock); _leaktracker61_log_delete_obj_mem(memblock, 0); } inline void operator delete[](void* memblock, const char *file, int line, const char* FunctionName) { free(memblock); _leaktracker61_log_delete_obj_mem(memblock, 1); } #endif //__BORLANDC__ namespace leaktracker { //Heap allocation debugging code class debug_mem_allocation { public: enum ACTION_SWITCH{AllocateMem, DeAllocMem, GenerateReport}; debug_mem_allocation(const char* FileName, int LineNo, const char* FunctionName) :m_FileName(FileName), m_LineNo(LineNo), m_FuncName(FunctionName){} template T& operator<<(T &ptr) { _leaktracker61_log_last_alloc_pointer(m_FileName, m_LineNo, m_FuncName); return ptr; } template T& operator<<(const T &ptr) { _leaktracker61_log_last_alloc_pointer(m_FileName, m_LineNo, m_FuncName); return const_cast(ptr); } inline void SaveMe(){ _leaktracker61_SaveMe(m_FileName, m_LineNo, m_FuncName); } template int open_W(chrType s, int o, int p = -1) { if (p == -1) return _leaktracker61_GenericResourceAllocatorWithIntReturn(_wopen(s,o), m_FileName, m_LineNo, m_FuncName, "_wopen"); return _leaktracker61_GenericResourceAllocatorWithIntReturn(_wopen(s,o,p), m_FileName, m_LineNo, m_FuncName, "_wopen"); } template int open_A(chrType s, int o, int p = -1) { if (p == -1) return _leaktracker61_GenericResourceAllocatorWithIntReturn(_open(s,o), m_FileName, m_LineNo, m_FuncName, "_open"); return _leaktracker61_GenericResourceAllocatorWithIntReturn(_open(s,o,p), m_FileName, m_LineNo, m_FuncName, "_open"); } template int sopen_W(chrType s, int o, int shflg, int p = -1) { if (p == -1) return _leaktracker61_GenericResourceAllocatorWithIntReturn(_wsopen(s,o,shflg), m_FileName, m_LineNo, m_FuncName, "_wsopen"); return _leaktracker61_GenericResourceAllocatorWithIntReturn(_wsopen(s,o,shflg,p), m_FileName, m_LineNo, m_FuncName, "_wsopen"); } template int sopen_A(chrType s, int o, int shflg, int p = -1) { if (p == -1) return _leaktracker61_GenericResourceAllocatorWithIntReturn(_sopen(s,o,shflg), m_FileName, m_LineNo, m_FuncName, "_sopen"); return _leaktracker61_GenericResourceAllocatorWithIntReturn(_sopen(s,o,shflg,p), m_FileName, m_LineNo, m_FuncName, "_sopen"); } private: const char* m_FileName; const int m_LineNo; const char* m_FuncName; }; }//End of namespace leaktracker //#define new (0)?NULL:leaktracker::debug_mem_allocation(__FILE__, __LINE__, __FUNCTION__)<< new #define _leaktracker61_NEW new(__FILE__, __LINE__, __FUNCTION__) #define new _leaktracker61_NEW #define delete leaktracker::debug_mem_allocation(__FILE__, __LINE__, __FUNCTION__).SaveMe(), delete #endif //defined(__cplusplus) && defined(INCLUDE_CPLUSPLUS_LEAKTRACKER_IMPL__) #ifdef __cplusplus extern "C" { #endif //__cplusplus int _leaktracker61_open(int h, const char* FileName, int LineNo, const char* FuncName); int _leaktracker61_creat(int h, const char* FileName, int LineNo, const char* FuncName); int _leaktracker61_sopen(int h, const char* FileName, int LineNo, const char* FuncName); int _leaktracker61_findclose(int ReturnValue, int h, const char* FileName, int LineNo, const char* FuncName); int _leaktracker61_wopen(int h, const char* FileName, int LineNo, const char* FuncName); int _leaktracker61_wsopen(int h, const char* FileName, int LineNo, const char* FuncName); int _leaktracker61_wcreat(int h, const char* FileName, int LineNo, const char* FuncName); int _leaktracker61_close(int ReturnValue, int h, const char* FileName, int LineNo, const char* FuncName); _leaktracker61_intptr_t _leaktracker61_findfirst(_leaktracker61_intptr_t h, const char* FileName, int LineNo, const char* FuncName); _leaktracker61_intptr_t _leaktracker61_wfindfirst(_leaktracker61_intptr_t h, const char* FileName, int LineNo, const char* FuncName); #if defined(CreateMutex) || defined(OpenMutex) || defined(CreateEvent) || defined(OpenEvent) || defined(CreateSemaphore) || defined(OpenSemaphore) || defined(CreateWaitableTimer) || defined(OpenWaitableTimer) || defined(CreateFileMapping) || defined(OpenFileMapping) || defined(CreateFile) || defined(FindFirstFileEx) #define _leaktracker61_WIN32 HANDLE _leaktracker61_LogHandleCreateApiAction(HANDLE h, const char* ApiFunctionName, const char* FileName__, int LineNo__, const char* FuncName__, int AllocArgumentBitMask, const char*StrAllocArgument, DWORD dwNumberAllocArgument1, DWORD dwNumberAllocArgument2); BOOL _leaktracker61_LogHandlePointerCreateApiActionReturnBool(BOOL ReturnValue, PHANDLE Phndl, const char* ApiFunctionName, const char* FileName__, int LineNo__, const char* FuncName__); BOOL _leaktracker61_LogHandleCloseApiAction(BOOL b, HANDLE h, const char* FileName__, int LineNo__, const char* FuncName__); BOOL _leaktracker61_CreateProcess(BOOL ReturnValue, void* h, const char*ResourceAllocatorName, const char* FileName__, int LineNo__, const char* FuncName__); #endif //defined(CreateMutex) || defined(OpenMutex) || defined(CreateEvent) || defined(OpenEvent) || defined(CreateSemaphore) || defined(OpenSemaphore) || defined(CreateWaitableTimer) || defined(OpenWaitableTimer) || defined(CreateFileMapping) || defined(OpenFileMapping) || defined(CreateFile) || defined(FindFirstFileEx) #ifdef __cplusplus } #endif //__cplusplus #ifndef LEAKTRACKER_INCLUDE_FROM_LEAKTRACKER_CPP_ #define malloc(x) _leaktracker61_GenericResourceAllocatorWithVoidReturn(malloc(x), __FILE__, __LINE__, __FUNCTION__, "malloc", 8, NULL, 0, 0,x,0) #define realloc(m,s) _leaktracker61_realloc(realloc(m,s),m, __FILE__, __LINE__, __FUNCTION__) #define calloc(m,s) _leaktracker61_GenericResourceAllocatorWithVoidReturn(calloc(m,s), __FILE__, __LINE__, __FUNCTION__, "calloc", 24, NULL, 0, 0, m, s) #define free(a) _leaktracker61_free(a, __FILE__, __LINE__, __FUNCTION__),free(a), _leaktracker61_SetPointerToNullValueIfOptionSet((void**)&a) #define _strdup(x) _leaktracker61_strdup(_strdup(x), __FILE__, __LINE__, __FUNCTION__) #ifndef EXCLUDE_MACROS_WITHOUT_TRAILING_UNDERSCORE_ #define strdup _strdup #define creat _creat #define findfirst _findfirst #define findclose _findclose #define wfindfirst _wfindfirst #define wcreat _wcreat #define fdopen _fdopen #define sopen _sopen #define wopen _wopen #define wsopen _wsopen #endif //!EXCLUDE_MACROS_WITHOUT_TRAILING_UNDERSCORE_ //The above macros are included by default because the names are unique //The following two macros are excluded by default because the names are too common and often found as member methods or variables #ifdef INCLUDE_MACROS_WITHOUT_TRAILING_UNDERSCORE_ #define close _close #define open _open #endif //INCLUDE_MACROS_WITHOUT_TRAILING_UNDERSCORE_ #define _creat(a,b) _leaktracker61_creat(_creat(a,b), __FILE__, __LINE__, __FUNCTION__) #define _close(a) _leaktracker61_close(_close(a), a, __FILE__, __LINE__, __FUNCTION__) #define _findfirst(a,b) _leaktracker61_findfirst(_findfirst(a,b), __FILE__, __LINE__, __FUNCTION__) #define _findclose(a) _leaktracker61_findclose(_findclose(a), a, __FILE__, __LINE__, __FUNCTION__) #define _wfindfirst(a,b) _leaktracker61_wfindfirst(_wfindfirst(a,b), __FILE__, __LINE__, __FUNCTION__) #define _wcreat(a,b) _leaktracker61_wcreat(_wcreat(a,b), __FILE__, __LINE__, __FUNCTION__) #define fopen(a,b) (FILE*)_leaktracker61_GenericResourceAllocatorWithVoidReturn(fopen(a,b), __FILE__, __LINE__, __FUNCTION__, "fopen", 1, a, 0,0,0,0) #define _fdopen(a,b) (FILE*)_leaktracker61_GenericResourceAllocatorAndDeallocateWithVoidReturn2(_fdopen(a,b), a, __FILE__, __LINE__, __FUNCTION__, "_fdopen") #define freopen(a,b,c) (FILE*)_leaktracker61_GenericResourceAllocatorAndDeallocateWithVoidReturn(freopen(a,b,c), c, __FILE__, __LINE__, __FUNCTION__, "freopen") #define fclose(a) _leaktracker61_GenericResourceDeAllocatorWithIntReturn(fclose(a), a, __FILE__, __LINE__, __FUNCTION__, "fclose") #if defined(__cplusplus) && defined(INCLUDE_CPLUSPLUS_LEAKTRACKER_IMPL__) #define _open leaktracker::debug_mem_allocation(__FILE__, __LINE__, __FUNCTION__).open_A #define _wopen leaktracker::debug_mem_allocation(__FILE__, __LINE__, __FUNCTION__).open_W #define _sopen leaktracker::debug_mem_allocation(__FILE__, __LINE__, __FUNCTION__).sopen_A #define _wsopen leaktracker::debug_mem_allocation(__FILE__, __LINE__, __FUNCTION__).sopen_W #else #ifdef LTDLL_USE_PMODE_ARG_MACRO_FOR_OPEN #define _open(a,b,c) _leaktracker61_open(_open(a,b,c), __FILE__, __LINE__, __FUNCTION__) #define _wopen(a,b,c) _leaktracker61_open(_wopen(a,b,c), __FILE__, __LINE__, __FUNCTION__) #define _sopen(a,b,c,d) _leaktracker61_sopen(_sopen(a,b,c,d), __FILE__, __LINE__, __FUNCTION__) #define _wsopen(a,b,c,d) _leaktracker61_wsopen(_wsopen(a,b,c,d), __FILE__, __LINE__, __FUNCTION__) #else #define _open(a,b) _leaktracker61_open(_open(a,b), __FILE__, __LINE__, __FUNCTION__) #define _wopen(a,b) _leaktracker61_open(_wopen(a,b), __FILE__, __LINE__, __FUNCTION__) #define _sopen(a,b,c) _leaktracker61_sopen(_sopen(a,b,c), __FILE__, __LINE__, __FUNCTION__) #define _wsopen(a,b,c) _leaktracker61_wsopen(_wsopen(a,b,c), __FILE__, __LINE__, __FUNCTION__) #endif //LTDLL_USE_PMODE_ARG_MACRO_FOR_OPEN #endif //defined(__cplusplus) && defined(INCLUDE_CPLUSPLUS_LEAKTRACKER_IMPL__) #ifdef _leaktracker61_WIN32 #define CreateMutexA(a,b,c) _leaktracker61_LogHandleCreateApiAction(CreateMutexA(a,b,c), "CreateMutexA", __FILE__, __LINE__, __FUNCTION__, 1,c,0,0) #define CreateMutexW(a,b,c) _leaktracker61_LogHandleCreateApiAction(CreateMutexW(a,b,c), "CreateMutexW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)c,0,0) #define OpenMutexA(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenMutexA(a,b,c), "OpenMutexA", __FILE__, __LINE__, __FUNCTION__, 1,c,0,0) #define OpenMutexW(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenMutexW(a,b,c), "OpenMutexW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)c,0,0) #define CreateEventA(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(CreateEventA(a,b,c,d), "CreateEventA", __FILE__, __LINE__, __FUNCTION__, 1,d,0,0) #define CreateEventW(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(CreateEventW(a,b,c,d), "CreateEventW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)d,0,0) #define OpenEventA(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenEventA(a,b,c), "OpenEventA", __FILE__, __LINE__, __FUNCTION__, 1,c,0,0) #define OpenEventW(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenEventW(a,b,c), "OpenEventW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)c,0,0) #define CreateSemaphoreA(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(CreateSemaphoreA(a,b,c,d), "CreateSemaphoreA", __FILE__, __LINE__, __FUNCTION__, 1,d,0,0) #define CreateSemaphoreW(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(CreateSemaphoreW(a,b,c,d), "CreateSemaphoreW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)d,0,0) #define OpenSemaphoreA(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenSemaphoreA(a,b,c), "OpenSemaphoreA", __FILE__, __LINE__, __FUNCTION__, 1,c,0,0) #define OpenSemaphoreW(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenSemaphoreW(a,b,c), "OpenSemaphoreW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)c,0,0) #define CreateWaitableTimerA(a,b,c) _leaktracker61_LogHandleCreateApiAction(CreateWaitableTimerA(a,b,c), "CreateWaitableTimerA", __FILE__, __LINE__, __FUNCTION__, 1,c,0,0) #define CreateWaitableTimerW(a,b,c) _leaktracker61_LogHandleCreateApiAction(CreateWaitableTimerW(a,b,c), "CreateWaitableTimerW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)c,0,0) #define OpenWaitableTimerA(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenWaitableTimerA(a,b,c), "OpenWaitableTimerA", __FILE__, __LINE__, __FUNCTION__, 1,c,0,0) #define OpenWaitableTimerW(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenWaitableTimerW(a,b,c), "OpenWaitableTimerW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)c,0,0) #define CreateFileMappingA(a,b,c,d,e,f) _leaktracker61_LogHandleCreateApiAction(CreateFileMappingA(a,b,c,d,e,f), "CreateFileMappingA", __FILE__, __LINE__, __FUNCTION__, 1,f,0,0) #define CreateFileMappingW(a,b,c,d,e,f) _leaktracker61_LogHandleCreateApiAction(CreateFileMappingW(a,b,c,d,e,f), "CreateFileMappingW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)f,0,0) #define OpenFileMappingA(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenFileMappingA(a,b,c), "OpenFileMappingA", __FILE__, __LINE__, __FUNCTION__, 1,c,0,0) #define OpenFileMappingW(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenFileMappingW(a,b,c), "OpenFileMappingW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)c,0,0) #define FindFirstChangeNotificationA(a,b,c) _leaktracker61_LogHandleCreateApiAction(FindFirstChangeNotificationA(a,b,c), "FindFirstChangeNotificationA", __FILE__, __LINE__, __FUNCTION__, 1,a,0,0) #define FindFirstChangeNotificationW(a,b,c) _leaktracker61_LogHandleCreateApiAction(FindFirstChangeNotificationW(a,b,c), "FindFirstChangeNotificationW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)a,0,0) #define FindCloseChangeNotification(a) _leaktracker61_LogHandleCloseApiAction(FindCloseChangeNotification(a), a, __FILE__, __LINE__, __FUNCTION__) #define CreateFileA(a,b,c,d,e,f,g) _leaktracker61_LogHandleCreateApiAction(CreateFileA(a,b,c,d,e,f,g), "CreateFileA", __FILE__, __LINE__, __FUNCTION__, 1,a,0,0) #define CreateFileW(a,b,c,d,e,f,g) _leaktracker61_LogHandleCreateApiAction(CreateFileW(a,b,c,d,e,f,g), "CreateFileW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)a,0,0) #define FindFirstFileExA(a,b,c,d,e,f) _leaktracker61_LogHandleCreateApiAction(FindFirstFileExA(a,b,c,d,e,f), "FindFirstFileExA", __FILE__, __LINE__, __FUNCTION__, 1,a,0,0) #define FindFirstFileExW(a,b,c,d,e,f) _leaktracker61_LogHandleCreateApiAction(FindFirstFileExW(a,b,c,d,e,f), "FindFirstFileExW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)a,0,0) #define OpenEventLogA(a,b) _leaktracker61_LogHandleCreateApiAction(OpenEventLogA(a,b), "OpenEventLogA", __FILE__, __LINE__, __FUNCTION__, 1,b,0,0) #define OpenEventLogW(a,b) _leaktracker61_LogHandleCreateApiAction(OpenEventLogW(a,b), "OpenEventLogW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)b,0,0) #define RegisterEventSourceA(a,b) _leaktracker61_LogHandleCreateApiAction(RegisterEventSourceA(a,b), "RegisterEventSourceA", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define RegisterEventSourceW(a,b) _leaktracker61_LogHandleCreateApiAction(RegisterEventSourceW(a,b), "RegisterEventSourceW", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define OpenBackupEventLogA(a,b) _leaktracker61_LogHandleCreateApiAction(OpenBackupEventLogA(a,b), "OpenBackupEventLogA", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define OpenBackupEventLogW(a,b) _leaktracker61_LogHandleCreateApiAction(OpenBackupEventLogW(a,b), "OpenBackupEventLogW", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CreateJobObjectA(a,b) _leaktracker61_LogHandleCreateApiAction(CreateJobObjectA(a,b), "CreateJobObjectA", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CreateJobObjectW(a,b) _leaktracker61_LogHandleCreateApiAction(CreateJobObjectW(a,b), "CreateJobObjectW", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define OpenJobObjectA(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenJobObjectA(a,b,c), "OpenJobObjectA", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define OpenJobObjectW(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenJobObjectW(a,b,c), "OpenJobObjectW", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define FindFirstVolumeA(a,b) _leaktracker61_LogHandleCreateApiAction(FindFirstVolumeA(a,b), "FindFirstVolumeA", __FILE__, __LINE__, __FUNCTION__, 1,a,0,0) #define FindFirstVolumeW(a,b) _leaktracker61_LogHandleCreateApiAction(FindFirstVolumeW(a,b), "FindFirstVolumeW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)a,0,0) #define CreateActCtxA(a) _leaktracker61_LogHandleCreateApiAction(CreateActCtxA(a), "CreateActCtxA", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CreateActCtxW(a) _leaktracker61_LogHandleCreateApiAction(CreateActCtxW(a), "CreateActCtxW", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define FindFirstVolumeMountPointA(a,b,c) _leaktracker61_LogHandleCreateApiAction(FindFirstVolumeMountPointA(a,b,c), "FindFirstVolumeMountPointA", __FILE__, __LINE__, __FUNCTION__, 1,a,0,0) #define FindFirstVolumeMountPointW(a,b,c) _leaktracker61_LogHandleCreateApiAction(FindFirstVolumeMountPointW(a,b,c), "FindFirstVolumeMountPointW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)a,0,0) #define FindVolumeMountPointClose(a) _leaktracker61_LogHandleCloseApiAction(FindVolumeMountPointClose(a), a, __FILE__, __LINE__, __FUNCTION__) #define CreateMailslotA(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(CreateMailslotA(a,b,c,d), "CreateMailslotA", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define BeginUpdateResourceA(a,b) _leaktracker61_LogHandleCreateApiAction(BeginUpdateResourceA(a,b), "BeginUpdateResourceA", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define BeginUpdateResourceW(a,b) _leaktracker61_LogHandleCreateApiAction(BeginUpdateResourceW(a,b), "BeginUpdateResourceW", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CloseHandle(a) _leaktracker61_LogHandleCloseApiAction(CloseHandle(a), a, __FILE__, __LINE__, __FUNCTION__) #define FindFirstStreamW(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(FindFirstStreamW(a,b,c,d), "FindFirstStreamW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)a,0,0) #define CreateNamedPipeA(a,b,c,d,e,f,g,h) _leaktracker61_LogHandleCreateApiAction(CreateNamedPipeA(a,b,c,d,e,f,g,h), "CreateNamedPipeA", __FILE__, __LINE__, __FUNCTION__, 1,a,0,0) #define CreateNamedPipeW(a,b,c,d,e,f,g,h) _leaktracker61_LogHandleCreateApiAction(CreateNamedPipeW(a,b,c,d,e,f,g,h), "CreateNamedPipeW", __FILE__, __LINE__, __FUNCTION__, 257,(char*)a,0,0) #define RegisterWaitForSingleObjectEx(a,b,c,d,e) _leaktracker61_LogHandleCreateApiAction(RegisterWaitForSingleObjectEx(a,b,c,d,e), "RegisterWaitForSingleObjectEx", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) //#define CreateTimerQueue _leaktracker61_LogHandleCreateApiAction(CreateTimerQueue(), "CreateTimerQueue", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) //#define GetProcessHeap _leaktracker61_LogHandleCreateApiAction(GetProcessHeap(), "GetProcessHeap", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) //#define GetCurrentProcess _leaktracker61_LogHandleCreateApiAction(GetCurrentProcess(), "GetCurrentProcess", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) //#define GetCurrentThread _leaktracker61_LogHandleCreateApiAction(GetCurrentThread(), "GetCurrentThread", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define SetTimerQueueTimer(a,b,c,d,e,f) _leaktracker61_LogHandleCreateApiAction(SetTimerQueueTimer(a,b,c,d,e,f), "SetTimerQueueTimer", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define HeapCreate(a,b,c) _leaktracker61_LogHandleCreateApiAction(HeapCreate(a,b,c), "HeapCreate", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define OpenProcess(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenProcess(a,b,c), "OpenProcess", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CreateThread(a,b,c,d,e,f) _leaktracker61_LogHandleCreateApiAction(CreateThread(a,b,c,d,e,f), "CreateThread", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CreateRemoteThread(a,b,c,d,e,f,g) _leaktracker61_LogHandleCreateApiAction(CreateRemoteThread(a,b,c,d,e,f,g), "CreateRemoteThread", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define OpenThread(a,b,c) _leaktracker61_LogHandleCreateApiAction(OpenThread(a,b,c), "OpenThread", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CreateIoCompletionPort(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(CreateIoCompletionPort(a,b,c,d), "CreateIoCompletionPort", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define GetStdHandle(a) _leaktracker61_LogHandleCreateApiAction(GetStdHandle(a), "GetStdHandle", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define CreateMemoryResourceNotification(a) _leaktracker61_LogHandleCreateApiAction(CreateMemoryResourceNotification(a), "CreateMemoryResourceNotification", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) #define ReOpenFile(a,b,c,d) _leaktracker61_LogHandleCreateApiAction(ReOpenFile(a,b,c,d), "ReOpenFile", __FILE__, __LINE__, __FUNCTION__, 0,0,0,0) //The following Windows API functions return BOOL, and sets one or more arguments to the allocated handle #define OpenProcessToken(a,b,c) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(OpenProcessToken(a,b,c), c, "OpenProcessToken", __FILE__, __LINE__, __FUNCTION__) #define OpenThreadToken(a,b,c,d) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(OpenThreadToken(a,b,c,d), d, "OpenThreadToken", __FILE__, __LINE__, __FUNCTION__) #define LogonUserA(a,b,c,d,e,f) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(LogonUserA(a,b,c,d,e,f), f, "LogonUserA", __FILE__, __LINE__, __FUNCTION__) #define LogonUserW(a,b,c,d,e,f) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(LogonUserW(a,b,c,d,e,f), f, "LogonUserW", __FILE__, __LINE__, __FUNCTION__) #define LogonUserExA(a,b,c,d,e,f,g,h,i,j) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(LogonUserExA(a,b,c,d,e,f,g,h,i,j), f, "LogonUserExA", __FILE__, __LINE__, __FUNCTION__) #define LogonUserExW(a,b,c,d,e,f,g,h,i,j) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(LogonUserExW(a,b,c,d,e,f,g,h,i,j), f, "LogonUserExW", __FILE__, __LINE__, __FUNCTION__) #define DuplicateTokenEx(a,b,c,d,e,f) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(DuplicateTokenEx(a,b,c,d,e,f), f, "DuplicateTokenEx", __FILE__, __LINE__, __FUNCTION__) #define CreateRestrictedToken(a,b,c,d,e,f,g,h,i) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(CreateRestrictedToken(a,b,c,d,e,f,g,h,i), i, "CreateRestrictedToken", __FILE__, __LINE__, __FUNCTION__) #define GetProcessHeaps(a,b) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(GetProcessHeaps(a,b), b, "GetProcessHeaps", __FILE__, __LINE__, __FUNCTION__) #define CreatePipe(a,b,c,d) _leaktracker61_LogHandlePointerCreateApiActionReturnBool2(CreatePipe(a,b,c,d), a, b, "CreatePipe", __FILE__, __LINE__, __FUNCTION__) #define DuplicateToken(a,b,c) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(DuplicateToken(a,b,c), c, "DuplicateToken", __FILE__, __LINE__, __FUNCTION__) #define CreateTimerQueueTimer(a,b,c,d,e,f,g) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(CreateTimerQueueTimer(a,b,c,d,e,f,g), a, "CreateTimerQueueTimer", __FILE__, __LINE__, __FUNCTION__) #define DuplicateHandle(a,b,c,d,e,f,g) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(DuplicateHandle(a,b,c,d,e,f,g), d, "DuplicateHandle", __FILE__, __LINE__, __FUNCTION__) #define RegisterWaitForSingleObject(a,b,c,d,e,f) _leaktracker61_LogHandlePointerCreateApiActionReturnBool(RegisterWaitForSingleObject(a,b,c,d,e,f), a, "RegisterWaitForSingleObject", __FILE__, __LINE__, __FUNCTION__) #define CreateProcessW(a,b,c,d,e,f,g,h,i,j) _leaktracker61_CreateProcess(CreateProcessW(a,b,c,d,e,f,g,h,i,j), j, "CreateProcessW", __FILE__, __LINE__, __FUNCTION__) #define CreateProcessA(a,b,c,d,e,f,g,h,i,j) _leaktracker61_CreateProcess(CreateProcessA(a,b,c,d,e,f,g,h,i,j), j, "CreateProcessA", __FILE__, __LINE__, __FUNCTION__) #define DeleteTimerQueue(a) _leaktracker61_LogHandleCloseApiAction(DeleteTimerQueue(a), a, __FILE__, __LINE__, __FUNCTION__) //The following API functions might need a special function to remove additional handles from the allocation list #define DeleteTimerQueueEx(a,b) _leaktracker61_LogHandleCloseApiAction(DeleteTimerQueueEx(a,b), a, __FILE__, __LINE__, __FUNCTION__) #define DeleteTimerQueueTimer(a,b,c) _leaktracker61_LogHandleCloseApiAction(DeleteTimerQueueTimer(a,b,c), a, __FILE__, __LINE__, __FUNCTION__) #define SysAllocString(a) (BSTR)_leaktracker61_GenericResourceAllocatorWithVoidReturn(SysAllocString(a), __FILE__, __LINE__, __FUNCTION__, "SysAllocString", 0,NULL, 0,0,0,0) #define SysAllocStringByteLen(a,b) (BSTR)_leaktracker61_GenericResourceAllocatorWithVoidReturn(SysAllocStringByteLen(a,b), __FILE__, __LINE__, __FUNCTION__, "SysAllocStringByteLen", 0,NULL, 0,0,0,0) #define SysReAllocString(a,b) (BSTR)_leaktracker61_GenericResourceAllocatorAndDeallocateWithVoidReturn(SysReAllocString(a,b), a, __FILE__, __LINE__, __FUNCTION__, "SysReAllocString") #define SysAllocStringLen(a,b) (BSTR)_leaktracker61_GenericResourceAllocatorWithVoidReturn(SysAllocStringLen(a,b), __FILE__, __LINE__, __FUNCTION__, "SysAllocStringLen", 0,NULL, 0,0,0,0) #define SysReAllocStringLen(a,b,c) (BSTR)_leaktracker61_GenericResourceAllocatorAndDeallocateWithVoidReturn(SysReAllocStringLen(a,b,c), a, __FILE__, __LINE__, __FUNCTION__, "SysReAllocStringLen") #endif //_leaktracker61_WIN32 #endif //!LEAKTRACKER_INCLUDE_FROM_LEAKTRACKER_CPP_ #else //defined(DEBUG_VERSION_) && defined(INCLUDE_C_LEAKTRACKER_IMPL__) #define _leaktracker61_DumpAllLeaks(FileName, iAppendToExistingFile) 0 #define _leaktracker61_EnableReportLeakOnApplication_Exit(FileName,iAppendToExistingFile) #define _leaktracker61_SetLeakTrackerOptions(x) 0 #endif //defined(DEBUG_VERSION_) && defined(INCLUDE_C_LEAKTRACKER_IMPL__) #endif //!LEAKTRACKER_H_