/*
File: MacMemory.java
Contains: Sample java bindings for MacMemory.h for use with JDirect 2.0 in MRJ 2.1.
Version: Technology: System 8.5
Release: MRJ 2.2
Copyright: © 1985-1999 by Apple Computer, Inc., all rights reserved
Bugs?: For bug reports, consult the following page on
the World Wide Web:
http://developer.apple.com/bugreporter/
Note: This is only sample code. You can copy any or all of these
classes into your own code. This sample code references other
sample classes in other files. You will need to put all sample
classes you use in the same package, or add import statements.
----------------------------
Some things commented out for better backwards-compatibility.
-jason
*/
package com.strangelight.mactoolbox;
import com.apple.mrj.macos.libraries.DriverServicesLib;
import com.apple.mrj.macos.libraries.InterfaceLib;
import com.apple.mrj.jdirect.Struct;
import com.apple.mrj.jdirect.ByteArrayStruct;
import com.apple.mrj.jdirect.PointerStruct;
import com.apple.mrj.jdirect.MethodClosureUPP;
// import com.apple.mrj.jdirect.NonNullArray;
/**
* The interface MemoryConstants contains java equivalents for all constants
* defined in the C header MacMemory.h
*
* When writing a java class which needs these constants, you can either use the
* fully qualified name of the constant (e.g. option = MemoryConstants.kWilyBit)
* or you can declare that your class implements MemoryConstants and then use the
* simple name (e.g. option = kWilyBit)
*/
public interface MemoryConstants {
/**
in C: 0x7FFFFFF0
the largest block possible
*/
public final int maxSize = 0x7FFFFFF0;
/**
in C: 8
*/
public final int defaultPhysicalEntryCount = 8;
/**
in C: 0
*/
public final short kPageInMemory = (short)0;
/**
in C: 1
*/
public final short kPageOnDisk = (short)1;
/**
in C: 2
*/
public final short kNotPaged = (short)2;
/**
in C: 1
valid in all Memory Managers
*/
public final byte k32BitHeap = (byte)1;
/**
in C: 2
true if new Heap Manager is present
*/
public final byte kNewStyleHeap = (byte)2;
/**
in C: 4
true if new Heap Manager is running in debug mode on this heap
*/
public final byte kNewDebugHeap = (byte)4;
/**
in C: 1
first version of VolumeVirtualMemoryInfo
*/
public final int kVolumeVirtualMemoryInfoVersion1= 1;
}
/**
* The class MemoryFunctions contains static native methods for all functions
* defined in the C header MacMemory.h
*
* These native methods are invoked via JDirect 2.0 which can bind directly to the MacOS
* shared library DriverServicesLib, InterfaceLib. Unlike JNI, no intermediate glue code is neeeded.
*
*/
public class MemoryFunctions implements DriverServicesLib, InterfaceLib {
/**
* No need to instantiate this class. All methods are static.
*/
private MemoryFunctions() {};
/**
* @return in C: Ptr
*/
public native static int GetApplLimit();
/**
* @return in C: THz
*/
public native static int SystemZone();
/**
* @return in C: THz
*/
public native static int ApplicationZone();
/**
* @return in C: Handle
*/
public native static int GZSaveHnd();
/**
* @return in C: Ptr
*/
public native static int TopMem();
/**
* @return in C: OSErr
*/
public native static short MemError();
/**
* @return in C: THz
*/
public native static int GetZone();
/**
* @param byteCount in C: Size byteCount
* @return in C: Handle
*/
public native static int NewHandle(int byteCount);
/**
* @param byteCount in C: Size byteCount
* @return in C: Handle
*/
public native static int NewHandleSys(int byteCount);
/**
* @param byteCount in C: Size byteCount
* @return in C: Handle
*/
public native static int NewHandleClear(int byteCount);
/**
* @param byteCount in C: Size byteCount
* @return in C: Handle
*/
public native static int NewHandleSysClear(int byteCount);
/**
* @param h in C: Handle h
* @return in C: THz
*/
public native static int HandleZone(int h);
/**
* @param p in C: Ptr p
* @return in C: Handle
*/
public native static int RecoverHandle(int p);
/**
* @param p in C: Ptr p
* @return in C: Handle
*/
public native static int RecoverHandleSys(int p);
/**
* @param byteCount in C: Size byteCount
* @return in C: Ptr
*/
public native static int NewPtr(int byteCount);
/**
* @param byteCount in C: Size byteCount
* @return in C: Ptr
*/
public native static int NewPtrSys(int byteCount);
/**
* @param byteCount in C: Size byteCount
* @return in C: Ptr
*/
public native static int NewPtrClear(int byteCount);
/**
* @param byteCount in C: Size byteCount
* @return in C: Ptr
*/
public native static int NewPtrSysClear(int byteCount);
/**
* @param p in C: Ptr p
* @return in C: THz
*/
public native static int PtrZone(int p);
/**
* @return in C: long
*/
public native static int MaxBlock();
/**
* @return in C: long
*/
public native static int MaxBlockSys();
/**
* @return in C: long
*/
public native static int StackSpace();
/**
* @return in C: Handle
*/
public native static int NewEmptyHandle();
/**
* @return in C: Handle
*/
public native static int NewEmptyHandleSys();
/**
* @param h in C: Handle h
*/
public native static void HLock(int h);
/**
* @param h in C: Handle h
*/
public native static void HUnlock(int h);
/**
* @param h in C: Handle h
*/
public native static void HPurge(int h);
/**
* @param h in C: Handle h
*/
public native static void HNoPurge(int h);
/**
* @param h in C: Handle h
*/
public native static void HLockHi(int h);
/**
* @param logicalSize in C: Size logicalSize
* @param resultCode in C: OSErr *resultCode
* @return in C: Handle
*/
public native static int TempNewHandle(int logicalSize, short [] resultCode);
/**
* @param grow in C: Size *grow
* @return in C: Size
*/
public native static int TempMaxMem(int [] grow);
/**
* @return in C: long
*/
public native static int TempFreeMem();
/**
* @param pgrowZone in C: GrowZoneUPP pgrowZone
* @param cmoreMasters in C: short cmoreMasters
* @param limitPtr in C: void *limitPtr
* @param startPtr in C: void *startPtr
*/
public static void InitZone(GrowZoneClosureUPP pgrowZone, short cmoreMasters, int limitPtr, int startPtr) {
InitZone(pgrowZone.getProc(), cmoreMasters, limitPtr, startPtr);
}
public native static void InitZone(int pgrowZone, short cmoreMasters, int limitPtr, int startPtr);
/**
* @param pgrowZone in C: GrowZoneUPP pgrowZone
* @param cmoreMasters in C: short cmoreMasters
* @param limitPtr in C: void *limitPtr
* @param startPtr in C: void *startPtr
*/
public static void InitZone(GrowZoneClosureUPP pgrowZone, short cmoreMasters, byte [] limitPtr, byte [] startPtr) {
InitZone(pgrowZone.getProc(), cmoreMasters, limitPtr, startPtr);
}
public native static void InitZone(int pgrowZone, short cmoreMasters, byte [] limitPtr, byte [] startPtr);
/**
* @param hz in C: THz hz
*/
public static void SetZone(ZoneStruct hz) {
SetZone(hz.getPointer());
}
public native static void SetZone(int hz);
/**
* @param cbNeeded in C: Size cbNeeded
* @return in C: Size
*/
public native static int CompactMem(int cbNeeded);
/**
* @param cbNeeded in C: Size cbNeeded
* @return in C: Size
*/
public native static int CompactMemSys(int cbNeeded);
/**
* @param cbNeeded in C: Size cbNeeded
*/
public native static void PurgeMem(int cbNeeded);
/**
* @param cbNeeded in C: Size cbNeeded
*/
public native static void PurgeMemSys(int cbNeeded);
/**
* @return in C: long
*/
public native static int FreeMem();
/**
* @return in C: long
*/
public native static int FreeMemSys();
/**
* @param cbNeeded in C: Size cbNeeded
*/
public native static void ReserveMem(int cbNeeded);
/**
* @param cbNeeded in C: Size cbNeeded
*/
public native static void ReserveMemSys(int cbNeeded);
/**
* @param grow in C: Size *grow
* @return in C: Size
*/
public native static int MaxMem(int [] grow);
/**
* @param grow in C: Size *grow
* @return in C: Size
*/
public native static int MaxMemSys(int [] grow);
/**
* @param growZone in C: GrowZoneUPP growZone
*/
public static void SetGrowZone(GrowZoneClosureUPP growZone) {
SetGrowZone(growZone.getProc());
}
public native static void SetGrowZone(int growZone);
/**
* @param h in C: Handle h
*/
public native static void MoveHHi(int h);
/**
* @param p in C: Ptr p
*/
public native static void DisposePtr(int p);
/**
* @param p in C: Ptr p
* @return in C: Size
*/
public native static int GetPtrSize(int p);
/**
* @param p in C: Ptr p
* @param newSize in C: Size newSize
*/
public native static void SetPtrSize(int p, int newSize);
/**
* @param h in C: Handle h
*/
public native static void DisposeHandle(int h);
/**
* @param h in C: Handle h
* @param newSize in C: Size newSize
*/
public native static void SetHandleSize(int h, int newSize);
/**
* @param h in C: Handle h
* @return in C: Size
*/
public native static int GetHandleSize(int h);
/**
* @param h in C: Handle h
* @return in C: Size
*/
public native static int InlineGetHandleSize(int h);
/**
* @param h in C: Handle h
* @param byteCount in C: Size byteCount
*/
public native static void ReallocateHandle(int h, int byteCount);
/**
* @param h in C: Handle h
* @param byteCount in C: Size byteCount
*/
public native static void ReallocateHandleSys(int h, int byteCount);
/**
* @param h in C: Handle h
*/
public native static void EmptyHandle(int h);
/**
* @param h in C: Handle h
*/
public native static void HSetRBit(int h);
/**
* @param h in C: Handle h
*/
public native static void HClrRBit(int h);
/**
* @param h in C: Handle h
* @return in C: SInt8
*/
public native static byte HGetState(int h);
/**
* @param h in C: Handle h
* @param flags in C: SInt8 flags
*/
public native static void HSetState(int h, byte flags);
/**
* @param total in C: long *total
* @param contig in C: long *contig
*/
public native static void PurgeSpace(int [] total, int [] contig);
/**
* @return in C: long
*/
public native static int PurgeSpaceTotal();
/**
* @return in C: long
*/
public native static int PurgeSpaceContiguous();
/**
* @return in C: long
*/
public native static int PurgeSpaceSysTotal();
/**
* @return in C: long
*/
public native static int PurgeSpaceSysContiguous();
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMove(int srcPtr, int destPtr, int byteCount);
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMove(byte [] srcPtr, byte [] destPtr, int byteCount);
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMoveData(int srcPtr, int destPtr, int byteCount);
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMoveData(byte [] srcPtr, byte [] destPtr, int byteCount);
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMoveUncached(int srcPtr, int destPtr, int byteCount);
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMoveUncached(byte [] srcPtr, byte [] destPtr, int byteCount);
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMoveDataUncached(int srcPtr, int destPtr, int byteCount);
/**
* @param srcPtr in C: const void *srcPtr
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockMoveDataUncached(byte [] srcPtr, byte [] destPtr, int byteCount);
/**
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockZero(int destPtr, int byteCount);
/**
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockZero(byte [] destPtr, int byteCount);
/**
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockZeroUncached(int destPtr, int byteCount);
/**
* @param destPtr in C: void *destPtr
* @param byteCount in C: Size byteCount
*/
public native static void BlockZeroUncached(byte [] destPtr, int byteCount);
/**
*/
public native static void MaxApplZone();
/**
* @param startPtr in C: void *startPtr
*/
public native static void SetApplBase(int startPtr);
/**
* @param startPtr in C: void *startPtr
*/
public native static void SetApplBase(byte [] startPtr);
/**
*/
public native static void MoreMasters();
// MoreMasterPointers() is not accessible from Java because it is only in CarbonLib
/**
* @param zoneLimit in C: void *zoneLimit
*/
public native static void SetApplLimit(int zoneLimit);
/**
* @param zoneLimit in C: void *zoneLimit
*/
public native static void SetApplLimit(byte [] zoneLimit);
/**
*/
public native static void InitApplZone();
/**
* @param h in C: Handle h
* @param resultCode in C: OSErr *resultCode
*/
public native static void TempHLock(int h, short [] resultCode);
/**
* @param h in C: Handle h
* @param resultCode in C: OSErr *resultCode
*/
public native static void TempHUnlock(int h, short [] resultCode);
/**
* @param h in C: Handle h
* @param resultCode in C: OSErr *resultCode
*/
public native static void TempDisposeHandle(int h, short [] resultCode);
/**
* @return in C: Ptr
*/
public native static int TempTopMem();
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short HoldMemory(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short HoldMemory(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short UnholdMemory(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short UnholdMemory(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short LockMemory(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short LockMemory(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short LockMemoryForOutput(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short LockMemoryForOutput(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short LockMemoryContiguous(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short LockMemoryContiguous(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short UnlockMemory(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short UnlockMemory(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short MakeMemoryResident(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short MakeMemoryResident(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short ReleaseMemoryData(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short ReleaseMemoryData(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short MakeMemoryNonResident(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short MakeMemoryNonResident(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short FlushMemory(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short FlushMemory(byte [] address, int count);
/**
* @param addresses in C: LogicalToPhysicalTable *addresses
* @param physicalEntryCountin C: unsigned long *physicalEntryCount
* @return in C: OSErr
public static short GetPhysical(LogicalToPhysicalTableStruct addresses, int [] physicalEntryCount) {
return GetPhysical(addresses.getByteArray(), NonNullArray.assert(physicalEntryCount));
}
public native static short GetPhysical(byte[] addresses, int [] physicalEntryCount);
*/
/**
* @param volVMInfo in C: VolumeVirtualMemoryInfoPtr volVMInfo
* @return in C: OSErr
*/
public static short GetVolumeVirtualMemoryInfo(VolumeVirtualMemoryInfoStruct volVMInfo) {
return GetVolumeVirtualMemoryInfo(volVMInfo.getByteArray());
}
public native static short GetVolumeVirtualMemoryInfo(byte[] volVMInfo);
/**
* @param userFunction in C: UserFnUPP userFunction
* @param argument in C: void *argument
* @return in C: OSErr
*/
public static short DeferUserFn(UserFnClosureUPP userFunction, int argument) {
return DeferUserFn(userFunction.getProc(), argument);
}
public native static short DeferUserFn(int userFunction, int argument);
/**
* @param userFunction in C: UserFnUPP userFunction
* @param argument in C: void *argument
* @return in C: OSErr
*/
public static short DeferUserFn(UserFnClosureUPP userFunction, byte [] argument) {
return DeferUserFn(userFunction.getProc(), argument);
}
public native static short DeferUserFn(int userFunction, byte [] argument);
/**
* @return in C: long
*/
public native static int DebuggerGetMax();
/**
*/
public native static void DebuggerEnter();
/**
*/
public native static void DebuggerExit();
/**
*/
public native static void DebuggerPoll();
/**
* @param address in C: const void *address
* @return in C: PageState
*/
public native static short GetPageState(int address);
/**
* @param address in C: const void *address
* @return in C: PageState
*/
public native static short GetPageState(byte [] address);
/**
* @return in C: Boolean
*/
public native static boolean PageFaultFatal();
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short DebuggerLockMemory(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short DebuggerLockMemory(byte [] address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short DebuggerUnlockMemory(int address, int count);
/**
* @param address in C: void *address
* @param count in C: unsigned long count
* @return in C: OSErr
*/
public native static short DebuggerUnlockMemory(byte [] address, int count);
/**
* @return in C: StatusRegisterContents
*/
public native static short EnterSupervisorMode();
/**
* @param theAddress in C: void *theAddress
* @return in C: Ptr
*/
public native static int StripAddress(int theAddress);
/**
* @param theAddress in C: void *theAddress
* @return in C: Ptr
*/
public native static int StripAddress(byte [] theAddress);
/**
* @param addr24 in C: void *addr24
* @return in C: Ptr
*/
public native static int Translate24To32(int addr24);
/**
* @param addr24 in C: void *addr24
* @return in C: Ptr
*/
public native static int Translate24To32(byte [] addr24);
/**
* @param theHndl in C: Handle *theHndl
* @return in C: OSErr
*/
public native static short HandToHand(int [] theHndl);
/**
* @param srcPtr in C: const void *srcPtr
* @param dstHndl in C: Handle dstHndl
* @param size in C: long size
* @return in C: OSErr
*/
public native static short PtrToXHand(int srcPtr, int dstHndl, int size);
/**
* @param srcPtr in C: const void *srcPtr
* @param dstHndl in C: Handle dstHndl
* @param size in C: long size
* @return in C: OSErr
*/
public native static short PtrToXHand(byte [] srcPtr, int dstHndl, int size);
/**
* @param srcPtr in C: const void *srcPtr
* @param dstHndl in C: Handle *dstHndl
* @param size in C: long size
* @return in C: OSErr
*/
public native static short PtrToHand(int srcPtr, int [] dstHndl, int size);
/**
* @param srcPtr in C: const void *srcPtr
* @param dstHndl in C: Handle *dstHndl
* @param size in C: long size
* @return in C: OSErr
*/
public native static short PtrToHand(byte [] srcPtr, int [] dstHndl, int size);
/**
* @param hand1 in C: Handle hand1
* @param hand2 in C: Handle hand2
* @return in C: OSErr
*/
public native static short HandAndHand(int hand1, int hand2);
/**
* @param ptr1 in C: const void *ptr1
* @param hand2 in C: Handle hand2
* @param size in C: long size
* @return in C: OSErr
*/
public native static short PtrAndHand(int ptr1, int hand2, int size);
/**
* @param ptr1 in C: const void *ptr1
* @param hand2 in C: Handle hand2
* @param size in C: long size
* @return in C: OSErr
*/
public native static short PtrAndHand(byte [] ptr1, int hand2, int size);
// CheckAllHeaps() is not accessible from Java because it is only in CarbonLib
// IsHeapValid() is not accessible from Java because it is only in CarbonLib
// IsHandleValid() is not accessible from Java because it is only in CarbonLib
// IsPointerValid() is not accessible from Java because it is only in CarbonLib
}
/**
* ZoneStruct is a class which holds a reference to the C struct Zone defined in MacMemory.h
* This class contains a get and set method for each field in Zone.
* Using JDirect 2.0, a ZoneStruct can be passed to a native toolbox function
* that expects a pointer to a Zone by using the getPointer() method.
*/
public class ZoneStruct extends PointerStruct {
/**
* Constructs a ZoneStruct given a pointer to a MacOS toolbox Zone
*/
public ZoneStruct(int pointer) {
super(pointer);
}
/**
* in C: Ptr bkLim
* @return field bkLim of struct Zone
*/
public final int getBkLim() {
return getIntAt(0);
}
/**
* in C: Ptr bkLim
* @param bkLim sets field bkLim of struct Zone
*/
public final void setBkLim(int bkLim) {
setIntAt(0, bkLim);
}
/**
* in C: Ptr purgePtr
* @return field purgePtr of struct Zone
*/
public final int getPurgePtr() {
return getIntAt(4);
}
/**
* in C: Ptr purgePtr
* @param purgePtr sets field purgePtr of struct Zone
*/
public final void setPurgePtr(int purgePtr) {
setIntAt(4, purgePtr);
}
/**
* in C: Ptr hFstFree
* @return field hFstFree of struct Zone
*/
public final int getHFstFree() {
return getIntAt(8);
}
/**
* in C: Ptr hFstFree
* @param hFstFree sets field hFstFree of struct Zone
*/
public final void setHFstFree(int hFstFree) {
setIntAt(8, hFstFree);
}
/**
* in C: long zcbFree
* @return field zcbFree of struct Zone
*/
public final int getZcbFree() {
return getIntAt(12);
}
/**
* in C: long zcbFree
* @param zcbFree sets field zcbFree of struct Zone
*/
public final void setZcbFree(int zcbFree) {
setIntAt(12, zcbFree);
}
/**
* in C: GrowZoneUPP gzProc
* @return field gzProc of struct Zone
*/
public final int getGzProc() {
return getIntAt(16);
}
/**
* in C: GrowZoneUPP gzProc
* @param gzProc sets field gzProc of struct Zone
*/
public final void setGzProc(int gzProc) {
setIntAt(16, gzProc);
}
/**
* in C: short moreMast
* @return field moreMast of struct Zone
*/
public final short getMoreMast() {
return getShortAt(20);
}
/**
* in C: short moreMast
* @param moreMast sets field moreMast of struct Zone
*/
public final void setMoreMast(short moreMast) {
setShortAt(20, moreMast);
}
/**
* in C: short flags
* @return field flags of struct Zone
*/
public final short getFlags() {
return getShortAt(22);
}
/**
* in C: short flags
* @param flags sets field flags of struct Zone
*/
public final void setFlags(short flags) {
setShortAt(22, flags);
}
/**
* in C: short cntRel
* @return field cntRel of struct Zone
*/
public final short getCntRel() {
return getShortAt(24);
}
/**
* in C: short cntRel
* @param cntRel sets field cntRel of struct Zone
*/
public final void setCntRel(short cntRel) {
setShortAt(24, cntRel);
}
/**
* in C: short maxRel
* @return field maxRel of struct Zone
*/
public final short getMaxRel() {
return getShortAt(26);
}
/**
* in C: short maxRel
* @param maxRel sets field maxRel of struct Zone
*/
public final void setMaxRel(short maxRel) {
setShortAt(26, maxRel);
}
/**
* in C: short cntNRel
* @return field cntNRel of struct Zone
*/
public final short getCntNRel() {
return getShortAt(28);
}
/**
* in C: short cntNRel
* @param cntNRel sets field cntNRel of struct Zone
*/
public final void setCntNRel(short cntNRel) {
setShortAt(28, cntNRel);
}
/**
* in C: SInt8 heapType
* @return field heapType of struct Zone
*/
public final byte getHeapType() {
return getByteAt(30);
}
/**
* in C: SInt8 heapType
* @param heapType sets field heapType of struct Zone
*/
public final void setHeapType(byte heapType) {
setByteAt(30, heapType);
}
/**
* in C: SInt8 unused
* @return field unused of struct Zone
*/
public final byte getUnused() {
return getByteAt(31);
}
/**
* in C: SInt8 unused
* @param unused sets field unused of struct Zone
*/
public final void setUnused(byte unused) {
setByteAt(31, unused);
}
/**
* in C: short cntEmpty
* @return field cntEmpty of struct Zone
*/
public final short getCntEmpty() {
return getShortAt(32);
}
/**
* in C: short cntEmpty
* @param cntEmpty sets field cntEmpty of struct Zone
*/
public final void setCntEmpty(short cntEmpty) {
setShortAt(32, cntEmpty);
}
/**
* in C: short cntHandles
* @return field cntHandles of struct Zone
*/
public final short getCntHandles() {
return getShortAt(34);
}
/**
* in C: short cntHandles
* @param cntHandles sets field cntHandles of struct Zone
*/
public final void setCntHandles(short cntHandles) {
setShortAt(34, cntHandles);
}
/**
* in C: long minCBFree
* @return field minCBFree of struct Zone
*/
public final int getMinCBFree() {
return getIntAt(36);
}
/**
* in C: long minCBFree
* @param minCBFree sets field minCBFree of struct Zone
*/
public final void setMinCBFree(int minCBFree) {
setIntAt(36, minCBFree);
}
/**
* in C: PurgeUPP purgeProc
* @return field purgeProc of struct Zone
*/
public final int getPurgeProc() {
return getIntAt(40);
}
/**
* in C: PurgeUPP purgeProc
* @param purgeProc sets field purgeProc of struct Zone
*/
public final void setPurgeProc(int purgeProc) {
setIntAt(40, purgeProc);
}
/**
* in C: Ptr sparePtr
* @return field sparePtr of struct Zone
*/
public final int getSparePtr() {
return getIntAt(44);
}
/**
* in C: Ptr sparePtr
* @param sparePtr sets field sparePtr of struct Zone
*/
public final void setSparePtr(int sparePtr) {
setIntAt(44, sparePtr);
}
/**
* in C: Ptr allocPtr
* @return field allocPtr of struct Zone
*/
public final int getAllocPtr() {
return getIntAt(48);
}
/**
* in C: Ptr allocPtr
* @param allocPtr sets field allocPtr of struct Zone
*/
public final void setAllocPtr(int allocPtr) {
setIntAt(48, allocPtr);
}
/**
* in C: short heapData
* @return field heapData of struct Zone
*/
public final short getHeapData() {
return getShortAt(52);
}
/**
* in C: short heapData
* @param heapData sets field heapData of struct Zone
*/
public final void setHeapData(short heapData) {
setShortAt(52, heapData);
}
/**
* Size of struct Zone in bytes
*/
public final static int sizeOfZone = 54;
public int getSize() {
return sizeOfZone;
}
}
/**
* MemoryBlockStruct is a class which mimics the C struct MemoryBlock defined in MacMemory.h
* This class contains a get and set method for each field in MemoryBlock.
* Using JDirect 2.0, a MemoryBlockStruct can be passed to a native toolbox function
* that expects a pointer to a MemoryBlock by using the getByteArray() method.
*/
public class MemoryBlockStruct extends ByteArrayStruct {
/**
* Constructs an uninitialized MemoryBlockStruct
*/
public MemoryBlockStruct() {
super(sizeOfMemoryBlock);
}
/**
* Constructs a MemoryBlockStruct and initializes it with the data in another Struct.
* Useful when a C struct MemoryBlock is embedded in another C struct and you want to
* copy it out.
* @param src the Struct containing the data to be copied
* @param offsetInSrc the offest in of the data in src
*/
public MemoryBlockStruct(Struct src, int offsetInSrc) {
super(sizeOfMemoryBlock);
byte[] bytes = src.getBytesAt(offsetInSrc, sizeOfMemoryBlock);
this.setBytesAt(0, bytes);
}
/**
* Used only by subclasses of MemoryBlockStruct
*/
protected MemoryBlockStruct(int size) {
super(size);
}
/**
* in C: void *address
* @return field address of struct MemoryBlock
*/
public final int getAddress() {
return getIntAt(0);
}
/**
* in C: void *address
* @param address sets field address of struct MemoryBlock
*/
public final void setAddress(int address) {
setIntAt(0, address);
}
/**
* in C: unsigned long count
* @return field count of struct MemoryBlock
*/
public final int getCount() {
return getIntAt(4);
}
/**
* in C: unsigned long count
* @param count sets field count of struct MemoryBlock
*/
public final void setCount(int count) {
setIntAt(4, count);
}
/**
* Size of struct MemoryBlock in bytes
*/
public final static int sizeOfMemoryBlock = 8;
public long getValue() {
return getLongAt(0);
}
}
/**
* LogicalToPhysicalTableStruct is a class which mimics the C struct LogicalToPhysicalTable defined in MacMemory.h
* This class contains a get and set method for each field in LogicalToPhysicalTable.
* Using JDirect 2.0, a LogicalToPhysicalTableStruct can be passed to a native toolbox function
* that expects a pointer to a LogicalToPhysicalTable by using the getByteArray() method.
*/
public class LogicalToPhysicalTableStruct extends ByteArrayStruct {
/**
* Constructs an uninitialized LogicalToPhysicalTableStruct
*/
public LogicalToPhysicalTableStruct() {
super(sizeOfLogicalToPhysicalTable);
}
/**
* Constructs a LogicalToPhysicalTableStruct and initializes it with the data in another Struct.
* Useful when a C struct LogicalToPhysicalTable is embedded in another C struct and you want to
* copy it out.
* @param src the Struct containing the data to be copied
* @param offsetInSrc the offest in of the data in src
*/
public LogicalToPhysicalTableStruct(Struct src, int offsetInSrc) {
super(sizeOfLogicalToPhysicalTable);
byte[] bytes = src.getBytesAt(offsetInSrc, sizeOfLogicalToPhysicalTable);
this.setBytesAt(0, bytes);
}
/**
* Used only by subclasses of LogicalToPhysicalTableStruct
*/
protected LogicalToPhysicalTableStruct(int size) {
super(size);
}
/**
* in C: MemoryBlock logical
* @return field logical of struct LogicalToPhysicalTable
*/
public final MemoryBlockStruct getLogical() {
return new MemoryBlockStruct (this, 0);
}
/**
* in C: MemoryBlock logical
* @param logical sets field logical of struct LogicalToPhysicalTable
*/
public final void setLogical(MemoryBlockStruct logical) {
setStructAt(0, logical);
}
/**
* in C: MemoryBlock physical[8]
* @param arrayindex zero based index
* @return arrayindex element of field physical of struct LogicalToPhysicalTable
*/
public final MemoryBlockStruct getPhysical(int arrayindex) {
return new MemoryBlockStruct (this, 8 + (arrayindex*8));
}
/**
* in C: MemoryBlock physical[8]
* @param arrayindex zero based index
* @param physical sets arrayindex element of field physical of struct LogicalToPhysicalTable
*/
public final void setPhysical(int arrayindex, MemoryBlockStruct physical) {
setStructAt(8 + (arrayindex*8), physical);
}
/**
* Size of struct LogicalToPhysicalTable in bytes
*/
public final static int sizeOfLogicalToPhysicalTable = 72;
}
/**
* VolumeVirtualMemoryInfoStruct is a class which mimics the C struct VolumeVirtualMemoryInfo defined in MacMemory.h
* This class contains a get and set method for each field in VolumeVirtualMemoryInfo.
* Using JDirect 2.0, a VolumeVirtualMemoryInfoStruct can be passed to a native toolbox function
* that expects a pointer to a VolumeVirtualMemoryInfo by using the getByteArray() method.
*/
public class VolumeVirtualMemoryInfoStruct extends ByteArrayStruct {
/**
* Constructs an uninitialized VolumeVirtualMemoryInfoStruct
*/
public VolumeVirtualMemoryInfoStruct() {
super(sizeOfVolumeVirtualMemoryInfo);
}
/**
* Constructs a VolumeVirtualMemoryInfoStruct and initializes it with the data in another Struct.
* Useful when a C struct VolumeVirtualMemoryInfo is embedded in another C struct and you want to
* copy it out.
* @param src the Struct containing the data to be copied
* @param offsetInSrc the offest in of the data in src
*/
public VolumeVirtualMemoryInfoStruct(Struct src, int offsetInSrc) {
super(sizeOfVolumeVirtualMemoryInfo);
byte[] bytes = src.getBytesAt(offsetInSrc, sizeOfVolumeVirtualMemoryInfo);
this.setBytesAt(0, bytes);
}
/**
* Used only by subclasses of VolumeVirtualMemoryInfoStruct
*/
protected VolumeVirtualMemoryInfoStruct(int size) {
super(size);
}
/**
* in C: PBVersion version
* @return field version of struct VolumeVirtualMemoryInfo
*/
public final int getVersion() {
return getIntAt(0);
}
/**
* in C: PBVersion version
* @param version sets field version of struct VolumeVirtualMemoryInfo
*/
public final void setVersion(int version) {
setIntAt(0, version);
}
/**
* in C: SInt16 volumeRefNum
* @return field volumeRefNum of struct VolumeVirtualMemoryInfo
*/
public final short getVolumeRefNum() {
return getShortAt(4);
}
/**
* in C: SInt16 volumeRefNum
* @param volumeRefNum sets field volumeRefNum of struct VolumeVirtualMemoryInfo
*/
public final void setVolumeRefNum(short volumeRefNum) {
setShortAt(4, volumeRefNum);
}
/**
* in C: Boolean inUse
* @return field inUse of struct VolumeVirtualMemoryInfo
*/
public final boolean getInUse() {
return getBooleanAt(6);
}
/**
* in C: Boolean inUse
* @param inUse sets field inUse of struct VolumeVirtualMemoryInfo
*/
public final void setInUse(boolean inUse) {
setBooleanAt(6, inUse);
}
/**
* in C: UInt8 _fill
* @return field _fill of struct VolumeVirtualMemoryInfo
*/
public final byte get_fill() {
return getByteAt(7);
}
/**
* in C: UInt8 _fill
* @param _fill sets field _fill of struct VolumeVirtualMemoryInfo
*/
public final void set_fill(byte _fill) {
setByteAt(7, _fill);
}
/**
* in C: UInt32 vmOptions
* @return field vmOptions of struct VolumeVirtualMemoryInfo
*/
public final int getVmOptions() {
return getIntAt(8);
}
/**
* in C: UInt32 vmOptions
* @param vmOptions sets field vmOptions of struct VolumeVirtualMemoryInfo
*/
public final void setVmOptions(int vmOptions) {
setIntAt(8, vmOptions);
}
/**
* Size of struct VolumeVirtualMemoryInfo in bytes
*/
public final static int sizeOfVolumeVirtualMemoryInfo = 12;
}
/**
* The interface GrowZoneInterface defines the java interface which a class
* must implement if it wants to be called by native code which expects a GrowZoneProcPtr
* function pointer as defined in the C header MacMemory.h
*
* @see GrowZoneClosureUPP
*/
public interface GrowZoneInterface {
/**
* The method GrowZone will be invoked via a GrowZoneClosureUPP thunk.
* No conversion is done to wrap java objects around the raw native parameters.
* You may need to do the conversion yourself.
*
* @param cbNeeded in C: Size cbNeeded
* @return in C: long
*/
public int GrowZone(int cbNeeded);
}
/**
* The class GrowZoneClosureUPP defines thunk objects which support transitioning
* from a GrowZoneProcPtr (as defined in the C header MacMemory.hfile) function pointer * into the MRJ Java VM.
*
*
* @see GrowZoneInterface
*/
public final class GrowZoneClosureUPP extends MethodClosureUPP {
/**
* To instantiate a GrowZoneClosureUPP object you must pass the constructor an object which implements
* the GrowZoneInterface interface.
* Do not subclass this class. It is a thunk that glues native code to java code.
*/
public GrowZoneClosureUPP(GrowZoneInterface context) {
super(context, "GrowZone", "(I)I", 0x000000F0);
}
}
/**
* The interface PurgeInterface defines the java interface which a class
* must implement if it wants to be called by native code which expects a PurgeProcPtr
* function pointer as defined in the C header MacMemory.h
*
* @see PurgeClosureUPP
*/
public interface PurgeInterface {
/**
* The method Purge will be invoked via a PurgeClosureUPP thunk.
* No conversion is done to wrap java objects around the raw native parameters.
* You may need to do the conversion yourself.
*
* @param blockToPurge in C: Handle blockToPurge
*/
public void Purge(int blockToPurge);
}
/**
* The class PurgeClosureUPP defines thunk objects which support transitioning
* from a PurgeProcPtr (as defined in the C header MacMemory.hfile) function pointer * into the MRJ Java VM.
*
*
* @see PurgeInterface
*/
public final class PurgeClosureUPP extends MethodClosureUPP {
/**
* To instantiate a PurgeClosureUPP object you must pass the constructor an object which implements
* the PurgeInterface interface.
* Do not subclass this class. It is a thunk that glues native code to java code.
*/
public PurgeClosureUPP(PurgeInterface context) {
super(context, "Purge", "(I)V", 0x000000C0);
}
}
/**
* The interface UserFnInterface defines the java interface which a class
* must implement if it wants to be called by native code which expects a UserFnProcPtr
* function pointer as defined in the C header MacMemory.h
*
* @see UserFnClosureUPP
*/
public interface UserFnInterface {
/**
* The method UserFn will be invoked via a UserFnClosureUPP thunk.
* No conversion is done to wrap java objects around the raw native parameters.
* You may need to do the conversion yourself.
*
* @param parameter in C: void *parameter
*/
public void UserFn(int parameter);
}
/**
* The class UserFnClosureUPP defines thunk objects which support transitioning
* from a UserFnProcPtr (as defined in the C header MacMemory.hfile) function pointer * into the MRJ Java VM.
*
*
* @see UserFnInterface
*/
public final class UserFnClosureUPP extends MethodClosureUPP {
/**
* To instantiate a UserFnClosureUPP object you must pass the constructor an object which implements
* the UserFnInterface interface.
* Do not subclass this class. It is a thunk that glues native code to java code.
*/
public UserFnClosureUPP(UserFnInterface context) {
super(context, "UserFn", "(I)V", 0x00009802);
}
}