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