home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tv20cpp.zip / src / new.cpp < prev    next >
C/C++ Source or Header  |  1998-01-19  |  4KB  |  206 lines
  1. /*
  2.  * new.cc
  3.  *
  4.  * Turbo Vision - Version 2.0
  5.  *
  6.  * Copyright (c) 1994 by Borland International
  7.  * All Rights Reserved.
  8.  *
  9.  * Modified by Sergio Sigala <ssigala@globalnet.it>
  10.  */
  11.  
  12. #define NDEBUG
  13. #include <assert.h>
  14. #include <stdlib.h>
  15.  
  16. #define Uses_TVMemMgr
  17. #include <tvision/tv.h>
  18.  
  19. TBufListEntry * TBufListEntry::bufList = 0;
  20.  
  21. TBufListEntry::TBufListEntry( void*& o ) : owner( o )
  22. {
  23.     next = bufList;
  24.     prev = 0;
  25.     bufList = this;
  26.     if( next != 0 )
  27.         next->prev = this;
  28. }
  29.  
  30. TBufListEntry::~TBufListEntry()
  31. {
  32.     owner = 0;
  33.     if( prev == 0 )
  34.         bufList = next;
  35.     else
  36.         prev->next = next;
  37.     if( next != 0 )
  38.         next->prev = prev;
  39. }
  40.  
  41. void *TBufListEntry::operator new( size_t sz, size_t extra )
  42. {
  43.     return malloc( sz + extra*sizeof( unsigned ) );
  44. }
  45.  
  46. void *TBufListEntry::operator new( size_t )
  47. {
  48.     return 0;
  49. }
  50.  
  51. void TBufListEntry::operator delete( void *b )
  52. {
  53.     free( b );
  54. }
  55.  
  56. Boolean TBufListEntry::freeHead()
  57. {
  58.     if( bufList == 0 )
  59.         return False;
  60.     else
  61.         {
  62.         delete bufList;
  63.         return True;
  64.         }
  65. }
  66.  
  67. void * TVMemMgr::safetyPool = 0;
  68. size_t TVMemMgr::safetyPoolSize = 0;
  69. int TVMemMgr::inited = 0;
  70.  
  71. TVMemMgr memMgr;
  72.  
  73. TVMemMgr::TVMemMgr()
  74. {
  75.     if( !inited )
  76.         resizeSafetyPool();
  77. };
  78.  
  79. void TVMemMgr::resizeSafetyPool( size_t sz )
  80. {
  81.     inited = 1;
  82.     free( safetyPool );
  83.     if( sz == 0 )
  84.         safetyPool = 0;
  85.     else
  86.         safetyPool = malloc( sz );
  87.     safetyPoolSize = sz;
  88. }
  89.  
  90. int TVMemMgr::safetyPoolExhausted()
  91. {
  92.     return inited && (safetyPool == 0);
  93. }
  94.  
  95. void TVMemMgr::allocateDiscardable( void *&adr, size_t sz )
  96. {
  97.     if( safetyPoolExhausted() )
  98.         adr = 0;
  99.     else
  100.         {
  101.         TBufListEntry *newEntry = new( sz ) TBufListEntry( adr );
  102.         if( newEntry == 0 )
  103.             adr = 0;
  104.         else
  105.             adr = (char *)newEntry + sizeof(TBufListEntry);
  106.         }
  107. }
  108.  
  109. void TVMemMgr::freeDiscardable( void *block )
  110. {
  111.     delete (TBufListEntry *)((char *)block - sizeof(TBufListEntry));
  112. }
  113.  
  114. #ifndef __UNPATCHED
  115. void TVMemMgr::clearSafetyPool()
  116. {
  117.     resizeSafetyPool( 0 );
  118.     inited = 0;
  119. }
  120.  
  121. void TVMemMgr::suspend()
  122. {
  123.     while(TBufListEntry::freeHead())
  124.     ;
  125. }
  126. #endif
  127.  
  128. #if !defined( NDEBUG )
  129. const BLK_SIZE = 16;
  130. const BLK_DATA = 0xA6;
  131. #else
  132. const BLK_SIZE = 0;
  133. #endif
  134.  
  135. /* SS: this makes g++ happy */
  136.  
  137. //static void * allocBlock( size_t sz )
  138. void * allocBlock( size_t sz )
  139. {
  140.     assert( heapcheck() >= 0 );
  141.  
  142.     sz += BLK_SIZE;
  143.     if( sz == 0 )
  144.         sz = 1;
  145.  
  146.     void *temp = malloc( sz );
  147.     while( temp == 0 && TBufListEntry::freeHead() == True )
  148.         temp = malloc( sz );
  149.     if( temp == 0 )
  150.         if( TVMemMgr::safetyPoolExhausted() )
  151.             abort();
  152.         else
  153.             {
  154.             TVMemMgr::resizeSafetyPool( 0 );
  155.             temp = malloc( sz );
  156.             if( temp == 0 )
  157.                 abort();
  158.             }
  159. #if !defined( NDEBUG )
  160.     memset( temp, BLK_DATA, BLK_SIZE );
  161. #endif
  162.     return (char *)temp + BLK_SIZE;
  163. }
  164.  
  165. void * operator new[] ( size_t sz )
  166. {
  167.    return allocBlock(sz);
  168. }
  169.  
  170. void * operator new ( size_t sz )
  171. {
  172.    return allocBlock(sz);
  173. }
  174.  
  175. #if !defined( NDEBUG )
  176. static void check( void *blk )
  177. {
  178.     for( int i = 0; i < BLK_SIZE; i++ )
  179.         assert( *((unsigned char *)blk + i) == BLK_DATA );
  180. }
  181. #endif
  182.  
  183. static void deleteBlock( void *blk )
  184. {
  185.     assert( heapcheck() >= 0 );
  186.     if( blk == 0 )
  187.         return;
  188.     void *tmp = (char *)blk - BLK_SIZE;
  189. #if !defined( NDEBUG )
  190.     check( tmp );
  191. #endif
  192.     free( tmp );
  193.     if( TVMemMgr::safetyPoolExhausted() )
  194.         TVMemMgr::resizeSafetyPool();
  195. }
  196.  
  197. void operator delete ( void *blk )
  198. {
  199.    deleteBlock(blk);
  200. }
  201.  
  202. void operator delete[] ( void *blk )
  203. {
  204.    deleteBlock(blk);
  205. }
  206.