Google
 

Trailing-Edge - PDP-10 Archives - BB-R595B-SM_11-9-85 - mcb/v3p0/rsx11m.r16
There are 2 other files named rsx11m.r16 in the archive. Click here to see a list.
!%title 'Bliss-16 System Interface file for RSX-11M'
!%sbttl 'RSX11M - Copyright Notice and Revision History'
!
!		COPYRIGHT (c) 1977, 1978, 1979, 1980 BY
!	      DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
!
! THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
! ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
! INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
! COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
! OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
! TRANSFERRED.
!
! THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
! AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
! CORPORATION.
!
! DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
! SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
!
!

!++
! FACILITY: BLISS System Interfaces
!
! ABSTRACT:
!    This file contains definitions for use in programs
! to be executed under RSX-11M.  For documentation on the use of these
! definitions see the RSX-11M Executive Reference Manual.
! 
!
! ENVIRONMENT: To be used in a BLISS-16 program.
!
! AUTHOR: B. Dawson, CREATION DATE: 13-Jun-78
!
! MODIFIED BY:
!
! 01 B. Dawson	12-Dec-78    The RSX_EMT macro was producing the wrong code 
!	    for testing the carry bit.
!
! 02 B. Dawson	25-Mar-79    There were uses of GMRKT$_ (an undefined symbol),
!	    in MRKT$. All occurances of GMRKT were changed to MRKT.
!
! 03 H. Siegler April-79	Incorporated all symbols and definitions for
!	SPCIO$, DRERR$, FILIO$, IOERR$, and TTSYM$.   All values are in octal
!	notation.
!
!	Corrected QIO$ and QIOW$ macros to insert the  6 <PRL> parameters
!	into the DPB in the proper order.
!
!	Revised the RSX_EMT macro for BLISS16 for code optimization and 
!	conformance to RSX-11M Directive Usage.
!
!	Includes Macros WDBBK$, RDBBK$, RDBDF$, and WDBDF$.
!
!	Redefined Parameters Buffer Offsets for Directives GTIM$,GREG$,GTSK$,
!	GLUN$, and GPRT$ from field to macro.
!
! 04 H. Siegler August 29, 1979
!	Included TSK argument to RCVD directives
!
!	Converted all DRERR$ values to full word to conform with contents of
!	$DSW.
!
!	Included the CINT$ (connect to interupt vector) Directive.
!
! 05 W. Clark 09-Nov-79
!	Renamed the Utility Macros to avoid symbol naming conflicts
!	with user code.
!
!	Changed GLUN$ info buffer definitions from macros to fields.
!	Added GLUN$INFO definition for this information buffer.
!
!	Added $QIO_STATUS definition for the QIO Status Block.
!
!	Corrected the following macro definitions:  ABRT$S, ALTP$S, CSRQ$S,
!		GPRT$S, RCVD$S, RQST$S, RSUM$S, RUN$S, SDAT$S, SREF$S
!
!	Reformatted nearly all macro definitions.
!
! 06 G. Hetrick 14-Nov-79
!	Eliminated an inconsistency between RCVD$S and SDAT$S in regard to the
!	task name parameter.  Both macros now expect the task name to already
!	be in RAD50 format.
!
! 07 G. Hetrick 21-Nov-79
!	Corrected the spelling of SVDB_ and SVTK_.
!
! 08 T. Van Court 30-Nov-79
!	Corrections to in-line forms of executive calls that deal with tasks, 
!	and renamed local names in those macros to avoid conflicts with user
!       names.
!
!	Make $RSX$RAD50_2 work as a parameter to a linkage
!
! 09  Mike Cogan  13-Feb-80
!	formatting changes
!
! 10  Mike Cogan  15-Feb-80
!	moved error and function codes to FCS11.R16 (see revision 12)
!
! 11  Mike Cogan  15-Feb-80
!	added defn.s for 11M V3.2
!
! 12  Don Frank  28-Feb-80
!	Copied error and fuction codes to new require file RSXEFC.R16 from
!	FCS11.R16 (see 10), System interface files (RSX11M.R16 and IAS.R16)
!	now REQUIRE RSXEFC.
!
! 13   Dan Brown 23-Oct-81
!	Fixed problem with SPWN$S directive
!--
!%sbttl 'RSX11M - Utility macros for easy definition'

MACRO

    $rsx$rad50_2( nam ) =
	%RAD50_11 %EXACTSTRING(3, %C' ', nam), 
	$rsx$second_3(%EXPLODE(%EXACTSTRING(6, %C' ', nam))) %,

    $rsx$second_3(x1,x2,x3,a,b,c) =
	%RAD50_11 %STRING(a,b,c) %,

    $rsx$bind( name, arg ) =
	%IF %NULL(arg)
	  %THEN
	    LITERAL %NAME( name, '0' ) = 0,
		    %NAME( name, '1' ) = 0;
	  %ELSE
	    BIND %NAME( name, '0' ) = .(arg),
		 %NAME( name, '1' ) = .((arg)+2);
	  %FI %,

    $rsx$emt( err ) =        ! Use this form with BLISS16
	BEGIN
	LINKAGE RSX = EMT : CLEARSTACK VALUECBIT;
	%IF %NULL(err)
	  %THEN
	    NOT RSX(%O'377',%REMAINING)
	  %ELSE
	     IF RSX(%O'377',%REMAINING) THEN err
	  %FI
	END %,

!    $rsx$emt( err ) =        ! Obsolete form previously used with BLS16C
!	(LINKAGE RSX = EMT : CLEARSTACK;
!	builtin ROT;
!	%IF %NULL(err)
!	%THEN IF NOT ROT(RSX(%O'377',%REMAINING),1) THEN 1 ELSE 0
!	%ELSE  IF ROT(RSX(%O'377',%REMAINING),1) THEN err ELSE 0 %FI ) %,

    $rsx$default( default, actual ) =
	%IF %NULL(actual) %THEN default %ELSE actual %FI  %,

! Zero pad arguments for DPB Structure
    $rsx$pad6( p1, p2, p3, p4, p5, p6 ) =
	p1+0, p2+0, p3+0, p4+0, p5+0, p6+0 %,

! Zero pad 6 arguments in reverse order for Stack Form
    $rsx$pad_6( p1, p2, p3, p4, p5, p6 ) =    
	p6+0, p5+0, p4+0, p3+0, p2+0, p1+0 %,

    $RSX_TASK_NAME( nam ) =
	UPLIT( %RAD50_11 nam ) %;
!%sbttl 'RSX11M - DIRECTIVE CODES (DIC)'
!
!	Format:
!		n, c , l
!		where	n - RSX Executive function name
!			c  - predefined directive code
!			l    - number of words in DPB
!	the first word of the DPB is then formed by
!		n$_ = c + l^8
!

macro	$rsx$dics [n,c,l] = %name(n,'$_') = c + l^8 %;

LITERAL	$rsx$dics (

	ABRT, 83, 3,
	ALTP,  9, 4,
	ALUN,  7, 4,
	ASTX,115, 1,
	ATRG, 57, 2,
	CINT,129, 7,
	CLEF, 31, 2,
	CMKT, 27, 1,		! (there is also a 3 word version)
	CNCT,146, 3,
	CRAW,117, 2,
	CRGF,157, 2,
	CRRG, 55, 2,
	CSRQ, 25, 3,
	DECL, 35, 1,
	DSAR, 99, 1,
	DSCP, 95, 1,
	DTRG, 59, 2,
	ELAW,119, 2,
	ELGF,159, 2,
	ENAR,101, 1,
	ENCP, 97, 1,
	EXIF, 53, 2,
	EXIT, 51, 1,
	EXST, 29, 2,
	EXTK, 89, 3,
	GLUN,  5, 3,
	GMCR,127,41,
	GMCX,113, 2,
	GPRT, 65, 4,
	GREG, 65, 4,
	GSSW,125, 1,
	GTIM, 61, 2,
	GTSK, 63, 2,
	IHAR, 99, 1,
	MAP ,121, 2,
	MRKT, 23, 5,
	QIO ,  1,12,
	QIOW,  3,12,
	RCST,139, 4,
	RCVD, 75, 4,
	RCVX, 77, 4,
	RDAF, 39, 2,
	RDXF, 39, 3,
	RQST, 11, 7,
	RREF, 81, 2,
	RSUM, 47, 3,
	RUN , 17,11,
	SDAT, 71, 5,
	SETF, 33, 2,
	SFPA,111, 2,
	SPND, 45, 1,
	SPRA,109, 2,
	SPWN, 11,14,
	SRDA,107, 2,
	SREF, 69, 5,
	SRRA, 21, 2,
	STLO,137, 3,
	STOP,131, 1,
	STSE,135, 2,
	SVDB,103, 3,
	SVTK,105, 3,
	UMAP,123, 2,
	USTP,133, 3,
	WSIG, 49, 1,
	WTLO, 43, 3,
	WTSE, 41, 2
	) ;

undeclare %quote $rsx$dics ;
!%sbttl 'RSX11M - DIRECTIVE LOCAL FIELD DEFINITIONS'
!
!	Format:
!		"name"$F = SET ... TES
!
!		where	name - RSX Executive function name
!			...  - predefined local symbols
!

FIELD
	ABRT$F = set
	    A$BTTN = [1,0,16,0]	tes,	! Task name.

	ALTP$F = set
	  A$LTTN = [1,0,16,0],		! Task name.
	  A$LTPR = [3,0,16,0] tes,	! Priority.

	ALUN$F = set
	  A$LULU = [1,0,16,0],		! Logical Unit number.
	  A$LUNA = [2,0,16,0],		! Physical device name.
	  A$LUNU = [3,0,16,0] tes,	! Physical device unit number.

	ATRG$F = set
	  A$TRBA = [1,0,16,0] tes,	! Region def. block address.

	CINT$F = set
	  C$INVE = [1,0,16,0],		! Vector Address
	  C$INBA = [2,0,16,0],		! Base Address
	  C$INIS = [3,0,16,0],		! ISR Address
	  C$INDI = [4,0,16,0],		! Ena/Dis Interupt Routine Address
	  C$INPS = [5,0,16,0],		! Priority - word aligned - note macro-11 expansion.   H.Siegler
	  C$INAS = [6,0,16,0] tes,	! AST Address

	CLEF$F = set
	  C$LEEF = [1,0,16,0] tes,	! Event Flag number.

	CMKT$F = set
	  C$MKEF = [0,0,16,0],		! Event flag number
	  C$MKAE = [1,0,16,0] tes,	! Mark time request AST routine address

	CNCT$F = set
	  C$NCTN = [1,0,16,0],		! Task name
	  C$NCEF = [3,0,16,0],		! Event flag
	  C$NCEA = [4,0,16,0],		! AST routine address
	  C$NCES = [5,0,16,0] tes,	! Exit status block address

	CRAW$F = set
	  C$RABA = [1,0,16,0] tes,	! Window def. block address.

	CRGF$F = set
	  C$RGRP = [1,0,16,0] tes,	! Group number

	CRRG$F = set
	  C$RRBA = [1,0,16,0] tes,	! Region def. block address.

	CSRQ$F = set
	  C$SRTN = [1,0,16,0] tes,	! Target Task name.

	DTRG$F = set
	  D$TRBA = [1,0,16,0] tes,	! Region def. block address.

	ELAW$F = set
	  E$LABA = [1,0,16,0] tes,	! Window def. block address.

	ELGF$F = set
	  E$LGRP = [1,0,16,0] tes,	! Group number

	EXIF$F = set
	  E$XFEF = [1,0,16,0] tes,	! Event flag number.

	EXST$F = set
	  E$XSTS = [1,0,16,0] tes,	! Value of status to be returned

	EXTK$F = set
	  E$XTIN = [1,0,16,0] tes,	! Extend increment.

	GLUN$F = set
	  G$LULU = [1,0,16,0],		! Logical Unit number.
	  G$LUBA = [2,0,16,0] tes,	! Buffer address.

	GMCR$F = set
	  G$MCRB = [1,0,16,0] tes,	! MCR Line Buffer.

	GMCX$F = set
	  G$MCVA = [1,0,16,0] tes,	! Vector address.

	GPRT$F = set
	  G$PRPN = [1,0,16,0],		! Partition name.
	  G$PRBA = [3,0,16,0] tes,	! Buffer address.

	GREG$F = set
	  G$RGID = [2,0,16,0],		! Region ID.
	  G$RGBA = [3,0,16,0] tes,	! Buffer address.

	GTIM$F = set
	  G$TIBA = [1,0,16,0] tes,	! Buffer address.

	GTSK$F = set
	  G$TSBA = [1,0,16,0] tes,	! Buffer address.

	MAP$F = set
	  M$APBA = [1,0,16,0] tes,	! Window def. Block address.

	MRKT$F = set
	  M$KTEF = [1,0,16,0],		! Event Flag number.
	  M$KTMG = [2,0,16,0],		! Time magnitude.
	  M$KTUN = [3,0,16,0],		! Time Unit.
	  M$KTAE = [4,0,16,0] tes,	! AST Entry point address.

	QIO$F = set
	  Q$IOFN = [1,0,16,0],		! I/O function code.
	  Q$IOLU = [2,0,16,0],		! Logical unit number.
	  Q$IOEF = [3,8,8,0],		! Event Flag number.
	  Q$IOPR = [3,0,8,0],		! Priority.
	  Q$IOSB = [4,0,16,0],		! Address of I/O status block.
	  Q$IOAE = [5,0,16,0],		! Address of I/O done AST routine.
	  Q$IOPL = [6,0,16,0] tes,	! Parameter list.

!	QIOW$F = QIO$F,

	RCST$F = set
	  R$CSTN = [1,0,16,0],		! Task name
	  R$CSBF = [3,0,16,0] tes,	! Buffer address

	RCVD$F = set
	  R$VDTN = [1,0,16,0],		! Sender Task Name.
	  R$VDBA = [3,0,16,0] tes,	! Buffer address.

	RCVX$F = set
	  R$VXTN = [1,0,16,0],		! Sender Task Name.
	  R$VXBA = [3,0,16,0] tes,	! Buffer address.

	RDAF$F = set
	  R$DABA = [1,0,16,0] tes,	! Buffer address.

!	RDXF$F = RDAF$F,

	RQST$F = set
	  R$QSTN = [1,0,16,0],		! Task name.
	  R$QSPN = [3,0,16,0],		! Partition name.
	  R$QSPR = [5,0,16,0],		! Priority.
	  R$QSGC = [6,8,8,0],		! UIC Group.
	  R$QSPC = [6,0,8,0] tes,		! UIC Member.

	RREF$F = set
	  R$REBA = [1,0,16,0] tes,	! Window def. Block address.

	RSUM$F = set
	  R$SUTN = [1,0,16,0] tes,	! Task name.

	RUN$F = set
	  R$UNTN = [1,0,16,0],		! Task name.
	  R$UNPN = [3,0,16,0],		! Partition name.
	  R$UNPR = [5,0,16,0],		! Priority.
	  R$UNGC = [6,8,8,0],		! UIC Group code.
	  R$UNPC = [6,0,8,0],		! UIC Member code.
	  R$UNSM = [7,0,16,0],		! Schedule magnitude.
	  R$UNSU = [8,0,16,0],		! Schedule unit.
	  R$UNRM = [9,0,16,0],		! Reschedule magnitude.
	  R$UNRU = [10,0,16,0] tes,	! Reschedule unit.

	SDAT$F = set
	  S$DATN = [1,0,16,0],		! Task name.
	  S$DABA = [3,0,16,0],		! Buffer address.
	  S$DAEF = [4,0,16,0] tes,	! Event Flag number.

	SETF$F = set
	  S$ETEF = [1,0,16,0] tes,	! Event Flag number.

	SFPA$F = set
	  S$FPAE = [1,0,16,0] tes,	! AST Entry address.

	SPRA$F = set
	  S$PRAE = [1,0,16,0] tes,	! AST Entry address.

	SPWN$F = set
	  S$PWTN = [1,0,16,0],		! Task name
	  S$PWXX = [3,0,16,0],		! (Reserved)
	  S$PWUM = [6,0, 8,0],		! User member code
	  S$PWUG = [6,8, 8,0],		! User group code
	  S$PWEF = [7,0,16,0],		! Event flag number
	  S$PWEA = [8,0,16,0],		! Exit AST routine address
	  S$PWES = [9,0,16,0],		! Exit status block address
	  S$PWCA =[10,0,16,0],		! Command line address
	  S$PWCL =[11,0,16,0],		! Command line length
	  S$PWVT =[12,0,16,0],		! Terminal unit number
	  S$PWDN =[13,0,16,0] tes,	! Device name

	SRDA$F = set
	  S$DRAE = [1,0,16,0] tes,	! AST Entry address.

	SREF$F = set
	  S$RETN = [1,0,16,0],		! Receiver Task name.
	  S$REBA = [4,0,16,0],		! Window def. Block address.
	  S$REEF = [5,0,16,0] tes,	! Event Flag number.

	SRRA$F = set
	  S$RRAE = [1,0,16,0] tes,	! AST Entry address.

	STLO$F = set
	  S$TLGR = [1,0,16,0],		! Group flags
	  S$TLMS = [2,0,16,0] tes,	! Mask word

	STSE$F = set
	  S$TSEF = [1,0,16,0] tes,	! Local event flag number

	SVDB$F = set
	  S$VDTA = [1,0,16,0],		! Table address.
	  S$VDTL = [2,0,16,0] tes,	! Table length.

	SVTK$F = set
	  S$VTTA = [1,0,16,0],		! Table address.
	  S$VTTL = [2,0,16,0] tes,	! Table length.

	UMAP$F = set
	  U$MABA = [1,0,16,0] tes,	! Window def. block address.

	USTP$F = set
	  U$STTN = [1,0,16,0] tes,	! Task name

	WTSE$F = set
	  W$TSEF = [1,0,16,0] tes;	! Event Flag number.
!%sbttl 'RSX11M - REGION DEFINITION BLOCK'

FIELD
	RDBDF$ = set			! Region Definition Block Offsets
	  R$GID  = [0,0,16,0],		! Region ID
	  R$GSIZ = [1,0,16,0],		! Number of 32 word blocks in region
	  R$GNAM = [2,0,16,0],		! Name of Region
	  R$GPAR = [4,0,16,0],		! Main partition name
	  R$GSTS = [6,0,16,0],		! Status word.
	  R$GPRO = [7,0,16,0] tes;	! Region protection word

literal		!  Region Definition Block Status Bit Values

	RS$CRR	= %o'100000',
	RS$UNM	= %o'40000',
	RS$MDL	= %o'200',
	RS$NDL	= %o'100',
	RS$ATT	= %o'40',
	RS$NEX	= %o'20',
	RS$DEL	= %o'10',
	RS$EXT	= %o'4',
	RS$WRT	= %o'2',
	RS$RED	= %o'1';

MACRO	! Regional Definition Block Create Macro

    RDBBK$(siz, nam, par, sts, pro) =

	BLOCK[8]  FIELD(RDBDF$)
	    INITIAL(
		0,
		$rsx$default( 0, siz ),
		$rsx$rad50_2( nam ),
		$rsx$rad50_2( par ),
		$rsx$default( 0, %remove ( sts )),
		$rsx$default( 0, pro )) %;
!%sbttl 'RSX11M - WINDOW DEFINITION BLOCK'

FIELD
	WDBDF$ = set			! Window Definition Block Offsets
	  W$NAPR = [0,8,8,0],		! Base APR
	  W$NID  = [0,0,8,0],		! Window ID
	  W$NBAS = [1,0,16,0],		! Virtual base address
	  W$NSIZ = [2,0,16,0],		! Number of 32 word blocks in window
	  W$NRID = [3,0,16,0],		! Region ID
	  W$NOFF = [4,0,16,0],		! Offset in region (# of 32W blocks)
	  W$NLEN = [5,0,16,0],		! Length to map (# of 32W blocks)
	  W$NSTS = [6,0,16,0],		! Window status
	  W$NSRB = [7,0,16,0] tes;	! Buffer address (# of bytes)

literal		!  Window Definition Block Status Bit Values

	WS$CRW	= %o'100000',
	WS$UNW	= %o'40000',
	WS$ELW	= %o'20000',
	WS$RRF	= %o'10000',
	WS$64B	= %o'400',
	WS$MAP	= %o'200',
	WS$RCX	= %o'100',
	WS$DEL	= %o'10',
	WS$EXT	= %o'4',
	WS$WRT	= %o'2',
	WS$RED	= %o'1';

MACRO	! Window Definition Block Create Macro

    WDBBK$(apr, siz, rid, off, len, sts, srb) =

	BLOCK[8]  FIELD(WDBDF$)
	    INITIAL(
		$rsx$default( 0, apr ^ 8),
		0,
		$rsx$default( 0, siz),
		$rsx$default( 0, rid),
		$rsx$default( 0, off),
		$rsx$default( 0, len),
		$rsx$default( 0, %remove( sts )),
		$rsx$default( 0, srb)) %;
!%sbttl 'RSX11M - GLUN$ INFORMATION'

FIELD
	$GL$FIELDS = set		! GLUN$ information buffer
	  G$LUNA = [0,0,16,0],		! Device name (ASCII)
	  G$LUNU = [1,0,8,0],		! Device unit number (binary)
	  G$LUFB = [1,8,8,0],		! Driver flag value
	  G$LUCW = [2,0,16,0],		! 4 Device Characteristics Words
	  GL$FLAGS = [2,0,16,0],	! Device characteristics:
	    GL$UNIT_REC	  = [2,0,1,0],	!    unit record device
	    GL$CC	  = [2,1,1,0],	!    carriage control device
	    GL$TERMINAL	  = [2,2,1,0],	!    terminal device
	    GL$DIRECTORY  = [2,3,1,0],	!    directory device (e.g., disk, DECtape)
	    GL$1_DIRECTORY= [2,4,1,0],	!    single directory device (e.g., ANSI magtape)
	    GL$SEQUENTIAL = [2,5,1,0],	!    sequential device (e.g., ANSI magtape)
	    GL$MASSBUS	  = [2,9,1,0],	!    massbus device
	    GL$USER_DIAG  = [2,10,1,0],	!    user-mode diagnostics supported
	    GL$SOFT_LOCK  = [2,11,1,0],	!    unit software write-locked
	    GL$PSEUDO	  = [2,12,1,0],	!    pseudo device
	    GL$COMM_CHAN  = [2,13,1,0],	!    device mountable as communications channel (e.g, DP11)
	    GL$FILES_11	  = [2,14,1,0],	!    device mountable as FILES-11 device (e.g., disk)
	    GL$MOUNTABLE  = [2,15,1,0],	!    GL$COMM_CHAN OR GL$FILES_11
	GL$BUFF_SIZE = [5,0,16,0]	! default buffer size for device
	tes;

MACRO
	GLUN$INFO =
		BLOCK[6] FIELD($gl$fields) %;
!%sbttl 'RSX11M - MISCELLANEOUS "GET" INFORMATION'

MACRO					! GPRT$ Parameters Buffer Offsets
	G$PRPB = 0,0,16,0 %,		! Block number of Base address
	G$PRPS = 1,0,16,0 %,		! Number of blocks in Partition
	G$PRFW = 2,0,16,0 %;		! Partition flags word

MACRO					! GREG$ Parameters Buffer Offsets
	G$RGRB = 0,0,16,0 %,		! Block number of Base address
	G$RGRS = 1,0,16,0 %,		! Number of blocks in Region
	G$RGFW = 2,0,16,0 %;		! Region flags word.

MACRO					! GTIM$ Parameters Buffer Offsets
	G$TIYR = 0,0,16,0 %,		! Year
	G$TIMO = 1,0,16,0 %,		! Month
	G$TIDA = 2,0,16,0 %,		! Day
	G$TIHR = 3,0,16,0 %,		! Hour
	G$TIMI = 4,0,16,0 %,		! Minute
	G$TISC = 5,0,16,0 %,		! Second
	G$TICT = 6,0,16,0 %,		! Clock ticks of second
	G$TICP = 7,0,16,0 %;		! Number of ticks per second

MACRO					! GTSK$ Parameters Buffer Offsets
	G$TSTN = 0,0,16,0  %,		! Issuing Task's Name
	G$TSPN = 2,0,16,0  %,		! Partition name
	G$TSRN = 4,0,16,0  %,		! Not in RSX-11M, RSX-11D Compatability
	G$TSPR = 6,0,16,0  %,		! Run Priority
	G$TSPC = 7,0,8,0   %,		! User UIC Member Code
	G$TSGC = 7,8,8,0   %,		! User UIC Group Code
	G$TSNL = 8,0,16,0  %,		! Number of LUNS
	G$TSMT = 9,0,16,0  %,		! Not in RSX-11M, RSX-11D Compatability
	G$TSFW = 10,0,16,0 %,		! Not in RSX-11M, RSX-11D Compatability
	G$TSVA = 11,0,16,0 %,		! Address of Task's SST Vector Tables
	G$TSVL = 12,0,16,0 %,		! Size of SST Vector Tables in words
	G$TSTS = 13,0,16,0 %,		! Task's Window 0 size (in bytes)
	G$TSSY = 14,0,16,0 %,		! System on which task is running
	G$TSDU = 15,0,16,0 %;		! Protection or log-in UIC

literal		! GTSK$ System-Type Values

	RX$IAS	= %o'000003',
	RX$11D	= %o'000000',
	RX$11M	= %o'000001',
	RX$11S	= %o'000002',
	$$$OST	= %o'000004';
!%sbttl 'RSX11M - I/O STATUS BLOCK'

FIELD
	$qs$fields = set		! QIO Status Block
	  QS$ERROR	= [0,0,16,0],	! Composite error code:
	  QS$ERR	= [0,0,8,1],	!    error code
	  QS$ERR1	= [0,8,8,1],	!    0 = I/O error, -1 = directive error
	  QS$IO_COUNT	= [1,0,16,0]	! I/O count (bytes)
	  tes;

MACRO
	$QIO_STATUS =
	    BLOCK[ 2 ]  FIELD( $qs$fields ) %;
!%sbttl 'RSX11M - RSX-11M DIRECTIVES'

!	The "name"$ form creates a compile-time DPB which can then
!	be executed at run-time with the DIR$ macro.
!	The "name"$S form creates a run-time DPB on the stack and
!	then executes it.

MACRO

    ABRT$( tsk ) =	! ABORT TASK
	BLOCK[ ABRT$_ ^ -8 ]  FIELD( ABRT$F )  INITIAL( ABRT$_, $rsx$rad50_2(tsk) ) %,

    ABRT$S( tsk, err ) =	! ABORT TASK
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, $$tsk1, $$tsk0, ABRT$_ )
	END %,

    ALTP$( tsk, pri ) =	! ALTER PRIORITY
	BLOCK[ ALTP$_ ^ -8 ]  FIELD( ABRT$F )  INITIAL( ALTP$_, $rsx$rad50_2(tsk), pri ) %,

    ALTP$S( tsk, pri, err ) =	! ALTER PRIORITY
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, pri, $$tsk1, $$tsk0, ALTP$_ )
	END %,

    ALUN$( lun, dev, unt ) =	! ASSIGN LUN
	BLOCK[ ALUN$_ ^ -8 ]  FIELD( ALUN$F )  INITIAL( ALUN$_, lun, %ASCII dev, unt ) %, 

    ALUN$S( lun, dev, unt, err ) =	! ASSIGN LUN
	$rsx$emt( err, unt, dev, lun, ALUN$_ ) %, 

    ASTX$S( err ) =	! AST SERVICE EXIT
	$rsx$emt( err, ASTX$_ ) %,

    ATRG$( rdb ) =	! ATTACH REGION
	BLOCK[ ATRG$_ ^ -8 ]  FIELD( ATRG$F )  INITIAL( ATRG$_, rdb ) %, 

    ATRG$S( rdb, err ) =	! ATTACH REGION
	$rsx$emt( err, rdb, ATRG$_ ) %, 

    CINT$( vec, base, isr, edir, pri, ast ) =	! CONNECT TO INTERUPT VECTOR
	BLOCK[ CINT$_ ^ -8 ]  FIELD( CINT$F )
	    INITIAL( CINT$_, $rsx$default(0,vec), $rsx$default(0,base), $rsx$default(0,isr), $rsx$default(0,edir),
		$rsx$default(0,pri), $rsx$default(0,ast) ) %,

    CINT$S( vec, base, isr, edir, pri, ast, err ) =	! CONNECT TO INTERUPT VECTOR
	$rsx$emt( err, $rsx$default(0,ast), $rsx$default(0,pri), $rsx$default(0,edir),
		$rsx$default(0,isr), $rsx$default(0,base), $rsx$default(0,vec), CINT$_ ) %,

    CLEF$( efn ) =	! CLEAR EVENT FLAGS
	BLOCK[ CLEF$_ ^ -8 ]  FIELD( CLEF$F )  INITIAL( CLEF$_, efn ) %, 

    CLEF$S( efn, err ) =	! CLEAR EVENT FLAGS
	$rsx$emt( err, efn, CLEF$_ ) %, 

    CMKT$S( err ) =	! CANCEL MARK TIME REQUESTS (all)
	$rsx$emt( err, CMKT$_ ) %,

!    CMKT$S( efn, ast, err ) =	! CANCEL MARK TIME REQUEST (one)

    CNCT$( tname, efn, east, esb ) =	! CONNECT
	BLOCK[ CNCT$_ ^ -8 ]  FIELD( CNCT$F )  
	INITIAL( CNCT$_, $rsx$rad50_2(tname), efn, east, esb ) %,

    CNCT$S( tname, efn, east, esb, err) =	! CONNECT
	BEGIN
	$rsx$bind( $$tname, tname )
	$rsx$emt( err, esb, east, efn, $$tname1, $$tname0, CNCT$_ )
	END %,

    CRAW$( wdb ) =	! CREATE ADDRESS WINDOW
	BLOCK[ CRAW$_ ^ -8 ]  FIELD( CRAW$F )  INITIAL( CRAW$_, wdb ) %,

    CRAW$S( wdb, err ) =	! CREATE ADDRESS WINDOW
	$rsx$emt( err, wdb, CRAW$_ ) %,

    CRGF$( group ) =	! CREATE GROUP GLOBAL EVENT FLAGS
	BLOCK[ CRGF$_ ^ -8 ]  FIELD( CRGF$F )  INITIAL( CRGF$_, group ) %,

    CRGF$S( group, err ) =	! CREATE GROUP GLOBAL EVENT FLAGS
	$rsx$emt( err, group, CRGF$_ ) %,

    CRRG$( rdb ) =	! CREATE REGION
	BLOCK[ CRRG$_ ^ -8 ]  FIELD( CRRG$F )  INITIAL( CRRG$_, rdb ) %, 

    CRRG$S( rdb, err ) =	! CREATE REGION
	$rsx$emt( err, rdb, CRRG$_ ) %, 

    CSRQ$( tsk ) =	! CANCEL TIME BASED INITIATION REQUESTS
	BLOCK[ CSRQ$_ ^ -8 ]  FIELD( CSRQ$F )  INITIAL( CSRQ$_, $rsx$rad50_2(tsk) ) %,

    CSRQ$S( tsk, err ) =	! CANCEL TIME BASED INITIATION REQUESTS
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, $$tsk1, $$tsk0, CSRQ$_ )
	END %,

    DECL$S( err ) =	! DECLARE SIGNIFICANT EVENT
	$rsx$emt( err, DECL$_ ) %,

    DIR$( adr, err ) =
	! this macro causes execution of the DPB at "adr".
	! this would normally have been created by a 'name'$ function call.
	$rsx$emt(err,adr) %,

    DSAR$S( err ) =	! DISABLE AST RECOGNITION
	$rsx$emt( err, DSAR$_ ) %,

    DSCP$S( err ) =	! DISABLE CHECKPOINTING
	$rsx$emt( err, DSCP$_ ) %,

    DTRG$( rdb ) =	! DETACH REGION
	BLOCK[ DTRG$_ ^ -8 ]  FIELD( DTRG$F )  INITIAL( DTRG$_, rdb ) %, 

    DTRG$S( rdb, err ) =	! DETACH REGION
	$rsx$emt( err, rdb, DTRG$_ ) %, 

    ELAW$( wdb ) =	! ELIMINATE ADDRESS WINDOW
	BLOCK[ ELAW$_ ^ -8 ]  FIELD( ELAW$F )  INITIAL( ELAW$_, wdb ) %, 

    ELAW$S( wdb, err ) =	! ELIMINATE ADDRESS WINDOW
	$rsx$emt( err, wdb, ELAW$_ ) %,

    ELFG$( group ) =	! ELIMINATE GROUP GLOBAL EVENT FLAGS
	BLOCK[ ELFG$_ ^ -8 ]  FIELD( ELFG$F )  INITIAL( ELFG$_, group ) %,

    ELFG$S( group, err ) =	! ELIMINATE GROUP GLOBAL EVENT FLAGS
	$rsx$emt( err, group, ELFG$_ ) %,

    ENAR$S( err ) =	! ENABLE AST RECOGNITION
	$rsx$emt( err, ENAR$_ ) %,

    ENCP$S( err ) =	! ENABLE CHECKPOINTING
	$rsx$emt( err, ENCP$_ ) %,

    EXIF$( efn ) =	! EXIT IF EVENT FLAG NOT SET
	BLOCK[ EXIF$_ ^ -8 ]  FIELD( EXIF$F )  INITIAL( EXIF$_, efn ) %,

    EXIF$S( efn, err ) =	! EXIT IF EVENT FLAG NOT SET
	$rsx$emt( err, efn, EXIF$_ ) %, 

    EXIT$S( err ) =	! TASK EXIT
	$rsx$emt( err, EXIT$_ ) %,

    EXST$( status ) =	! EXIT WITH STATUS
	BLOCK[ EXST$_ ^ -8 ]  FIELD( EXST$F )  INITIAL( EXST$_, status ) %,

    EXST$S( status, err ) =	! EXIT WITH STATUS
	$rsx$emt( err, status, EXST$_ ) %,

    EXTK$( inc ) = 	! EXTEND TASK
	BLOCK[ EXTK$_ ^ -8 ]  FIELD( EXTK$F )  INITIAL( EXTK$_, inc ) %, 

    EXTK$S( inc, err ) =	! EXTEND TASK
	$rsx$emt( err, 0 , inc , EXTK$_ ) %, 

    GLUN$( lun, buf ) =	! GET LUN INFORMATION
	BLOCK[ GLUN$_ ^ -8 ]  FIELD( GLUN$F )  INITIAL( GLUN$_, lun, buf ) %, 

    GLUN$S( lun, buf, err ) =	! GET LUN INFORMATION
	$rsx$emt( err, buf, lun, GLUN$_ ) %, 

    GMCR$ =	! GET MCR COMMAND LINE
	BLOCK[ GMCR$_ ^ -8 ]  FIELD( GMCR$F )  INITIAL( GMCR$_, REP 40 OF (0) ) %,

!    GMCR$S =	! GET MCR COMMAND LINE  (not supplied)

    GMCX$( vec ) =	! GET MAPPING CONTEXT
	BLOCK[ GMCX$_ ^ -8 ]  FIELD( GMCX$F )  INITIAL( GMCX$_, vec ) %, 

    GMCX$S( vec, err ) =	! GET MAPPING CONTEXT
	$rsx$emt( err, vec, GMCX$_ ) %, 

    GPRT$( prt, buf ) =	! GET PARTITION PARAMETERS
	BLOCK[  GPPT$_ ^ -8 ]  FIELD( GPRT$F )
		INITIAL( GPRT$_, %IF %NULL(prt) %THEN 0,0 %ELSE $rsx$rad50_2(prt) %FI, buf ) %,

    GPRT$S( prt, buf, err ) =	! GET PARTITION PARAMETERS
	%IF %NULL(buf)
	%THEN
	    %ERROR( '"buf" parameter must be specified' )
	    %EXITMACRO
	%FI
	BEGIN
	$rsx$bind( $$prt, prt )
	$rsx$emt( err, buf, $$prt1, $$prt0, GPRT$_ )
	END %, 

    GREG$( rid, buf ) =	! GET REGION PARAMETERS
	BLOCK[ GREG$_ ^ -8 ]  FIELD( GREG$F )  INITIAL( GREG$_, 0, rid, buf ) %, 

    GREG$S( rid, buf, err ) =	! GET REGION PARAMETERS
	$rsx$emt( err, buf, rid, 0, GREG$_ ) %, 

    GSSW$S( err ) =	! GET SENSE SWITCHES
	$rsx$emt( err, GSSW$_ ) %,

    GTIM$( buf ) =	! GET TIME PARAMETERS
	BLOCK[ GTIM$_ ^ -8 ]  FIELD( GTIM$F )  INITIAL( GTIM$_, buf ) %,

    GTIM$S( buf, err ) =	! GET TIME PARAMETERS
	$rsx$emt( err, buf, GTIM$_ ) %, 

    GTSK$( buf ) =	! GET TASK PARAMETERS
	BLOCK[ GTSK$_ ^ -8 ]  FIELD( GTSK$F )  INITIAL( GTSK$_, buf ) %,

    GTSK$S( buf, err ) =	! GET TASK PARAMETERS
	$rsx$emt( err, buf, GTSK$_ ) %,

!    IHAR$S 	! INHIBIT AST RECOGNITION  (not supplied.  see DSAR$S)

    MAP$( wdb )=	! MAP ADDRESS WINDOW
	BLOCK[ MAP$_ ^ -8 ]  FIELD( MAP$F )  INITIAL( MAP$_, wdb ) %, 

    MAP$S( wdb, err ) =	! MAP ADDRESS WINDOW
	$rsx$emt( err, wdb, MAP$_ ) %, 

    MRKT$( efn, tmg, tnt, ast ) =	! MARK TIME
	BLOCK[ MRKT$_ ^ -8 ]  FIELD( MRKT$F )
	    INITIAL( MRKT$_, $rsx$default(0,efn), tmg, tnt, $rsx$default(0,ast) ) %,

    MRKT$S( efn, tmg, tnt, ast, err ) =	! MARK TIME
	$rsx$emt( err, $rsx$default(0,ast), tnt, tmg, $rsx$default(0,efn),MRKT$_ ) %,

    QIO$( fnc, lun, efn, pri, isb, ast, prl ) =	! QUEUE I/O REQUEST
	BLOCK[ QIO$_ ^ -8 ]  FIELD( QIO$F )
	    INITIAL( QIO$_, fnc, lun, $rsx$default(0,pri)^8+$rsx$default(0,efn), $rsx$default(0,isb),
			$rsx$default(0,ast), $rsx$pad6(%remove(prl)) ) %,

    QIO$S( fnc, lun, efn, pri, isb, ast, prl, err ) =	! QUEUE I/O REQUEST
	$rsx$emt( err, $rsx$pad_6(%remove(prl)), $rsx$default(0,ast), $rsx$default(0,isb),
		$rsx$default(0,pri)^8+$rsx$default(0,efn),lun,fnc,QIO$_ ) %,

    QIOW$( fnc, lun, efn, pri, isb, ast, prl ) =	! QUEUE I/O REQUEST AND WAIT
	BLOCK[ QIOW$_ ^ -8 ]  FIELD( QIO$F )
	    INITIAL( QIOW$_, fnc, lun, $rsx$default(0,pri)^8+$rsx$default(0,efn), $rsx$default(0,isb),
		$rsx$default(0,ast), $rsx$pad6(%remove(prl)) ) %,

    QIOW$S( fnc, lun, efn, pri, isb, ast, prl, err ) =	! QUEUE I/O REQUEST AND WAIT
	$rsx$emt( err, $rsx$pad_6(%remove(prl)), $rsx$default(0,ast), $rsx$default(0,isb),
	$rsx$default(0,pri)^8+$rsx$default(0,efn),lun,fnc,QIOW$_ ) %,

    RCST$( tname, buf ) =	! RECEIVE DATA OR STOP
	BLOCK[ RCST$_ ^ -8 ]  FIELD( RCST$F )
	INITIAL( RCST$_, $rsx$rad50_2(tsk), buf ) %,

    RCST$S( tname, buf, err ) =	! RECEIVE DATA OR STOP
	BEGIN
	$rsx$bind( $$tname, tname )
	$rsx$emt( err, buf, $$tname1, $$tname0, RCST$_ )
	END %,

    RCVD$( tsk, buf ) =	! RECEIVE DATA
	BLOCK[ RCVD$_ ^ -8 ]  FIELD( RCVD$F )  INITIAL( RCVD$_, $rsx$rad50_2(tsk), buf ) %,

    RCVD$S( tsk, buf, err ) =	! RECEIVE DATA
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, buf, $$tsk1, $$tsk0, RCVD$_ ) %, 

    RCVX$( tsk, buf ) =	! RECEIVE DATA OR EXIT
	BLOCK[ RCVX$_ ^ -8 ]  FIELD( RCVX$F )  INITIAL( RCVX$_, $rsx$rad50_2(tsk), buf ) %,

    RCVX$S( tsk, buf, err ) =	! RECEIVE DATA OR EXIT
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, buf, $$tsk1, $$tsk0, RCVX$_ ) %, 

    RDAF$( buf ) =	! READ ALL EVENT FLAGS
	BLOCK[ RDAF$_ ^ -8 ]  FIELD( RDAF$F )  INITIAL( RDAF$_, buf ) %,

    RDAF$S( buf, err ) =	! READ ALL EVENT FLAGS
	$rsx$emt( err, buf, RDAF$_ ) %,

    RDXF$( buf ) =	! READ EXTENDED EVENT FLAGS
	BLOCK[ RDXF$_ ^ -8 ]  FIELD( RDXF$F )  INITIAL( RDXF$_, buf ) %,

    RDXF$S( buf, err ) =	! READ EXTENDED EVENT FLAGS
	$rsx$emt( err, buf, RDXF$_ ) %,

    RQST$( tsk, prt, pri, ugc, umc ) =	! REQUEST
	BLOCK[ RQST$_ ^ -8 ]  FIELD( RQST$F )  INITIAL( RQST$_, $rsx$rad50_2(tsk), 0, 0, 0, umc+ugc^8 ) %, 

    RQST$S( tsk, prt, pri, ugc, umc, err ) =	! REQUEST
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, umc+ugc^8, 0, 0, 0, $$tsk1, $$tsk0, RQST$_ )
	END %,

    RREF$( wdb ) =	! RECEIVE BY REFERENCE
	BLOCK[ RREF$_ ^ -8 ]  FIELD( RREF$F )  INITIAL( RREF$_, wdb ) %,

    RREF$S( wdb, err ) =	! RECEIVE BY REFERENCE
	$rsx$emt( err, wdb, RREF$_ ) %, 

    RSUM$( tsk ) =	! RESUME
	BLOCK[ RSUM$_ ^ -8 ]  FIELD( RSUM$F )  INITIAL( RSUM$_, $rsx$rad50_2(tsk) ) %,

    RSUM$S( tsk, err ) =	! RESUME
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, $$tsk1, $$tsk0, RSUM$_ )
	END %,

    RUN$( tsk, prt, pri, ugc, umc, smg, snt, rmg, rnt ) =	! RUN
	BLOCK[ RUN$_ ^ -8 ]  FIELD( RUN$F )
	    INITIAL( RUN$_, $rsx$rad50_2(tsk), 0, 0, 0, ugc^8+umc, smg, snt, rmg, rnt ) %, 

    RUN$S( tsk, prt, pri, ugc, umc, smg, snt, rmg, rnt, err ) =	! RUN
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, rnt, rmg, snt, smg, ugc^8+umc, 0, 0, 0, $$tsk1, $$tsk0, RUN$_ )
	END %,

    SDAT$( tsk, buf, efn ) =	! SEND DATA
	BLOCK[ SDAT$_ ^ -8 ]  FIELD( SDAT$F )  INITIAL( SDAT$_, $rsx$rad50_2(tsk), buf, $rsx$default(0,efn) ) %,

    SDAT$S( tsk, buf, efn, err ) =	! SEND DATA
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, $rsx$default(0,efn), buf, $$tsk1, $$tsk0, SDAT$_ )
	END %,

    SETF$( efn ) =	! SET EVENT FLAG
	BLOCK[ SETF$_ ^ -8 ]  FIELD( SETF$F )  INITIAL( SETF$_, efn ) %,

    SETF$S( efn, err ) =	! SET EVENT FLAG
	$rsx$emt( err, efn, SETF$_ ) %, 

    SFPA$( ast ) =	! SPECIFY FLOATING POINT PROCESSOR EXCEPTION AST
	BLOCK[ SFPA$_ ^ -8 ]  FIELD( SFPA$F )  INITIAL( SFPA$_, $rsx$default(0,ast) ) %,

    SFPA$S( ast, err ) =	! SPECIFY FLOATING POINT PROCESSOR EXCEPTION AST
	$rsx$emt( err, $rsx$default(0,ast), SFPA$_ ) %, 

    SPND$S( err ) =	! SUSPEND
	$rsx$emt( err, SPND$_ ) %,

    SPRA$( ast ) =	! SPECIFY POWER RECOVERY AST
	BLOCK[ SPRA$_ ^ -8 ]  FIELD( SPRA$F )  INITIAL( SPRA$_, $rsx$default(0,ast) ) %,

    SPRA$S( ast, err ) =	! SPECIFY POWER RECOVERY AST
	$rsx$emt( err, $rsx$default(0,ast), SPRA$_ ) %,

    SPWN$(tname,xx,yy,ugc,umc,efn,east,esb,cmdlin,cmdlen,unum,dnam) =	! SPAWN
	BLOCK[ SPWN$_ ^ -8 ]  FIELD( SPWN$F )
	INITIAL(SPWN$_,$rsx$rad50_2(tname),0,0,0,ugc^8+umc,
	  efn,east,esb,cmdlin,cmdlen,unum,%ASCII dnam) %,

    SPWN$S(tname,xx,yy,ugc,umc,efn,east,esb,cmdlin,cmdlen,unum,dnam,err) =	! SPAWN
	BEGIN
	$rsx$bind( $$tname, tname )
	$rsx$emt( err,%ASCII dnam,unum,cmdlen,cmdlin,esb,east,efn,
	ugc^8+umc,0,0,0,$$tname1,$$tname0,SPWN$_)
	END %,

    SRDA$( ast ) =	! SPECIFY RECEIVE DATA AST
	BLOCK[ SRDA$_ ^ -8 ]  FIELD( SRDA$F )  INITIAL( SRDA$_, $rsx$default(0,ast) ) %,

    SRDA$S( ast, err ) =	! SPECIFY RECEIVE DATA AST
	$rsx$emt( err, $rsx$default(0,ast), SRDA$_ ) %, 

    SREF$( tsk, wdb, efn ) =	! SEND BY REFERENCE
	BLOCK[ SREF$_ ^ -8 ]  FIELD( SREF$F )  INITIAL( SREF$_, $rsx$rad50_2(tsk), $rsx$default(0,efn), wdb ) %, 

    SREF$S( tsk, wdb, efn, err ) =	! SEND BY REFERENCE
	BEGIN
	$rsx$bind( $$tsk, tsk )
	$rsx$emt( err, wdb, $rsx$default(0,efn), $$tsk1, $$tsk0, SREF$_ )
	END %,

    SRRA$( ast ) =	! SPECIFY RECEIVE BY REFERENCE AST
	BLOCK[ SRRA$_ ^ -8 ]  FIELD( SRRA$F )  INITIAL( SRRA$_, $rsx$default(0,ast) ) %,

    SRRA$S( ast, err ) =	! SPECIFY RECEIVE BY REFERENCE AST
	$rsx$emt( err, $rsx$default(0,ast), SRRA$_ ) %,

    STLO$( grp,msk ) =	! STOP FOR LOGICAL OR OF EVENT FLAGS
	BLOCK[ STLO$_ ^ -8 ]  FIELD( STLO$F )  INITIAL( STLO$_, grp, msk ) %,

    STLO$S( grp,msk,err ) =	! STOP FOR LOGICAL OR OF EVENT FLAGS
	$rsx$emt( err, msk, grp, STLO$_ ) %,

    STOP$S( err ) =	! STOP
	$rsx$emt( err, STOP$_ ) %,

    STSE$( efn ) =	! STOP FOR SINGLE EVENT FLAG
	BLOCK[ STSE$_ ^ -8 ]  FIELD( STSE$F )  INITIAL( STSE$_, efn ) %,

    STSE$S( efn, err ) =	! STOP FOR SINGLE EVENT FLAG
	$rsx$emt( err, efn, STSE$_ ) %,

    SVDB$( adr, len ) =	! SPECIFY SST VECTOR TABLE FOR DEBUGGING AID
	BLOCK[ SVDB$_ ^ -8 ]  FIELD( SVDB$F )  INITIAL( SVDB$_, $rsx$default(0,adr), $rsx$default(0,len) ) %,

    SVDB$S( adr, len, err ) =	! SPECIFY SST VECTOR TABLE FOR DEBUGGING AID
	$rsx$emt( err, $rsx$default(0,len), $rsx$default(0,adr), SVDB$_ ) %, 

    SVTK$( adr, len ) =	! SPECIFY SST VECTOR TABLE FOR TASK
	BLOCK[ SVTK$_ ^ -8 ]  FIELD( SVTK$F )  INITIAL( SVTK$_, $rsx$default(0,adr), $rsx$default(0,len) ) %,

    SVTK$S( adr, len, err ) =	! SPECIFY SST VECTOR TABLE FOR TASK
	$rsx$emt( err, $rsx$default(0,len), $rsx$default(0,adr), SVTK$_ ) %, 

    UMAP$( wdb ) =	! UNMAP ADDRESS WINDOW
	BLOCK[ UMAP$_ ^ -8 ]  FIELD( UMAP$F )  INITIAL( UMAP$_, wdb ) %,

    UMAP$S( wdb, err ) =	! UNMAP ADDRESS WINDOW
	$rsx$emt( err, wdb, UMAP$_ ) %,

    USTP$( tname ) =	! UNSTOP TASK
	BLOCK[ USTP$_ ^ -8 ]  FIELD( USTP$F )
	INITIAL( USTP$_, $rsx$rad50_2(tname) ) %,

    USTP$S( tname, err ) =	! UNSTOP TASK
	BEGIN
	$rsx$bind( $$tname, tname )
	$rsx$emt( err, $$tname1, $$tname0, USTP$_ )
	END %,

    WSIG$S( err ) =	! WAIT FOR SIGNIFICANT EVENT
	$rsx$emt( err, WSIG$_ ) %, 

    WTLO$( grp, msk ) =	! WAIT FOR LOGICAL 'OR' OF EVENT FLAGS
	BLOCK[ WTLO$_ ^ -8 ]  INITIAL( WTLO$_, grp, msk ) %,

    WTLO$S( grp, msk, err ) =	! WAIT FOR LOGICAL 'OR' OF EVENT FLAGS
	$rsx$emt( err, msk, grp, WTLO$_ ) %, 

    WTSE$( efn ) =	! WAIT FOR SINGLE EVENT FLAG
	BLOCK[ WTSE$_ ^ -8 ]  FIELD( WTSE$F )  INITIAL( WTSE$_, efn ) %,

    WTSE$S( efn, err ) =	! WAIT FOR SINGLE EVENT FLAG
	$rsx$emt( err, efn, WTSE$_ ) %;
!%sbttl 'RSX11M - Include Error and Function Codes'

REQUIRE 'BLI:RSXEFC';


!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!
!									!
!  E N D   O F   R S X 1 1 M . R 1 6   S Y S T E M   I N T E R F A C E  !
!									!
!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!