Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clean up of memory debugging macros and chanegs to compile with CW7 (patch 548408)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@15278 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2002-04-26 23:08:19 +00:00
parent e669d97ae5
commit b2edef6f2f
2 changed files with 172 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
include/wx/object.h
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: object.h
// Name: wx/object.h
// Purpose: wxObject class, plus run-time type information macros
// Author: Julian Smart
// Modified by: Ron Lee
@@ -32,6 +32,8 @@ class WXDLLEXPORT wxObject;
// conditional compilation
// ----------------------------------------------------------------------------
// this shouldn't be needed any longer as <wx/msw/private.h> does it but it
// doesn't hurt neither
#ifdef GetClassName
#undef GetClassName
#endif
@@ -41,6 +43,7 @@ class WXDLLEXPORT wxObject;
class WXDLLEXPORT wxClassInfo;
class WXDLLEXPORT wxHashTable;
class WXDLLEXPORT wxObjectRefData;
#if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
#include "wx/ioswrap.h"
@@ -292,17 +295,14 @@ name##PluginSentinel m_pluginsentinel;
#define wxIS_KIND_OF(obj, className) obj->IsKindOf(&className::sm_class##className)
// Just seems a bit nicer-looking (pretend it's not a macro)
#define wxIsKindOf(obj, className) obj->IsKindOf(&className::sm_class##className)
// to be replaced by dynamic_cast<> in the future
#define wxDynamicCast(obj, className) \
(className *) wxCheckDynamicCast((wxObject*)(obj), &className::sm_class##className)
// The 'this' pointer is always true, so use this version
// to cast the this pointer and avoid compiler warnings.
#define wxDynamicCastThis(className) \
(IsKindOf(&className::sm_class##className) ? (className *)(this) : (className *)0)
@@ -323,8 +323,7 @@ inline void wxCheckCast(void *ptr)
#endif // __WXDEBUG__
// Unfortunately Borland seems to need this include.
// for some reason Borland seems to need this include.
#if wxUSE_STD_IOSTREAM \
&& (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT) \
&& defined(__BORLANDC__)
@@ -333,55 +332,112 @@ inline void wxCheckCast(void *ptr)
#else
#include <iostream>
#endif
#endif // wxUSE_IOSTREAMH
// ----------------------------------------------------------------------------
// set up memory debugging macros
// ----------------------------------------------------------------------------
/*
Which new/delete operator variants do we want?
_WX_WANT_NEW_SIZET_WXCHAR_INT = void *operator new (size_t size, wxChar *fileName = 0, int lineNum = 0)
_WX_WANT_DELETE_VOID = void operator delete (void * buf)
_WX_WANT_DELETE_VOID_CONSTCHAR_SIZET = void operator delete (void *buf, const char *_fname, size_t _line)
_WX_WANT_DELETE_VOID_WXCHAR_INT = void operator delete(void *buf, wxChar*, int)
_WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT = void *operator new[] (size_t size, wxChar *fileName , int lineNum = 0)
_WX_WANT_ARRAY_DELETE_VOID = void operator delete[] (void *buf)
_WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int )
*/
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
// All compilers get this one
#define _WX_WANT_NEW_SIZET_WXCHAR_INT
// Everyone except Visage gets the next one
#ifndef __VISAGECPP__
#define _WX_WANT_DELETE_VOID
#endif
// Only visage gets this one under the correct circumstances
#if defined(__VISAGECPP__) && __DEBUG_ALLOC__
#define _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
#endif
// Only VC++ 6.0 and CodeWarrior compilers get overloaded delete that matches new
#if ( defined(__VISUALC__) && (__VISUALC__ >= 1200) ) || defined(__MWERKS__)
#define _WX_WANT_DELETE_VOID_WXCHAR_INT
#endif
// Now see who (if anyone) gets the array memory operators
#if wxUSE_ARRAY_MEMORY_OPERATORS
// Everyone except Visual C++ (cause problems for VC++ - crashes)
#if !defined(__VISUALC__)
#define _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
#endif
// Everyone except Visual C++ (cause problems for VC++ - crashes)
#if !defined(__VISUALC__)
#define _WX_WANT_ARRAY_DELETE_VOID
#endif
// Only CodeWarrior 6 or higher
#if defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
#define _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT
#endif
#endif // wxUSE_ARRAY_MEMORY_OPERATORS
#endif // WXDEBUG && wxUSE_MEMORY_TRACING
// ----------------------------------------------------------------------------
// wxObject
// wxObject: the root class of wxWindows object hierarchy
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxObjectRefData;
class WXDLLEXPORT wxObject
{
DECLARE_ABSTRACT_CLASS(wxObject)
public:
wxObject() : m_refData(0) {}
wxObject() { m_refData = NULL; }
virtual ~wxObject() { UnRef(); }
bool IsKindOf(wxClassInfo *info) const;
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
void *operator new (size_t size, wxChar *fileName = 0, int lineNum = 0);
#ifndef __VISAGECPP__
// Turn on the correct set of new and delete operators
#ifdef _WX_WANT_NEW_SIZET_WXCHAR_INT
void *operator new ( size_t size, wxChar *fileName = NULL, int lineNum = 0 );
#endif
#ifdef _WX_WANT_DELETE_VOID
void operator delete ( void * buf );
#elif __DEBUG_ALLOC__
#endif
#ifdef _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
void operator delete ( void *buf, const char *_fname, size_t _line );
#endif
// VC++ 6.0
#if defined(__VISUALC__) && (__VISUALC__ >= 1200)
#ifdef _WX_WANT_DELETE_VOID_WXCHAR_INT
void operator delete ( void *buf, wxChar*, int );
#endif
// Causes problems for VC++
#ifdef _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
void *operator new[] ( size_t size, wxChar *fileName = NULL, int lineNum = 0 );
#endif
#if wxUSE_ARRAY_MEMORY_OPERATORS && !defined(__VISUALC__) && !defined( __MWERKS__)
void *operator new[] (size_t size, wxChar *fileName = 0, int lineNum = 0);
#ifdef _WX_WANT_ARRAY_DELETE_VOID
void operator delete[] ( void *buf );
#endif
#ifdef __MWERKS__
void *operator new[] (size_t size, wxChar *fileName , int lineNum = 0);
void *operator new[] (size_t size) { return operator new[] ( size, 0, 0 ) ; }
void operator delete[] (void *buf);
#ifdef _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT
void operator delete[] (void* buf, wxChar*, int );
#endif
#endif // Debug & memory tracing
#if wxUSE_STD_IOSTREAM && (defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT)
virtual void Dump(wxSTD ostream& str);
@@ -417,6 +473,9 @@ protected:
wxObjectRefData *m_refData;
};
// ----------------------------------------------------------------------------
// wxObjectRefData: ref counted data meant to be stored in wxObject
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxObjectRefData
{
@@ -426,7 +485,8 @@ public:
wxObjectRefData() : m_count(1) { }
virtual ~wxObjectRefData() { }
inline int GetRefCount() const { return m_count; }
int GetRefCount() const { return m_count; }
private:
int m_count;
};
@@ -434,20 +494,24 @@ private:
inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
{
return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : 0;
return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL;
}
// ----------------------------------------------------------------------------
// more debugging macros
// ----------------------------------------------------------------------------
#ifdef __WXDEBUG__
#ifndef WXDEBUG_NEW
#define WXDEBUG_NEW new(__TFILE__,__LINE__)
#endif
#else
#else // !__WXDEBUG__
#define WXDEBUG_NEW new
#endif
// Redefine new to be the debugging version. This doesn't
// work with all compilers, in which case you need to
// use WXDEBUG_NEW explicitly if you wish to use the debugging version.
// Redefine new to be the debugging version. This doesn't work with all
// compilers, in which case you need to use WXDEBUG_NEW explicitly if you wish
// to use the debugging version.
#if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
#define new new(__TFILE__,__LINE__)
@@ -455,4 +519,3 @@ inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
#endif // _WX_OBJECTH__
// vi:sts=4:sw=4:et

66
src/common/object.cpp
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: object.cpp
// Name: src/common/object.cpp
// Purpose: wxObject implementation
// Author: Julian Smart
// Modified by: Ron Lee
@@ -15,7 +15,6 @@
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
@@ -27,7 +26,6 @@
#endif
#include <string.h>
#include <assert.h>
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#include "wx/memory.h"
@@ -43,19 +41,18 @@
#else
#define DEBUG_PRINTF(NAME)
#endif
#endif
#endif // __WXDEBUG__ || wxUSE_DEBUG_CONTEXT
wxClassInfo wxObject::sm_classwxObject( wxT("wxObject"), 0, 0,
(int) sizeof(wxObject),
(wxObjectConstructorFn) 0 );
wxClassInfo* wxClassInfo::sm_first = 0;
wxHashTable* wxClassInfo::sm_classTable = 0;
wxClassInfo* wxClassInfo::sm_first = NULL;
wxHashTable* wxClassInfo::sm_classTable = NULL;
// These are here so we can avoid 'always true/false' warnings
// by referring to these instead of TRUE/FALSE
const bool wxTrue = TRUE;
const bool wxFalse = FALSE;
@@ -63,7 +60,6 @@ const bool wxFalse = FALSE;
// E.g. is wxWindow a kind of wxObject?
// Go from this class to superclass, taking into account
// two possible base classes.
bool wxObject::IsKindOf(wxClassInfo *info) const
{
wxClassInfo *thisInfo = GetClassInfo();
@@ -76,57 +72,60 @@ void wxObject::Dump(wxSTD ostream& str)
if (GetClassInfo() && GetClassInfo()->GetClassName())
str << GetClassInfo()->GetClassName();
else
str << "unknown object class";
str << _T("unknown object class");
}
#endif
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
#ifdef new
#undef new
#endif
#ifdef _WX_WANT_NEW_SIZET_WXCHAR_INT
void *wxObject::operator new ( size_t size, wxChar *fileName, int lineNum )
{
return wxDebugAlloc(size, fileName, lineNum, TRUE);
}
#endif
#ifndef __VISAGECPP__
#ifdef _WX_WANT_DELETE_VOID
void wxObject::operator delete ( void *buf )
{
wxDebugFree(buf);
}
#elif __DEBUG_ALLOC__
#endif
#ifdef _WX_WANT_DELETE_VOID_CONSTCHAR_SIZET
void wxObject::operator delete ( void *buf, const char *_fname, size_t _line )
{
wxDebugFree(buf);
}
#endif
// VC++ 6.0
#if defined(__VISUALC__) && (__VISUALC__ >= 1200)
void wxObject::operator delete(void *pData, wxChar *WXUNUSED(fileName), int WXUNUSED(lineNum))
#ifdef _WX_WANT_DELETE_VOID_WXCHAR_INT
void wxObject::operator delete ( void *buf, wxChar *WXUNUSED(fileName), int WXUNUSED(lineNum) )
{
::operator delete(pData);
wxDebugFree(buf);
}
#endif
// Cause problems for VC++ - crashes
#if (!defined(__VISUALC__) && wxUSE_ARRAY_MEMORY_OPERATORS ) || defined(__MWERKS__)
void *wxObject::operator new[] (size_t size, wxChar *fileName, int lineNum)
#ifdef _WX_WANT_ARRAY_NEW_SIZET_WXCHAR_INT
void *wxObject::operator new[] ( size_t size, wxChar* WXUNUSED(fileName), int WXUNUSED(lineNum) )
{
return wxDebugAlloc(size, fileName, lineNum, TRUE, TRUE);
}
#endif
#ifdef _WX_WANT_ARRAY_DELETE_VOID
void wxObject::operator delete[] ( void *buf )
{
wxDebugFree(buf, TRUE);
}
#endif
#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
#ifdef _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT
void wxObject::operator delete[] (void * buf, wxChar* WXUNUSED(fileName), int WXUNUSED(lineNum) )
{
wxDebugFree(buf, TRUE);
}
#endif
// ----------------------------------------------------------------------------
@@ -212,7 +211,7 @@ void wxClassInfo::InitializeClasses()
void wxClassInfo::CleanUpClasses()
{
delete wxClassInfo::sm_classTable;
wxClassInfo::sm_classTable = 0;
wxClassInfo::sm_classTable = NULL;
}
@@ -225,14 +224,19 @@ wxObject *wxCreateDynamicObject(const wxChar *name)
if ( wxClassInfo::sm_classTable )
{
wxClassInfo *info = (wxClassInfo *)wxClassInfo::sm_classTable->Get(name);
return info != 0 ? info->CreateObject() : 0;
return info ? info->CreateObject() : NULL;
}
else
else // no sm_classTable yet
{
for ( wxClassInfo *info = wxClassInfo::sm_first;
info;
info = info->m_next )
{
for(wxClassInfo *info = wxClassInfo::sm_first; info; info = info->m_next)
if (info->m_className && wxStrcmp(info->m_className, name) == 0)
return info->CreateObject();
return 0;
}
return NULL;
}
}