$Save Nolist

DECLARE
$IF WORD16
	WORD_16N		LITERALLY	'WORD',
	WORD_32N		LITERALLY	'DWORD';
$ELSE
	WORD_16N		LITERALLY	'HWORD',
	WORD_32N		LITERALLY	'WORD';
$ENDIF

/************************************************************
*                                                           *
*  External Declarations for iRMX III NUCLEUS System calls  *
*                                                           *
************************************************************/

RQ$AcceptControl:
	PROCEDURE(
		region$tok,
		except$ptr) EXTERNAL;
	DECLARE
		region$tok TOKEN,
		except$ptr POINTER;
END RQ$AcceptControl;

RQ$AlterComposite:
	PROCEDURE(
		extension$tok,
		composite,
		component$index,
		replacing$object,
		except$ptr) EXTERNAL;
	DECLARE
		extension$tok TOKEN,
		composite TOKEN,
		component$index WORD_16N,
		replacing$object TOKEN,
		except$ptr POINTER;
END RQ$AlterComposite;

RQ$CatalogObject:
	PROCEDURE(
		job$tok,
		object,
		name,
		except$ptr) EXTERNAL;
	DECLARE
		job$tok TOKEN,
		object TOKEN,
		name POINTER,
		except$ptr POINTER;
END RQ$CatalogObject;

RQ$CreateComposite:
	PROCEDURE(
		type$token,
		compo$list,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		type$token TOKEN,
		compo$list POINTER,
		except$ptr POINTER;
END RQ$CreateComposite;

RQ$CreateExtension:
	PROCEDURE(
		type$code,
		deletion$mbx,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		type$code WORD_16N,
		deletion$mbx TOKEN,
		except$ptr POINTER;
END RQ$CreateExtension;

RQ$CreateJob:
	PROCEDURE(
		dir$size,
		param$obj,
		pool$min,
		pool$max,
		max$objects,
		max$tasks,
		max$prior,
		exception$info$ptr,
		job$flags,
		task$priority,
		start$addr,
		data$seg,
		stack_p,
		stack$size,
		task$flags,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		dir$size WORD_16N,
		param$obj TOKEN,
		pool$min WORD_32N,
		pool$max WORD_32N,
		max$objects WORD_16N,
		max$tasks WORD_16N,
		max$prior BYTE,
		exception$info$ptr POINTER,
		job$flags WORD_16N,
		task$priority BYTE,
		start$addr POINTER,
		data$seg SELECTOR,
		stack_p POINTER,
		stack$size WORD_32N,
		task$flags WORD_16N,
		except$ptr POINTER;
END RQ$CreateJob;

RQ$CreateMailbox:
	PROCEDURE(
		mbx$flags,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		mbx$flags WORD_16N,
		except$ptr POINTER;
END RQ$CreateMailbox;

RQ$CreateRegion:
	PROCEDURE(
		region$flags,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		region$flags WORD_16N,
		except$ptr POINTER;
END RQ$CreateRegion;

RQ$CreateSegment:
	PROCEDURE(
		size,
		except$ptr) SELECTOR EXTERNAL;
	DECLARE
		size WORD_32N,
		except$ptr POINTER;
END RQ$CreateSegment;

RQ$CreateSemaphore:
	PROCEDURE(
		init$value,
		max$value,
		sema$flags,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		init$value WORD_16N,
		max$value WORD_16N,
		sema$flags WORD_16N,
		except$ptr POINTER;
END RQ$CreateSemaphore;

RQ$CreateTask:
	PROCEDURE(
		priority,
		start$addr,
		data$seg,
		stack_p,
		stack$size,
		task$flags,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		priority BYTE,
		start$addr POINTER,
		data$seg SELECTOR,
		stack_p POINTER,
		stack$size WORD_32N,
		task$flags WORD_16N,
		except$ptr POINTER;
END RQ$CreateTask;

RQ$DeleteComposite:
	PROCEDURE(
		extension$tok,
		composite,
		except$ptr) EXTERNAL;
	DECLARE
		extension$tok TOKEN,
		composite TOKEN,
		except$ptr POINTER;
END RQ$DeleteComposite;

RQ$DeleteExtension:
	PROCEDURE(
		extension$tok,
		except$ptr) EXTERNAL;
	DECLARE
		extension$tok TOKEN,
		except$ptr POINTER;
END RQ$DeleteExtension;

RQ$DeleteJob:
	PROCEDURE(
		job$tok,
		except$ptr) EXTERNAL;
	DECLARE
		job$tok TOKEN,
		except$ptr POINTER;
END RQ$DeleteJob;

RQ$DeleteMailbox:
	PROCEDURE(
		mbx,
		except$ptr) EXTERNAL;
	DECLARE
		mbx TOKEN,
		except$ptr POINTER;
END RQ$DeleteMailbox;

RQ$DeleteRegion:
	PROCEDURE(
		region$tok,
		except$ptr) EXTERNAL;
	DECLARE
		region$tok TOKEN,
		except$ptr POINTER;
END RQ$DeleteRegion;

RQ$DeleteSegment:
	PROCEDURE(
		segment$tok,
		except$ptr) EXTERNAL;
	DECLARE
		segment$tok SELECTOR,
		except$ptr POINTER;
END RQ$DeleteSegment;

RQ$DeleteSemaphore:
	PROCEDURE(
		semaphore$tok,
		except$ptr) EXTERNAL;
	DECLARE
		semaphore$tok TOKEN,
		except$ptr POINTER;
END RQ$DeleteSemaphore;

RQ$DeleteTask:
	PROCEDURE(
		task$tok,
		except$ptr) EXTERNAL;
	DECLARE
		task$tok TOKEN,
		except$ptr POINTER;
END RQ$DeleteTask;

RQ$Disable:
	PROCEDURE(
		level,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		except$ptr POINTER;
END RQ$Disable;

RQ$DisableDeletion:
	PROCEDURE(
		object,
		except$ptr) EXTERNAL;
	DECLARE
		object TOKEN,
		except$ptr POINTER;
END RQ$DisableDeletion;

RQ$Enable:
	PROCEDURE(
		level,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		except$ptr POINTER;
END RQ$Enable;

RQ$EnableDeletion:
	PROCEDURE(
		object,
		except$ptr) EXTERNAL;
	DECLARE
		object TOKEN,
		except$ptr POINTER;
END RQ$EnableDeletion;

RQ$EndInitTask:
	PROCEDURE EXTERNAL;
END RQ$EndInitTask;

RQ$EnterInterrupt:
	PROCEDURE(
		level,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		except$ptr POINTER;
END RQ$EnterInterrupt;

RQ$ExitInterrupt:
	PROCEDURE(
		level,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		except$ptr POINTER;
END RQ$ExitInterrupt;

RQ$ForceDelete:
	PROCEDURE(
		extension$tok,
		object,
		except$ptr) EXTERNAL;
	DECLARE
		extension$tok TOKEN,
		object TOKEN,
		except$ptr POINTER;
END RQ$ForceDelete;

RQ$GetExceptionHandler:
	PROCEDURE(
		exception$info$ptr,
		except$ptr) EXTERNAL;
	DECLARE
		exception$info$ptr POINTER,
		except$ptr POINTER;
END RQ$GetExceptionHandler;

RQ$GetLevel:
	PROCEDURE(
		except$ptr) WORD_16N EXTERNAL;
	DECLARE
		except$ptr POINTER;
END RQ$GetLevel;

RQ$GetPoolAttrib:
	PROCEDURE(
		attrib$ptr,
		except$ptr) EXTERNAL;
	DECLARE
		attrib$ptr POINTER,
		except$ptr POINTER;
END RQ$GetPoolAttrib;

RQ$GetPriority:
	PROCEDURE(
		task$tok,
		except$ptr) BYTE EXTERNAL;
	DECLARE
		task$tok TOKEN,
		except$ptr POINTER;
END RQ$GetPriority;

RQ$GetSize:
	PROCEDURE(
		segment$tok,
		except$ptr) WORD_32N EXTERNAL;
	DECLARE
		segment$tok SELECTOR,
		except$ptr POINTER;
END RQ$GetSize;

RQ$GetTaskTokens:
	PROCEDURE(
		selection,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		selection BYTE,
		except$ptr POINTER;
END RQ$GetTaskTokens;

RQ$GetType:
	PROCEDURE(
		object,
		except$ptr) WORD_16N EXTERNAL;
	DECLARE
		object TOKEN,
		except$ptr POINTER;
END RQ$GetType;

RQ$InspectComposite:
	PROCEDURE(
		extension$tok,
		composite,
		token$list,
		except$ptr) EXTERNAL;
	DECLARE
		extension$tok TOKEN,
		composite TOKEN,
		token$list POINTER,
		except$ptr POINTER;
END RQ$InspectComposite;

RQ$LookupObject:
	PROCEDURE(
		job$tok,
		name,
		time$limit,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		job$tok TOKEN,
		name POINTER,
		time$limit WORD_16N,
		except$ptr POINTER;
END RQ$LookupObject;

RQ$Offspring:
	PROCEDURE(
		job$tok,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		job$tok TOKEN,
		except$ptr POINTER;
END RQ$Offspring;

RQ$ReceiveControl:
	PROCEDURE(
		region$tok,
		except$ptr) EXTERNAL;
	DECLARE
		region$tok TOKEN,
		except$ptr POINTER;
END RQ$ReceiveControl;

RQ$ReceiveData:
	PROCEDURE(
		mbx,
		msg$ptr,
		time$limit,
		except$ptr) WORD_16N EXTERNAL;
	DECLARE
		mbx TOKEN,
		msg$ptr POINTER,
		time$limit WORD_16N,
		except$ptr POINTER;
END RQ$ReceiveData;

RQ$ReceiveMessage:
	PROCEDURE(
		mbx,
		time$limit,
		response$xch,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		mbx TOKEN,
		time$limit WORD_16N,
		response$xch POINTER,
		except$ptr POINTER;
END RQ$ReceiveMessage;

RQ$ReceiveUnits:
	PROCEDURE(
		semaphore$tok,
		units,
		time$limit,
		except$ptr) WORD_16N EXTERNAL;
	DECLARE
		semaphore$tok TOKEN,
		units WORD_16N,
		time$limit WORD_16N,
		except$ptr POINTER;
END RQ$ReceiveUnits;

RQ$ResetInterrupt:
	PROCEDURE(
		level,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		except$ptr POINTER;
END RQ$ResetInterrupt;

RQ$ResumeTask:
	PROCEDURE(
		task$tok,
		except$ptr) EXTERNAL;
	DECLARE
		task$tok TOKEN,
		except$ptr POINTER;
END RQ$ResumeTask;

RQ$SendControl:
	PROCEDURE(
		except$ptr) EXTERNAL;
	DECLARE
		except$ptr POINTER;
END RQ$SendControl;

RQ$SendData:
	PROCEDURE(
		mbx,
		msg$ptr,
		msg$len,
		except$ptr) EXTERNAL;
	DECLARE
		mbx TOKEN,
		msg$ptr POINTER,
		msg$len WORD_16N,
		except$ptr POINTER;
END RQ$SendData;

RQ$SendMessage:
	PROCEDURE(
		mbx,
		object,
		response,
		except$ptr) EXTERNAL;
	DECLARE
		mbx TOKEN,
		object TOKEN,
		response TOKEN,
		except$ptr POINTER;
END RQ$SendMessage;

RQ$SendUnits:
	PROCEDURE(
		semaphore$tok,
		units,
		except$ptr) EXTERNAL;
	DECLARE
		semaphore$tok TOKEN,
		units WORD_16N,
		except$ptr POINTER;
END RQ$SendUnits;

RQ$SetExceptionHandler:
	PROCEDURE(
		exception$info$ptr,
		except$ptr) EXTERNAL;
	DECLARE
		exception$info$ptr POINTER,
		except$ptr POINTER;
END RQ$SetExceptionHandler;

RQ$SetInterrupt:
	PROCEDURE(
		level,
		int$task$flag,
		int$handler$addr,
		int$handler$DS,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		int$task$flag WORD_16N,
		int$handler$addr POINTER,
		int$handler$DS SELECTOR,
		except$ptr POINTER;
END RQ$SetInterrupt;

RQ$SetPoolMin:
	PROCEDURE(
		new$min,
		except$ptr) EXTERNAL;
	DECLARE
		new$min WORD_32N,
		except$ptr POINTER;
END RQ$SetPoolMin;

RQ$SetPriority:
	PROCEDURE(
		task$tok,
		priority,
		except$ptr) EXTERNAL;
	DECLARE
		task$tok TOKEN,
		priority BYTE,
		except$ptr POINTER;
END RQ$SetPriority;

RQ$SignalException:
	PROCEDURE(
		exception$code,
		param$num,
		stack_p,
		primitive,
		npx$status,
		except$ptr) EXTERNAL;
	DECLARE
		exception$code WORD_16N,
		param$num BYTE,
		stack_p WORD_32N,
		primitive WORD_16N,
		npx$status WORD_16N,
		except$ptr POINTER;
END RQ$SignalException;

RQ$SignalInterrupt:
	PROCEDURE(
		level,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		except$ptr POINTER;
END RQ$SignalInterrupt;

RQ$Sleep:
	PROCEDURE(
		time$limit,
		except$ptr) EXTERNAL;
	DECLARE
		time$limit WORD_16N,
		except$ptr POINTER;
END RQ$Sleep;

RQ$SuspendTask:
	PROCEDURE(
		task$tok,
		except$ptr) EXTERNAL;
	DECLARE
		task$tok TOKEN,
		except$ptr POINTER;
END RQ$SuspendTask;

RQE$TimedInterrupt:
	PROCEDURE(
		level,
		time$limit,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		time$limit WORD_16N,
		except$ptr POINTER;
END RQE$TimedInterrupt;

RQ$UnCatalogObject:
	PROCEDURE(
		job$tok,
		name,
		except$ptr) EXTERNAL;
	DECLARE
		job$tok TOKEN,
		name POINTER,
		except$ptr POINTER;
END RQ$UnCatalogObject;

RQ$WaitInterrupt:
	PROCEDURE(
		level,
		except$ptr) EXTERNAL;
	DECLARE
		level WORD_16N,
		except$ptr POINTER;
END RQ$WaitInterrupt;

RQE$ChangeDescriptor:
	PROCEDURE(
		desc,
		phys$addr,
		size,
		except$ptr) EXTERNAL;
	DECLARE
		desc TOKEN,
		phys$addr WORD_32N,
		size WORD_32N,
		except$ptr POINTER;
END RQE$ChangeDescriptor;

RQE$ChangeObjectAccess:
	PROCEDURE(
		obj_tok,
		access,
		limit$mode,
		except$ptr) EXTERNAL;
	DECLARE
		obj_tok TOKEN,
		access BYTE,
		limit$mode BYTE,
		except$ptr POINTER;
END RQE$ChangeObjectAccess;

RQE$CreateDescriptor:
	PROCEDURE(
		phys$addr,
		size,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		phys$addr WORD_32N,
		size WORD_32N,
		except$ptr POINTER;
END RQE$CreateDescriptor;

RQE$CreateJob:
	PROCEDURE(
		dir$size,
		param$obj,
		pool$min,
		pool$max,
		max$objects,
		max$tasks,
		max$prior,
		exception$info$ptr,
		job$flags,
		task$priority,
		start$addr,
		data$seg,
		stack_p,
		stack$size,
		task$flags,
		except$ptr) TOKEN EXTERNAL;
	DECLARE
		dir$size WORD_16N,
		param$obj TOKEN,
		pool$min WORD_32N,
		pool$max WORD_32N,
		max$objects WORD_16N,
		max$tasks WORD_16N,
		max$prior BYTE,
		exception$info$ptr POINTER,
		job$flags WORD_16N,
		task$priority BYTE,
		start$addr POINTER,
		data$seg SELECTOR,
		stack_p POINTER,
		stack$size WORD_32N,
		task$flags WORD_16N,
		except$ptr POINTER;
END RQE$CreateJob;

RQE$DeleteDescriptor:
	PROCEDURE(
		desc,
		except$ptr) EXTERNAL;
	DECLARE
		desc TOKEN,
		except$ptr POINTER;
END RQE$DeleteDescriptor;

RQE$GetAddress:
	PROCEDURE(
		logic$addr,
		except$ptr) WORD_32N EXTERNAL;
	DECLARE
		logic$addr POINTER,
		except$ptr POINTER;
END RQE$GetAddress;

RQE$GetObjectAccess:
	PROCEDURE(
		obj_tok,
		access_p,
		except$ptr) EXTERNAL;
	DECLARE
		obj_tok TOKEN,
		access_p POINTER,
		except$ptr POINTER;
END RQE$GetObjectAccess;

RQE$GetPoolAttrib:
	PROCEDURE(
		attrib$ptr,
		except$ptr) EXTERNAL;
	DECLARE
		attrib$ptr POINTER,
		except$ptr POINTER;
END RQE$GetPoolAttrib;

RQE$Offspring:
	PROCEDURE(
		job$tok,
		list$ptr,
		except$ptr) EXTERNAL;
	DECLARE
		job$tok TOKEN,
		list$ptr POINTER,
		except$ptr POINTER;
END RQE$Offspring;

RQE$SetOSextension:
	PROCEDURE(
		gate$num,
		start$addr,
		except$ptr) EXTERNAL;
	DECLARE
		gate$num WORD_16N,
		start$addr POINTER,
		except$ptr POINTER;
END RQE$SetOSextension;

rq$create$buffer$pool: PROCEDURE(max$bufs, flags, excep$p) TOKEN EXTERNAL;
DECLARE	max$bufs	WORD_16N;
DECLARE	flags		WORD_16N;
DECLARE	excep$p		POINTER;
END rq$create$buffer$pool;

rq$delete$buffer$pool: PROCEDURE(buffer$pool, excep$p) EXTERNAL;
DECLARE	buffer$pool	TOKEN;
DECLARE	excep$p		POINTER;
END rq$delete$buffer$pool;

rq$request$buffer: PROCEDURE(pool$t, size, excep$p) TOKEN EXTERNAL;
DECLARE	pool$t		TOKEN;
DECLARE	size		WORD_32N;
DECLARE	excep$p		POINTER;
END rq$request$buffer;

rq$release$buffer: PROCEDURE(pool$t, buf$p, flags, excep$p) EXTERNAL;
DECLARE	pool$t		TOKEN;
DECLARE	buf$p		TOKEN;
DECLARE	flags		WORD_16N;
DECLARE	excep$p		POINTER;
END rq$release$buffer;

rq$get$interconnect: PROCEDURE(board$id, reg$id, excep$p) BYTE EXTERNAL;
DECLARE	board$id	BYTE;
DECLARE	reg$id		WORD_16N;
DECLARE	excep$p		POINTER;
END rq$get$interconnect;

rq$set$interconnect: PROCEDURE(value, slot, register, excep$p) EXTERNAL;
DECLARE	value		BYTE;
DECLARE	slot		BYTE;
DECLARE	register	WORD_16N;
DECLARE	excep$p		POINTER;
END rq$set$interconnect;

rq$attach$buffer$pool: PROCEDURE( buffer$pool, port$t, excep$p ) EXTERNAL;

	DECLARE buffer$pool		TOKEN,
			port$t			TOKEN,
			excep$p			POINTER;

END rq$attach$buffer$pool;

rq$attach$port: PROCEDURE( source$port, sink$port, excep$p ) EXTERNAL;

	DECLARE source$port		TOKEN,
			sink$port		TOKEN,
			excep$p			POINTER;

END rq$attach$port;

rq$broadcast: PROCEDURE( source, socket, control$p, excep$p ) EXTERNAL;
			
	DECLARE	source			TOKEN,
			socket			WORD_32N,
			control$p		POINTER,
			excep$p			POINTER;

END rq$broadcast;

rq$cancel: PROCEDURE( source, trans$id, excep$p ) EXTERNAL;
			
	DECLARE	source			TOKEN,
			trans$id		WORD_16N,
			excep$p			POINTER;

END rq$cancel;

rq$connect: PROCEDURE( local$end, remote$end, excep$p ) EXTERNAL;

	DECLARE local$end		TOKEN,
			remote$end		WORD_32N,
			excep$p			POINTER;

END rq$connect;

rq$create$port: PROCEDURE( queue$size, info$p, excep$p ) TOKEN EXTERNAL;

	DECLARE queue$size		WORD_16N,
			info$p			POINTER,
			excep$p			POINTER;

END rq$create$port;

rq$delete$port: PROCEDURE( port, excep$p ) EXTERNAL;

	DECLARE port			TOKEN,
			excep$p			POINTER;

END rq$delete$port;

rq$detach$buffer$pool: PROCEDURE( port, excep$p ) TOKEN EXTERNAL;

	DECLARE port			TOKEN,
			excep$p			POINTER;

END rq$detach$buffer$pool;

rq$detach$port: PROCEDURE( port, excep$p ) EXTERNAL;

	DECLARE port			TOKEN,
			excep$p			POINTER;

END rq$detach$port;

rq$get$host$id: PROCEDURE( excep$p ) WORD_16N EXTERNAL;

	DECLARE excep$p			POINTER;

END rq$get$host$id;

rq$get$port$attributes: PROCEDURE( port, info$p, excep$p ) EXTERNAL;

	DECLARE port			TOKEN,
			info$p			POINTER,
			excep$p			POINTER;

END rq$get$port$attributes;

rq$receive$fragment: PROCEDURE( destination, socket, rsvp$trans$id, 
								fragment$p, fragment$length, 
								flags, excep$p ) EXTERNAL;
			
	DECLARE	destination		TOKEN,
			socket			WORD_32N,
			rsvp$trans$id	WORD_16N,
			fragment$p		POINTER,
			fragment$length	WORD_32N,
			flags			WORD_16N,
			excep$p			POINTER;

END rq$receive$fragment;

rq$receive$reply: PROCEDURE( destination, rsvp$trans$id, 
							 time$limit, info$p, excep$p ) POINTER EXTERNAL;
			
	DECLARE	destination		TOKEN,
			rsvp$trans$id	WORD_16N,
			time$limit		WORD_16N,
			info$p			POINTER,
			excep$p			POINTER;

END rq$receive$reply;

rq$receive: PROCEDURE( destination, 
					   time$limit, info$p, excep$p ) POINTER EXTERNAL;
			
	DECLARE	destination		TOKEN,
			time$limit		WORD_16N,
			info$p			POINTER,
			excep$p			POINTER;

END rq$receive;

rq$send: PROCEDURE( source, socket, control$p, data$p, data$length,
						flags, excep$p) WORD_16N EXTERNAL;

	DECLARE	source			TOKEN,
			socket			WORD_32N,
			control$p		POINTER,
			data$p			POINTER,
			data$length		WORD_32N,
			flags			WORD_16N,
			excep$p			POINTER;

END rq$send;

rq$send$reply: PROCEDURE( source, socket, rsvp$trans$id, control$p, data$p,
							data$length, flags, excep$p ) WORD_16N EXTERNAL;

	DECLARE	source			TOKEN,
			socket			WORD_32N,
			rsvp$trans$id	WORD_16N,
			control$p		POINTER,
			data$p			POINTER,
			data$length		WORD_32N,
			flags			WORD_16N,
			excep$p			POINTER;

END rq$send$reply;

rq$send$rsvp: PROCEDURE( source, socket, control$p, data$p, data$length, 
							rsvp$data$p, rsvp$data$length, 
							flags, excep$p ) WORD_16N EXTERNAL;

	DECLARE	source				TOKEN,
			socket				WORD_32N,
			control$p			POINTER,
			data$p				POINTER,
			data$length			WORD_32N,
			rsvp$data$p			POINTER,
			rsvp$data$length	WORD_32N,
			flags				WORD_16N,
			excep$p				POINTER;

END rq$send$rsvp;

rq$send$signal: PROCEDURE ( port$t, 
                            except$ptr) EXTERNAL;

DECLARE port$t          TOKEN,
        except$ptr      POINTER;

END rq$send$signal;

rq$receive$signal: PROCEDURE ( port$t,
                               time$limit,
                               except$ptr) EXTERNAL;

DECLARE port$t          TOKEN,
        time$limit      WORD_16N,
        except$ptr      POINTER;

END rq$receive$signal;

$Restore