Package Name: memory
with Interfaces.C; use Interfaces.C;
with Interfaces.C.Extensions; use Interfaces.C.Extensions;
with Types; use Types;
package Memory is
--
-- File: Memory.h
--
-- Contains: Memory Manager Interfaces.
--
-- Version: Technology: System 7.5
-- Package: Universal Interfaces 2.0 in ÒMPW LatestÓ on ETO #17
--
-- Copyright: © 1984-1995 by Apple Computer, Inc.
-- All rights reserved.
--
-- Bugs?: If you find a problem with this file, use the Apple Bug Reporter
-- stack. Include the file and version information (from above)
-- in the problem description and send to:
-- Internet: apple.bugs@applelink.apple.com
-- AppleLink: APPLE.BUGS
--
--
-- size of a block in bytes
subtype Size is Long_Integer;
type GrowZoneProcPtr is access function
(cbNeeded : in Size)
return Long_Integer;
type PurgeProcPtr is Access procedure
(blockToPurge : in Handle);
subtype GrowZoneUPP is UniversalProcPtr;
subtype PurgeUPP is UniversalProcPtr;
subtype UserFnUPP is UniversalProcPtr;
type Zone is
record
bkLim : Ptr;
purgePtr : Ptr;
hFstFree : Ptr;
zcbFree : Long_Integer;
gzProc : GrowZoneUPP;
moreMast : Short_Integer;
flags : Short_Integer;
cntRel : Short_Integer;
maxRel : Short_Integer;
cntNRel : Short_Integer;
heapType : Byte;
unused : Byte;
cntEmpty : Short_Integer;
cntHandles : Short_Integer;
minCBFree : Long_Integer;
purgeProc : PurgeUPP;
sparePtr : Ptr;
allocPtr : Ptr;
heapData : Short_Integer;
end record;
type THz is Access Zone;
type MemoryBlock is
record
address : Void_Ptr;
count : unsigned_long;
end record;
type MemoryBlock_Vec_8 is array (0 .. 7) of MemoryBlock;
type LogicalToPhysicalTable is
record
logical : MemoryBlock;
physical : MemoryBlock_Vec_8;
end record;
subtype PageState is Short_Integer;
subtype StatusRegisterContents is Short_Integer;
function GetApplLimit
return Ptr;
pragma Import (C, GetApplLimit, "GetApplLimit", "GetApplLimit");
function SystemZone
return THz;
pragma Import (C, SystemZone, "SystemZone", "SystemZone");
function ApplicationZone
return THz;
pragma Import (C, ApplicationZone, "ApplicationZone", "ApplicationZone");
function GZSaveHnd
return Handle;
pragma Import (C, GZSaveHnd, "GZSaveHnd", "GZSaveHnd");
function TopMem
return Ptr;
pragma Import (C, TopMem, "TopMem", "TopMem");
function MemError
return OSErr;
pragma Import (C, MemError, "MemError", "MemError");
function GetZone
return THz;
pragma Import (C, GetZone, "GetZone", "GetZone");
function NewHandle
(byteCount : in Size)
return Handle;
pragma Import (C, NewHandle, "NewHandle", "NewHandle");
function NewHandleSys
(byteCount : in Size)
return Handle;
pragma Import (C, NewHandleSys, "NewHandleSys", "NewHandleSys");
function NewHandleClear
(byteCount : in Size)
return Handle;
pragma Import (C, NewHandleClear, "NewHandleClear", "NewHandleClear");
function NewHandleSysClear
(byteCount : in Size)
return Handle;
pragma Import (C, NewHandleSysClear, "NewHandleSysClear", "NewHandleSysClear");
function HandleZone
(h : in Handle)
return THz;
pragma Import (C, HandleZone, "HandleZone", "HandleZone");
function RecoverHandle
(p : in Ptr)
return Handle;
pragma Import (C, RecoverHandle, "RecoverHandle", "RecoverHandle");
function RecoverHandleSys
(p : in Ptr)
return Handle;
pragma Import (C, RecoverHandleSys, "RecoverHandleSys", "RecoverHandleSys");
function NewPtr
(byteCount : in Size)
return Ptr;
pragma Import (C, NewPtr, "NewPtr", "NewPtr");
function NewPtrSys
(byteCount : in Size)
return Ptr;
pragma Import (C, NewPtrSys, "NewPtrSys", "NewPtrSys");
function NewPtrClear
(byteCount : in Size)
return Ptr;
pragma Import (C, NewPtrClear, "NewPtrClear", "NewPtrClear");
function NewPtrSysClear
(byteCount : in Size)
return Ptr;
pragma Import (C, NewPtrSysClear, "NewPtrSysClear", "NewPtrSysClear");
function PtrZone
(p : in Ptr)
return THz;
pragma Import (C, PtrZone, "PtrZone", "PtrZone");
function MaxBlock
return Long_Integer;
pragma Import (C, MaxBlock, "MaxBlock", "MaxBlock");
function MaxBlockSys
return Long_Integer;
pragma Import (C, MaxBlockSys, "MaxBlockSys", "MaxBlockSys");
function StackSpace
return Long_Integer;
pragma Import (C, StackSpace, "StackSpace", "StackSpace");
function NewEmptyHandle
return Handle;
pragma Import (C, NewEmptyHandle, "NewEmptyHandle", "NewEmptyHandle");
function NewEmptyHandleSys
return Handle;
pragma Import (C, NewEmptyHandleSys, "NewEmptyHandleSys", "NewEmptyHandleSys");
procedure HLock
(h : in Handle);
pragma Import (C, HLock, "HLock", "HLock");
procedure HUnlock
(h : in Handle);
pragma Import (C, HUnlock, "HUnlock", "HUnlock");
procedure HPurge
(h : in Handle);
pragma Import (C, HPurge, "HPurge", "HPurge");
procedure HNoPurge
(h : in Handle);
pragma Import (C, HNoPurge, "HNoPurge", "HNoPurge");
procedure HLockHi
(h : in Handle);
pragma Import (C, HLockHi, "HLockHi", "HLockHi");
function TempNewHandle
(logicalSize : in Size;
resultCode : access OSErr)
return Handle;
pragma Import (C, TempNewHandle, "TempNewHandle", "TempNewHandle");
function TempMaxMem
(grow : access Size)
return Size;
pragma Import (C, TempMaxMem, "TempMaxMem", "TempMaxMem");
function TempFreeMem
return Long_Integer;
pragma Import (C, TempFreeMem, "TempFreeMem", "TempFreeMem");
-- Temporary Memory routines renamed, but obsolete, in System 7.0 and later.
procedure TempHLock
(h : in Handle;
resultCode : access OSErr);
pragma Import (C, TempHLock, "TempHLock", "TempHLock");
procedure TempHUnlock
(h : in Handle;
resultCode : access OSErr);
pragma Import (C, TempHUnlock, "TempHUnlock", "TempHUnlock");
procedure TempDisposeHandle
(h : in Handle;
resultCode : access OSErr);
pragma Import (C, TempDisposeHandle, "TempDisposeHandle", "TempDisposeHandle");
function TempTopMem
return Ptr;
pragma Import (C, TempTopMem, "TempTopMem", "TempTopMem");
procedure InitApplZone;
pragma Import (C, InitApplZone, "InitApplZone", "InitApplZone");
procedure InitZone
(pgrowZone : in GrowZoneUPP;
cmoreMasters : in Short_Integer;
limitPtr : in Void_Ptr;
startPtr : in Void_Ptr);
pragma Import (C, InitZone, "InitZone", "InitZone");
procedure SetZone
(hz : in THz);
pragma Import (C, SetZone, "SetZone", "SetZone");
function CompactMem
(cbNeeded : in Size)
return Size;
pragma Import (C, CompactMem, "CompactMem", "CompactMem");
function CompactMemSys
(cbNeeded : in Size)
return Size;
pragma Import (C, CompactMemSys, "CompactMemSys", "CompactMemSys");
procedure PurgeMem
(cbNeeded : in Size);
pragma Import (C, PurgeMem, "PurgeMem", "PurgeMem");
procedure PurgeMemSys
(cbNeeded : in Size);
pragma Import (C, PurgeMemSys, "PurgeMemSys", "PurgeMemSys");
function FreeMem
return Long_Integer;
pragma Import (C, FreeMem, "FreeMem", "FreeMem");
function FreeMemSys
return Long_Integer;
pragma Import (C, FreeMemSys, "FreeMemSys", "FreeMemSys");
procedure ReserveMem
(cbNeeded : in Size);
pragma Import (C, ReserveMem, "ReserveMem", "ReserveMem");
procedure ReserveMemSys
(cbNeeded : in Size);
pragma Import (C, ReserveMemSys, "ReserveMemSys", "ReserveMemSys");
function MaxMem
(grow : access Size)
return Size;
pragma Import (C, MaxMem, "MaxMem", "MaxMem");
function MaxMemSys
(grow : access Size)
return Size;
pragma Import (C, MaxMemSys, "MaxMemSys", "MaxMemSys");
procedure SetGrowZone
(growZone : in GrowZoneUPP);
pragma Import (C, SetGrowZone, "SetGrowZone", "SetGrowZone");
procedure SetApplLimit
(zoneLimit : in Void_Ptr);
pragma Import (C, SetApplLimit, "SetApplLimit", "SetApplLimit");
procedure MoveHHi
(h : in Handle);
pragma Import (C, MoveHHi, "MoveHHi", "MoveHHi");
procedure DisposePtr
(p : in Ptr);
pragma Import (C, DisposePtr, "DisposePtr", "DisposePtr");
function GetPtrSize
(p : in Ptr)
return Size;
pragma Import (C, GetPtrSize, "GetPtrSize", "GetPtrSize");
procedure SetPtrSize
(p : in Ptr;
newSize : in Size);
pragma Import (C, SetPtrSize, "SetPtrSize", "SetPtrSize");
procedure DisposeHandle
(h : in Handle);
pragma Import (C, DisposeHandle, "DisposeHandle", "DisposeHandle");
procedure SetHandleSize
(h : in Handle;
newSize : in Size);
pragma Import (C, SetHandleSize, "SetHandleSize", "SetHandleSize");
function GetHandleSize
(h : in Handle)
return Size;
pragma Import (C, GetHandleSize, "GetHandleSize", "GetHandleSize");
function InlineGetHandleSize
(h : in Handle)
return Size;
pragma Import (C, InlineGetHandleSize, "InlineGetHandleSize", "InlineGetHandleSize");
procedure ReallocateHandle
(h : in Handle;
byteCount : in Size);
pragma Import (C, ReallocateHandle, "ReallocateHandle", "ReallocateHandle");
procedure EmptyHandle
(h : in Handle);
pragma Import (C, EmptyHandle, "EmptyHandle", "EmptyHandle");
procedure HSetRBit
(h : in Handle);
pragma Import (C, HSetRBit, "HSetRBit", "HSetRBit");
procedure HClrRBit
(h : in Handle);
pragma Import (C, HClrRBit, "HClrRBit", "HClrRBit");
procedure MoreMasters;
pragma Import (C, MoreMasters, "MoreMasters", "MoreMasters");
procedure BlockMove
(srcPtr : in Void_Ptr;
destPtr : in Void_Ptr;
byteCount : in Size);
pragma Import (C, BlockMove, "BlockMove", "BlockMove");
procedure BlockMoveData
(srcPtr : in Void_Ptr;
destPtr : in Void_Ptr;
byteCount : in Size);
pragma Import (C, BlockMoveData, "BlockMoveData", "BlockMoveData");
procedure PurgeSpace
(total : access Long_Integer;
contig : access Long_Integer);
pragma Import (C, PurgeSpace, "PurgeSpace", "PurgeSpace");
function HGetState
(h : in Handle)
return SInt8;
pragma Import (C, HGetState, "HGetState", "HGetState");
procedure HSetState
(h : in Handle;
flags : in SInt8);
pragma Import (C, HSetState, "HSetState", "HSetState");
procedure SetApplBase
(startPtr : in Void_Ptr);
pragma Import (C, SetApplBase, "SetApplBase", "SetApplBase");
procedure MaxApplZone;
pragma Import (C, MaxApplZone, "MaxApplZone", "MaxApplZone");
function HoldMemory
(address : in Void_Ptr;
count : in unsigned_long)
return OSErr;
pragma Import (C, HoldMemory, "HoldMemory", "HoldMemory");
function UnholdMemory
(address : in Void_Ptr;
count : in unsigned_long)
return OSErr;
pragma Import (C, UnholdMemory, "UnholdMemory", "UnholdMemory");
function LockMemory
(address : in Void_Ptr;
count : in unsigned_long)
return OSErr;
pragma Import (C, LockMemory, "LockMemory", "LockMemory");
function LockMemoryContiguous
(address : in Void_Ptr;
count : in unsigned_long)
return OSErr;
pragma Import (C, LockMemoryContiguous, "LockMemoryContiguous", "LockMemoryContiguous");
function UnlockMemory
(address : in Void_Ptr;
count : in unsigned_long)
return OSErr;
pragma Import (C, UnlockMemory, "UnlockMemory", "UnlockMemory");
function GetPhysical
(addresses : access LogicalToPhysicalTable;
physicalEntryCount : access unsigned_long)
return OSErr;
pragma Import (C, GetPhysical, "GetPhysical", "GetPhysical");
function DeferUserFn
(userFunction : in UserFnUPP;
argument : in Void_Ptr)
return OSErr;
pragma Import (C, DeferUserFn, "DeferUserFn", "DeferUserFn");
function DebuggerGetMax
return Long_Integer;
pragma Import (C, DebuggerGetMax, "DebuggerGetMax", "DebuggerGetMax");
procedure DebuggerEnter;
pragma Import (C, DebuggerEnter, "DebuggerEnter", "DebuggerEnter");
procedure DebuggerExit;
pragma Import (C, DebuggerExit, "DebuggerExit", "DebuggerExit");
procedure DebuggerPoll;
pragma Import (C, DebuggerPoll, "DebuggerPoll", "DebuggerPoll");
function GetPageState
(address : in Void_Ptr)
return PageState;
pragma Import (C, GetPageState, "GetPageState", "GetPageState");
function PageFaultFatal
return Boolean;
pragma Import (C, PageFaultFatal, "PageFaultFatal", "PageFaultFatal");
function DebuggerLockMemory
(address : in Void_Ptr;
count : in unsigned_long)
return OSErr;
pragma Import (C, DebuggerLockMemory, "DebuggerLockMemory", "DebuggerLockMemory");
function DebuggerUnlockMemory
(address : in Void_Ptr;
count : in unsigned_long)
return OSErr;
pragma Import (C, DebuggerUnlockMemory, "DebuggerUnlockMemory", "DebuggerUnlockMemory");
function EnterSupervisorMode
return StatusRegisterContents;
pragma Import (C, EnterSupervisorMode, "EnterSupervisorMode", "EnterSupervisorMode");
function HandToHand
(theHndl : access Handle)
return OSErr;
pragma Import (C, HandToHand, "HandToHand", "HandToHand");
function PtrToXHand
(srcPtr : in Void_Ptr;
dstHndl : in Handle;
size : in Long_Integer)
return OSErr;
pragma Import (C, PtrToXHand, "PtrToXHand", "PtrToXHand");
function PtrToHand
(srcPtr : in Void_Ptr;
dstHndl : access Handle;
size : in Long_Integer)
return OSErr;
pragma Import (C, PtrToHand, "PtrToHand", "PtrToHand");
function HandAndHand
(hand1 : in Handle;
hand2 : in Handle)
return OSErr;
pragma Import (C, HandAndHand, "HandAndHand", "HandAndHand");
function PtrAndHand
(ptr1 : in Void_Ptr;
hand2 : in Handle;
size : in Long_Integer)
return OSErr;
pragma Import (C, PtrAndHand, "PtrAndHand", "PtrAndHand");
end Memory;