X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5260b1c582632afeb8f25db7f10697c8d45461b4..edea62818b7808c11e2c536b52941809f338f2fb:/src/common/memory.cpp diff --git a/src/common/memory.cpp b/src/common/memory.cpp index fee8108d50..90812da1f1 100644 --- a/src/common/memory.cpp +++ b/src/common/memory.cpp @@ -5,11 +5,11 @@ // Modified by: // Created: 04/01/98 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart and Markus Holzem -// Licence: wxWindows license +// Copyright: (c) Julian Smart +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "memory.h" #endif @@ -24,35 +24,37 @@ #include "wx/defs.h" #endif -#if (DEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT +#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) // #pragma implementation #endif #ifndef WX_PRECOMP #include "wx/utils.h" #include "wx/app.h" +#include "wx/hash.h" #endif +#if wxUSE_THREADS +#include "wx/thread.h" +#endif + +#include "wx/log.h" #include -#if USE_IOSTREAMH -#include -#else -#include -#endif -#include +#include "wx/ioswrap.h" -#if !defined(__WATCOMC__) && !defined(__VMS__) +#if !defined(__WATCOMC__) && !(defined(__VMS__) && ( __VMS_VER < 70000000 ) )\ + && !defined( __MWERKS__ ) && !defined(__SALFORDC__) #include #endif #include #include -#ifdef __WINDOWS__ -#include +#ifdef __WXMSW__ +#include "wx/msw/wrapwin.h" #ifdef GetClassInfo #undef GetClassInfo @@ -66,17 +68,22 @@ #include "wx/memory.h" -/* +#if wxUSE_THREADS && defined(__WXDEBUG__) +#define USE_THREADSAFE_MEMORY_ALLOCATION 1 +#else +#define USE_THREADSAFE_MEMORY_ALLOCATION 0 +#endif + + #ifdef new #undef new #endif -*/ // wxDebugContext wxTheDebugContext; /* Redefine new and delete so that we can pick up situations where: - - we overwrite or underwrite areas of malloc'd memory. - - we use uninitialise variables + - we overwrite or underwrite areas of malloc'd memory. + - we use uninitialise variables Only do this in debug mode. We change new to get enough memory to allocate a struct, followed @@ -110,10 +117,8 @@ */ void wxMemStruct::ErrorMsg (const char * mesg) { - wxTrace("wxWindows memory checking error: %s\n", mesg); + wxLogMessage(wxT("wxWidgets memory checking error: %s"), mesg); PrintNode (); - -// << m_fileName << ' ' << m_lineNum << endl; } /* @@ -121,10 +126,8 @@ void wxMemStruct::ErrorMsg (const char * mesg) */ void wxMemStruct::ErrorMsg () { - wxTrace("wxWindows over/underwrite memory error: \n"); + wxLogMessage(wxT("wxWidgets over/underwrite memory error:")); PrintNode (); - -// cerr << m_fileName << ' ' << m_lineNum << endl; } @@ -138,9 +141,9 @@ void wxMemStruct::ErrorMsg () int wxMemStruct::AssertList () { if (wxDebugContext::GetHead () != 0 && ! (wxDebugContext::GetHead ())->AssertIt () || - wxDebugContext::GetTail () != 0 && ! wxDebugContext::GetTail ()->AssertIt ()) { - ErrorMsg ("Head or tail pointers trashed"); - return 0; + wxDebugContext::GetTail () != 0 && ! wxDebugContext::GetTail ()->AssertIt ()) { + ErrorMsg ("Head or tail pointers trashed"); + return 0; } return 1; } @@ -160,8 +163,8 @@ int wxMemStruct::AssertList () int wxMemStruct::AssertIt () { return (m_id == MemStructId && - (m_prev == 0 || m_prev->m_id == MemStructId) && - (m_next == 0 || m_next->m_id == MemStructId)); + (m_prev == 0 || m_prev->m_id == MemStructId) && + (m_next == 0 || m_next->m_id == MemStructId)); } @@ -172,19 +175,19 @@ int wxMemStruct::AssertIt () int wxMemStruct::Append () { if (! AssertList ()) - return 0; + return 0; if (wxDebugContext::GetHead () == 0) { - if (wxDebugContext::GetTail () != 0) { - ErrorMsg ("Null list should have a null tail pointer"); - return 0; - } - (void) wxDebugContext::SetHead (this); - (void) wxDebugContext::SetTail (this); + if (wxDebugContext::GetTail () != 0) { + ErrorMsg ("Null list should have a null tail pointer"); + return 0; + } + (void) wxDebugContext::SetHead (this); + (void) wxDebugContext::SetTail (this); } else { - wxDebugContext::GetTail ()->m_next = this; - this->m_prev = wxDebugContext::GetTail (); - (void) wxDebugContext::SetTail (this); + wxDebugContext::GetTail ()->m_next = this; + this->m_prev = wxDebugContext::GetTail (); + (void) wxDebugContext::SetTail (this); } return 1; } @@ -198,51 +201,51 @@ int wxMemStruct::Append () int wxMemStruct::Unlink () { if (! AssertList ()) - return 0; + return 0; if (wxDebugContext::GetHead () == 0 || wxDebugContext::GetTail () == 0) { - ErrorMsg ("Trying to remove node from empty list"); - return 0; + ErrorMsg ("Trying to remove node from empty list"); + return 0; } // Handle the part of the list before this node. if (m_prev == 0) { - if (this != wxDebugContext::GetHead ()) { - ErrorMsg ("No previous node for non-head node"); - return 0; - } - (void) wxDebugContext::SetHead (m_next); + if (this != wxDebugContext::GetHead ()) { + ErrorMsg ("No previous node for non-head node"); + return 0; + } + (void) wxDebugContext::SetHead (m_next); } else { - if (! m_prev->AssertIt ()) { - ErrorMsg ("Trashed previous pointer"); - return 0; - } - - if (m_prev->m_next != this) { - ErrorMsg ("List is inconsistent"); - return 0; - } - m_prev->m_next = m_next; + if (! m_prev->AssertIt ()) { + ErrorMsg ("Trashed previous pointer"); + return 0; + } + + if (m_prev->m_next != this) { + ErrorMsg ("List is inconsistent"); + return 0; + } + m_prev->m_next = m_next; } // Handle the part of the list after this node. if (m_next == 0) { - if (this != wxDebugContext::GetTail ()) { - ErrorMsg ("No next node for non-tail node"); - return 0; - } - (void) wxDebugContext::SetTail (m_prev); + if (this != wxDebugContext::GetTail ()) { + ErrorMsg ("No next node for non-tail node"); + return 0; + } + (void) wxDebugContext::SetTail (m_prev); } else { - if (! m_next->AssertIt ()) { - ErrorMsg ("Trashed next pointer"); - return 0; - } - - if (m_next->m_prev != this) { - ErrorMsg ("List is inconsistent"); - return 0; - } - m_next->m_prev = m_prev; + if (! m_next->AssertIt ()) { + ErrorMsg ("Trashed next pointer"); + return 0; + } + + if (m_next->m_prev != this) { + ErrorMsg ("List is inconsistent"); + return 0; + } + m_next->m_prev = m_prev; } return 1; @@ -259,22 +262,22 @@ int wxMemStruct::CheckBlock () int nFailures = 0; if (m_firstMarker != MemStartCheck) { - nFailures++; - ErrorMsg (); + nFailures++; + ErrorMsg (); } - + char * pointer = wxDebugContext::MidMarkerPos ((char *) this); if (* (wxMarkerType *) pointer != MemMidCheck) { - nFailures++; - ErrorMsg (); + nFailures++; + ErrorMsg (); } - + pointer = wxDebugContext::EndMarkerPos ((char *) this, RequestSize ()); if (* (wxMarkerType *) pointer != MemEndCheck) { - nFailures++; - ErrorMsg (); + nFailures++; + ErrorMsg (); } - + return nFailures; } @@ -285,12 +288,12 @@ int wxMemStruct::CheckBlock () int wxMemStruct::CheckAllPrevious () { int nFailures = 0; - + for (wxMemStruct * st = this->m_prev; st != 0; st = st->m_prev) { - if (st->AssertIt ()) - nFailures += st->CheckBlock (); - else - return -1; + if (st->AssertIt ()) + nFailures += st->CheckBlock (); + else + return -1; } return nFailures; @@ -327,50 +330,80 @@ void wxMemStruct::PrintNode () wxObject *obj = (wxObject *)m_actualData; wxClassInfo *info = obj->GetClassInfo(); + // Let's put this in standard form so IDEs can load the file at the appropriate + // line + wxString msg; + + if (m_fileName) + msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum); + if (info && info->GetClassName()) - wxTrace("%s", info->GetClassName()); + msg += info->GetClassName(); else - wxTrace("Object"); + msg += wxT("object"); - if (m_fileName) - wxTrace(" (%s %d)", m_fileName, (int)m_lineNum); + wxString msg2; + msg2.Printf(wxT(" at 0x%lX, size %d"), (long)GetActualData(), (int)RequestSize()); + msg += msg2; - wxTrace(" at $%lX, size %d\n", (long)GetActualData(), (int)RequestSize()); + wxLogMessage(msg); } else { - wxTrace("Non-object data"); + wxString msg; + if (m_fileName) - wxTrace(" (%s %d)", m_fileName, (int)m_lineNum); - wxTrace(" at $%lX, size %d\n", (long)GetActualData(), (int)RequestSize()); + msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum); + msg += wxT("non-object data"); + wxString msg2; + msg2.Printf(wxT(" at 0x%lX, size %d\n"), (long)GetActualData(), (int)RequestSize()); + msg += msg2; + + wxLogMessage(msg); } } void wxMemStruct::Dump () { if (!ValidateNode()) return; - + if (m_isObject) { wxObject *obj = (wxObject *)m_actualData; -// wxClassInfo *info = obj->GetClassInfo(); + wxString msg; if (m_fileName) - wxTrace("Item (%s %d)", m_fileName, (int)m_lineNum); - else - wxTrace("Item"); + msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum); - wxTrace(" at $%lX, size %d: ", (long)GetActualData(), (int)RequestSize()); -// wxTrace(info->GetClassName()); + + /* TODO: We no longer have a stream (using wxLogDebug) so we can't dump it. + * Instead, do what wxObject::Dump does. + * What should we do long-term, eliminate Dumping? Or specify + * that MyClass::Dump should use wxLogDebug? Ugh. obj->Dump(wxDebugContext::GetStream()); - wxTrace("\n"); + */ + + if (obj->GetClassInfo() && obj->GetClassInfo()->GetClassName()) + msg += obj->GetClassInfo()->GetClassName(); + else + msg += wxT("unknown object class"); + + wxString msg2; + msg2.Printf(wxT(" at 0x%lX, size %d"), (long)GetActualData(), (int)RequestSize()); + msg += msg2; + + wxDebugContext::OutputDumpLine(msg); } else { - wxTrace("Non-object data"); + wxString msg; if (m_fileName) - wxTrace(" (%s %d)", m_fileName, (int)m_lineNum); - wxTrace(" at $%lX, size %d\n", (long)GetActualData(), (int)RequestSize()); + msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum); + + wxString msg2; + msg2.Printf(wxT("non-object data at 0x%lX, size %d"), (long)GetActualData(), (int)RequestSize() ); + msg += msg2; + wxDebugContext::OutputDumpLine(msg); } } @@ -383,13 +416,15 @@ int wxMemStruct::ValidateNode () { char * startPointer = (char *) this; if (!AssertIt ()) { - if (IsDeleted ()) - ErrorMsg ("Object already deleted"); - else { - // Can't use the error routines as we have no recognisable object. - wxTrace("Can't verify memory struct - all bets are off!\n"); - } - return 0; + if (IsDeleted ()) + ErrorMsg ("Object already deleted"); + else { + // Can't use the error routines as we have no recognisable object. +#ifndef __WXGTK__ + wxLogMessage(wxT("Can't verify memory struct - all bets are off!")); +#endif + } + return 0; } /* @@ -403,20 +438,20 @@ int wxMemStruct::ValidateNode () if (* (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer) != MemMidCheck) ErrorMsg (); if (* (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer, - RequestSize ()) != - MemEndCheck) + RequestSize ()) != + MemEndCheck) ErrorMsg (); // Back to before the extra buffer and check that // we can still read what we originally wrote. if (Marker () != MemStartCheck || - * (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer) - != MemMidCheck || - * (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer, - RequestSize ()) != MemEndCheck) + * (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer) + != MemMidCheck || + * (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer, + RequestSize ()) != MemEndCheck) { - ErrorMsg (); - return 0; + ErrorMsg (); + return 0; } return 1; @@ -428,100 +463,25 @@ int wxMemStruct::ValidateNode () wxMemStruct *wxDebugContext::m_head = NULL; wxMemStruct *wxDebugContext::m_tail = NULL; -// ostream *wxDebugContext::m_debugStream = NULL; -// streambuf *wxDebugContext::m_streamBuf = NULL; -// Must initialise these in wxEntry, and then delete them just before wxEntry exits -streambuf *wxDebugContext::m_streamBuf = NULL; -ostream *wxDebugContext::m_debugStream = NULL; - -bool wxDebugContext::m_checkPrevious = FALSE; +bool wxDebugContext::m_checkPrevious = false; int wxDebugContext::debugLevel = 1; -bool wxDebugContext::debugOn = TRUE; +bool wxDebugContext::debugOn = true; wxMemStruct *wxDebugContext::checkPoint = NULL; +// For faster alignment calculation +static wxMarkerType markerCalc[2]; +int wxDebugContext::m_balign = (int)((char *)&markerCalc[1] - (char*)&markerCalc[0]); +int wxDebugContext::m_balignmask = (int)((char *)&markerCalc[1] - (char*)&markerCalc[0]) - 1; + wxDebugContext::wxDebugContext(void) { -// m_streamBuf = new wxDebugStreamBuf; -// m_debugStream = new ostream(m_streamBuf); } wxDebugContext::~wxDebugContext(void) { - SetStream(NULL, NULL); -} - -/* - * It's bizarre, but with BC++ 4.5, the value of str changes - * between SetFile and SetStream. - */ - -void wxDebugContext::SetStream(ostream *str, streambuf *buf) -{ -/* - if (str) - { - char buff[128]; - sprintf(buff, "SetStream (1): str is %ld", (long) str); - MessageBox(NULL, buff, "Memory", MB_OK); - } -*/ - - if (m_debugStream) - { - m_debugStream->flush(); - delete m_debugStream; - } - m_debugStream = NULL; - - // Not allowed in Watcom (~streambuf is protected). - // Is this trying to say something significant to us?? -#ifndef __WATCOMC__ - if (m_streamBuf) - { - streambuf* oldBuf = m_streamBuf; - m_streamBuf = NULL; - delete oldBuf; - } -#endif - m_streamBuf = buf; - m_debugStream = str; -} - -bool wxDebugContext::SetFile(const wxString& file) -{ - ofstream *str = new ofstream((char *) (const char *)file); - - if (str->bad()) - { - delete str; - return FALSE; - } - else - { -/* - char buf[40]; - sprintf(buf, "SetFile: str is %ld", (long) str); - MessageBox(NULL, buf, "Memory", MB_OK); -*/ - SetStream(str); - return TRUE; - } } -bool wxDebugContext::SetStandardError(void) -{ -#if !defined(_WINDLL) - wxDebugStreamBuf *buf = new wxDebugStreamBuf; - ostream *stream = new ostream(m_streamBuf); - SetStream(stream, buf); - return TRUE; -#else - return FALSE; -#endif -} - - /* Work out the positions of the markers by creating an array of 2 markers and comparing the addresses of the 2 elements. Use this number as the @@ -563,7 +523,7 @@ char * wxDebugContext::EndMarkerPos (const char * buf, const size_t size) char * wxDebugContext::StartPos (const char * caller) { return ((char *) (caller - wxDebugContext::PaddedSize (sizeof(wxMarkerType)) - - wxDebugContext::PaddedSize (sizeof (wxMemStruct)))); + wxDebugContext::PaddedSize (sizeof (wxMemStruct)))); } /* @@ -573,6 +533,9 @@ char * wxDebugContext::StartPos (const char * caller) I don't know how portable this stuff is, but it seems to work for me at the moment. It would be real nice if I knew more about this! + + // Note: this function is now obsolete (along with CalcAlignment) + // because the calculations are done statically, for greater speed. */ size_t wxDebugContext::GetPadding (const size_t size) { @@ -580,11 +543,17 @@ size_t wxDebugContext::GetPadding (const size_t size) return (pad) ? sizeof(wxMarkerType) - pad : 0; } - - size_t wxDebugContext::PaddedSize (const size_t size) { - return size + GetPadding (size); + // Added by Terry Farnham to replace + // slow GetPadding call. + int padb; + + padb = size & m_balignmask; + if(padb) + return(size + m_balign - padb); + else + return(size); } /* @@ -595,7 +564,7 @@ size_t wxDebugContext::PaddedSize (const size_t size) size_t wxDebugContext::TotSize (const size_t reqSize) { return (PaddedSize (sizeof (wxMemStruct)) + PaddedSize (reqSize) + - 2 * sizeof(wxMarkerType)); + 2 * sizeof(wxMarkerType)); } @@ -606,11 +575,13 @@ void wxDebugContext::TraverseList (PmSFV func, wxMemStruct *from) { if (!from) from = wxDebugContext::GetHead (); - - for (wxMemStruct * st = from; st != 0; st = st->m_next) + + wxMemStruct * st = NULL; + for (st = from; st != 0; st = st->m_next) { void* data = st->GetActualData(); - if ((data != (void*)m_debugStream) && (data != (void*) m_streamBuf)) +// if ((data != (void*)m_debugStream) && (data != (void*) m_streamBuf)) + if (data != (void*) wxLog::GetActiveTarget()) { (st->*func) (); } @@ -623,56 +594,58 @@ void wxDebugContext::TraverseList (PmSFV func, wxMemStruct *from) */ bool wxDebugContext::PrintList (void) { -#if DEBUG - if (!HasStream()) - return FALSE; - - TraverseList ((PmSFV)&wxMemStruct::PrintNode, (checkPoint ? checkPoint->m_next : NULL)); +#ifdef __WXDEBUG__ + TraverseList ((PmSFV)&wxMemStruct::PrintNode, (checkPoint ? checkPoint->m_next : (wxMemStruct*)NULL)); - return TRUE; + return true; #else - return FALSE; + return false; #endif } bool wxDebugContext::Dump(void) { -#if DEBUG - if (!HasStream()) - return FALSE; - - if (TRUE) +#ifdef __WXDEBUG__ { - char* appName = "application"; - wxString appNameStr(""); + wxChar* appName = (wxChar*) wxT("application"); + wxString appNameStr; if (wxTheApp) { appNameStr = wxTheApp->GetAppName(); - appName = (char*) (const char*) appNameStr; - wxTrace("Memory dump of %s at %s:\n", appName, wxNow()); + appName = WXSTRINGCAST appNameStr; + OutputDumpLine(wxT("----- Memory dump of %s at %s -----"), appName, WXSTRINGCAST wxNow() ); + } + else + { + OutputDumpLine( wxT("----- Memory dump -----") ); } } - TraverseList ((PmSFV)&wxMemStruct::Dump, (checkPoint ? checkPoint->m_next : NULL)); - return TRUE; + TraverseList ((PmSFV)&wxMemStruct::Dump, (checkPoint ? checkPoint->m_next : (wxMemStruct*)NULL)); + + OutputDumpLine(wxEmptyString); + OutputDumpLine(wxEmptyString); + + return true; #else - return FALSE; + return false; #endif } +#ifdef __WXDEBUG__ struct wxDebugStatsStruct { long instanceCount; long totalSize; - char *instanceClass; + wxChar *instanceClass; wxDebugStatsStruct *next; }; -static wxDebugStatsStruct *FindStatsStruct(wxDebugStatsStruct *st, char *name) +static wxDebugStatsStruct *FindStatsStruct(wxDebugStatsStruct *st, wxChar *name) { while (st) { - if (strcmp(st->instanceClass, name) == 0) + if (wxStrcmp(st->instanceClass, name) == 0) return st; st = st->next; } @@ -684,38 +657,51 @@ static wxDebugStatsStruct *InsertStatsStruct(wxDebugStatsStruct *head, wxDebugSt st->next = head; return st; } +#endif bool wxDebugContext::PrintStatistics(bool detailed) { -#if DEBUG - if (!HasStream()) - return FALSE; +#ifdef __WXDEBUG__ + { + wxChar* appName = (wxChar*) wxT("application"); + wxString appNameStr; + if (wxTheApp) + { + appNameStr = wxTheApp->GetAppName(); + appName = WXSTRINGCAST appNameStr; + OutputDumpLine(wxT("----- Memory statistics of %s at %s -----"), appName, WXSTRINGCAST wxNow() ); + } + else + { + OutputDumpLine( wxT("----- Memory statistics -----") ); + } + } bool currentMode = GetDebugMode(); - SetDebugMode(FALSE); - + SetDebugMode(false); + long noNonObjectNodes = 0; long noObjectNodes = 0; long totalSize = 0; wxDebugStatsStruct *list = NULL; - wxMemStruct *from = (checkPoint ? checkPoint->m_next : NULL); + wxMemStruct *from = (checkPoint ? checkPoint->m_next : (wxMemStruct*)NULL ); if (!from) from = wxDebugContext::GetHead (); - wxMemStruct *st; + wxMemStruct *st; for (st = from; st != 0; st = st->m_next) { void* data = st->GetActualData(); - if (detailed && (data != (void*)m_debugStream) && (data != (void*) m_streamBuf)) + if (detailed && (data != (void*) wxLog::GetActiveTarget())) { - char *className = "nonobject"; + wxChar *className = (wxChar*) wxT("nonobject"); if (st->m_isObject && st->GetActualData()) { wxObject *obj = (wxObject *)st->GetActualData(); if (obj->GetClassInfo()->GetClassName()) - className = obj->GetClassInfo()->GetClassName(); + className = (wxChar*)obj->GetClassInfo()->GetClassName(); } wxDebugStatsStruct *stats = FindStatsStruct(list, className); if (!stats) @@ -730,7 +716,7 @@ bool wxDebugContext::PrintStatistics(bool detailed) stats->totalSize += st->RequestSize(); } - if ((data != (void*)m_debugStream) && (data != (void*) m_streamBuf)) + if (data != (void*) wxLog::GetActiveTarget()) { totalSize += st->RequestSize(); if (st->m_isObject) @@ -744,67 +730,83 @@ bool wxDebugContext::PrintStatistics(bool detailed) { while (list) { - wxTrace("%ld objects of class %s, total size %ld\n", + OutputDumpLine(wxT("%ld objects of class %s, total size %ld"), list->instanceCount, list->instanceClass, list->totalSize); wxDebugStatsStruct *old = list; list = old->next; free((char *)old); } - wxTrace("\n"); + OutputDumpLine(wxEmptyString); } - + SetDebugMode(currentMode); - wxTrace("Number of object items: %ld\n", noObjectNodes); - wxTrace("Number of non-object items: %ld\n", noNonObjectNodes); - wxTrace("Total allocated size: %ld\n", totalSize); + OutputDumpLine(wxT("Number of object items: %ld"), noObjectNodes); + OutputDumpLine(wxT("Number of non-object items: %ld"), noNonObjectNodes); + OutputDumpLine(wxT("Total allocated size: %ld"), totalSize); + OutputDumpLine(wxEmptyString); + OutputDumpLine(wxEmptyString); - return TRUE; + return true; #else - return FALSE; + (void)detailed; + return false; #endif -} +} bool wxDebugContext::PrintClasses(void) { - if (!HasStream()) - return FALSE; - - if (TRUE) { - char* appName = "application"; - wxString appNameStr(""); + wxChar* appName = (wxChar*) wxT("application"); + wxString appNameStr; if (wxTheApp) { appNameStr = wxTheApp->GetAppName(); - appName = (char*) (const char*) appNameStr; - wxTrace("Classes in %s:\n\n", appName); + appName = WXSTRINGCAST appNameStr; + wxLogMessage(wxT("----- Classes in %s -----"), appName); } } int n = 0; - wxClassInfo *info = wxClassInfo::first; - while (info) + wxHashTable::compatibility_iterator node; + wxClassInfo *info; + + wxClassInfo::sm_classTable->BeginFind(); + node = wxClassInfo::sm_classTable->Next(); + while (node) { + info = (wxClassInfo *)node->GetData(); if (info->GetClassName()) { - wxTrace("%s ", info->GetClassName()); - - if (info->GetBaseClassName1() && !info->GetBaseClassName2()) - wxTrace("is a %s", info->GetBaseClassName1()); - else if (info->GetBaseClassName1() && info->GetBaseClassName2()) - wxTrace("is a %s, %s", info->GetBaseClassName1(), info->GetBaseClassName2()); - if (info->objectConstructor) - wxTrace(": dynamic\n"); - else - wxTrace("\n"); + wxString msg(info->GetClassName()); + msg += wxT(" "); + + if (info->GetBaseClassName1() && !info->GetBaseClassName2()) + { + msg += wxT("is a "); + msg += info->GetBaseClassName1(); + } + else if (info->GetBaseClassName1() && info->GetBaseClassName2()) + { + msg += wxT("is a "); + msg += info->GetBaseClassName1() ; + msg += wxT(", "); + msg += info->GetBaseClassName2() ; + } + if (info->GetConstructor()) + msg += wxT(": dynamic"); + + wxLogMessage(msg); } - info = info->next; + node = wxClassInfo::sm_classTable->Next(); n ++; } - wxTrace("\nThere are %d classes derived from wxObject.\n", n); - return TRUE; -} + wxLogMessage(wxEmptyString); + wxLogMessage(wxT("There are %d classes derived from wxObject."), n); + wxLogMessage(wxEmptyString); + wxLogMessage(wxEmptyString); + return true; +} void wxDebugContext::SetCheckpoint(bool all) { @@ -818,8 +820,8 @@ void wxDebugContext::SetCheckpoint(bool all) int wxDebugContext::Check(bool checkAll) { int nFailures = 0; - - wxMemStruct *from = (checkPoint ? checkPoint->m_next : NULL); + + wxMemStruct *from = (checkPoint ? checkPoint->m_next : (wxMemStruct*)NULL ); if (!from || checkAll) from = wxDebugContext::GetHead (); @@ -836,102 +838,146 @@ int wxDebugContext::Check(bool checkAll) // Count the number of non-wxDebugContext-related objects // that are outstanding -int wxDebugContext::CountObjectsLeft(void) +int wxDebugContext::CountObjectsLeft(bool sinceCheckpoint) { int n = 0; - - wxMemStruct *from = wxDebugContext::GetHead (); + + wxMemStruct *from = NULL; + if (sinceCheckpoint && checkPoint) + from = checkPoint->m_next; + else + from = wxDebugContext::GetHead () ; for (wxMemStruct * st = from; st != 0; st = st->m_next) { void* data = st->GetActualData(); - if ((data != (void*)m_debugStream) && (data != (void*) m_streamBuf)) + if (data != (void*) wxLog::GetActiveTarget()) n ++; } return n ; } -/* - The global operator new used for everything apart from getting - dynamic storage within this function itself. -*/ +// This function is used to output the dump +void wxDebugContext::OutputDumpLine(const wxChar *szFormat, ...) +{ + // a buffer of 2048 bytes should be long enough for a file name + // and a class name + wxChar buf[2048]; + int count; + va_list argptr; + va_start(argptr, szFormat); + buf[sizeof(buf)/sizeof(wxChar)-1] = _T('\0'); + + // keep 3 bytes for a \r\n\0 + count = wxVsnprintf(buf, sizeof(buf)/sizeof(wxChar)-3, szFormat, argptr); + + if ( count < 0 ) + count = sizeof(buf)/sizeof(wxChar)-3; + buf[count]=_T('\r'); + buf[count+1]=_T('\n'); + buf[count+2]=_T('\0'); + + wxMessageOutputDebug dbgout; + dbgout.Printf(buf); +} -// We'll only do malloc and free for the moment: leave the interesting -// stuff for the wxObject versions. -#if DEBUG && USE_GLOBAL_MEMORY_OPERATORS +#if USE_THREADSAFE_MEMORY_ALLOCATION +static bool memSectionOk = false; -#ifdef new -#undef new -#endif +class MemoryCriticalSection : public wxCriticalSection +{ +public: + MemoryCriticalSection() { + memSectionOk = true; + } + ~MemoryCriticalSection() { + memSectionOk = false; + } +}; + +class MemoryCriticalSectionLocker +{ +public: + inline MemoryCriticalSectionLocker(wxCriticalSection& critsect) + : m_critsect(critsect), m_locked(memSectionOk) { if(m_locked) m_critsect.Enter(); } + inline ~MemoryCriticalSectionLocker() { if(m_locked) m_critsect.Leave(); } + +private: + // no assignment operator nor copy ctor + MemoryCriticalSectionLocker(const MemoryCriticalSectionLocker&); + MemoryCriticalSectionLocker& operator=(const MemoryCriticalSectionLocker&); + + wxCriticalSection& m_critsect; + bool m_locked; +}; + +static MemoryCriticalSection memLocker; -// Seems OK all of a sudden. Maybe to do with linking with multithreaded library? -#if 0 // def _MSC_VER -#define NO_DEBUG_ALLOCATION #endif -// Unfortunately ~wxDebugStreamBuf doesn't work (VC++ 5) when we enable the debugging -// code. I have no idea why. In BC++ 4.5, we have a similar problem the debug -// stream myseriously changing pointer address between being passed from SetFile to SetStream. -// See docs/msw/issues.txt. -void * operator new (size_t size, char * fileName, int lineNum) +#if !(defined(__WXMSW__) && (defined(WXUSINGDLL) || defined(WXMAKINGDLL_BASE))) +#ifdef __WXDEBUG__ +#if wxUSE_GLOBAL_MEMORY_OPERATORS +void * operator new (size_t size, wxChar * fileName, int lineNum) { -#ifdef NO_DEBUG_ALLOCATION - return malloc(size); -#else - return wxDebugAlloc(size, fileName, lineNum, FALSE, FALSE); -#endif + return wxDebugAlloc(size, fileName, lineNum, false, false); } -#if !( defined (_MSC_VER) && (_MSC_VER <= 800) ) -void * operator new[] (size_t size, char * fileName, int lineNum) +void * operator new (size_t size) { -#ifdef NO_DEBUG_ALLOCATION - return malloc(size); -#else - return wxDebugAlloc(size, fileName, lineNum, FALSE, TRUE); -#endif + return wxDebugAlloc(size, NULL, 0, false); } -#endif void operator delete (void * buf) { -#ifdef NO_DEBUG_ALLOCATION - free((char*) buf); -#else - wxDebugFree(buf); -#endif + wxDebugFree(buf, false); } -#if !( defined (_MSC_VER) && (_MSC_VER <= 800) ) -void operator delete[] (void * buf) +#if wxUSE_ARRAY_MEMORY_OPERATORS +void * operator new[] (size_t size) { -#ifdef NO_DEBUG_ALLOCATION - free((char*) buf); -#else - wxDebugFree(buf, TRUE); -#endif + return wxDebugAlloc(size, NULL, 0, false, true); } -#endif -#endif +void * operator new[] (size_t size, wxChar * fileName, int lineNum) +{ + return wxDebugAlloc(size, fileName, lineNum, false, true); +} + +void operator delete[] (void * buf) +{ + wxDebugFree(buf, true); +} +#endif // wxUSE_ARRAY_MEMORY_OPERATORS +#endif // !(defined(__WXMSW__) && (defined(WXUSINGDLL) || defined(WXMAKINGDLL_BASE))) +#endif // wxUSE_GLOBAL_MEMORY_OPERATORS // TODO: store whether this is a vector or not. -void * wxDebugAlloc(size_t size, char * fileName, int lineNum, bool isObject, bool isVect) +void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool WXUNUSED(isVect) ) { +#if USE_THREADSAFE_MEMORY_ALLOCATION + MemoryCriticalSectionLocker lock(memLocker); +#endif + // If not in debugging allocation mode, do the normal thing // so we don't leave any trace of ourselves in the node list. +#if defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 ) +// VA 3.0 still has trouble in here + return (void *)malloc(size); +#endif if (!wxDebugContext::GetDebugMode()) { return (void *)malloc(size); } - - char * buf = (char *) malloc(wxDebugContext::TotSize (size)); + + int totSize = wxDebugContext::TotSize (size); + char * buf = (char *) malloc(totSize); if (!buf) { - wxTrace("Call to malloc (%ld) failed.\n", (long)size); - return 0; + wxLogMessage(wxT("Call to malloc (%ld) failed."), (long)size); + return 0; } wxMemStruct * st = (wxMemStruct *)buf; st->m_firstMarker = MemStartCheck; @@ -945,15 +991,15 @@ void * wxDebugAlloc(size_t size, char * fileName, int lineNum, bool isObject, bo // Errors from Append() shouldn't really happen - but just in case! if (st->Append () == 0) { - st->ErrorMsg ("Trying to append new node"); + st->ErrorMsg ("Trying to append new node"); } - + if (wxDebugContext::GetCheckPrevious ()) { - if (st->CheckAllPrevious () < 0) { - st->ErrorMsg ("Checking previous nodes"); - } + if (st->CheckAllPrevious () < 0) { + st->ErrorMsg ("Checking previous nodes"); + } } - + // Set up the extra markers at the middle and end. char * ptr = wxDebugContext::MidMarkerPos (buf); * (wxMarkerType *) ptr = MemMidCheck; @@ -969,11 +1015,19 @@ void * wxDebugAlloc(size_t size, char * fileName, int lineNum, bool isObject, bo } // TODO: check whether was allocated as a vector -void wxDebugFree(void * buf, bool isVect) +void wxDebugFree(void * buf, bool WXUNUSED(isVect) ) { +#if USE_THREADSAFE_MEMORY_ALLOCATION + MemoryCriticalSectionLocker lock(memLocker); +#endif + if (!buf) return; - + +#if defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 ) +// VA 3.0 still has trouble in here + free((char *)buf); +#endif // If not in debugging allocation mode, do the normal thing // so we don't leave any trace of ourselves in the node list. if (!wxDebugContext::GetDebugMode()) @@ -988,7 +1042,7 @@ void wxDebugFree(void * buf, bool isVect) wxMemStruct * st = (wxMemStruct *) wxDebugContext::StructPos (startPointer); if (! st->ValidateNode ()) - return; + return; // If this is the current checkpoint, we need to // move the checkpoint back so it points to a valid @@ -1000,28 +1054,30 @@ void wxDebugFree(void * buf, bool isVect) { st->ErrorMsg ("Unlinking deleted node"); } - + // Now put in the fill char into the id slot and the caller requested // memory locations. st->SetDeleted (); (void) memset (wxDebugContext::CallerMemPos (startPointer), MemFillChar, - st->RequestSize ()); + st->RequestSize ()); - // Don't allow delayed freeing of memory in this version -// if (!wxDebugContext::GetDelayFree()) -// free((void *)st); free((char *)st); } +#endif // __WXDEBUG__ + // Trace: send output to the current debugging stream -void wxTrace(const char *fmt ...) +void wxTrace(const wxChar * ...) { - va_list ap; - static char buffer[512]; +#if 1 + wxFAIL_MSG(wxT("wxTrace is now obsolete. Please use wxDebugXXX instead.")); +#else + va_list ap; + static wxChar buffer[512]; va_start(ap, fmt); -#ifdef __WINDOWS__ +#ifdef __WXMSW__ wvsprintf(buffer,fmt,ap) ; #else vsprintf(buffer,fmt,ap) ; @@ -1035,26 +1091,34 @@ void wxTrace(const char *fmt ...) wxDebugContext::GetStream().flush(); } else -#ifdef __WINDOWS__ - OutputDebugString((LPCSTR)buffer) ; +#ifdef __WXMSW__ +#ifdef __WIN32__ + OutputDebugString((LPCTSTR)buffer) ; +#else + OutputDebugString((const char*) buffer) ; +#endif #else fprintf(stderr, buffer); #endif +#endif } // Trace with level -void wxTraceLevel(int level, const char *fmt ...) +void wxTraceLevel(int, const wxChar * ...) { +#if 1 + wxFAIL_MSG(wxT("wxTrace is now obsolete. Please use wxDebugXXX instead.")); +#else if (wxDebugContext::GetLevel() < level) return; - + va_list ap; - static char buffer[512]; + static wxChar buffer[512]; va_start(ap, fmt); -#ifdef __WINDOWS__ - wvsprintf(buffer,fmt,ap) ; +#ifdef __WXMSW__ + wxWvsprintf(buffer,fmt,ap) ; #else vsprintf(buffer,fmt,ap) ; #endif @@ -1067,20 +1131,40 @@ void wxTraceLevel(int level, const char *fmt ...) wxDebugContext::GetStream().flush(); } else -#ifdef __WINDOWS__ - OutputDebugString((LPCSTR)buffer) ; +#ifdef __WXMSW__ +#ifdef __WIN32__ + OutputDebugString((LPCTSTR)buffer) ; +#else + OutputDebugString((const char*) buffer) ; +#endif #else fprintf(stderr, buffer); #endif +#endif } -#else // USE_MEMORY_TRACING && DEBUG -void wxTrace(const char *WXUNUSED(fmt) ...) -{ -} +//---------------------------------------------------------------------------- +// Final cleanup after all global objects in all files have been destroyed +//---------------------------------------------------------------------------- + +// Don't set it to 0 by dynamic initialization +// Some compilers will really do the assignment later +// All global variables are initialized to 0 at the very beginning, and this is just fine. +int wxDebugContextDumpDelayCounter::sm_count; -void wxTraceLevel(int WXUNUSED(level), const char *WXUNUSED(fmt) ...) +void wxDebugContextDumpDelayCounter::DoDump() { + if (wxDebugContext::CountObjectsLeft(true) > 0) + { + wxDebugContext::OutputDumpLine(wxT("There were memory leaks.\n")); + wxDebugContext::Dump(); + wxDebugContext::PrintStatistics(); + } } -#endif + +// Even if there is nothing else, make sure that there is at +// least one cleanup counter object +static wxDebugContextDumpDelayCounter wxDebugContextDumpDelayCounter_One; + +#endif // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT