MachCall: SIGNAL [errorCode: msgReturnT, explanation: Rope.ROPE];

MachAnomaly: SIGNAL [explanation: Rope.ROPE];

kernReturnT: TYPE = INT32;

KernSuccess: INT = 0;

KernInvalidAddress: INT = 1;

KernProtectionFailure: INT = 2;

KernNoSpace: INT = 3;

KernInvalidArgument: INT = 4;

KernFailure: INT = 5;

KernResourceShortage: INT = 6;

KernNotReceiver: INT = 7;

KernNoAccess: INT = 8;

MsgSizeMax: INT = 8192;

msgSizeT: TYPE = CARD32;

msgOptionT: TYPE = CARD32;

msgHeaderT: TYPE = MACHINE DEPENDENT RECORD [

msgTypeT: TYPE = MACHINE DEPENDENT RECORD [

msgTypeLongT: TYPE = MACHINE DEPENDENT RECORD [

notificationT: TYPE = MACHINE DEPENDENT RECORD [

deathPillT: TYPE = MACHINE DEPENDENT RECORD [

msgReturnT: TYPE = INT;

Known values for the msg←type←name field. The only types known to the Mach kernel are the port types, and those types used in the kernel RPC interface.

MsgTypeUnstructured: INT = 0;

MsgTypeBit: INT =  0;

MsgTypeBoolean: INT = 0;

MsgTypeInteger16: INT = 1;

MsgTypeInteger32: INT = 2;

MsgTypePortOwnership: INT = 3;

MsgTypePortReceive: INT = 4;

MsgTypePortAll: INT = 5;

MsgTypePort: INT =  6;

MsgTypeChar: INT =  8;

MsgTypeByte: INT =  9;

MsgTypeInteger8: INT = 9;

MsgTypeReal: INT =  10;

MsgTypeString: INT =  12;

MsgTypeStringC: INT = 12;

MsgTypeInvalid: INT = 13;  -- Used by the kernel to mark invalid data

Options to IPC primitives. These can be combined by or'ing; the combination RPC call uses both SEND← and RCV← options at once.

MsgOptionNone: INT = 0000H;  -- Terminate only when message op works

SendTimeout: INT =  0001H;  -- Terminate on timeout elapsed

SendNotify: INT =  0002H;  -- Terminate with reply message if need be

SendInterrupt: INT = 0004H;  -- Terminate on software interrupt

SendAlways: INT =  0008H;  -- KERNEL only: never block

SendKernel: INT =  0010H;  -- KERNEL only: kernel is originator

RcvTimeout: INT =  0100H;  -- Terminate on timeout elapsed

RcvNoSenders: INT = 0200H;  -- Terminate if I'm the only sender left

RcvInterrupt: INT =  0400H;  -- Terminate on software interrupt

Send codes.

SendSuccess: INT = 0;

SendErrorsStart: INT = -100;

SendInvalidMemory: INT = -101;  -- Message structure or out-of-line data invalid

SendInvalidPort: INT = -102;  -- Reference to inacessible port

SendTimedOut: INT =  -103;  -- Terminated due to timeout

SendWillNotify: INT = -105;  -- Last message accepted until notification sent

SendNotifyInProgress: INT = -106;  -- Already awaiting a notification

SendKernelRefused: INT = -107;  -- Message to the kernel refused

SendInterrupted: INT = -108;  -- Software interrupt during send

SendMsgTooLarge: INT = -109;  -- Message specified was too large

SendMsgTooSmall: INT = -110;  -- Data specified exceeds message size

SendMsgSizeChange: INT = -111;  -- Message size changed while being copied

RcvErrorsStart: INT = -200;

RcvInvalidMemory: INT = -201;

RCVInvalidPort: INT = -202;

RcvTimedOut: INT =  -203;

RcvTooLarge: INT =  -204;  -- Message structure too small to hold data

RcvNotEnoughMemory: INT = -205;  -- Unable to find address space to put out-of-line data

RcvOnlySender: INT =  -206;  -- Receiver/owner are only remaining senders

RcvInterrupted: INT =  -207;

RcvPortChange: INT =  -208;  -- Port receiver changed, or port became enabled

NotifyFirst: INT =   0100B;

NotifyPortDeleted: INT =   NotifyFirst + 001;

NotifyMsgAccepted: INT =  NotifyFirst + 002;

NotifyOwnershipRights: INT =  NotifyFirst + 003;

NotifyReceiveRights: INT =  NotifyFirst + 004;

NotifyLast: INT =   NotifyFirst + 015B;

MigTypeError: INT =  -300;  -- Type check failure

MigReplyMismatch: INT = -301;  -- Wrong return message ID

MigRemoteError: INT = -302;  -- Server detected error

MigBadId: INT =  -303;  -- Bad message ID

MigBadArguments: INT = -304;  -- Server found wrong arguments

MigNoReply: INT =  -305;  -- Server shouldn't reply

MigException: INT =  -306;  -- Server raised exception

MigArrayTooLarge: INT = -307;  -- User specified array not large enough to hold returned array

portT: TYPE = RECORD [portNumber: INT32];

portArrayT: TYPE = POINTER TO portT;

ListOfPorts: TYPE = LIST OF portT;

taskT: TYPE = portT;

vmTaskT: TYPE = taskT;

threadT: TYPE = portT;

vmOffsetT: TYPE = CARD32;

vmSizeT: TYPE = CARD32;

vmAddressT: TYPE = vmOffsetT;

pointerT: TYPE = vmOffsetT;

pagingObjectT: TYPE = portT;

caddrT: TYPE = POINTER TO CHAR;

netnameNameT: TYPE = ARRAY[0..80) OF CHAR;

PortNull: portT = [0];

PortEnabled: portT = [-1];

PortDefault: portT = [-1];

PortInvalid: portT = [-2];

MachPortsSlotsUsed: INT = 3;

taskSelf: PROC RETURNS [targetTask: taskT];

taskNotify: PROC RETURNS [notifyPort: portT];

taskData: PROC RETURNS [dataPort: portT];

vmAllocate: PROC [targetTask: vmTaskT, address: vmAddressT, size: vmSizeT, anywhere: BOOL, raiseSignal: BOOL] RETURNS [mappedAddress: vmAddressT, kernCode: kernReturnT];

vmAllocateWithPager: PROC [targetTask: vmTaskT, address: vmAddressT, size: vmSizeT, anywhere: BOOL, pagingObject: pagingObjectT, offset: vmOffsetT, raiseSignal: BOOL] RETURNS [mappedAddress: vmAddressT, kernCode: kernReturnT];

vmDeallocate: PROC [targetTask: vmTaskT, address: vmAddressT, size: vmSizeT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];

msgSend: PROC [header: REF msgHeaderT, option: msgOptionT, timeout: INT, raiseSignal: BOOL] RETURNS [msgCode: msgReturnT];

msgReceive: PROC [header: REF msgHeaderT, option: msgOptionT, timeout: INT, raiseSignal: BOOL] RETURNS [msgCode: msgReturnT];

msgRPC: PROC [header: REF msgHeaderT, option: msgOptionT, rcvSize: INT, sendTimeout: INT, rcvTimeout: INT, raiseSignal: BOOL] RETURNS [msgCode: msgReturnT];

nameServerPort: PROC RETURNS [portT];

environmentPort: PROC RETURNS [portT];

servicePort: PROC RETURNS [portT];

MachPortsLookup: PROC [targetTask: taskT, raiseSignal: BOOL] RETURNS [intPortSet: portArrayT, intPortArrayCount: INT, kernCode: kernReturnT];

portAllocate: PROC [targetTask: taskT, raiseSignal: BOOL] RETURNS [newPort: portT, kernCode: kernReturnT];

portDeallocate: PROC [targetTask: taskT, localPort: portT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];

portRestrict: PROC [targetTask: taskT, port: portT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];

portUnrestrict: PROC [targetTask: taskT, port: portT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];

portMessages: PROC [targetTask: taskT, ports: portArrayT, portsCount: POINTER TO INT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];

portStatus: PROC [targetTask: taskT, myPort: portT, raiseSignal: BOOL] RETURNS [unrestricted: BOOL, numMsgs: INT, backlog: INT, owner: BOOL, receiver: BOOL, kernCode: kernReturnT];

portSetBacklog: PROC [targetTask: taskT, myPort: portT, backlog: INT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];

netnameCheckIn: PROC [ServPort: portT, portName: Rope.ROPE, signature: portT, portId: portT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];

netnameLookUp: PROC [ServPort: portT, hostName: Rope.ROPE, portName: Rope.ROPE, raiseSignal: BOOL] RETURNS [portId: portT, kernCode: kernReturnT];

netnameCheckOut: PROC [ServPort: portT, portName: Rope.ROPE, signature: portT, raiseSignal: BOOL] RETURNS [kernCode: kernReturnT];