]> git.saurik.com Git - wxWidgets.git/blob - src/common/memory.cpp
implement wxGTK wxBitmapButton in terms of wxButton
[wxWidgets.git] / 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