]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: memory.h | |
3 | // Purpose: MDI classes | |
4 | // Author: Arthur Seaton, Julian Smart | |
5 | // Modified by: | |
6 | // Created: 29/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998 Julian Smart | |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_MEMORYH__ | |
13 | #define _WX_MEMORYH__ | |
14 | ||
15 | #ifdef __GNUG__ | |
16 | #pragma interface "memory.h" | |
17 | #endif | |
18 | ||
19 | #include "wx/defs.h" | |
20 | #include "wx/string.h" | |
21 | ||
22 | /* | |
23 | The macro which will be expanded to include the file and line number | |
24 | info, or to be a straight call to the new operator. | |
25 | */ | |
26 | ||
27 | #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT | |
28 | ||
29 | #include <stddef.h> | |
30 | ||
31 | #if wxUSE_IOSTREAMH | |
32 | // N.B. BC++ doesn't have istream.h, ostream.h | |
33 | # include <iostream.h> | |
34 | #else | |
35 | # include <ostream> | |
36 | # if defined(__VISUALC__) || defined(__MWERKS__) | |
37 | using namespace std; | |
38 | # endif | |
39 | #endif | |
40 | ||
41 | #ifdef __WXDEBUG__ | |
42 | ||
43 | void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool isVect = FALSE); | |
44 | void wxDebugFree(void * buf, bool isVect = FALSE); | |
45 | ||
46 | // Global versions of the new and delete operators. | |
47 | #if wxUSE_GLOBAL_MEMORY_OPERATORS | |
48 | ||
49 | // Undefine temporarily (new is #defined in object.h) because we want to | |
50 | // declare some new operators. | |
51 | #ifdef new | |
52 | #undef new | |
53 | #endif | |
54 | ||
55 | #if defined(__SUNCC__) | |
56 | #define wxUSE_ARRAY_MEMORY_OPERATORS 0 | |
57 | #elif !( defined (__VISUALC__) && (__VISUALC__ <= 1020) ) || defined( __MWERKS__) | |
58 | #define wxUSE_ARRAY_MEMORY_OPERATORS 1 | |
59 | #elif defined (__SGI_CC_) | |
60 | // only supported by -n32 compilers | |
61 | #ifndef __EDG_ABI_COMPATIBILITY_VERSION | |
62 | #define wxUSE_ARRAY_MEMORY_OPERATORS 0 | |
63 | #endif | |
64 | #else | |
65 | // ::operator new[] is a recent C++ feature, so assume it's not supported | |
66 | #define wxUSE_ARRAY_MEMORY_OPERATORS 0 | |
67 | #endif | |
68 | ||
69 | // Added JACS 25/11/98: needed for some compilers | |
70 | void * operator new (size_t size); | |
71 | void * operator new (size_t size, wxChar * fileName, int lineNum); | |
72 | #if !defined(__VISAGECPP__) | |
73 | void operator delete (void * buf); | |
74 | #endif | |
75 | ||
76 | #if wxUSE_ARRAY_MEMORY_OPERATORS | |
77 | void * operator new[] (size_t size); | |
78 | void * operator new[] (size_t size, wxChar * fileName, int lineNum); | |
79 | void operator delete[] (void * buf); | |
80 | #endif | |
81 | ||
82 | // VC++ 6.0 | |
83 | #if defined(__VISUALC__) && (__VISUALC__ >= 1200) | |
84 | void operator delete(void *buf, wxChar*, int); | |
85 | void operator delete[](void *buf, wxChar*, int); | |
86 | #endif | |
87 | ||
88 | #endif | |
89 | // wxUSE_GLOBAL_MEMORY_OPERATORS | |
90 | #endif | |
91 | // __WXDEBUG__ | |
92 | ||
93 | typedef unsigned int wxMarkerType; | |
94 | ||
95 | /* | |
96 | Define the struct which will be placed at the start of all dynamically | |
97 | allocated memory. | |
98 | */ | |
99 | ||
100 | class WXDLLEXPORT wxMemStruct { | |
101 | ||
102 | friend class WXDLLEXPORT wxDebugContext; // access to the m_next pointer for list traversal. | |
103 | ||
104 | public: | |
105 | public: | |
106 | int AssertList (); | |
107 | ||
108 | size_t RequestSize () { return m_reqSize; } | |
109 | wxMarkerType Marker () { return m_firstMarker; } | |
110 | ||
111 | // When an object is deleted we set the id slot to a specific value. | |
112 | inline void SetDeleted (); | |
113 | inline int IsDeleted (); | |
114 | ||
115 | int Append (); | |
116 | int Unlink (); | |
117 | ||
118 | // Used to determine if the object is really a wxMemStruct. | |
119 | // Not a foolproof test by any means, but better than none I hope! | |
120 | int AssertIt (); | |
121 | ||
122 | // Do all validation on a node. | |
123 | int ValidateNode (); | |
124 | ||
125 | // Check the integrity of a node and of the list, node by node. | |
126 | int CheckBlock (); | |
127 | int CheckAllPrevious (); | |
128 | ||
129 | // Print a single node. | |
130 | void PrintNode (); | |
131 | ||
132 | // Called when the memory linking functions get an error. | |
133 | void ErrorMsg (const char *); | |
134 | void ErrorMsg (); | |
135 | ||
136 | inline void *GetActualData(void) const { return m_actualData; } | |
137 | ||
138 | void Dump(void); | |
139 | ||
140 | public: | |
141 | // Check for underwriting. There are 2 of these checks. This one | |
142 | // inside the struct and another right after the struct. | |
143 | wxMarkerType m_firstMarker; | |
144 | ||
145 | // File name and line number are from cpp. | |
146 | wxChar* m_fileName; | |
147 | int m_lineNum; | |
148 | ||
149 | // The amount of memory requested by the caller. | |
150 | size_t m_reqSize; | |
151 | ||
152 | // Used to try to verify that we really are dealing with an object | |
153 | // of the required class. Can be 1 of 2 values these indicating a valid | |
154 | // wxMemStruct object, or a deleted wxMemStruct object. | |
155 | wxMarkerType m_id; | |
156 | ||
157 | wxMemStruct * m_prev; | |
158 | wxMemStruct * m_next; | |
159 | ||
160 | void * m_actualData; | |
161 | bool m_isObject; | |
162 | }; | |
163 | ||
164 | ||
165 | typedef void (wxMemStruct::*PmSFV) (); | |
166 | ||
167 | ||
168 | /* | |
169 | Debugging class. This will only have a single instance, but it\'s | |
170 | a reasonable way to keep everything together and to make this | |
171 | available for change if needed by someone else. | |
172 | A lot of this stuff would be better off within the wxMemStruct class, but | |
173 | it\'s stuff which we need to access at times when there is no wxMemStruct | |
174 | object so we use this class instead. Think of it as a collection of | |
175 | globals which have to do with the wxMemStruct class. | |
176 | */ | |
177 | ||
178 | class WXDLLEXPORT wxDebugContext { | |
179 | ||
180 | protected: | |
181 | // Used to set alignment for markers. | |
182 | static size_t CalcAlignment (); | |
183 | ||
184 | // Returns the amount of padding needed after something of the given | |
185 | // size. This is so that when we cast pointers backwards and forwards | |
186 | // the pointer value will be valid for a wxMarkerType. | |
187 | static size_t GetPadding (const size_t size) ; | |
188 | ||
189 | // Traverse the list. | |
190 | static void TraverseList (PmSFV, wxMemStruct *from = NULL); | |
191 | ||
192 | static streambuf *m_streamBuf; | |
193 | static ostream *m_debugStream; | |
194 | ||
195 | static int debugLevel; | |
196 | static bool debugOn; | |
197 | ||
198 | public: | |
199 | // Set a checkpoint to dump only the memory from | |
200 | // a given point | |
201 | static wxMemStruct *checkPoint; | |
202 | ||
203 | wxDebugContext(void); | |
204 | ~wxDebugContext(void); | |
205 | ||
206 | static bool HasStream(void) { return (m_debugStream != NULL); }; | |
207 | static ostream& GetStream(void) { return *m_debugStream; } | |
208 | static streambuf *GetStreamBuf(void) { return m_streamBuf; } | |
209 | static void SetStream(ostream *stream, streambuf *buf = NULL); | |
210 | static bool SetFile(const wxString& file); | |
211 | static bool SetStandardError(void); | |
212 | ||
213 | static int GetLevel(void) { return debugLevel; } | |
214 | static void SetLevel(int level) { debugLevel = level; } | |
215 | ||
216 | static bool GetDebugMode(void) { return debugOn; } | |
217 | static void SetDebugMode(bool flag) { debugOn = flag; } | |
218 | ||
219 | static void SetCheckpoint(bool all = FALSE); | |
220 | static wxMemStruct *GetCheckpoint(void) { return checkPoint; } | |
221 | ||
222 | // Calculated from the request size and any padding needed | |
223 | // before the final marker. | |
224 | static size_t PaddedSize (const size_t reqSize); | |
225 | ||
226 | // Calc the total amount of space we need from the system | |
227 | // to satisfy a caller request. This includes all padding. | |
228 | static size_t TotSize (const size_t reqSize); | |
229 | ||
230 | // Return valid pointers to offsets within the allocated memory. | |
231 | static char * StructPos (const char * buf); | |
232 | static char * MidMarkerPos (const char * buf); | |
233 | static char * CallerMemPos (const char * buf); | |
234 | static char * EndMarkerPos (const char * buf, const size_t size); | |
235 | ||
236 | // Given a pointer to the start of the caller requested area | |
237 | // return a pointer to the start of the entire alloc\'d buffer. | |
238 | static char * StartPos (const char * caller); | |
239 | ||
240 | // Access to the list. | |
241 | static wxMemStruct * GetHead () { return m_head; } | |
242 | static wxMemStruct * GetTail () { return m_tail; } | |
243 | ||
244 | // Set the list sentinals. | |
245 | static wxMemStruct * SetHead (wxMemStruct * st) { return (m_head = st); } | |
246 | static wxMemStruct * SetTail (wxMemStruct * st) { return (m_tail = st); } | |
247 | ||
248 | // If this is set then every new operation checks the validity | |
249 | // of the all previous nodes in the list. | |
250 | static bool GetCheckPrevious () { return m_checkPrevious; } | |
251 | static void SetCheckPrevious (bool value) { m_checkPrevious = value; } | |
252 | ||
253 | // Checks all nodes, or all nodes if checkAll is TRUE | |
254 | static int Check(bool checkAll = FALSE); | |
255 | ||
256 | // Print out the list of wxMemStruct nodes. | |
257 | static bool PrintList(void); | |
258 | ||
259 | // Dump objects | |
260 | static bool Dump(void); | |
261 | ||
262 | // Print statistics | |
263 | static bool PrintStatistics(bool detailed = TRUE); | |
264 | ||
265 | // Print out the classes in the application. | |
266 | static bool PrintClasses(void); | |
267 | ||
268 | // Count the number of non-wxDebugContext-related objects | |
269 | // that are outstanding | |
270 | static int CountObjectsLeft(bool sinceCheckpoint = FALSE); | |
271 | ||
272 | private: | |
273 | // Store these here to allow access to the list without | |
274 | // needing to have a wxMemStruct object. | |
275 | static wxMemStruct* m_head; | |
276 | static wxMemStruct* m_tail; | |
277 | ||
278 | // Set to FALSE if we're not checking all previous nodes when | |
279 | // we do a new. Set to TRUE when we are. | |
280 | static bool m_checkPrevious; | |
281 | }; | |
282 | ||
283 | // Output a debug message, in a system dependent fashion. | |
284 | void WXDLLEXPORT wxTrace(const wxChar *fmt ...); | |
285 | void WXDLLEXPORT wxTraceLevel(int level, const wxChar *fmt ...); | |
286 | ||
287 | #define WXTRACE wxTrace | |
288 | #define WXTRACELEVEL wxTraceLevel | |
289 | ||
290 | #else // else part for the #if __WXDEBUG__ | |
291 | ||
292 | inline void wxTrace(const wxChar *WXUNUSED(fmt)) {} | |
293 | inline void wxTraceLevel(int WXUNUSED(level), const wxChar *WXUNUSED(fmt)) {} | |
294 | ||
295 | #define WXTRACE TRUE ? (void)0 : wxTrace | |
296 | #define WXTRACELEVEL TRUE ? (void)0 : wxTraceLevel | |
297 | // #define WXDEBUG_NEW new | |
298 | ||
299 | #endif // __WXDEBUG__ | |
300 | ||
301 | #endif | |
302 | // _WX_MEMORYH__ | |
303 |