if you want to debug memory leaks, include msapi/vld.h into m_core.h

then install Visual Leak Detector (https://vld.codeplex.com/) and enjoy.
64-bit programs are supported

git-svn-id: http://svn.miranda-ng.org/main/trunk@16831 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 350 insertions, 0 deletions

diff --git a/include/msapi/vld.h b/include/msapi/vld.h
new file mode 100644
index 0000000000..b2dda9e34d
--- /dev/null
+++ b/include/msapi/vld.h
@@ -0,0 +1,350 @@
+////////////////////////////////////////////////////////////////////////////////

+//

+//  Visual Leak Detector - Import Library Header

+//  Copyright (c) 2005-2014 VLD Team

+//

+//  This library is free software; you can redistribute it and/or

+//  modify it under the terms of the GNU Lesser General Public

+//  License as published by the Free Software Foundation; either

+//  version 2.1 of the License, or (at your option) any later version.

+//

+//  This library is distributed in the hope that it will be useful,

+//  but WITHOUT ANY WARRANTY; without even the implied warranty of

+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+//  Lesser General Public License for more details.

+//

+//  You should have received a copy of the GNU Lesser General Public

+//  License along with this library; if not, write to the Free Software

+//  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

+//

+//  See COPYING.txt for the full terms of the GNU Lesser General Public License.

+//

+////////////////////////////////////////////////////////////////////////////////

+

+#pragma once

+

+#include "vld_def.h"

+

+typedef int            VLD_BOOL;

+typedef unsigned int   VLD_UINT;

+typedef size_t         VLD_SIZET;

+typedef void*          VLD_HMODULE;

+

+#if defined _DEBUG || defined VLD_FORCE_ENABLE

+

+#ifdef _WIN64

+#pragma comment(lib, "vld64.lib")

+#else

+#pragma comment(lib, "vld32.lib")

+#endif

+

+// Force a symbolic reference to the global VisualLeakDetector class object from

+// the DLL. This ensures that the DLL is loaded and linked with the program,

+// even if no code otherwise imports any of the DLL's exports.

+#pragma comment(linker, "/include:__imp_?g_vld@@3VVisualLeakDetector@@A")

+

+////////////////////////////////////////////////////////////////////////////////

+//

+//  Visual Leak Detector APIs

+//

+

+#ifdef __cplusplus

+extern "C" {

+#endif // __cplusplus

+

+// VLDDisable - Disables Visual Leak Detector's memory leak detection at

+//   runtime. If memory leak detection is already disabled, then calling this

+//   function has no effect.

+//

+//  Note: In multithreaded programs, this function operates on a per-thread

+//    basis. In other words, if you call this function from one thread, then

+//    memory leak detection is only disabled for that thread. If memory leak

+//    detection is enabled for other threads, then it will remain enabled for

+//    those other threads. It was designed to work this way to insulate you,

+//    the programmer, from having to ensure thread synchronization when calling

+//    VLDEnable() and VLDDisable(). Without this, calling these two functions

+//    unsynchronized could result in unpredictable and unintended behavior.

+//    But this also means that if you want to disable memory leak detection

+//    process-wide, then you need to call this function from every thread in

+//    the process.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDDisable ();

+

+// VLDEnable - Enables Visual Leak Detector's memory leak detection at runtime.

+//   If memory leak detection is already enabled, which it is by default, then

+//   calling this function has no effect.

+//

+//  Note: In multithreaded programs, this function operates on a per-thread

+//    basis. In other words, if you call this function from one thread, then

+//    memory leak detection is only enabled for that thread. If memory leak

+//    detection is disabled for other threads, then it will remain disabled for

+//    those other threads. It was designed to work this way to insulate you,

+//    the programmer, from having to ensure thread synchronization when calling

+//    VLDEnable() and VLDDisable(). Without this, calling these two functions

+//    unsynchronized could result in unpredictable and unintended behavior.

+//    But this also means that if you want to enable memory leak detection

+//    process-wide, then you need to call this function from every thread in

+//    the process.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDEnable ();

+

+// VLDRestore - Restore Visual Leak Detector's previous state.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDRestore ();

+

+// VLDGlobalDisable - Disables Visual Leak Detector's memory leak detection at

+//   runtime in all threads. If memory leak detection is already disabled,

+//   then calling this function has no effect.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDGlobalDisable ();

+

+// VLDGlobalEnable - Enables Visual Leak Detector's memory leak detection

+//   at runtime in all threads. If memory leak detection is already enabled,

+//   which it is by default, then calling this function has no effect.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDGlobalEnable ();

+

+// VLDReportLeaks - Report leaks up to the execution point.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) VLD_UINT VLDReportLeaks ();

+

+// VLDReportThreadLeaks - Report thread leaks up to the execution point.

+//

+// threadId: thread Id.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) VLD_UINT VLDReportThreadLeaks (VLD_UINT threadId);

+

+// VLDGetLeaksCount - Return memory leaks count to the execution point.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) VLD_UINT VLDGetLeaksCount ();

+

+// VLDGetThreadLeaksCount - Return thread memory leaks count to the execution point.

+//

+// threadId: thread Id.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) VLD_UINT VLDGetThreadLeaksCount (VLD_UINT threadId);

+

+// VLDMarkAllLeaksAsReported - Mark all leaks as reported.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDMarkAllLeaksAsReported ();

+

+// VLDMarkThreadLeaksAsReported - Mark thread leaks as reported.

+//

+// threadId: thread Id.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDMarkThreadLeaksAsReported (VLD_UINT threadId);

+

+

+// VLDRefreshModules - Look for recently loaded DLLs and patch them if necessary.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDRefreshModules();

+

+

+// VLDEnableModule - Enable Memory leak checking on the specified module.

+//

+// module: module handle.

+//

+//  Return Value:

+//

+//    None.

+//

+

+__declspec(dllimport) void VLDEnableModule(VLD_HMODULE module);

+

+

+// VLDDisableModule - Disable Memory leak checking on the specified module.

+//

+// module: module handle.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDDisableModule(VLD_HMODULE module);

+

+// VLDGetOptions - Return all current options.

+//

+//  Return Value:

+//

+//    Mask of current options.

+//

+__declspec(dllimport) VLD_UINT VLDGetOptions();

+

+// VLDGetReportFilename - Return current report filename.

+//

+// filename: current report filename (max characters - MAX_PATH).

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDGetReportFilename(wchar_t *filename);

+

+// VLDSetOptions - Update the report options via function call rather than INI file.

+//

+// option_mask: Only the following flags are checked

+// VLD_OPT_AGGREGATE_DUPLICATES

+// VLD_OPT_MODULE_LIST_INCLUDE

+// VLD_OPT_SAFE_STACK_WALK

+// VLD_OPT_SLOW_DEBUGGER_DUMP

+// VLD_OPT_TRACE_INTERNAL_FRAMES

+// VLD_OPT_START_DISABLED

+// VLD_OPT_SKIP_HEAPFREE_LEAKS

+// VLD_OPT_VALIDATE_HEAPFREE

+//

+// maxDataDump: maximum number of user-data bytes to dump for each leaked block.

+//

+// maxTraceFrames: maximum number of frames per stack trace for each leaked block.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDSetOptions(VLD_UINT option_mask, VLD_SIZET maxDataDump, VLD_UINT maxTraceFrames);

+

+// VLDSetModulesList - Set list of modules included/excluded in leak detection

+// depending on parameter "includeModules".

+//

+// modules: list of modules to be forcefully included/excluded in leak detection.

+//

+// includeModules: include or exclude that modules.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDSetModulesList(const wchar_t *modules, VLD_BOOL includeModules);

+

+// VLDGetModulesList - Return current list of included/excluded modules

+// depending on flag VLD_OPT_TRACE_INTERNAL_FRAMES.

+//

+// modules: destination string for list of included/excluded modules (maximum length 512 characters).

+//

+// size: maximum string size.

+//

+//  Return Value:

+//

+//    VLD_BOOL: TRUE if include modules, otherwise FALSE.

+//

+__declspec(dllimport) VLD_BOOL VLDGetModulesList(wchar_t *modules, VLD_UINT size);

+

+// VLDSetReportOptions - Update the report options via function call rather than INI file.

+//

+// Only the following flags are checked

+// VLD_OPT_REPORT_TO_DEBUGGER

+// VLD_OPT_REPORT_TO_FILE

+// VLD_OPT_REPORT_TO_STDOUT

+// VLD_OPT_UNICODE_REPORT

+//

+// filename is optional and can be NULL.

+//

+//  Return Value:

+//

+//    None.

+//

+__declspec(dllimport) void VLDSetReportOptions(VLD_UINT option_mask, const wchar_t *filename);

+

+// VLDSetReportHook - Installs or uninstalls a client-defined reporting function by hooking it

+//  into the C run-time debug reporting process (debug version only).

+//

+// mode: The action to take: VLD_RPTHOOK_INSTALL or VLD_RPTHOOK_REMOVE.

+//

+// pfnNewHook: Report hook to install or remove.

+//

+//  Return Value:

+//

+//    int: 0 if success.

+//

+__declspec(dllimport) int VLDSetReportHook(int mode,  VLD_REPORT_HOOK pfnNewHook);

+

+// VLDResolveCallstacks - Performs symbol resolution for all saved extent CallStack's that have

+// been tracked by Visual Leak Detector. This function is necessary for applications that

+// dynamically load and unload modules, and through which memory leaks might be included.

+// If this is NOT called, stack traces may have stack frames with no symbol information. This

+// happens because the symbol API's cannot look up symbols for a binary / module that has been unloaded

+// from the process.

+//

+//  Return Value:

+//

+//    int: 0 if successfully resolved all callstacks.

+//

+__declspec(dllexport) int VLDResolveCallstacks();

+

+#ifdef __cplusplus

+}

+#endif // __cplusplus

+

+#else // !_DEBUG

+

+#define VLDEnable()

+#define VLDDisable()

+#define VLDRestore()

+#define VLDGlobalDisable()

+#define VLDGlobalEnable()

+#define VLDReportLeaks() (0)

+#define VLDReportThreadLeaks() (0)

+#define VLDGetLeaksCount() (0)

+#define VLDGetThreadLeaksCount() (0)

+#define VLDMarkAllLeaksAsReported()

+#define VLDMarkThreadLeaksAsReported(a)

+#define VLDRefreshModules()

+#define VLDEnableModule(a)

+#define VLDDisableModule(b)

+#define VLDGetOptions() (0)

+#define VLDGetReportFilename(a)

+#define VLDSetOptions(a, b, c)

+#define VLDSetReportHook(a, b)

+#define VLDSetModulesList(a)

+#define VLDGetModulesList(a, b) (FALSE)

+#define VLDSetReportOptions(a, b)

+#define VLDResolveCallstacks() (0)

+

+#endif // _DEBUG