home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 April: Mac OS SDK / Dev.CD Apr 96 SDK / Dev.CD Apr 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc Development Framework / ODFDev / ODF / OS / ODUtils / Sources / ODMemory.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-08  |  11.4 KB  |  392 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        ODMemory.cpp
  3.  
  4.     Contains:    Procedural implementation to the Memory component
  5.  
  6.     Owned by:    Jens Alfke
  7.  
  8.     Copyright: © 1993-95 by Apple Computer, Inc., all rights reserved.
  9. */
  10.  
  11. #ifndef _ODMEMORY_
  12. #include "ODMemory.h"
  13. #endif
  14.  
  15. #ifndef _MEMMGR_
  16. #include "MemMgr.h"
  17. #endif
  18.  
  19. #ifndef __CODEFRAGMENTS__
  20. #include <CodeFragments.h>
  21. #endif
  22.  
  23. #ifndef __ERRORS__
  24. #include <Errors.h>
  25. #endif
  26.  
  27. #ifndef _EXCEPT_
  28. #include "Except.h"
  29. #endif
  30.  
  31. #ifndef _ODDEBUG_
  32. #include "ODDebug.h"
  33. #endif
  34.  
  35. // ----- [HLX] Added Begin  -----
  36. #ifndef   FWMEMTAS_H
  37. #include "FWMemTas.h"
  38. #endif
  39. // ----- [HLX] Added End  -----
  40.  
  41. #ifndef _UTILERRS_
  42. #include "UtilErrs.h"
  43. #endif
  44.  
  45. //========================================================================================
  46. // Constants
  47. //========================================================================================
  48.  
  49. const size_t kSystemHeapInitialSize = 20 * 1024;
  50. const size_t kSystemHeapGrowBySize  = 32 * 1024;
  51.  
  52. const ODSize kMinAppHeapSpace        = 16 * 1024;
  53. const ODSize kMinContigAppHeapSpace =  6 * 1024;
  54.  
  55. //========================================================================================
  56. // Global variables
  57. //========================================================================================
  58.  
  59. //static ODMemoryHeapID    gDefaultHeap; // ----- [HLX] Changed  -----
  60. #if 0
  61. #pragma lib_export on                // Need to tell compiler that gSystemHeap is imported
  62. extern void* gSystemHeap;            // Lives in Shared Globals library, MemShard.cpp.
  63. #pragma lib_export off
  64. #endif /* 0 */
  65. //========================================================================================
  66. // Initialization
  67. //========================================================================================
  68.  
  69.  
  70. OSErr InitODMemory( )
  71. {
  72. // ----- [HLX] Changed Begin -----
  73. //    gDefaultHeap = MMGetDefaultHeap();
  74. //    return gDefaultHeap ?noErr :memFullErr;
  75.     return noErr;
  76. // ----- [HLX] Changed End -----
  77. }
  78.  
  79. // Note: CFMInit stuff is now in UtilInit.cpp
  80.  
  81. //extern "C" pascal OSErr UtilitiesCFMInit( CFragInitBlockPtr );
  82.  
  83. // For use inside OpenDoc only. Parts won't need to use this but
  84. // should call InitODMemory from their own CFMInit routines.
  85. //pascal OSErr UtilitiesCFMInit (CFragInitBlockPtr /*initBlkPtr*/)
  86. //{
  87. //    return InitODMemory();
  88. //}
  89.  
  90.  
  91. //========================================================================================
  92. // Function declarations for operations on pointer based blocks
  93. //========================================================================================
  94.  
  95.  
  96. //----------------------------------------------------------------------------------------
  97. // ODGetDefaultHeap
  98. //----------------------------------------------------------------------------------------
  99.  
  100. ODMemoryHeapID ODGetDefaultHeap()
  101. {
  102. // ----- [HLX] Changed Begin -----
  103.     return FW_CMemoryTaskGlobals::GetMemoryGlobals().gMemoryHeap;
  104. //    ASSERTM(gDefaultHeap,kODErrAssertionFailed,"You didn't call InitODMemory!");
  105. //    return gDefaultHeap;
  106. // ----- [HLX] Changed End -----
  107. }
  108. #if 0
  109. //----------------------------------------------------------------------------------------
  110. // ODGetSystemHeap
  111. //----------------------------------------------------------------------------------------
  112.  
  113. ODMemoryHeapID ODGetSystemHeap()
  114. {
  115.     // The system heap should be created only by the OD system process.
  116.     
  117.     if( !gSystemHeap ) {
  118.         gSystemHeap = ODCreateHeap(    kSystemHeapInitialSize,
  119.                                     kSystemHeapGrowBySize,
  120.                                     kODTrue,"OpenDoc System Heap" );
  121.         THROW_IF_NULL(gSystemHeap);
  122.     }
  123.     return (ODMemoryHeapID)gSystemHeap;
  124. }
  125. #endif /* 0 */
  126. //----------------------------------------------------------------------------------------
  127. // ODCreateHeap
  128. //----------------------------------------------------------------------------------------
  129.  
  130. ODMemoryHeapID ODCreateHeap(unsigned long sizeInitial, unsigned long sizeIncrement,
  131.                             Boolean fromSysMemory, const char *name)
  132. {
  133.     MemHeap *heap = MMNewHeap(fromSysMemory ?kMMSysMemory :kMMTempMemory,
  134.                               sizeInitial, sizeIncrement, name);
  135.     if( !heap )
  136.         THROW(kODErrOutOfMemory);
  137.     return heap;
  138. }
  139.  
  140. //----------------------------------------------------------------------------------------
  141. // ODDestroyHeap
  142. //----------------------------------------------------------------------------------------
  143.  
  144. void ODDestroyHeap(ODMemoryHeapID heapID)
  145. {
  146.     MMDisposeHeap(heapID);
  147. }
  148.  
  149. //----------------------------------------------------------------------------------------
  150. // ODNewPtr
  151. //----------------------------------------------------------------------------------------
  152.  
  153. void *ODNewPtr(ODBlockSize blkSize, ODMemoryHeapID heapID)
  154. {
  155.     if( heapID == kODNULL ) {
  156. // ----- [HLX] Changed Begin -----
  157. //        ASSERTM(gDefaultHeap,kODErrAssertionFailed,"You didn't call InitODMemory!");
  158. //        heapID = gDefaultHeap;
  159.         heapID = ODGetDefaultHeap();
  160. // ----- [HLX] Changed End -----
  161.     }
  162.     void *block = MMAllocateIn(blkSize,heapID);
  163.     if( !block )
  164.         THROW(kODErrOutOfMemory);
  165.     return block;
  166. }
  167.  
  168. //----------------------------------------------------------------------------------------
  169. // ODNewPtrClear
  170. //----------------------------------------------------------------------------------------
  171.  
  172. void *ODNewPtrClear(ODBlockSize blkSize, ODMemoryHeapID heapID)
  173. {
  174.     if( heapID == kODNULL ) {
  175. // ----- [HLX] Changed Begin -----
  176. //        ASSERTM(gDefaultHeap,kODErrAssertionFailed,"You didn't call InitODMemory!");
  177. //        heapID = gDefaultHeap;
  178.         heapID = ODGetDefaultHeap();
  179. // ----- [HLX] Changed End -----
  180.     }
  181.     void *block = MMAllocateClearIn(blkSize,heapID);
  182.     if( !block )
  183.         THROW(kODErrOutOfMemory);
  184.     return block;
  185. }
  186.  
  187. //----------------------------------------------------------------------------------------
  188. // ODReallocate
  189. //----------------------------------------------------------------------------------------
  190.  
  191. void *ODReallocate(void *block, ODBlockSize newSize)
  192. {
  193.     block = MMReallocate(block,newSize);
  194.     if( !block && newSize>0 )
  195.         THROW(kODErrOutOfMemory);
  196.     return block;
  197. }
  198.  
  199. //------------------------------------------------------------------------------
  200. // ODDisposePtr
  201. //------------------------------------------------------------------------------
  202.  
  203. void ODDisposePtr(void *pointer)
  204. {
  205.     MMFree(pointer);
  206. }
  207.  
  208. //----------------------------------------------------------------------------------------
  209. // ODRecoverHeapID
  210. //----------------------------------------------------------------------------------------
  211.  
  212. ODMemoryHeapID ODRecoverHeapID(const void *block)
  213. {
  214.     ODMemoryHeapID heap = MMGetHeap(block);
  215.     if( !heap )
  216.         THROW(kODErrInvalidBlock);
  217.     return heap;
  218. }
  219.  
  220.  
  221.  
  222. //----------------------------------------------------------------------------------------
  223. // ODBlockIsObject
  224. //----------------------------------------------------------------------------------------
  225.  
  226. void ODBlockIsObject( void *block, ODBoolean isObject )
  227. {
  228.     MMSetIsObject(block,isObject);
  229. }
  230.  
  231.  
  232. //----------------------------------------------------------------------------------------
  233. // ODIsBlockAnObject
  234. //----------------------------------------------------------------------------------------
  235.  
  236. ODBoolean ODIsBlockAnObject( const void *block )
  237. {
  238.     return MMIsObject(block);
  239. }
  240.  
  241.  
  242. //========================================================================================
  243. // Function declarations for operations on handle based blocks
  244. //========================================================================================
  245.  
  246. //----------------------------------------------------------------------------------------
  247. // ODNewHandle
  248. //----------------------------------------------------------------------------------------
  249.  
  250. ODHandle ODNewHandle(ODULong howBig)
  251. {
  252.     ODHandle h = (ODHandle) MMAllocateHandleIn(howBig,kMMTempMemory);
  253.     if( !h )
  254.         THROW(kODErrOutOfMemory);
  255.     return h;
  256.         
  257. }
  258.  
  259. //----------------------------------------------------------------------------------------
  260. // ODDisposeHandle
  261. //----------------------------------------------------------------------------------------
  262.  
  263. void ODDisposeHandle(ODHandle handle)
  264. {
  265.     MMFreeHandle((MMHandle)handle);
  266. }
  267.  
  268. //----------------------------------------------------------------------------------------
  269. // ODCopyHandle
  270. //----------------------------------------------------------------------------------------
  271.  
  272. ODHandle ODCopyHandle(ODHandle handle)
  273. {
  274.     ODHandle h = (ODHandle) MMCopyHandle((MMHandle)handle);
  275.     if( !h )
  276.         THROW(kODErrOutOfMemory);
  277.     return h;
  278. }
  279.  
  280. //----------------------------------------------------------------------------------------
  281. // ODGetHandleSize(ODHandle handle)
  282. //----------------------------------------------------------------------------------------
  283.  
  284. ODULong ODGetHandleSize(ODHandle handle)
  285. {
  286.     return MMGetHandleSize((MMHandle)handle);
  287. }
  288.  
  289. //----------------------------------------------------------------------------------------
  290. // ODSetHandleSize(ODHandle handle, ODULong blkSize)
  291. //----------------------------------------------------------------------------------------
  292.  
  293. void ODSetHandleSize(ODHandle handle, ODULong blkSize)
  294. {
  295.     if( !MMSetHandleSize((MMHandle)handle,blkSize) )
  296.         THROW(kODErrOutOfMemory);
  297.  
  298. }
  299.  
  300. //----------------------------------------------------------------------------------------
  301. // ODLockHandle(ODHandle handle)
  302. //----------------------------------------------------------------------------------------
  303.  
  304. void* ODLockHandle(ODHandle handle)
  305. {
  306.     void *p = MMLockHandle((MMHandle)handle);
  307.     if( !p )
  308.         THROW(kODErrOutOfMemory);
  309.     return p;
  310. }
  311.  
  312. //----------------------------------------------------------------------------------------
  313. // ODUnlockPtr(void* ptr)
  314. //----------------------------------------------------------------------------------------
  315.  
  316. void ODUnlockPtr(void* ptr)
  317. {
  318.     MMUnlockPtr(ptr);
  319. }
  320.  
  321. //----------------------------------------------------------------------------------------
  322. // ODUnlockHandle(ODHandle handle)
  323. //----------------------------------------------------------------------------------------
  324.  
  325. void ODUnlockHandle(ODHandle handle)
  326. {
  327.     MMUnlockHandle((MMHandle)handle);
  328. }
  329.  
  330.  
  331. //========================================================================================
  332. // Function declarations utility functions
  333. //========================================================================================
  334.  
  335. //------------------------------------------------------------------------------
  336. // ODBlockMove
  337. //------------------------------------------------------------------------------
  338.  
  339.  
  340. void ODBlockMove( const void *from, void *to, ODULong size)
  341. {
  342.     MMMove(to,from,size);
  343. }
  344.  
  345.  
  346. //------------------------------------------------------------------------------
  347. // ODNewRgn
  348. //------------------------------------------------------------------------------
  349.  
  350. RgnHandle ODNewRgn( )
  351. {
  352.     RgnHandle r = (RgnHandle) ODNewHandle(sizeof(Region));
  353.     (**r).rgnSize = sizeof(Region);
  354.     SetRect(&(**r).rgnBBox, 0,0,0,0);
  355.     return r;
  356. }
  357.  
  358. //------------------------------------------------------------------------------
  359. // ODRequireFreeSpace
  360. //------------------------------------------------------------------------------
  361.  
  362.  
  363. ODBoolean
  364. ODHaveFreeSpace( ODSize haveTotal, ODSize haveContig /*=0*/,
  365.                  ODBoolean appHeap /*=false*/ )
  366. {
  367.     size_t total, contig;
  368.     if( appHeap )
  369.         MMSystemFreeSpace(kMMAppMemory, &total,&contig);
  370.     else
  371.         MMGetFreeSpace(ODGetDefaultHeap(),&total,&contig ); // [HLX] changed
  372.     return total>=haveTotal && contig>=haveContig;
  373. }
  374.  
  375. void
  376. ODRequireFreeSpace( ODSize total, ODSize contig, ODBoolean appHeap )
  377. {
  378.     if( !ODHaveFreeSpace(total,contig,appHeap) )
  379.         THROW(appHeap ?memFullErr :kODErrOutOfMemory);
  380.     
  381.     // I decided it made sense to throw a Mac mem mgr error if the
  382.     // app heap is full, since this is the error you'd get if you
  383.     // tried to d
  384. }
  385.  
  386. void
  387. ODCheckAppHeapSpace( )
  388. {
  389.     if( !ODHaveFreeSpace(kMinAppHeapSpace,kMinContigAppHeapSpace,kODTrue) )
  390.         THROW(memFullErr);
  391. }
  392.