home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Memory.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  14.8 KB  |  578 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Memory.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Memory;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __MEMORY__}
  27. {$SETC __MEMORY__ := 1}
  28.  
  29. {$I+}
  30. {$SETC MemoryIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __MIXEDMODE__}
  40. {$I MixedMode.p}
  41. {$ENDC}
  42.  
  43. {$PUSH}
  44. {$ALIGN MAC68K}
  45. {$LibExport+}
  46.  
  47. CONST
  48.     maxSize                        = $800000;                        {Max data block size is 8 megabytes}
  49.     defaultPhysicalEntryCount    = 8;
  50. { values returned from the GetPageState function }
  51.     kPageInMemory                = 0;
  52.     kPageOnDisk                    = 1;
  53.     kNotPaged                    = 2;
  54.  
  55. { masks for Zone->heapType field }
  56.     k32BitHeap                    = 1;                            { valid in all Memory Managers }
  57.     kNewStyleHeap                = 2;                            { true if new Heap Manager is present }
  58.     kNewDebugHeap                = 4;                            { true if new Heap Manager is running in debug mode on this heap }
  59.  
  60. { size of a block in bytes }
  61.     
  62. TYPE
  63.     Size = LONGINT;
  64.  
  65.     GrowZoneProcPtr = ProcPtr;  { FUNCTION GrowZone(cbNeeded: Size): LONGINT; }
  66.     PurgeProcPtr = ProcPtr;  { PROCEDURE Purge(blockToPurge: Handle); }
  67.     {
  68.         UserFnProcPtr uses register based parameters on the 68k and cannot
  69.         be written in or called from a high-level language without the help of
  70.         mixed mode or assembly glue.
  71.  
  72.         In:
  73.          => *parameter      A0.L
  74.     }
  75.     UserFnProcPtr = ProcPtr;  { PROCEDURE UserFn(parameter: UNIV Ptr); }
  76.     GrowZoneUPP = UniversalProcPtr;
  77.     PurgeUPP = UniversalProcPtr;
  78.     UserFnUPP = UniversalProcPtr;
  79.  
  80.     THz = ^Zone;
  81.  
  82.     Zone = RECORD
  83.         bkLim:                    Ptr;
  84.         purgePtr:                Ptr;
  85.         hFstFree:                Ptr;
  86.         zcbFree:                LONGINT;
  87.         gzProc:                    GrowZoneUPP;
  88.         moreMast:                INTEGER;
  89.         flags:                    INTEGER;
  90.         cntRel:                    INTEGER;
  91.         maxRel:                    INTEGER;
  92.         cntNRel:                INTEGER;
  93.         heapType:                SInt8;
  94.         unused:                    SInt8;
  95.         cntEmpty:                INTEGER;
  96.         cntHandles:                INTEGER;
  97.         minCBFree:                LONGINT;
  98.         purgeProc:                PurgeUPP;
  99.         sparePtr:                Ptr;
  100.         allocPtr:                Ptr;
  101.         heapData:                INTEGER;
  102.     END;
  103.     MemoryBlock = RECORD
  104.         address:                Ptr;
  105.         count:                    LONGINT;
  106.     END;
  107.     LogicalToPhysicalTable = RECORD
  108.         logical:                MemoryBlock;
  109.         physical:                ARRAY [0..defaultPhysicalEntryCount-1] OF MemoryBlock;
  110.     END;
  111.     PageState = INTEGER;
  112.  
  113.     StatusRegisterContents = INTEGER;
  114.  
  115. CONST
  116.     uppGrowZoneProcInfo = $000000F0; { FUNCTION (4 byte param): 4 byte result; }
  117.     uppPurgeProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  118.     uppUserFnProcInfo = $00009802; { Register PROCEDURE (4 bytes in A0); }
  119.  
  120. FUNCTION NewGrowZoneProc(userRoutine: GrowZoneProcPtr): GrowZoneUPP;
  121.     {$IFC NOT GENERATINGCFM }
  122.     INLINE $2E9F;
  123.     {$ENDC}
  124.  
  125. FUNCTION NewPurgeProc(userRoutine: PurgeProcPtr): PurgeUPP;
  126.     {$IFC NOT GENERATINGCFM }
  127.     INLINE $2E9F;
  128.     {$ENDC}
  129.  
  130. FUNCTION NewUserFnProc(userRoutine: UserFnProcPtr): UserFnUPP;
  131.     {$IFC NOT GENERATINGCFM }
  132.     INLINE $2E9F;
  133.     {$ENDC}
  134.  
  135. FUNCTION CallGrowZoneProc(cbNeeded: Size; userRoutine: GrowZoneUPP): LONGINT;
  136.     {$IFC NOT GENERATINGCFM}
  137.     INLINE $205F, $4E90;
  138.     {$ENDC}
  139.  
  140. PROCEDURE CallPurgeProc(blockToPurge: Handle; userRoutine: PurgeUPP);
  141.     {$IFC NOT GENERATINGCFM}
  142.     INLINE $205F, $4E90;
  143.     {$ENDC}
  144.  
  145. PROCEDURE CallUserFnProc(parameter: UNIV Ptr; userRoutine: UserFnUPP);
  146.     {$IFC NOT GENERATINGCFM}
  147.     {To be implemented:  Glue to move parameters into registers.}
  148.     {$ENDC}
  149. FUNCTION GetApplLimit : Ptr;
  150.     {$IFC NOT CFMSYSTEMCALLS}
  151.     INLINE $2EB8, $0130;            { MOVE.L $0130,(SP) }
  152.     {$ENDC}
  153.  
  154. FUNCTION SystemZone : THz;
  155.     {$IFC NOT CFMSYSTEMCALLS}
  156.     INLINE $2EB8, $02A6;            { MOVE.L $02A6,(SP) }
  157.     {$ENDC}
  158.  
  159. FUNCTION ApplicationZone : THz;
  160.     {$IFC NOT CFMSYSTEMCALLS}
  161.     INLINE $2EB8, $02AA;            { MOVE.L $02AA,(SP) }
  162.     {$ENDC}
  163.  
  164. FUNCTION GZSaveHnd : Handle;
  165.     {$IFC NOT CFMSYSTEMCALLS}
  166.     INLINE $2EB8, $0328;            { MOVE.L $0328,(SP) }
  167.     {$ENDC}
  168.  
  169. FUNCTION TopMem : Ptr;
  170.     {$IFC NOT CFMSYSTEMCALLS}
  171.     INLINE $2EB8, $0108;            { MOVE.L $0108,(SP) }
  172.     {$ENDC}
  173.  
  174. FUNCTION MemError : OSErr;
  175.     {$IFC NOT CFMSYSTEMCALLS}
  176.     INLINE $3EB8, $0220;            { MOVE.W $0220,(SP) }
  177.     {$ENDC}
  178.  
  179. FUNCTION GetZone: THz;
  180.     {$IFC NOT GENERATINGCFM}
  181.     INLINE $A11A, $2E88;
  182.     {$ENDC}
  183. FUNCTION NewHandle(byteCount: Size): Handle;
  184.     {$IFC NOT GENERATINGCFM}
  185.     INLINE $201F, $A122, $2E88;
  186.     {$ENDC}
  187. FUNCTION NewHandleSys(byteCount: Size): Handle;
  188.     {$IFC NOT GENERATINGCFM}
  189.     INLINE $201F, $A522, $2E88;
  190.     {$ENDC}
  191. FUNCTION NewHandleClear(byteCount: Size): Handle;
  192.     {$IFC NOT GENERATINGCFM}
  193.     INLINE $201F, $A322, $2E88;
  194.     {$ENDC}
  195. FUNCTION NewHandleSysClear(byteCount: Size): Handle;
  196.     {$IFC NOT GENERATINGCFM}
  197.     INLINE $201F, $A722, $2E88;
  198.     {$ENDC}
  199. FUNCTION HandleZone(h: Handle): THz;
  200.     {$IFC NOT GENERATINGCFM}
  201.     INLINE $205F, $A126, $2E88;
  202.     {$ENDC}
  203. FUNCTION RecoverHandle(p: Ptr): Handle;
  204.     {$IFC NOT GENERATINGCFM}
  205.     INLINE $205F, $A128, $2E88;
  206.     {$ENDC}
  207. FUNCTION RecoverHandleSys(p: Ptr): Handle;
  208.     {$IFC NOT GENERATINGCFM}
  209.     INLINE $205F, $A528, $2E88;
  210.     {$ENDC}
  211. FUNCTION NewPtr(byteCount: Size): Ptr;
  212.     {$IFC NOT GENERATINGCFM}
  213.     INLINE $201F, $A11E, $2E88;
  214.     {$ENDC}
  215. FUNCTION NewPtrSys(byteCount: Size): Ptr;
  216.     {$IFC NOT GENERATINGCFM}
  217.     INLINE $201F, $A51E, $2E88;
  218.     {$ENDC}
  219. FUNCTION NewPtrClear(byteCount: Size): Ptr;
  220.     {$IFC NOT GENERATINGCFM}
  221.     INLINE $201F, $A31E, $2E88;
  222.     {$ENDC}
  223. FUNCTION NewPtrSysClear(byteCount: Size): Ptr;
  224.     {$IFC NOT GENERATINGCFM}
  225.     INLINE $201F, $A71E, $2E88;
  226.     {$ENDC}
  227. FUNCTION PtrZone(p: Ptr): THz;
  228.     {$IFC NOT GENERATINGCFM}
  229.     INLINE $205F, $A148, $2E88;
  230.     {$ENDC}
  231. FUNCTION MaxBlock: LONGINT;
  232.     {$IFC NOT GENERATINGCFM}
  233.     INLINE $A061, $2E80;
  234.     {$ENDC}
  235. FUNCTION MaxBlockSys: LONGINT;
  236.     {$IFC NOT GENERATINGCFM}
  237.     INLINE $A461, $2E80;
  238.     {$ENDC}
  239. FUNCTION StackSpace: LONGINT;
  240.     {$IFC NOT GENERATINGCFM}
  241.     INLINE $A065, $2E80;
  242.     {$ENDC}
  243. FUNCTION NewEmptyHandle: Handle;
  244.     {$IFC NOT GENERATINGCFM}
  245.     INLINE $A166, $2E88;
  246.     {$ENDC}
  247. FUNCTION NewEmptyHandleSys: Handle;
  248.     {$IFC NOT GENERATINGCFM}
  249.     INLINE $A566, $2E88;
  250.     {$ENDC}
  251. PROCEDURE HLock(h: Handle);
  252.     {$IFC NOT GENERATINGCFM}
  253.     INLINE $205F, $A029;
  254.     {$ENDC}
  255. PROCEDURE HUnlock(h: Handle);
  256.     {$IFC NOT GENERATINGCFM}
  257.     INLINE $205F, $A02A;
  258.     {$ENDC}
  259. PROCEDURE HPurge(h: Handle);
  260.     {$IFC NOT GENERATINGCFM}
  261.     INLINE $205F, $A049;
  262.     {$ENDC}
  263. PROCEDURE HNoPurge(h: Handle);
  264.     {$IFC NOT GENERATINGCFM}
  265.     INLINE $205F, $A04A;
  266.     {$ENDC}
  267. PROCEDURE HLockHi(h: Handle);
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $205F, $A064, $A029;
  270.     {$ENDC}
  271. FUNCTION TempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $3F3C, $001D, $A88F;
  274.     {$ENDC}
  275. FUNCTION TempMaxMem(VAR grow: Size): Size;
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $3F3C, $0015, $A88F;
  278.     {$ENDC}
  279. FUNCTION TempFreeMem: LONGINT;
  280.     {$IFC NOT GENERATINGCFM}
  281.     INLINE $3F3C, $0018, $A88F;
  282.     {$ENDC}
  283. {  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  }
  284. PROCEDURE TempHLock(h: Handle; VAR resultCode: OSErr);
  285.     {$IFC NOT GENERATINGCFM}
  286.     INLINE $3F3C, $001E, $A88F;
  287.     {$ENDC}
  288. PROCEDURE TempHUnlock(h: Handle; VAR resultCode: OSErr);
  289.     {$IFC NOT GENERATINGCFM}
  290.     INLINE $3F3C, $001F, $A88F;
  291.     {$ENDC}
  292. PROCEDURE TempDisposeHandle(h: Handle; VAR resultCode: OSErr);
  293.     {$IFC NOT GENERATINGCFM}
  294.     INLINE $3F3C, $0020, $A88F;
  295.     {$ENDC}
  296. FUNCTION TempTopMem: Ptr;
  297.     {$IFC NOT GENERATINGCFM}
  298.     INLINE $3F3C, $0016, $A88F;
  299.     {$ENDC}
  300. PROCEDURE InitApplZone;
  301.     {$IFC NOT GENERATINGCFM}
  302.     INLINE $A02C;
  303.     {$ENDC}
  304. PROCEDURE InitZone(pgrowZone: GrowZoneUPP; cmoreMasters: INTEGER; limitPtr: UNIV Ptr; startPtr: UNIV Ptr);
  305. PROCEDURE SetZone(hz: THz);
  306.     {$IFC NOT GENERATINGCFM}
  307.     INLINE $205F, $A01B;
  308.     {$ENDC}
  309. FUNCTION CompactMem(cbNeeded: Size): Size;
  310.     {$IFC NOT GENERATINGCFM}
  311.     INLINE $201F, $A04C, $2E80;
  312.     {$ENDC}
  313. FUNCTION CompactMemSys(cbNeeded: Size): Size;
  314.     {$IFC NOT GENERATINGCFM}
  315.     INLINE $201F, $A44C, $2E80;
  316.     {$ENDC}
  317. PROCEDURE PurgeMem(cbNeeded: Size);
  318.     {$IFC NOT GENERATINGCFM}
  319.     INLINE $201F, $A04D;
  320.     {$ENDC}
  321. PROCEDURE PurgeMemSys(cbNeeded: Size);
  322.     {$IFC NOT GENERATINGCFM}
  323.     INLINE $201F, $A44D;
  324.     {$ENDC}
  325. FUNCTION FreeMem: LONGINT;
  326.     {$IFC NOT GENERATINGCFM}
  327.     INLINE $A01C, $2E80;
  328.     {$ENDC}
  329. FUNCTION FreeMemSys: LONGINT;
  330.     {$IFC NOT GENERATINGCFM}
  331.     INLINE $A41C, $2E80;
  332.     {$ENDC}
  333. PROCEDURE ReserveMem(cbNeeded: Size);
  334.     {$IFC NOT GENERATINGCFM}
  335.     INLINE $201F, $A040;
  336.     {$ENDC}
  337. PROCEDURE ReserveMemSys(cbNeeded: Size);
  338.     {$IFC NOT GENERATINGCFM}
  339.     INLINE $201F, $A440;
  340.     {$ENDC}
  341. FUNCTION MaxMem(VAR grow: Size): Size;
  342.     {$IFC NOT GENERATINGCFM}
  343.     INLINE $225F, $A11D, $2288, $2E80;
  344.     {$ENDC}
  345. FUNCTION MaxMemSys(VAR grow: Size): Size;
  346.     {$IFC NOT GENERATINGCFM}
  347.     INLINE $225F, $A51D, $2288, $2E80;
  348.     {$ENDC}
  349. PROCEDURE SetGrowZone(growZone: GrowZoneUPP);
  350.     {$IFC NOT GENERATINGCFM}
  351.     INLINE $205F, $A04B;
  352.     {$ENDC}
  353. PROCEDURE SetApplLimit(zoneLimit: UNIV Ptr);
  354.     {$IFC NOT GENERATINGCFM}
  355.     INLINE $205F, $A02D;
  356.     {$ENDC}
  357. PROCEDURE MoveHHi(h: Handle);
  358.     {$IFC NOT GENERATINGCFM}
  359.     INLINE $205F, $A064;
  360.     {$ENDC}
  361. PROCEDURE DisposePtr(p: Ptr);
  362.     {$IFC NOT GENERATINGCFM}
  363.     INLINE $205F, $A01F;
  364.     {$ENDC}
  365. FUNCTION GetPtrSize(p: Ptr): Size;
  366. PROCEDURE SetPtrSize(p: Ptr; newSize: Size);
  367.     {$IFC NOT GENERATINGCFM}
  368.     INLINE $201F, $205F, $A020;
  369.     {$ENDC}
  370. PROCEDURE DisposeHandle(h: Handle);
  371.     {$IFC NOT GENERATINGCFM}
  372.     INLINE $205F, $A023;
  373.     {$ENDC}
  374. PROCEDURE SetHandleSize(h: Handle; newSize: Size);
  375.     {$IFC NOT GENERATINGCFM}
  376.     INLINE $201F, $205F, $A024;
  377.     {$ENDC}
  378. FUNCTION GetHandleSize(h: Handle): Size;
  379. FUNCTION InlineGetHandleSize(h: Handle): Size;
  380.     {$IFC NOT GENERATINGCFM}
  381.     INLINE $205F, $A025, $2E80;
  382.     {$ENDC}
  383. PROCEDURE ReallocateHandle(h: Handle; byteCount: Size);
  384.     {$IFC NOT GENERATINGCFM}
  385.     INLINE $201F, $205F, $A027;
  386.     {$ENDC}
  387. PROCEDURE EmptyHandle(h: Handle);
  388.     {$IFC NOT GENERATINGCFM}
  389.     INLINE $205F, $A02B;
  390.     {$ENDC}
  391. PROCEDURE HSetRBit(h: Handle);
  392.     {$IFC NOT GENERATINGCFM}
  393.     INLINE $205F, $A067;
  394.     {$ENDC}
  395. PROCEDURE HClrRBit(h: Handle);
  396.     {$IFC NOT GENERATINGCFM}
  397.     INLINE $205F, $A068;
  398.     {$ENDC}
  399. PROCEDURE MoreMasters;
  400.     {$IFC NOT GENERATINGCFM}
  401.     INLINE $A036;
  402.     {$ENDC}
  403. PROCEDURE BlockMove(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  404.     {$IFC NOT GENERATINGCFM}
  405.     INLINE $201F, $225F, $205F, $A02E;
  406.     {$ENDC}
  407. PROCEDURE BlockMoveData(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  408.     {$IFC NOT GENERATINGCFM}
  409.     INLINE $201F, $225F, $205F, $A22E;
  410.     {$ENDC}
  411. PROCEDURE PurgeSpace(VAR total: LONGINT; VAR contig: LONGINT);
  412. FUNCTION HGetState(h: Handle): SInt8;
  413.     {$IFC NOT GENERATINGCFM}
  414.     INLINE $205F, $A069, $1E80;
  415.     {$ENDC}
  416. PROCEDURE HSetState(h: Handle; flags: ByteParameter);
  417.     {$IFC NOT GENERATINGCFM}
  418.     INLINE $101F, $205F, $A06A;
  419.     {$ENDC}
  420. PROCEDURE SetApplBase(startPtr: UNIV Ptr);
  421.     {$IFC NOT GENERATINGCFM}
  422.     INLINE $205F, $A057;
  423.     {$ENDC}
  424. PROCEDURE MaxApplZone;
  425.     {$IFC NOT GENERATINGCFM}
  426.     INLINE $A063;
  427.     {$ENDC}
  428. FUNCTION HoldMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  429.     {$IFC NOT GENERATINGCFM}
  430.     INLINE $225F, $205F, $7000, $A05C, $3E80;
  431.     {$ENDC}
  432. FUNCTION UnholdMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  433.     {$IFC NOT GENERATINGCFM}
  434.     INLINE $225F, $205F, $7001, $A05C, $3E80;
  435.     {$ENDC}
  436. FUNCTION LockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  437.     {$IFC NOT GENERATINGCFM}
  438.     INLINE $225F, $205F, $7002, $A05C, $3E80;
  439.     {$ENDC}
  440. FUNCTION LockMemoryContiguous(address: UNIV Ptr; count: LONGINT): OSErr;
  441.     {$IFC NOT GENERATINGCFM}
  442.     INLINE $225F, $205F, $7004, $A05C, $3E80;
  443.     {$ENDC}
  444. FUNCTION UnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  445.     {$IFC NOT GENERATINGCFM}
  446.     INLINE $225F, $205F, $7003, $A05C, $3E80;
  447.     {$ENDC}
  448. FUNCTION GetPhysical(VAR addresses: LogicalToPhysicalTable; VAR physicalEntryCount: LONGINT): OSErr;
  449. FUNCTION DeferUserFn(userFunction: UserFnUPP; argument: UNIV Ptr): OSErr;
  450.     {$IFC NOT GENERATINGCFM}
  451.     INLINE $201F, $205F, $A08F, $3E80;
  452.     {$ENDC}
  453. FUNCTION DebuggerGetMax: LONGINT;
  454.     {$IFC NOT GENERATINGCFM}
  455.     INLINE $7000, $A08D, $2E80;
  456.     {$ENDC}
  457. PROCEDURE DebuggerEnter;
  458.     {$IFC NOT GENERATINGCFM}
  459.     INLINE $7001, $A08D;
  460.     {$ENDC}
  461. PROCEDURE DebuggerExit;
  462.     {$IFC NOT GENERATINGCFM}
  463.     INLINE $7002, $A08D;
  464.     {$ENDC}
  465. PROCEDURE DebuggerPoll;
  466.     {$IFC NOT GENERATINGCFM}
  467.     INLINE $7003, $A08D;
  468.     {$ENDC}
  469. FUNCTION GetPageState(address: UNIV Ptr): PageState;
  470.     {$IFC NOT GENERATINGCFM}
  471.     INLINE $205F, $7004, $A08D, $3E80;
  472.     {$ENDC}
  473. FUNCTION PageFaultFatal: BOOLEAN;
  474.     {$IFC NOT GENERATINGCFM}
  475.     INLINE $7005, $A08D, $1E80;
  476.     {$ENDC}
  477. FUNCTION DebuggerLockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  478.     {$IFC NOT GENERATINGCFM}
  479.     INLINE $225F, $205F, $7006, $A08D, $3E80;
  480.     {$ENDC}
  481. FUNCTION DebuggerUnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  482.     {$IFC NOT GENERATINGCFM}
  483.     INLINE $225F, $205F, $7007, $A08D, $3E80;
  484.     {$ENDC}
  485. FUNCTION EnterSupervisorMode: StatusRegisterContents;
  486.     {$IFC NOT GENERATINGCFM}
  487.     INLINE $7008, $A08D, $3E80;
  488.     {$ENDC}
  489. { StripAddress and Translate24To32 macro to nothing on PowerPC
  490.    StripAddress is implemented as a trap in System 6 or later }
  491. {$IFC SystemSixOrLater }
  492. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  493.     {$IFC NOT GENERATINGCFM}
  494.     INLINE $201F, $A055, $2E80;
  495.     {$ENDC}
  496. {$ELSEC}
  497. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  498. {$ENDC}
  499. FUNCTION Translate24To32(addr24: UNIV Ptr): Ptr;
  500.     {$IFC NOT GENERATINGCFM}
  501.     INLINE $201F, $A091, $2E80;
  502.     {$ENDC}
  503. FUNCTION HandToHand(VAR theHndl: Handle): OSErr;
  504. FUNCTION PtrToXHand(srcPtr: UNIV Ptr; dstHndl: Handle; size: LONGINT): OSErr;
  505.     {$IFC NOT GENERATINGCFM}
  506.     INLINE $201F, $225F, $205F, $A9E2, $3E80;
  507.     {$ENDC}
  508. FUNCTION PtrToHand(srcPtr: UNIV Ptr; VAR dstHndl: Handle; size: LONGINT): OSErr;
  509. FUNCTION HandAndHand(hand1: Handle; hand2: Handle): OSErr;
  510.     {$IFC NOT GENERATINGCFM}
  511.     INLINE $225F, $205F, $A9E4, $3E80;
  512.     {$ENDC}
  513. FUNCTION PtrAndHand(ptr1: UNIV Ptr; hand2: Handle; size: LONGINT): OSErr;
  514.     {$IFC NOT GENERATINGCFM}
  515.     INLINE $201F, $225F, $205F, $A9EF, $3E80;
  516.     {$ENDC}
  517. {$IFC OLDROUTINENAMES }
  518. FUNCTION ApplicZone: THz;
  519.     {$IFC NOT GENERATINGCFM}
  520.     INLINE $2EB8, $02AA;
  521.     {$ENDC}
  522. FUNCTION MFTempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  523.     {$IFC NOT GENERATINGCFM}
  524.     INLINE $3F3C, $001D, $A88F;
  525.     {$ENDC}
  526. FUNCTION MFMaxMem(VAR grow: Size): Size;
  527.     {$IFC NOT GENERATINGCFM}
  528.     INLINE $3F3C, $0015, $A88F;
  529.     {$ENDC}
  530. FUNCTION MFFreeMem: LONGINT;
  531.     {$IFC NOT GENERATINGCFM}
  532.     INLINE $3F3C, $0018, $A88F;
  533.     {$ENDC}
  534. PROCEDURE MFTempHLock(h: Handle; VAR resultCode: OSErr);
  535.     {$IFC NOT GENERATINGCFM}
  536.     INLINE $3F3C, $001E, $A88F;
  537.     {$ENDC}
  538. PROCEDURE MFTempHUnlock(h: Handle; VAR resultCode: OSErr);
  539.     {$IFC NOT GENERATINGCFM}
  540.     INLINE $3F3C, $001F, $A88F;
  541.     {$ENDC}
  542. PROCEDURE MFTempDisposHandle(h: Handle; VAR resultCode: OSErr);
  543.     {$IFC NOT GENERATINGCFM}
  544.     INLINE $3F3C, $0020, $A88F;
  545.     {$ENDC}
  546. FUNCTION MFTopMem: Ptr;
  547.     {$IFC NOT GENERATINGCFM}
  548.     INLINE $3F3C, $0016, $A88F;
  549.     {$ENDC}
  550. PROCEDURE ResrvMem(cbNeeded: Size);
  551.     {$IFC NOT GENERATINGCFM}
  552.     INLINE $201F, $A040;
  553.     {$ENDC}
  554. PROCEDURE DisposPtr(p: Ptr);
  555.     {$IFC NOT GENERATINGCFM}
  556.     INLINE $205F, $A01F;
  557.     {$ENDC}
  558. PROCEDURE DisposHandle(h: Handle);
  559.     {$IFC NOT GENERATINGCFM}
  560.     INLINE $205F, $A023;
  561.     {$ENDC}
  562. PROCEDURE ReallocHandle(h: Handle; byteCount: Size);
  563.     {$IFC NOT GENERATINGCFM}
  564.     INLINE $201F, $205F, $A027;
  565.     {$ENDC}
  566. {$ENDC}
  567.  
  568. {$ALIGN RESET}
  569. {$POP}
  570.  
  571. {$SETC UsingIncludes := MemoryIncludes}
  572.  
  573. {$ENDC} {__MEMORY__}
  574.  
  575. {$IFC NOT UsingIncludes}
  576.  END.
  577. {$ENDC}
  578.