src/common/memory.cpp

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