home *** CD-ROM | disk | FTP | other *** search
/ Game.EXE 2002 April / Game.EXE_04_2002.iso / Alawar / msvc / safe_new.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2002-03-02  |  2.9 KB  |  147 lines
  1. #include "safe_new.h"
  2. #undef new
  3.  
  4. #include <windows.h>
  5. #include <memory>
  6.  
  7. #if 1 // ┼±δΦ 1, ≥ε ∩α∞ ≥ⁿ ß≤Σσ≥ ∩≡εΓσ≡ ≥ⁿ± 
  8.  
  9. struct MemNode
  10. {
  11.     MemNode * prev;
  12.     MemNode * next;
  13.     const char * file;
  14.     int line;
  15.     int size;
  16. };
  17.  
  18. static MemNode start = { 0,0,0,0,0 };
  19. static int simple_counter = 0;
  20.  
  21. struct Reporter
  22. {
  23. public:
  24.     ~Reporter()
  25.     {
  26.         MemNode * curr = start.next;
  27.  
  28.         HANDLE hfile = CreateFile( "memory.log", GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL );
  29.         if( hfile != INVALID_HANDLE_VALUE )
  30.         {
  31.             DWORD read = 0;
  32.             char head[] = "    size | line | file\n---------+------+----------\n";
  33.             WriteFile( hfile, head, strlen(head), &read, NULL );
  34.             for( ; curr ; curr = curr->next )
  35.             {
  36.                 char buff[1024];
  37.                 int bs = wsprintf( buff,"%8d |%5d | %s\n", curr->size, curr->line, curr->file );
  38.                 WriteFile( hfile, buff, bs, &read, NULL );
  39.             }
  40.             CloseHandle( hfile ); hfile = INVALID_HANDLE_VALUE;
  41.         }
  42.     }
  43. };
  44.  
  45.  
  46. static Reporter reporter;
  47.  
  48. static void * our_alloc( size_t s, const char * file, int line )
  49. {
  50.     void * mama = malloc( s + sizeof(MemNode) );
  51.     if( mama == 0 )
  52.     {
  53.         throw std::bad_alloc();
  54.     }
  55.     ++simple_counter;
  56.  
  57.     char * chama = (char *)mama;
  58.     MemNode * just = (MemNode *)mama;
  59.  
  60.     just->file = file;
  61.     just->line = line;
  62.     just->size = s;
  63.  
  64.     MemNode * next = start.next;
  65.     just->next = next;
  66.     if( next )
  67.         next->prev = just;
  68.  
  69.     just->prev = &start;
  70.     start.next = just;
  71.  
  72.     void * p = (void *)( chama + sizeof(MemNode) );
  73.     return p;
  74. }
  75.  
  76. void our_free( void * p, const char * file, int line )
  77. {
  78.     if( p == 0 )
  79.         return;
  80.     --simple_counter;
  81.     char * chama = (char *)p - sizeof(MemNode);
  82.     void * mama = chama;
  83.     MemNode * just = (MemNode *)mama;
  84.  
  85.     MemNode * prev = just->prev;
  86.     MemNode * next = just->next;
  87.  
  88.     prev->next = next;
  89.     if( next )
  90.         next->prev = prev;
  91.     free( mama );
  92. }
  93.  
  94. void * __cdecl operator new( size_t s, const char * file, int line )
  95. {
  96.     return our_alloc( s, file, line );
  97. }
  98.  
  99. void __cdecl operator delete( void * p, const char * file, int line )
  100. {
  101.     our_free( p, file, line );
  102. }
  103.  
  104. void * __cdecl operator new( size_t s )
  105. {
  106.     return operator new( s, "Runtime", 0 );
  107. }
  108.  
  109. void __cdecl operator delete( void * p )
  110. {
  111.     operator delete( p, "Runtime", 0 );
  112. }
  113.  
  114. #else
  115.  
  116. void * __cdecl operator new( size_t s, const char * file, int line )
  117. {
  118.     return operator new( s );
  119. }
  120.  
  121. void __cdecl operator delete( void * p, const char * file, int line )
  122. {
  123.     operator delete( p );
  124. }
  125.  
  126. #endif
  127.  
  128. void * __cdecl operator new[]( size_t s )
  129. {
  130.     return operator new( s );
  131. }
  132.  
  133. void __cdecl operator delete[]( void * p )
  134. {
  135.     operator delete( p );
  136. }
  137.  
  138. void * __cdecl operator new[]( size_t s, const char * file, int line )
  139. {
  140.     return operator new( s, file, line );
  141. }
  142.  
  143. void __cdecl operator delete[]( void * p, const char * file, int line )
  144. {
  145.     operator delete( p, file, line );
  146. }
  147.