home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c082_144 / 9.ddi / TVSRC.ZIP / NEW.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-10  |  4.1 KB  |  185 lines
  1. /*------------------------------------------------------------*/
  2. /* filename -       new.cpp                                   */
  3. /*------------------------------------------------------------*/ 
  4.                                                               
  5. /*------------------------------------------------------------*/
  6. /*                                                            */
  7. /*    Turbo Vision -  Version 1.0                             */
  8. /*                                                            */
  9. /*                                                            */
  10. /*    Copyright (c) 1991 by Borland International             */
  11. /*    All Rights Reserved.                                    */
  12. /*                                                            */
  13. /*------------------------------------------------------------*/
  14.  
  15. #include <assert.h>
  16.  
  17. #if !defined( __MEM_H )
  18. #include <Mem.h>
  19. #endif  // __MEM_H
  20.  
  21. #if !defined( __ALLOC_H )
  22. #include <Alloc.h>
  23. #endif  // __ALLOC_H
  24.  
  25. #if !defined( __STDLIB_H )
  26. #include <StdLib.h>
  27. #endif  // __STDLIB_H
  28.  
  29. #define Uses_TVMemMgr
  30. #include <tv.h>
  31.  
  32. TBufListEntry * near TBufListEntry::bufList = 0;
  33.  
  34. TBufListEntry::TBufListEntry( void*& o ) : owner( o )
  35. {
  36.     next = bufList;
  37.     prev = 0;
  38.     bufList = this;
  39.     if( next != 0 )
  40.         next->prev = this;
  41. }
  42.  
  43. TBufListEntry::~TBufListEntry()
  44. {
  45.     owner = 0;
  46.     if( prev == 0 )
  47.         bufList = next;
  48.     else
  49.         prev->next = next;
  50.     if( next != 0 )
  51.         next->prev = prev;
  52. }
  53.  
  54. void *TBufListEntry::operator new( size_t sz, size_t extra )
  55. {
  56.     return malloc( sz + extra*sizeof( unsigned ) );
  57. }
  58.  
  59. void *TBufListEntry::operator new( size_t )
  60. {
  61.     return 0;
  62. }
  63.  
  64. void TBufListEntry::operator delete( void *b )
  65. {
  66.     free( b );
  67. }
  68.  
  69. Boolean TBufListEntry::freeHead()
  70. {
  71.     if( bufList == 0 )
  72.         return False;
  73.     else
  74.         {
  75.         delete bufList;
  76.         return True;
  77.         }
  78. }
  79.  
  80. void * near TVMemMgr::safetyPool = 0;
  81. size_t near TVMemMgr::safetyPoolSize = 0;
  82. int near TVMemMgr::inited = 0;
  83.  
  84. TVMemMgr memMgr;
  85.  
  86. TVMemMgr::TVMemMgr()
  87. {
  88.     if( !inited )
  89.         resizeSafetyPool();
  90. };
  91.  
  92. void TVMemMgr::resizeSafetyPool( size_t sz )
  93. {
  94.     inited = 1;
  95.     free( safetyPool );
  96.     if( sz == 0 )
  97.         safetyPool = 0;
  98.     else
  99.         safetyPool = malloc( sz );
  100.     safetyPoolSize = sz;
  101. }
  102.  
  103. int TVMemMgr::safetyPoolExhausted()
  104. {
  105.     return inited && (safetyPool == 0);
  106. }
  107.  
  108. void TVMemMgr::allocateDiscardable( void *&adr, size_t sz )
  109. {
  110.     if( safetyPoolExhausted() )
  111.         adr = 0;
  112.     else
  113.         {
  114.         TBufListEntry *newEntry = new( sz ) TBufListEntry( adr );
  115.         if( newEntry == 0 )
  116.             adr = 0;
  117.         else
  118.             adr = (char *)newEntry + sizeof(TBufListEntry);
  119.         }
  120. }
  121.  
  122. void TVMemMgr::freeDiscardable( void *block )
  123. {
  124.     delete (TBufListEntry *)((char *)block - sizeof(TBufListEntry));
  125. }
  126.  
  127.  
  128.  
  129. #if !defined( NDEBUG )
  130. const BLK_SIZE = 16;
  131. const BLK_DATA = 0xA6;
  132. #else
  133. const BLK_SIZE = 0;
  134. #endif
  135.  
  136. void *operator new( size_t sz )
  137. {
  138.     assert( heapcheck() >= 0 );
  139.  
  140.     sz += BLK_SIZE;
  141.     if( sz == 0 )
  142.         sz = 1;
  143.  
  144.     void *temp = malloc( sz );
  145.     while( temp == 0 && TBufListEntry::freeHead() == True )
  146.         temp = malloc( sz );
  147.     if( temp == 0 )
  148.         if( TVMemMgr::safetyPoolExhausted() )
  149.             abort();
  150.         else
  151.             {
  152.             TVMemMgr::resizeSafetyPool( 0 );
  153.             temp = malloc( sz );
  154.             if( temp == 0 )
  155.                 abort();
  156.             }
  157. #if !defined( NDEBUG )
  158.     memset( temp, BLK_DATA, BLK_SIZE );
  159. #endif
  160.     return (char *)temp + BLK_SIZE;
  161. }
  162.  
  163. #if !defined( NDEBUG )
  164. static void check( void *blk )
  165. {
  166.     for( int i = 0; i < BLK_SIZE; i++ )
  167.         assert( *((unsigned char *)blk + i) == BLK_DATA );
  168. }
  169. #endif
  170.  
  171. void operator delete( void *blk )
  172. {
  173.     assert( heapcheck() >= 0 );
  174.     if( blk == 0 )
  175.         return;
  176.     void *tmp = (char *)blk - BLK_SIZE;
  177. #if !defined( NDEBUG )
  178.     check( tmp );
  179. #endif
  180.     free( tmp );
  181.     if( TVMemMgr::safetyPoolExhausted() )
  182.         TVMemMgr::resizeSafetyPool();
  183. }
  184.  
  185.