include/wx/memory.h

   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 WXDLLEXPORT void * operator new (size_t size, wxChar * fileName, int lineNum);
  72
  73 #if !defined(__VISAGECPP__)
  74 void operator delete (void * buf);
  75 #endif
  76
  77 #if wxUSE_ARRAY_MEMORY_OPERATORS
  78     WXDLLEXPORT void* operator new[] (size_t size);
  79     WXDLLEXPORT void* operator new[] (size_t size, wxChar * fileName, int lineNum);
  80     WXDLLEXPORT void operator delete[] (void * buf);
  81 #endif
  82
  83 // VC++ 6.0
  84 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
  85     WXDLLEXPORT void operator delete(void *buf, wxChar*, int);
  86     WXDLLEXPORT void operator delete[](void *buf, wxChar*, int);
  87 #endif
  88
  89 #endif
  90   // wxUSE_GLOBAL_MEMORY_OPERATORS
  91 #endif
  92   // __WXDEBUG__
  93
  94 typedef unsigned int wxMarkerType;
  95
  96 /*
  97   Define the struct which will be placed at the start of all dynamically
  98   allocated memory.
  99 */
 100
 101 class WXDLLEXPORT wxMemStruct {
 102
 103 friend class WXDLLEXPORT wxDebugContext; // access to the m_next pointer for list traversal.
 104
 105 public:
 106 public:
 107     int AssertList ();
 108
 109     size_t RequestSize () { return m_reqSize; }
 110     wxMarkerType Marker () { return m_firstMarker; }
 111
 112     // When an object is deleted we set the id slot to a specific value.
 113     inline void SetDeleted ();
 114     inline int IsDeleted ();
 115
 116     int Append ();
 117     int Unlink ();
 118
 119     // Used to determine if the object is really a wxMemStruct.
 120     // Not a foolproof test by any means, but better than none I hope!
 121     int AssertIt ();
 122
 123     // Do all validation on a node.
 124     int ValidateNode ();
 125
 126     // Check the integrity of a node and of the list, node by node.
 127     int CheckBlock ();
 128     int CheckAllPrevious ();
 129
 130     // Print a single node.
 131     void PrintNode ();
 132
 133     // Called when the memory linking functions get an error.
 134     void ErrorMsg (const char *);
 135     void ErrorMsg ();
 136
 137     inline void *GetActualData(void) const { return m_actualData; }
 138
 139     void Dump(void);
 140
 141 public:
 142     // Check for underwriting. There are 2 of these checks. This one
 143     // inside the struct and another right after the struct.
 144     wxMarkerType        m_firstMarker;
 145
 146     // File name and line number are from cpp.
 147     wxChar*             m_fileName;
 148     int                 m_lineNum;
 149
 150     // The amount of memory requested by the caller.
 151     size_t              m_reqSize;
 152
 153     // Used to try to verify that we really are dealing with an object
 154     // of the required class. Can be 1 of 2 values these indicating a valid
 155     // wxMemStruct object, or a deleted wxMemStruct object.
 156     wxMarkerType        m_id;
 157
 158     wxMemStruct *       m_prev;
 159     wxMemStruct *       m_next;
 160
 161     void *              m_actualData;
 162     bool                m_isObject;
 163 };
 164
 165
 166 typedef void (wxMemStruct::*PmSFV) ();
 167
 168
 169 /*
 170   Debugging class. This will only have a single instance, but it\'s
 171   a reasonable way to keep everything together and to make this
 172   available for change if needed by someone else.
 173   A lot of this stuff would be better off within the wxMemStruct class, but
 174   it\'s stuff which we need to access at times when there is no wxMemStruct
 175   object so we use this class instead. Think of it as a collection of
 176   globals which have to do with the wxMemStruct class.
 177 */
 178
 179 class WXDLLEXPORT wxDebugContext {
 180
 181 protected:
 182     // Used to set alignment for markers.
 183     static size_t CalcAlignment ();
 184
 185     // Returns the amount of padding needed after something of the given
 186     // size. This is so that when we cast pointers backwards and forwards
 187     // the pointer value will be valid for a wxMarkerType.
 188     static size_t GetPadding (const size_t size) ;
 189
 190     // Traverse the list.
 191     static void TraverseList (PmSFV, wxMemStruct *from = NULL);
 192
 193     static streambuf *m_streamBuf;
 194     static ostream *m_debugStream;
 195
 196     static int debugLevel;
 197     static bool debugOn;
 198
 199         static int m_balign;                    // byte alignment
 200         static int m_balignmask;                // mask for performing byte alignment
 201 public:
 202     // Set a checkpoint to dump only the memory from
 203     // a given point
 204     static wxMemStruct *checkPoint;
 205
 206     wxDebugContext(void);
 207     ~wxDebugContext(void);
 208
 209     static bool HasStream(void) { return (m_debugStream != NULL); };
 210     static ostream& GetStream(void) { return *m_debugStream; }
 211     static streambuf *GetStreamBuf(void) { return m_streamBuf; }
 212     static void SetStream(ostream *stream, streambuf *buf = NULL);
 213     static bool SetFile(const wxString& file);
 214     static bool SetStandardError(void);
 215
 216     static int GetLevel(void) { return debugLevel; }
 217     static void SetLevel(int level) { debugLevel = level; }
 218
 219     static bool GetDebugMode(void) { return debugOn; }
 220     static void SetDebugMode(bool flag) { debugOn = flag; }
 221
 222     static void SetCheckpoint(bool all = FALSE);
 223     static wxMemStruct *GetCheckpoint(void) { return checkPoint; }
 224
 225     // Calculated from the request size and any padding needed
 226     // before the final marker.
 227     static size_t PaddedSize (const size_t reqSize);
 228
 229     // Calc the total amount of space we need from the system
 230     // to satisfy a caller request. This includes all padding.
 231     static size_t TotSize (const size_t reqSize);
 232
 233     // Return valid pointers to offsets within the allocated memory.
 234     static char * StructPos (const char * buf);
 235     static char * MidMarkerPos (const char * buf);
 236     static char * CallerMemPos (const char * buf);
 237     static char * EndMarkerPos (const char * buf, const size_t size);
 238
 239     // Given a pointer to the start of the caller requested area
 240     // return a pointer to the start of the entire alloc\'d buffer.
 241     static char * StartPos (const char * caller);
 242
 243     // Access to the list.
 244     static wxMemStruct * GetHead () { return m_head; }
 245     static wxMemStruct * GetTail () { return m_tail; }
 246
 247     // Set the list sentinals.
 248     static wxMemStruct * SetHead (wxMemStruct * st) { return (m_head = st); }
 249     static wxMemStruct * SetTail (wxMemStruct * st) { return (m_tail = st); }
 250
 251     // If this is set then every new operation checks the validity
 252     // of the all previous nodes in the list.
 253     static bool GetCheckPrevious () { return m_checkPrevious; }
 254     static void SetCheckPrevious (bool value) { m_checkPrevious = value; }
 255
 256     // Checks all nodes, or all nodes if checkAll is TRUE
 257     static int Check(bool checkAll = FALSE);
 258
 259     // Print out the list of wxMemStruct nodes.
 260     static bool PrintList(void);
 261
 262     // Dump objects
 263     static bool Dump(void);
 264
 265     // Print statistics
 266     static bool PrintStatistics(bool detailed = TRUE);
 267
 268     // Print out the classes in the application.
 269     static bool PrintClasses(void);
 270
 271     // Count the number of non-wxDebugContext-related objects
 272     // that are outstanding
 273     static int CountObjectsLeft(bool sinceCheckpoint = FALSE);
 274
 275 private:
 276     // Store these here to allow access to the list without
 277     // needing to have a wxMemStruct object.
 278     static wxMemStruct*         m_head;
 279     static wxMemStruct*         m_tail;
 280
 281     // Set to FALSE if we're not checking all previous nodes when
 282     // we do a new. Set to TRUE when we are.
 283     static bool                 m_checkPrevious;
 284 };
 285
 286 // Output a debug message, in a system dependent fashion.
 287 void WXDLLEXPORT wxTrace(const wxChar *fmt ...);
 288 void WXDLLEXPORT wxTraceLevel(int level, const wxChar *fmt ...);
 289
 290 #define WXTRACE wxTrace
 291 #define WXTRACELEVEL wxTraceLevel
 292
 293 #else // else part for the #if __WXDEBUG__
 294
 295 inline void wxTrace(const wxChar *WXUNUSED(fmt)) {}
 296 inline void wxTraceLevel(int WXUNUSED(level), const wxChar *WXUNUSED(fmt)) {}
 297
 298 #define WXTRACE TRUE ? (void)0 : wxTrace
 299 #define WXTRACELEVEL TRUE ? (void)0 : wxTraceLevel
 300 // #define WXDEBUG_NEW new
 301
 302 #endif // __WXDEBUG__
 303
 304 #endif
 305     // _WX_MEMORYH__
 306