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 !
! !
!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!