/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/memory.h
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/memory.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 5 months ago) by william
File MIME type: text/plain
File size: 11784 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/memory.h
3 // Purpose: Memory operations
4 // Author: Arthur Seaton, Julian Smart
5 // Modified by:
6 // Created: 29/01/98
7 // RCS-ID: $Id: memory.h 39634 2006-06-08 12:51:01Z ABX $
8 // Copyright: (c) 1998 Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_MEMORYH__
13 #define _WX_MEMORYH__
14
15 #include "wx/defs.h"
16 #include "wx/string.h"
17 #include "wx/msgout.h"
18
19 /*
20 The macro which will be expanded to include the file and line number
21 info, or to be a straight call to the new operator.
22 */
23
24 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
25
26 #include <stddef.h>
27
28 #ifdef __WXDEBUG__
29
30 WXDLLIMPEXP_BASE void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool isVect = false);
31 WXDLLIMPEXP_BASE void wxDebugFree(void * buf, bool isVect = false);
32
33 //**********************************************************************************
34 /*
35 The global operator new used for everything apart from getting
36 dynamic storage within this function itself.
37 */
38
39 // We'll only do malloc and free for the moment: leave the interesting
40 // stuff for the wxObject versions.
41
42
43 #if wxUSE_GLOBAL_MEMORY_OPERATORS
44
45 // Undefine temporarily (new is #defined in object.h) because we want to
46 // declare some new operators.
47 #ifdef new
48 #undef new
49 #endif
50
51 #if defined(__SUNCC__)
52 #define wxUSE_ARRAY_MEMORY_OPERATORS 0
53 #elif !( defined (__VISUALC__) && (__VISUALC__ <= 1020) ) || defined( __MWERKS__)
54 #define wxUSE_ARRAY_MEMORY_OPERATORS 1
55 #elif defined (__SGI_CC_)
56 // only supported by -n32 compilers
57 #ifndef __EDG_ABI_COMPATIBILITY_VERSION
58 #define wxUSE_ARRAY_MEMORY_OPERATORS 0
59 #endif
60 #elif !( defined (__VISUALC__) && (__VISUALC__ <= 1020) ) || defined( __MWERKS__)
61 #define wxUSE_ARRAY_MEMORY_OPERATORS 1
62 #else
63 // ::operator new[] is a recent C++ feature, so assume it's not supported
64 #define wxUSE_ARRAY_MEMORY_OPERATORS 0
65 #endif
66
67 // devik 2000-8-29: All new/delete ops are now inline because they can't
68 // be marked as dllexport/dllimport. It then leads to weird bugs when
69 // used on MSW as DLL
70 #if defined(__WXMSW__) && (defined(WXUSINGDLL) || defined(WXMAKINGDLL_BASE))
71 inline void * operator new (size_t size, wxChar * fileName, int lineNum)
72 {
73 return wxDebugAlloc(size, fileName, lineNum, false, false);
74 }
75
76 inline void * operator new (size_t size)
77 {
78 return wxDebugAlloc(size, NULL, 0, false);
79 }
80
81 inline void operator delete (void * buf)
82 {
83 wxDebugFree(buf, false);
84 }
85
86 #if wxUSE_ARRAY_MEMORY_OPERATORS
87 inline void * operator new[] (size_t size)
88 {
89 return wxDebugAlloc(size, NULL, 0, false, true);
90 }
91
92 inline void * operator new[] (size_t size, wxChar * fileName, int lineNum)
93 {
94 return wxDebugAlloc(size, fileName, lineNum, false, true);
95 }
96
97 inline void operator delete[] (void * buf)
98 {
99 wxDebugFree(buf, true);
100 }
101 #endif // wxUSE_ARRAY_MEMORY_OPERATORS
102
103 #else
104
105 void * operator new (size_t size, wxChar * fileName, int lineNum);
106
107 void * operator new (size_t size);
108
109 void operator delete (void * buf);
110
111 #if wxUSE_ARRAY_MEMORY_OPERATORS
112 void * operator new[] (size_t size);
113
114 void * operator new[] (size_t size, wxChar * fileName, int lineNum);
115
116 void operator delete[] (void * buf);
117 #endif // wxUSE_ARRAY_MEMORY_OPERATORS
118 #endif // defined(__WXMSW__) && (defined(WXUSINGDLL) || defined(WXMAKINGDLL_BASE))
119
120 // VC++ 6.0 and MWERKS
121 #if ( defined(__VISUALC__) && (__VISUALC__ >= 1200) ) || defined(__MWERKS__)
122 inline void operator delete(void* pData, wxChar* /* fileName */, int /* lineNum */)
123 {
124 wxDebugFree(pData, false);
125 }
126 inline void operator delete[](void* pData, wxChar* /* fileName */, int /* lineNum */)
127 {
128 wxDebugFree(pData, true);
129 }
130 #endif // __VISUALC__>=1200
131 #endif // wxUSE_GLOBAL_MEMORY_OPERATORS
132 #endif // __WXDEBUG__
133
134 //**********************************************************************************
135
136 typedef unsigned int wxMarkerType;
137
138 /*
139 Define the struct which will be placed at the start of all dynamically
140 allocated memory.
141 */
142
143 class WXDLLIMPEXP_BASE wxMemStruct {
144
145 friend class WXDLLIMPEXP_BASE wxDebugContext; // access to the m_next pointer for list traversal.
146
147 public:
148 public:
149 int AssertList ();
150
151 size_t RequestSize () { return m_reqSize; }
152 wxMarkerType Marker () { return m_firstMarker; }
153
154 // When an object is deleted we set the id slot to a specific value.
155 inline void SetDeleted ();
156 inline int IsDeleted ();
157
158 int Append ();
159 int Unlink ();
160
161 // Used to determine if the object is really a wxMemStruct.
162 // Not a foolproof test by any means, but better than none I hope!
163 int AssertIt ();
164
165 // Do all validation on a node.
166 int ValidateNode ();
167
168 // Check the integrity of a node and of the list, node by node.
169 int CheckBlock ();
170 int CheckAllPrevious ();
171
172 // Print a single node.
173 void PrintNode ();
174
175 // Called when the memory linking functions get an error.
176 void ErrorMsg (const char *);
177 void ErrorMsg ();
178
179 inline void *GetActualData(void) const { return m_actualData; }
180
181 void Dump(void);
182
183 public:
184 // Check for underwriting. There are 2 of these checks. This one
185 // inside the struct and another right after the struct.
186 wxMarkerType m_firstMarker;
187
188 // File name and line number are from cpp.
189 wxChar* m_fileName;
190 int m_lineNum;
191
192 // The amount of memory requested by the caller.
193 size_t m_reqSize;
194
195 // Used to try to verify that we really are dealing with an object
196 // of the required class. Can be 1 of 2 values these indicating a valid
197 // wxMemStruct object, or a deleted wxMemStruct object.
198 wxMarkerType m_id;
199
200 wxMemStruct * m_prev;
201 wxMemStruct * m_next;
202
203 void * m_actualData;
204 bool m_isObject;
205 };
206
207
208 typedef void (wxMemStruct::*PmSFV) ();
209
210
211 /*
212 Debugging class. This will only have a single instance, but it's
213 a reasonable way to keep everything together and to make this
214 available for change if needed by someone else.
215 A lot of this stuff would be better off within the wxMemStruct class, but
216 it's stuff which we need to access at times when there is no wxMemStruct
217 object so we use this class instead. Think of it as a collection of
218 globals which have to do with the wxMemStruct class.
219 */
220
221 class WXDLLIMPEXP_BASE wxDebugContext {
222
223 protected:
224 // Used to set alignment for markers.
225 static size_t CalcAlignment ();
226
227 // Returns the amount of padding needed after something of the given
228 // size. This is so that when we cast pointers backwards and forwards
229 // the pointer value will be valid for a wxMarkerType.
230 static size_t GetPadding (const size_t size) ;
231
232 // Traverse the list.
233 static void TraverseList (PmSFV, wxMemStruct *from = NULL);
234
235 static int debugLevel;
236 static bool debugOn;
237
238 static int m_balign; // byte alignment
239 static int m_balignmask; // mask for performing byte alignment
240 public:
241 // Set a checkpoint to dump only the memory from
242 // a given point
243 static wxMemStruct *checkPoint;
244
245 wxDebugContext(void);
246 ~wxDebugContext(void);
247
248 static int GetLevel(void) { return debugLevel; }
249 static void SetLevel(int level) { debugLevel = level; }
250
251 static bool GetDebugMode(void) { return debugOn; }
252 static void SetDebugMode(bool flag) { debugOn = flag; }
253
254 static void SetCheckpoint(bool all = false);
255 static wxMemStruct *GetCheckpoint(void) { return checkPoint; }
256
257 // Calculated from the request size and any padding needed
258 // before the final marker.
259 static size_t PaddedSize (const size_t reqSize);
260
261 // Calc the total amount of space we need from the system
262 // to satisfy a caller request. This includes all padding.
263 static size_t TotSize (const size_t reqSize);
264
265 // Return valid pointers to offsets within the allocated memory.
266 static char * StructPos (const char * buf);
267 static char * MidMarkerPos (const char * buf);
268 static char * CallerMemPos (const char * buf);
269 static char * EndMarkerPos (const char * buf, const size_t size);
270
271 // Given a pointer to the start of the caller requested area
272 // return a pointer to the start of the entire alloc\'d buffer.
273 static char * StartPos (const char * caller);
274
275 // Access to the list.
276 static wxMemStruct * GetHead () { return m_head; }
277 static wxMemStruct * GetTail () { return m_tail; }
278
279 // Set the list sentinals.
280 static wxMemStruct * SetHead (wxMemStruct * st) { return (m_head = st); }
281 static wxMemStruct * SetTail (wxMemStruct * st) { return (m_tail = st); }
282
283 // If this is set then every new operation checks the validity
284 // of the all previous nodes in the list.
285 static bool GetCheckPrevious () { return m_checkPrevious; }
286 static void SetCheckPrevious (bool value) { m_checkPrevious = value; }
287
288 // Checks all nodes, or all nodes if checkAll is true
289 static int Check(bool checkAll = false);
290
291 // Print out the list of wxMemStruct nodes.
292 static bool PrintList(void);
293
294 // Dump objects
295 static bool Dump(void);
296
297 // Print statistics
298 static bool PrintStatistics(bool detailed = true);
299
300 // Print out the classes in the application.
301 static bool PrintClasses(void);
302
303 // Count the number of non-wxDebugContext-related objects
304 // that are outstanding
305 static int CountObjectsLeft(bool sinceCheckpoint = false);
306
307 // This function is used to output the dump
308 static void OutputDumpLine(const wxChar *szFormat, ...);
309
310 private:
311 // Store these here to allow access to the list without
312 // needing to have a wxMemStruct object.
313 static wxMemStruct* m_head;
314 static wxMemStruct* m_tail;
315
316 // Set to false if we're not checking all previous nodes when
317 // we do a new. Set to true when we are.
318 static bool m_checkPrevious;
319 };
320
321 // Final cleanup (e.g. deleting the log object and doing memory leak checking)
322 // will be delayed until all wxDebugContextDumpDelayCounter objects have been
323 // destructed. Adding one wxDebugContextDumpDelayCounter per file will delay
324 // memory leak checking until after destructing all global objects.
325 class WXDLLIMPEXP_BASE wxDebugContextDumpDelayCounter
326 {
327 public:
328 wxDebugContextDumpDelayCounter() {
329 sm_count++;
330 }
331
332 ~wxDebugContextDumpDelayCounter() {
333 sm_count--;
334 if(!sm_count) DoDump();
335 }
336 private:
337 void DoDump();
338 static int sm_count;
339 };
340
341 // make leak dump after all globals have been destructed
342 static wxDebugContextDumpDelayCounter wxDebugContextDumpDelayCounter_File;
343 #define WXDEBUG_DUMPDELAYCOUNTER \
344 static wxDebugContextDumpDelayCounter wxDebugContextDumpDelayCounter_Extra;
345
346 // Output a debug message, in a system dependent fashion.
347 void WXDLLIMPEXP_BASE wxTrace(const wxChar *fmt ...) ATTRIBUTE_PRINTF_1;
348 void WXDLLIMPEXP_BASE wxTraceLevel(int level, const wxChar *fmt ...) ATTRIBUTE_PRINTF_2;
349
350 #define WXTRACE wxTrace
351 #define WXTRACELEVEL wxTraceLevel
352
353 #else // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
354
355 #define WXDEBUG_DUMPDELAYCOUNTER
356
357 // Borland C++ Builder 6 seems to have troubles with inline functions (see bug
358 // 819700)
359 #if 0
360 inline void wxTrace(const wxChar *WXUNUSED(fmt)) {}
361 inline void wxTraceLevel(int WXUNUSED(level), const wxChar *WXUNUSED(fmt)) {}
362 #else
363 #define wxTrace(fmt)
364 #define wxTraceLevel(l, fmt)
365 #endif
366
367 #define WXTRACE true ? (void)0 : wxTrace
368 #define WXTRACELEVEL true ? (void)0 : wxTraceLevel
369
370 #endif // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
371
372 #endif
373 // _WX_MEMORYH__

  ViewVC Help
Powered by ViewVC 1.1.22