src/common/memory.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/memory.cpp
   3 // Purpose:     Memory checking implementation
   4 // Author:      Arthur Seaton, Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_MEMORY_TRACING || wxUSE_DEBUG_CONTEXT
  20
  21 #include "wx/memory.h"
  22
  23 #ifndef WX_PRECOMP
  24     #ifdef __WXMSW__
  25         #include "wx/msw/wrapwin.h"
  26     #endif
  27     #include "wx/utils.h"
  28     #include "wx/app.h"
  29     #include "wx/hash.h"
  30     #include "wx/log.h"
  31 #endif
  32
  33 #if wxUSE_THREADS
  34     #include "wx/thread.h"
  35 #endif
  36
  37 #include <stdlib.h>
  38
  39 #include "wx/ioswrap.h"
  40
  41 #if !defined(__WATCOMC__) && !(defined(__VMS__) && ( __VMS_VER < 70000000 ) )\
  42      && !defined( __MWERKS__ )
  43 #include <memory.h>
  44 #endif
  45
  46 #include <stdarg.h>
  47 #include <string.h>
  48
  49 #if wxUSE_THREADS
  50 #define USE_THREADSAFE_MEMORY_ALLOCATION 1
  51 #else
  52 #define USE_THREADSAFE_MEMORY_ALLOCATION 0
  53 #endif
  54
  55
  56 #ifdef new
  57 #undef new
  58 #endif
  59
  60 // wxDebugContext wxTheDebugContext;
  61 /*
  62   Redefine new and delete so that we can pick up situations where:
  63         - we overwrite or underwrite areas of malloc'd memory.
  64         - we use uninitialise variables
  65   Only do this in debug mode.
  66
  67   We change new to get enough memory to allocate a struct, followed
  68   by the caller's requested memory, followed by a tag. The struct
  69   is used to create a doubly linked list of these areas and also
  70   contains another tag. The tags are used to determine when the area
  71   has been over/under written.
  72 */
  73
  74
  75 /*
  76   Values which are used to set the markers which will be tested for
  77   under/over write. There are 3 of these, one in the struct, one
  78   immediately after the struct but before the caller requested memory and
  79   one immediately after the requested memory.
  80 */
  81 #define MemStartCheck  0x23A8
  82 #define MemMidCheck  0xA328
  83 #define MemEndCheck 0x8A32
  84 #define MemFillChar 0xAF
  85 #define MemStructId  0x666D
  86
  87 /*
  88   External interface for the wxMemStruct class. Others are
  89   defined inline within the class def. Here we only need to be able
  90   to add and delete nodes from the list and handle errors in some way.
  91 */
  92
  93 /*
  94   Used for internal "this shouldn't happen" type of errors.
  95 */
  96 void wxMemStruct::ErrorMsg (const char * mesg)
  97 {
  98   wxLogMessage(wxT("wxWidgets memory checking error: %s"), mesg);
  99   PrintNode ();
 100 }
 101
 102 /*
 103   Used when we find an overwrite or an underwrite error.
 104 */
 105 void wxMemStruct::ErrorMsg ()
 106 {
 107   wxLogMessage(wxT("wxWidgets over/underwrite memory error:"));
 108   PrintNode ();
 109 }
 110
 111
 112 /*
 113   We want to find out if pointers have been overwritten as soon as is
 114   possible, so test everything before we dereference it. Of course it's still
 115   quite possible that, if things have been overwritten, this function will
 116   fall over, but the only way of dealing with that would cost too much in terms
 117   of time.
 118 */
 119 int wxMemStruct::AssertList ()
 120 {
 121     if (wxDebugContext::GetHead () != 0 && ! (wxDebugContext::GetHead ())->AssertIt () ||
 122         wxDebugContext::GetTail () != 0 && ! wxDebugContext::GetTail ()->AssertIt ()) {
 123         ErrorMsg ("Head or tail pointers trashed");
 124         return 0;
 125     }
 126     return 1;
 127 }
 128
 129
 130 /*
 131   Check that the thing we're pointing to has the correct id for a wxMemStruct
 132   object and also that it's previous and next pointers are pointing at objects
 133   which have valid ids.
 134   This is definitely not perfect since we could fall over just trying to access
 135   any of the slots which we use here, but I think it's about the best that I
 136   can do without doing something like taking all new wxMemStruct pointers and
 137   comparing them against all known pointer within the list and then only
 138   doing this sort of check _after_ you've found the pointer in the list. That
 139   would be safer, but also much more time consuming.
 140 */
 141 int wxMemStruct::AssertIt ()
 142 {
 143     return (m_id == MemStructId &&
 144             (m_prev == 0 || m_prev->m_id == MemStructId) &&
 145             (m_next == 0 || m_next->m_id == MemStructId));
 146 }
 147
 148
 149 /*
 150   Additions are always at the tail of the list.
 151   Returns 0 on error, non-zero on success.
 152 */
 153 int wxMemStruct::Append ()
 154 {
 155     if (! AssertList ())
 156         return 0;
 157
 158     if (wxDebugContext::GetHead () == 0) {
 159         if (wxDebugContext::GetTail () != 0) {
 160             ErrorMsg ("Null list should have a null tail pointer");
 161             return 0;
 162         }
 163         (void) wxDebugContext::SetHead (this);
 164         (void) wxDebugContext::SetTail (this);
 165     } else {
 166         wxDebugContext::GetTail ()->m_next = this;
 167         this->m_prev = wxDebugContext::GetTail ();
 168         (void) wxDebugContext::SetTail (this);
 169     }
 170     return 1;
 171 }
 172
 173
 174 /*
 175   Don't actually free up anything here as the space which is used
 176   by the node will be free'd up when the whole block is free'd.
 177   Returns 0 on error, non-zero on success.
 178 */
 179 int wxMemStruct::Unlink ()
 180 {
 181     if (! AssertList ())
 182         return 0;
 183
 184     if (wxDebugContext::GetHead () == 0 || wxDebugContext::GetTail () == 0) {
 185         ErrorMsg ("Trying to remove node from empty list");
 186         return 0;
 187     }
 188
 189     // Handle the part of the list before this node.
 190     if (m_prev == 0) {
 191         if (this != wxDebugContext::GetHead ()) {
 192             ErrorMsg ("No previous node for non-head node");
 193             return 0;
 194         }
 195         (void) wxDebugContext::SetHead (m_next);
 196     } else {
 197         if (! m_prev->AssertIt ()) {
 198             ErrorMsg ("Trashed previous pointer");
 199             return 0;
 200         }
 201
 202         if (m_prev->m_next != this) {
 203             ErrorMsg ("List is inconsistent");
 204             return 0;
 205         }
 206         m_prev->m_next = m_next;
 207     }
 208
 209     // Handle the part of the list after this node.
 210     if (m_next == 0) {
 211         if (this != wxDebugContext::GetTail ()) {
 212             ErrorMsg ("No next node for non-tail node");
 213             return 0;
 214         }
 215         (void) wxDebugContext::SetTail (m_prev);
 216     } else {
 217         if (! m_next->AssertIt ()) {
 218             ErrorMsg ("Trashed next pointer");
 219             return 0;
 220         }
 221
 222         if (m_next->m_prev != this) {
 223             ErrorMsg ("List is inconsistent");
 224             return 0;
 225         }
 226         m_next->m_prev = m_prev;
 227     }
 228
 229     return 1;
 230 }
 231
 232
 233
 234 /*
 235   Checks a node and block of memory to see that the markers are still
 236   intact.
 237 */
 238 int wxMemStruct::CheckBlock ()
 239 {
 240     int nFailures = 0;
 241
 242     if (m_firstMarker != MemStartCheck) {
 243         nFailures++;
 244         ErrorMsg ();
 245     }
 246
 247     char * pointer = wxDebugContext::MidMarkerPos ((char *) this);
 248     if (* (wxMarkerType *) pointer != MemMidCheck) {
 249         nFailures++;
 250         ErrorMsg ();
 251     }
 252
 253     pointer = wxDebugContext::EndMarkerPos ((char *) this, RequestSize ());
 254     if (* (wxMarkerType *) pointer != MemEndCheck) {
 255         nFailures++;
 256         ErrorMsg ();
 257     }
 258
 259     return nFailures;
 260 }
 261
 262
 263 /*
 264   Check the list of nodes to see if they are all ok.
 265 */
 266 int wxMemStruct::CheckAllPrevious ()
 267 {
 268     int nFailures = 0;
 269
 270     for (wxMemStruct * st = this->m_prev; st != 0; st = st->m_prev) {
 271         if (st->AssertIt ())
 272             nFailures += st->CheckBlock ();
 273         else
 274             return -1;
 275     }
 276
 277     return nFailures;
 278 }
 279
 280
 281 /*
 282   When we delete a node we set the id slot to a specific value and then test
 283   against this to see if a nodes have been deleted previously. I don't
 284   just set the entire memory to the fillChar because then I'd be overwriting
 285   useful stuff like the vtbl which may be needed to output the error message
 286   including the file name and line numbers. Without this info the whole point
 287   of this class is lost!
 288 */
 289 void wxMemStruct::SetDeleted ()
 290 {
 291     m_id = MemFillChar;
 292 }
 293
 294 int wxMemStruct::IsDeleted ()
 295 {
 296     return (m_id == MemFillChar);
 297 }
 298
 299
 300 /*
 301   Print out a single node. There are many far better ways of doing this
 302   but this will suffice for now.
 303 */
 304 void wxMemStruct::PrintNode ()
 305 {
 306   if (m_isObject)
 307   {
 308     wxObject *obj = (wxObject *)m_actualData;
 309     wxClassInfo *info = obj->GetClassInfo();
 310
 311     // Let's put this in standard form so IDEs can load the file at the appropriate
 312     // line
 313     wxString msg;
 314
 315     if (m_fileName)
 316       msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum);
 317
 318     if (info && info->GetClassName())
 319       msg += info->GetClassName();
 320     else
 321       msg += wxT("object");
 322
 323     wxString msg2;
 324     msg2.Printf(wxT(" at 0x%lX, size %d"), (long)GetActualData(), (int)RequestSize());
 325     msg += msg2;
 326
 327     wxLogMessage(msg);
 328   }
 329   else
 330   {
 331     wxString msg;
 332
 333     if (m_fileName)
 334       msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum);
 335     msg += wxT("non-object data");
 336     wxString msg2;
 337     msg2.Printf(wxT(" at 0x%lX, size %d\n"), (long)GetActualData(), (int)RequestSize());
 338     msg += msg2;
 339
 340     wxLogMessage(msg);
 341   }
 342 }
 343
 344 void wxMemStruct::Dump ()
 345 {
 346   if (!ValidateNode()) return;
 347
 348   if (m_isObject)
 349   {
 350     wxObject *obj = (wxObject *)m_actualData;
 351
 352     wxString msg;
 353     if (m_fileName)
 354       msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum);
 355
 356
 357     /* TODO: We no longer have a stream (using wxLogDebug) so we can't dump it.
 358      * Instead, do what wxObject::Dump does.
 359      * What should we do long-term, eliminate Dumping? Or specify
 360      * that MyClass::Dump should use wxLogDebug? Ugh.
 361     obj->Dump(wxDebugContext::GetStream());
 362      */
 363
 364     if (obj->GetClassInfo() && obj->GetClassInfo()->GetClassName())
 365       msg += obj->GetClassInfo()->GetClassName();
 366     else
 367       msg += wxT("unknown object class");
 368
 369     wxString msg2;
 370     msg2.Printf(wxT(" at 0x%lX, size %d"), (long)GetActualData(), (int)RequestSize());
 371     msg += msg2;
 372
 373     wxDebugContext::OutputDumpLine(msg.c_str());
 374   }
 375   else
 376   {
 377     wxString msg;
 378     if (m_fileName)
 379       msg.Printf(wxT("%s(%d): "), m_fileName, (int)m_lineNum);
 380
 381     wxString msg2;
 382     msg2.Printf(wxT("non-object data at 0x%lX, size %d"), (long)GetActualData(), (int)RequestSize() );
 383     msg += msg2;
 384     wxDebugContext::OutputDumpLine(msg.c_str());
 385   }
 386 }
 387
 388
 389 /*
 390   Validate a node. Check to see that the node is "clean" in the sense
 391   that nothing has over/underwritten it etc.
 392 */
 393 int wxMemStruct::ValidateNode ()
 394 {
 395     char * startPointer = (char *) this;
 396     if (!AssertIt ()) {
 397         if (IsDeleted ())
 398             ErrorMsg ("Object already deleted");
 399         else {
 400             // Can't use the error routines as we have no recognisable object.
 401 #ifndef __WXGTK__
 402              wxLogMessage(wxT("Can't verify memory struct - all bets are off!"));
 403 #endif
 404         }
 405         return 0;
 406     }
 407
 408 /*
 409     int i;
 410     for (i = 0; i < wxDebugContext::TotSize (requestSize ()); i++)
 411       cout << startPointer [i];
 412     cout << endl;
 413 */
 414     if (Marker () != MemStartCheck)
 415       ErrorMsg ();
 416     if (* (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer) != MemMidCheck)
 417       ErrorMsg ();
 418     if (* (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer,
 419                                               RequestSize ()) !=
 420         MemEndCheck)
 421       ErrorMsg ();
 422
 423     // Back to before the extra buffer and check that
 424     // we can still read what we originally wrote.
 425     if (Marker () != MemStartCheck ||
 426         * (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer)
 427                          != MemMidCheck ||
 428         * (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer,
 429                                               RequestSize ()) != MemEndCheck)
 430     {
 431         ErrorMsg ();
 432         return 0;
 433     }
 434
 435     return 1;
 436 }
 437
 438 /*
 439   The wxDebugContext class.
 440 */
 441
 442 wxMemStruct *wxDebugContext::m_head = NULL;
 443 wxMemStruct *wxDebugContext::m_tail = NULL;
 444
 445 bool wxDebugContext::m_checkPrevious = false;
 446 int wxDebugContext::debugLevel = 1;
 447 bool wxDebugContext::debugOn = true;
 448 wxMemStruct *wxDebugContext::checkPoint = NULL;
 449
 450 // For faster alignment calculation
 451 static wxMarkerType markerCalc[2];
 452 int wxDebugContext::m_balign = (int)((char *)&markerCalc[1] - (char*)&markerCalc[0]);
 453 int wxDebugContext::m_balignmask = (int)((char *)&markerCalc[1] - (char*)&markerCalc[0]) - 1;
 454
 455 // Pointer to global function to call at shutdown
 456 wxShutdownNotifyFunction wxDebugContext::sm_shutdownFn;
 457
 458 wxDebugContext::wxDebugContext(void)
 459 {
 460 }
 461
 462 wxDebugContext::~wxDebugContext(void)
 463 {
 464 }
 465
 466 /*
 467   Work out the positions of the markers by creating an array of 2 markers
 468   and comparing the addresses of the 2 elements. Use this number as the
 469   alignment for markers.
 470 */
 471 size_t wxDebugContext::CalcAlignment ()
 472 {
 473     wxMarkerType ar[2];
 474     return (char *) &ar[1] - (char *) &ar[0];
 475 }
 476
 477
 478 char * wxDebugContext::StructPos (const char * buf)
 479 {
 480     return (char *) buf;
 481 }
 482
 483 char * wxDebugContext::MidMarkerPos (const char * buf)
 484 {
 485     return StructPos (buf) + PaddedSize (sizeof (wxMemStruct));
 486 }
 487
 488 char * wxDebugContext::CallerMemPos (const char * buf)
 489 {
 490     return MidMarkerPos (buf) + PaddedSize (sizeof(wxMarkerType));
 491 }
 492
 493
 494 char * wxDebugContext::EndMarkerPos (const char * buf, const size_t size)
 495 {
 496     return CallerMemPos (buf) + PaddedSize (size);
 497 }
 498
 499
 500 /*
 501   Slightly different as this takes a pointer to the start of the caller
 502   requested region and returns a pointer to the start of the buffer.
 503   */
 504 char * wxDebugContext::StartPos (const char * caller)
 505 {
 506     return ((char *) (caller - wxDebugContext::PaddedSize (sizeof(wxMarkerType)) -
 507             wxDebugContext::PaddedSize (sizeof (wxMemStruct))));
 508 }
 509
 510 /*
 511   We may need padding between various parts of the allocated memory.
 512   Given a size of memory, this returns the amount of memory which should
 513   be allocated in order to allow for alignment of the following object.
 514
 515   I don't know how portable this stuff is, but it seems to work for me at
 516   the moment. It would be real nice if I knew more about this!
 517
 518   // Note: this function is now obsolete (along with CalcAlignment)
 519   // because the calculations are done statically, for greater speed.
 520 */
 521 size_t wxDebugContext::GetPadding (const size_t size)
 522 {
 523     size_t pad = size % CalcAlignment ();
 524     return (pad) ? sizeof(wxMarkerType) - pad : 0;
 525 }
 526
 527 size_t wxDebugContext::PaddedSize (const size_t size)
 528 {
 529     // Added by Terry Farnham <TJRT@pacbell.net> to replace
 530     // slow GetPadding call.
 531     int padb;
 532
 533     padb = size & m_balignmask;
 534     if(padb)
 535         return(size + m_balign - padb);
 536     else
 537         return(size);
 538 }
 539
 540 /*
 541   Returns the total amount of memory which we need to get from the system
 542   in order to satisfy a caller request. This includes space for the struct
 543   plus markers and the caller's memory as well.
 544 */
 545 size_t wxDebugContext::TotSize (const size_t reqSize)
 546 {
 547     return (PaddedSize (sizeof (wxMemStruct)) + PaddedSize (reqSize) +
 548             2 * sizeof(wxMarkerType));
 549 }
 550
 551
 552 /*
 553   Traverse the list of nodes executing the given function on each node.
 554 */
 555 void wxDebugContext::TraverseList (PmSFV func, wxMemStruct *from)
 556 {
 557   if (!from)
 558     from = wxDebugContext::GetHead ();
 559
 560   wxMemStruct * st = NULL;
 561   for (st = from; st != 0; st = st->m_next)
 562   {
 563       void* data = st->GetActualData();
 564 //      if ((data != (void*)m_debugStream) && (data != (void*) m_streamBuf))
 565       if (data != (void*) wxLog::GetActiveTarget())
 566       {
 567         (st->*func) ();
 568       }
 569   }
 570 }
 571
 572
 573 /*
 574   Print out the list.
 575   */
 576 bool wxDebugContext::PrintList (void)
 577 {
 578   TraverseList ((PmSFV)&wxMemStruct::PrintNode, (checkPoint ? checkPoint->m_next : NULL));
 579
 580   return true;
 581 }
 582
 583 bool wxDebugContext::Dump(void)
 584 {
 585   {
 586     const wxChar* appName = wxT("application");
 587     wxString appNameStr;
 588     if (wxTheApp)
 589     {
 590         appNameStr = wxTheApp->GetAppName();
 591         appName = appNameStr.c_str();
 592         OutputDumpLine(wxT("----- Memory dump of %s at %s -----"), appName, static_cast<const wxChar *>(wxNow().c_str()));
 593     }
 594     else
 595     {
 596       OutputDumpLine( wxT("----- Memory dump -----") );
 597     }
 598   }
 599
 600   TraverseList ((PmSFV)&wxMemStruct::Dump, (checkPoint ? checkPoint->m_next : NULL));
 601
 602   OutputDumpLine(wxEmptyString);
 603   OutputDumpLine(wxEmptyString);
 604
 605   return true;
 606 }
 607
 608 struct wxDebugStatsStruct
 609 {
 610   long instanceCount;
 611   long totalSize;
 612   wxChar *instanceClass;
 613   wxDebugStatsStruct *next;
 614 };
 615
 616 static wxDebugStatsStruct *FindStatsStruct(wxDebugStatsStruct *st, wxChar *name)
 617 {
 618   while (st)
 619   {
 620     if (wxStrcmp(st->instanceClass, name) == 0)
 621       return st;
 622     st = st->next;
 623   }
 624   return NULL;
 625 }
 626
 627 static wxDebugStatsStruct *InsertStatsStruct(wxDebugStatsStruct *head, wxDebugStatsStruct *st)
 628 {
 629   st->next = head;
 630   return st;
 631 }
 632
 633 bool wxDebugContext::PrintStatistics(bool detailed)
 634 {
 635   {
 636     const wxChar* appName = wxT("application");
 637     wxString appNameStr;
 638     if (wxTheApp)
 639     {
 640         appNameStr = wxTheApp->GetAppName();
 641         appName = appNameStr.c_str();
 642         OutputDumpLine(wxT("----- Memory statistics of %s at %s -----"), appName, static_cast<const wxChar *>(wxNow().c_str()));
 643     }
 644     else
 645     {
 646       OutputDumpLine( wxT("----- Memory statistics -----") );
 647     }
 648   }
 649
 650   bool currentMode = GetDebugMode();
 651   SetDebugMode(false);
 652
 653   long noNonObjectNodes = 0;
 654   long noObjectNodes = 0;
 655   long totalSize = 0;
 656
 657   wxDebugStatsStruct *list = NULL;
 658
 659   wxMemStruct *from = (checkPoint ? checkPoint->m_next : NULL );
 660   if (!from)
 661     from = wxDebugContext::GetHead ();
 662
 663   wxMemStruct *st;
 664   for (st = from; st != 0; st = st->m_next)
 665   {
 666     void* data = st->GetActualData();
 667     if (detailed && (data != (void*) wxLog::GetActiveTarget()))
 668     {
 669       wxChar *className = (wxChar*) wxT("nonobject");
 670       if (st->m_isObject && st->GetActualData())
 671       {
 672         wxObject *obj = (wxObject *)st->GetActualData();
 673         if (obj->GetClassInfo()->GetClassName())
 674           className = (wxChar*)obj->GetClassInfo()->GetClassName();
 675       }
 676       wxDebugStatsStruct *stats = FindStatsStruct(list, className);
 677       if (!stats)
 678       {
 679         stats = (wxDebugStatsStruct *)malloc(sizeof(wxDebugStatsStruct));
 680         stats->instanceClass = className;
 681         stats->instanceCount = 0;
 682         stats->totalSize = 0;
 683         list = InsertStatsStruct(list, stats);
 684       }
 685       stats->instanceCount ++;
 686       stats->totalSize += st->RequestSize();
 687     }
 688
 689     if (data != (void*) wxLog::GetActiveTarget())
 690     {
 691         totalSize += st->RequestSize();
 692         if (st->m_isObject)
 693             noObjectNodes ++;
 694         else
 695             noNonObjectNodes ++;
 696     }
 697   }
 698
 699   if (detailed)
 700   {
 701     while (list)
 702     {
 703       OutputDumpLine(wxT("%ld objects of class %s, total size %ld"),
 704           list->instanceCount, list->instanceClass, list->totalSize);
 705       wxDebugStatsStruct *old = list;
 706       list = old->next;
 707       free((char *)old);
 708     }
 709     OutputDumpLine(wxEmptyString);
 710   }
 711
 712   SetDebugMode(currentMode);
 713
 714   OutputDumpLine(wxT("Number of object items: %ld"), noObjectNodes);
 715   OutputDumpLine(wxT("Number of non-object items: %ld"), noNonObjectNodes);
 716   OutputDumpLine(wxT("Total allocated size: %ld"), totalSize);
 717   OutputDumpLine(wxEmptyString);
 718   OutputDumpLine(wxEmptyString);
 719
 720   return true;
 721 }
 722
 723 bool wxDebugContext::PrintClasses(void)
 724 {
 725   {
 726     const wxChar* appName = wxT("application");
 727     wxString appNameStr;
 728     if (wxTheApp)
 729     {
 730         appNameStr = wxTheApp->GetAppName();
 731         appName = appNameStr.c_str();
 732         wxLogMessage(wxT("----- Classes in %s -----"), appName);
 733     }
 734   }
 735
 736   int n = 0;
 737   const wxClassInfo *info;
 738
 739   for (wxClassInfo::const_iterator node = wxClassInfo::begin_classinfo(),
 740                                     end = wxClassInfo::end_classinfo();
 741        node != end; ++node)
 742   {
 743     info = *node;
 744     if (info->GetClassName())
 745     {
 746         wxString msg(info->GetClassName());
 747         msg += wxT(" ");
 748
 749         if (info->GetBaseClassName1() && !info->GetBaseClassName2())
 750         {
 751             msg += wxT("is a ");
 752             msg += info->GetBaseClassName1();
 753         }
 754         else if (info->GetBaseClassName1() && info->GetBaseClassName2())
 755         {
 756             msg += wxT("is a ");
 757             msg += info->GetBaseClassName1() ;
 758             msg += wxT(", ");
 759             msg += info->GetBaseClassName2() ;
 760         }
 761         if (info->GetConstructor())
 762             msg += wxT(": dynamic");
 763
 764         wxLogMessage(msg);
 765     }
 766     n ++;
 767   }
 768   wxLogMessage(wxEmptyString);
 769   wxLogMessage(wxT("There are %d classes derived from wxObject."), n);
 770   wxLogMessage(wxEmptyString);
 771   wxLogMessage(wxEmptyString);
 772   return true;
 773 }
 774
 775 void wxDebugContext::SetCheckpoint(bool all)
 776 {
 777   if (all)
 778     checkPoint = NULL;
 779   else
 780     checkPoint = m_tail;
 781 }
 782
 783 // Checks all nodes since checkpoint, or since start.
 784 int wxDebugContext::Check(bool checkAll)
 785 {
 786   int nFailures = 0;
 787
 788   wxMemStruct *from = (checkPoint ? checkPoint->m_next : NULL );
 789   if (!from || checkAll)
 790     from = wxDebugContext::GetHead ();
 791
 792   for (wxMemStruct * st = from; st != 0; st = st->m_next)
 793   {
 794     if (st->AssertIt ())
 795       nFailures += st->CheckBlock ();
 796     else
 797       return -1;
 798   }
 799
 800   return nFailures;
 801 }
 802
 803 // Count the number of non-wxDebugContext-related objects
 804 // that are outstanding
 805 int wxDebugContext::CountObjectsLeft(bool sinceCheckpoint)
 806 {
 807   int n = 0;
 808
 809   wxMemStruct *from = NULL;
 810   if (sinceCheckpoint && checkPoint)
 811     from = checkPoint->m_next;
 812   else
 813     from = wxDebugContext::GetHead () ;
 814
 815   for (wxMemStruct * st = from; st != 0; st = st->m_next)
 816   {
 817       void* data = st->GetActualData();
 818       if (data != (void*) wxLog::GetActiveTarget())
 819           n ++;
 820   }
 821
 822   return n ;
 823 }
 824
 825 // This function is used to output the dump
 826 void wxDebugContext::OutputDumpLine(const wxChar *szFormat, ...)
 827 {
 828     // a buffer of 2048 bytes should be long enough for a file name
 829     // and a class name
 830     wxChar buf[2048];
 831     int count;
 832     va_list argptr;
 833     va_start(argptr, szFormat);
 834     buf[sizeof(buf)/sizeof(wxChar)-1] = _T('\0');
 835
 836     // keep 3 bytes for a \r\n\0
 837     count = wxVsnprintf(buf, sizeof(buf)/sizeof(wxChar)-3, szFormat, argptr);
 838
 839     if ( count < 0 )
 840         count = sizeof(buf)/sizeof(wxChar)-3;
 841     buf[count]=_T('\r');
 842     buf[count+1]=_T('\n');
 843     buf[count+2]=_T('\0');
 844
 845     wxMessageOutputDebug dbgout;
 846     dbgout.Printf(buf);
 847 }
 848
 849 void wxDebugContext::SetShutdownNotifyFunction(wxShutdownNotifyFunction shutdownFn)
 850 {
 851     sm_shutdownFn = shutdownFn;
 852 }
 853
 854
 855 #if USE_THREADSAFE_MEMORY_ALLOCATION
 856 static bool memSectionOk = false;
 857
 858 class MemoryCriticalSection : public wxCriticalSection
 859 {
 860 public:
 861     MemoryCriticalSection() {
 862         memSectionOk = true;
 863     }
 864     ~MemoryCriticalSection() {
 865         memSectionOk = false;
 866     }
 867 };
 868
 869 class MemoryCriticalSectionLocker
 870 {
 871 public:
 872     inline MemoryCriticalSectionLocker(wxCriticalSection& critsect)
 873     : m_critsect(critsect), m_locked(memSectionOk) { if(m_locked) m_critsect.Enter(); }
 874     inline ~MemoryCriticalSectionLocker() { if(m_locked) m_critsect.Leave(); }
 875
 876 private:
 877     // no assignment operator nor copy ctor
 878     MemoryCriticalSectionLocker(const MemoryCriticalSectionLocker&);
 879     MemoryCriticalSectionLocker& operator=(const MemoryCriticalSectionLocker&);
 880
 881     wxCriticalSection& m_critsect;
 882     bool m_locked;
 883 };
 884
 885 static MemoryCriticalSection memLocker;
 886
 887 #endif // USE_THREADSAFE_MEMORY_ALLOCATION
 888
 889
 890 #if !(defined(__WXMSW__) && (defined(WXUSINGDLL) || defined(WXMAKINGDLL_BASE)))
 891 #if wxUSE_GLOBAL_MEMORY_OPERATORS
 892 void * operator new (size_t size, wxChar * fileName, int lineNum)
 893 {
 894     return wxDebugAlloc(size, fileName, lineNum, false, false);
 895 }
 896
 897 void * operator new (size_t size)
 898 {
 899     return wxDebugAlloc(size, NULL, 0, false);
 900 }
 901
 902 void operator delete (void * buf)
 903 {
 904     wxDebugFree(buf, false);
 905 }
 906
 907 #if wxUSE_ARRAY_MEMORY_OPERATORS
 908 void * operator new[] (size_t size)
 909 {
 910     return wxDebugAlloc(size, NULL, 0, false, true);
 911 }
 912
 913 void * operator new[] (size_t size, wxChar * fileName, int lineNum)
 914 {
 915     return wxDebugAlloc(size, fileName, lineNum, false, true);
 916 }
 917
 918 void operator delete[] (void * buf)
 919 {
 920   wxDebugFree(buf, true);
 921 }
 922 #endif // wxUSE_ARRAY_MEMORY_OPERATORS
 923 #endif // wxUSE_GLOBAL_MEMORY_OPERATORS
 924 #endif // !(defined(__WXMSW__) && (defined(WXUSINGDLL) || defined(WXMAKINGDLL_BASE)))
 925
 926 // TODO: store whether this is a vector or not.
 927 void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool WXUNUSED(isVect) )
 928 {
 929 #if USE_THREADSAFE_MEMORY_ALLOCATION
 930   MemoryCriticalSectionLocker lock(memLocker);
 931 #endif
 932
 933   // If not in debugging allocation mode, do the normal thing
 934   // so we don't leave any trace of ourselves in the node list.
 935
 936 #if defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )
 937 // VA 3.0 still has trouble in here
 938   return (void *)malloc(size);
 939 #endif
 940   if (!wxDebugContext::GetDebugMode())
 941   {
 942     return (void *)malloc(size);
 943   }
 944
 945     int totSize = wxDebugContext::TotSize (size);
 946     char * buf = (char *) malloc(totSize);
 947     if (!buf) {
 948         wxLogMessage(wxT("Call to malloc (%ld) failed."), (long)size);
 949         return 0;
 950     }
 951     wxMemStruct * st = (wxMemStruct *)buf;
 952     st->m_firstMarker = MemStartCheck;
 953     st->m_reqSize = size;
 954     st->m_fileName = fileName;
 955     st->m_lineNum = lineNum;
 956     st->m_id = MemStructId;
 957     st->m_prev = 0;
 958     st->m_next = 0;
 959     st->m_isObject = isObject;
 960
 961     // Errors from Append() shouldn't really happen - but just in case!
 962     if (st->Append () == 0) {
 963         st->ErrorMsg ("Trying to append new node");
 964     }
 965
 966     if (wxDebugContext::GetCheckPrevious ()) {
 967         if (st->CheckAllPrevious () < 0) {
 968             st->ErrorMsg ("Checking previous nodes");
 969         }
 970     }
 971
 972     // Set up the extra markers at the middle and end.
 973     char * ptr = wxDebugContext::MidMarkerPos (buf);
 974     * (wxMarkerType *) ptr = MemMidCheck;
 975     ptr = wxDebugContext::EndMarkerPos (buf, size);
 976     * (wxMarkerType *) ptr = MemEndCheck;
 977
 978     // pointer returned points to the start of the caller's
 979     // usable area.
 980     void *m_actualData = (void *) wxDebugContext::CallerMemPos (buf);
 981     st->m_actualData = m_actualData;
 982
 983     return m_actualData;
 984 }
 985
 986 // TODO: check whether was allocated as a vector
 987 void wxDebugFree(void * buf, bool WXUNUSED(isVect) )
 988 {
 989 #if USE_THREADSAFE_MEMORY_ALLOCATION
 990   MemoryCriticalSectionLocker lock(memLocker);
 991 #endif
 992
 993   if (!buf)
 994     return;
 995
 996 #if defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )
 997 // VA 3.0 still has trouble in here
 998   free((char *)buf);
 999 #endif
1000   // If not in debugging allocation mode, do the normal thing
1001   // so we don't leave any trace of ourselves in the node list.
1002   if (!wxDebugContext::GetDebugMode())
1003   {
1004     free((char *)buf);
1005     return;
1006   }
1007
1008     // Points to the start of the entire allocated area.
1009     char * startPointer = wxDebugContext::StartPos ((char *) buf);
1010     // Find the struct and make sure that it's identifiable.
1011     wxMemStruct * st = (wxMemStruct *) wxDebugContext::StructPos (startPointer);
1012
1013     if (! st->ValidateNode ())
1014         return;
1015
1016     // If this is the current checkpoint, we need to
1017     // move the checkpoint back so it points to a valid
1018     // node.
1019     if (st == wxDebugContext::checkPoint)
1020       wxDebugContext::checkPoint = wxDebugContext::checkPoint->m_prev;
1021
1022     if (! st->Unlink ())
1023     {
1024       st->ErrorMsg ("Unlinking deleted node");
1025     }
1026
1027     // Now put in the fill char into the id slot and the caller requested
1028     // memory locations.
1029     st->SetDeleted ();
1030     (void) memset (wxDebugContext::CallerMemPos (startPointer), MemFillChar,
1031                    st->RequestSize ());
1032
1033     free((char *)st);
1034 }
1035
1036 // Trace: send output to the current debugging stream
1037 void wxTrace(const wxChar * ...)
1038 {
1039 #if 1
1040     wxFAIL_MSG(wxT("wxTrace is now obsolete. Please use wxDebugXXX instead."));
1041 #else
1042     va_list ap;
1043   static wxChar buffer[512];
1044
1045   va_start(ap, fmt);
1046
1047 #ifdef __WXMSW__
1048   wvsprintf(buffer,fmt,ap) ;
1049 #else
1050   vsprintf(buffer,fmt,ap) ;
1051 #endif
1052
1053   va_end(ap);
1054
1055   if (wxDebugContext::HasStream())
1056   {
1057     wxDebugContext::GetStream() << buffer;
1058     wxDebugContext::GetStream().flush();
1059   }
1060   else
1061 #ifdef __WXMSW__
1062 #ifdef __WIN32__
1063     OutputDebugString((LPCTSTR)buffer) ;
1064 #else
1065     OutputDebugString((const char*) buffer) ;
1066 #endif
1067 #else
1068     fprintf(stderr, buffer);
1069 #endif
1070 #endif
1071 }
1072
1073 // Trace with level
1074 void wxTraceLevel(int, const wxChar * ...)
1075 {
1076 #if 1
1077     wxFAIL_MSG(wxT("wxTrace is now obsolete. Please use wxDebugXXX instead."));
1078 #else
1079   if (wxDebugContext::GetLevel() < level)
1080     return;
1081
1082   va_list ap;
1083   static wxChar buffer[512];
1084
1085   va_start(ap, fmt);
1086
1087 #ifdef __WXMSW__
1088   wxWvsprintf(buffer,fmt,ap) ;
1089 #else
1090   vsprintf(buffer,fmt,ap) ;
1091 #endif
1092
1093   va_end(ap);
1094
1095   if (wxDebugContext::HasStream())
1096   {
1097     wxDebugContext::GetStream() << buffer;
1098     wxDebugContext::GetStream().flush();
1099   }
1100   else
1101 #ifdef __WXMSW__
1102 #ifdef __WIN32__
1103     OutputDebugString((LPCTSTR)buffer) ;
1104 #else
1105     OutputDebugString((const char*) buffer) ;
1106 #endif
1107 #else
1108     fprintf(stderr, buffer);
1109 #endif
1110 #endif
1111 }
1112
1113 //----------------------------------------------------------------------------
1114 // Final cleanup after all global objects in all files have been destroyed
1115 //----------------------------------------------------------------------------
1116
1117 // Don't set it to 0 by dynamic initialization
1118 // Some compilers will really do the assignment later
1119 // All global variables are initialized to 0 at the very beginning, and this is just fine.
1120 int wxDebugContextDumpDelayCounter::sm_count;
1121
1122 wxDebugContextDumpDelayCounter::wxDebugContextDumpDelayCounter()
1123 {
1124     sm_count++;
1125 }
1126
1127 wxDebugContextDumpDelayCounter::~wxDebugContextDumpDelayCounter()
1128 {
1129     if ( !--sm_count )
1130     {
1131         // Notify app if we've been asked to do that
1132         if( wxDebugContext::sm_shutdownFn )
1133             wxDebugContext::sm_shutdownFn();
1134         DoDump();
1135     }
1136 }
1137
1138 void wxDebugContextDumpDelayCounter::DoDump()
1139 {
1140     if (wxDebugContext::CountObjectsLeft(true) > 0)
1141     {
1142         wxDebugContext::OutputDumpLine(wxT("There were memory leaks.\n"));
1143         wxDebugContext::Dump();
1144         wxDebugContext::PrintStatistics();
1145     }
1146 }
1147
1148 // Even if there is nothing else, make sure that there is at
1149 // least one cleanup counter object
1150 static wxDebugContextDumpDelayCounter wxDebugContextDumpDelayCounter_One;
1151
1152 #endif // wxUSE_MEMORY_TRACING || wxUSE_DEBUG_CONTEXT