1 EXE
 For help on MACR0-11 and FORTRAN calling sequences for executive  directives,
 type AID EXE dir, where "dir" is the MACRO-11 name for the  directive,
 or type AID EXE dirname, where "dirname" is the name of the directive.
 
 Remember that many directives have similar names.   Type the full name of the
 directive as a single word with underscores between words, such as:
 
         AID EXE VARIABLE_SEND_DATA
 
 or type the name of the Macro-11 directive, such as:
 
        AID EXE VSDA
 
 Additional help is available as follows:
 
 	AID EXE DIC              for directive identification codes,
 
 	AID EXE ERRORS           for executive directive error codes,
 
 	AID EXE FUNCTION_CODES   for common QIO function codes.
 
2 ERRORS
 The symbols listed below are  associated  with  the  directive  status word.
 STANDARD ERROR CODES RETURNED BY DIRECTIVES IN THE DIRECTIVE STATUS WORD
        IS.CLR  +00     Event flag was clear
        IS.SUC  +01     Operation complete, success
        IS.SET  +02     Event flag was set
 	IS.SPD	+02	Task was suspended
        IE.UPN  -01.    Insufficient dynamic storage
        IE.INS  -02.    Specified task not installed
 	IE.PTS	-03.	Partition too small for task
        IE.UNS  -04.    Insufficient dynamic storage for send
        IE.ULN  -05.    Unassigned lun
        IE.HWR  -06.    Device driver not resident
        IE.ACT  -07.    Task not active
        IE.ITS  -08.    Directive inconsistent with task state
        IE.FIX  -09.    Task already fixed/unfixed
        IE.CKP  -10.    Issuing task not checkpointable
        IE.TCH  -11.    Task is checkpointable
        IE.RBS  -15.    Receive buffer too small
        IE.PRI  -16.    Privilege violation
        IE.RSU  -17.    Resource in use
        IE.NSW  -18.    No swap space available
        IE.ILV  -19.    Specified vector illegal
        IE.AST  -80.    Directive issued/not issued from AST
        IE.MAP  -81.    Illegal mapping specified
        IE.IOP  -83.    Window has I/O in progress
        IE.ALG  -84.    Alignment error
        IE.WOV  -85.    Address window allocation overflow
        IE.NVR  -86.    Invalid region id
        IE.NVW  -87.    Invalid address window id
        IE.ITP  -88.    Invalid TI parameter
        IE.IBS  -89.    Invalid send buffer size ( > 256. )
        IE.LNL  -90.    Lun locked in use
        IE.IUI  -91.    Invalid uic
        IE.IDU  -92.    Invalid device or unit
        IE.ITI  -93.    Invalid time parameters
        IE.PNS  -94.    Partition/region not in system
        IE.IPR  -95.    Invalid priority ( > 250. )
        IE.ILU  -96.    Invalid lun
        IE.IEF  -97.    Invalid event flag
        IE.ADP  -98.    Part of DPB out of user's space
        IE.SDP  -99.    DIC or DPB size invalid
2 FUNCTION_CODES
 
 	Function code    Octal code    Decimal code       Meaning
 	-------------    ----------    ------------    -------------
 
 	   IO.ATT          001400          768.        attach device
 
 	   IO.DET          002000         1024.        detach device
 
 	   IO.KIL          000012           10.        cancel I/O requests
 
 	   IO.RLB          001000          512.        read logical block
 
 	   IO.RVB          010400         4352.        read virtual block
 
 	   IO.WLB          000400          256.        write logical block
 
 	   IO.WVB          011000         4608.        write virtual block
 
2 ABORT_TASK
2 ABRT
 Abort Task                                                       ABRT$
 
 FORTRAN Call:
 
     CALL ABORT (tsk[,ids])
 
       tsk  =  Task name to be aborted (RAD50)
 
       ids  =  Directive status
 
 Macro Call:
 
     ABRT$   tsk
 
       tsk  =  Task name to be aborted (RAD50)
 
2 ALTER_PRIORITY
2 ALTP
 Alter Priority                                                   ALTP$
 
 FORTRAN Call:
 
     CALL ALTPRI ([tsk],[ipri][,ids])
 
       tsk  =  Active task name
 
       ipri =  1-word integer value of new priority, from 1 to 250 (decimal)
 
       ids  =  Directive status
 
 Macro Call:
 
     ALTP$   [tsk][,pri]
 
       tsk  =  Active task name
 
       pri  =  New priority, from 1 to 250 (decimal)
 
2 ASSIGN_LUN
2 ALUN
 Assign LUN                                                       ALUN$
 
 FORTRAN Call:
 
     CALL ASNLUN (lun,dev,unt[,ids])
 
       lun  =  Logical unit number
 
       dev  =  Device name (format:  1A2)
 
       unt  =  Device unit number
 
       ids  =  Directive status
 
 Macro Call:
 
     ALUN$   lun,dev,unt
 
       lun  =  Logical unit number
 
       dev  =  Device name (two characters)
 
       unt  =  Device unit number
 
2 AST_SERVICE_EXIT
2 ASTX
 AST Service Exit ($S form recommended)                          ASTX$S
 
 FORTRAN Call:
 
     Neither the FORTRAN language nor the ISA standard permits  direct
     linking to system-trapping mechanisms;  therefore, this directive
     is not available to FORTRAN tasks.
 
 Macro Call:
 
     ASTX$S  [err]
 
       err  =  Error routine address
 
2 ATTACH_REGION
2 ATRG
 Attach Region                                                   ATRG$
 
 FORTRAN Call:
 
     CALL ATRG (irdb[,ids])
 
       irdb =  An 8-word integer array containing a Region Definition Block 
 
       ids  =  Directive status
 
 Macro Call:
 
     ATRG$   rdb
 
       rdb  =  Region Definition Block address
 
 See AID EXECUTIVE RDB for information on the Region Definition Block.
 
2 CONNECT_TO_INTERRUPT_VECTOR
2 CINT
 Connect To Interrupt Vector                                     CINT$
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     CINT$   vec,base,isr,edir,pri,ast
 
       vec  =  Interrupt vector address -- Must be in the range  60(8)
               to  highest  vector specified during SYSGEN, inclusive,
               and must be a multiple of 4
 
       base =  Virtual base address for kernel APR 5  mapping  of  the
               ISR, and enable/disable interrupt routines
 
       isr  =  Virtual address of the ISR, or 0 to disconnect from the
               interrupt vector
 
       edir =  Virtual address of the enable/disable interrupt routine
 
       pri  =  Initial priority at which the ISR is to execute
 
       ast  =  Virtual address of an AST routine to be  entered  after
               the fork-level routine queues an AST
 
2 CLEAR_EVENT_FLAG
2 CLEF
 Clear Event Flag                                                 CLEF$
 
 FORTRAN Call:
 
     CALL CLREF (efn[,ids])
 
       efn  =  Event flag number
 
       ids  =  Directive status
 
 Macro Call:
 
     CLEF$  efn
 
       efn  =  Event flag number
 
2 CANCEL_MARK_TIME_REQUESTS
2 CMKT
 Cancel Mark Time Requests                                         CMKT$
 
 FORTRAN Call:
 
     CALL CANMT ([efn][,ids])
 
       efn  =  Event flag number
 
       ids  =  Directive status
 
 Macro Call:
 
     CMKT$  [efn][,ast][,err]
 
       efn  =  Event flag number
 
       ast  =  Mark time AST address
 
       err  =  Error routine address
 
2 CONNECT
2 CNCT
 Connect                                                          CNCT$
 
 FORTRAN Call:
 
     CALL CNCT (rtname,[iefn],[iast],[iesb],[iparm][,ids])
 
       rtname  =  A single-precision, floating-point variable containing the
 		  name (RAD50) of the offspring task to be connected
 
       iefn    =  Event flag to be set when the offspring  task  exits
                  or emits status
 
       iast    =  Name of  an  AST  routine  to  be  called  when  the
                  offspring task exits or emits status
 
       iesb    =  Name of an 8-word exit status block to  be  written  when
                  the offspring task exits or emits status
 
       iparm   =  Name of a word to receive the status  block  address
                  when an AST occurs
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     CNCT$   tname, [efn],[east],[esb]
 
       tname   =  Name (RAD50) of the offspring task to be connected
 
       efn     =  The event flag to be cleared  on  issuance  and  set
                  when the offspring task exits or emits status
 
       east    =  Address of an AST routine  to  be  called  when  the
                  offspring task exits or emits status
 
       esb     =  Address of an 8-word status block to be written when
                  the offspring task exits or emits status
 
 See AID EXECUTIVE ESB for information on the Exit Status Block.
 
2 CHECKPOINT_COMMON_REGION
2 CPCR
 Checkpoint Common Region                                         CPCR$
 
 RSX-11M-PLUS only
 
 FORTRAN Call:
 
     CALL CPCR   (name[,ids])
 
       name  =  Name (in RAD50) of the common region to be checkpointed
 
       ids   =  Directive status
 
 Macro Call:
 
     CPCR$ name
 
       name  =  Name of the common region to be checkpointed
 
2 CREATE_ADDRESS_WINDOW
2 CRAW
 Create Address Window                                            CRAW$
 
 FORTRAN Call:
 
     CALL CRAW (iwdb[,ids])
 
       iwdb =  An 8-word integer array containing a Window Definition Block
 
       ids  =  Directive status
 
 Macro Call:
 
     CRAW$   wdb
 
       wdb  =  Window Definition Block address
 
 See AID EXECUTIVE WDB for information on the Window Definition Block.
 
2 CREATE_GROUP_GLOBAL_EVENT_FLAGS
 #CRGF
2 CRGF
 Create Group Global Event Flags                                  CRGF$
 
 FORTRAN Call:
 
     CALL CRGF ([group][,ids])
 
       group  =  Group number for the flags  to  be  created - If  not
                 specified,  the  task's  protection UIC (H.CUIC+1) in
                 the task's header is used
 
       ids    =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     CRGF$   [group]
 
       group  =  Group number for the flags  to  be  created - If  not
                 specified,  the  task's  protection UIC (H.CUIC+1) in
                 the task's header is used
 
2 CREATE_REGION
2 CRRG
 Create Region                                                    CRRG$
 
 FORTRAN Call:
 
     CALL CRRG (irdb[,ids])
 
       irdb =  An 8-word integer array containing a Region Definition Block
 
       ids  =  Directive status
 
 Macro Call:
 
     CRRG$   rdb
 
       rdb  =  Region Definition Block address
 
 See AID EXECUTIVE RDB for information on the Region Definition Block.
 
2 CREATE_VIRTUAL_TERMINAL
2 CRVT
 
 RSX-11M-PLUS only.
 
 Create Virtual Terminal                                          CRVT$
 
 FORTRAN Call:
 
     CALL CRVT ([iiast],[ioast],[iaast],[imlen],iparm[,ids])
 
       iiast   =  AST address at which input requests  from  offspring
                  tasks are serviced
 
       ioast   =  AST address at which output requests from  offspring
                  tasks are serviced
 
       iaast   =  AST address at which the parent task may be notified
                  of the completion of successful offspring attach and
                  detach requests to the virtual terminal unit
 
       imlen   =  Maximum buffer  length  allowed  for  offspring  I/O
                  requests
 
       iparm   =  Address of 3-word buffer to receive information from
                  the stack when an AST occurs
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     CRVT$   [iast],[oast],[aast],[mlen]
 
       iast    =  AST address at  which  input  requests  from  offspring
                  tasks are serviced
 
       oast    =  AST address at which  output  requests  from  offspring
                  tasks are serviced
 
       aast    =  AST address at which the parent task  may  be  notified
                  of the completion of successful  offspring  attach  and
                  detach requests  to  the  virtual  terminal  unit.  (If
                  this  parameter is not specified,  no  notification  of
                  attaches and detaches are returned to the parent task.)
 
       mlen    =  Maximum buffer length allowed for offspring I/O requests
 
2 CANCEL_TIME_BASED_INITIATION_REQUESTS
2 CSRQ
 Cancel Time Based Initiation Requests                            CSRQ$
 
 FORTRAN Call:
 
     CALL CANALL (tsk[,ids])
 
       tsk  =  Task name
 
       ids  =  Directive status
 
 Macro Call:
 
     CSRQ$  tsk
 
       tsk  =  Task name
 
2 DECLARE_SIGNIFICANT_EVENT
2 DECL
 Declare Significant Event ($S form recommended)                 DECL$S
 
 FORTRAN Call:
 
     CALL DECLAR ([,ids])
 
       ids  =  Directive status
 
 Macro Call:
 
     DECL$S  [,err]
 
       err  =  Error routine address
 
2 DISABLE_AST_RECOGNITION
2 DSAR
 Disable AST Recognition ($S form recommended)                   DSAR$S
 
 FORTRAN Call:
 
     CALL DSASTR [(ids)]
 
       ids  =  Directive status
 
 Macro Call:
 
     DSAR$S  [err]
 
       err  =  Error routine address
 
2 DISABLE_CHECKPOINTING
2 DSCP
 Disable Checkpointing ($S form recommended)                     DSCP$S
 
 FORTRAN Call:
 
     CALL DISCKP [(ids)]
 
  ids  =  Directive status
 
 Macro Call:
 
     DSCP$S  [err]
 
       err  =  Error routine address
 
2 DETACH_REGION
2 DTRG
 Detach Region                                                    DTRG$
 
 FORTRAN Call:
 
     CALL DTRG (irdb[,ids])
 
       irdb =  An 8-word integer array containing a Region Definition Block
 
       ids  =  Directive status
 
 Macro Call:
 
     DTRG$   rdb
 
       rdb  =  Region Definition Block address
 
 See AID EXECUTIVE RDB for information on the Region Definition Block.
 
2 ELIMINATE_ADDRESS_WINDOW
2 ELAW 
 Eliminate Address Window                                         ELAW$
 
 FORTRAN Call:
 
     CALL ELAW (iwdb[,ids])
 
       iwdbi   =  An 8-word integer array containing a Window Definition Block
 
       ids     =  Directive status
 
 Macro Call:
 
     ELAW$   wdb
 
       wdb     =  Window Definition Block address
 
 See AID EXECUTIVE WDB for information on the Window Definition Block.
 
2 ELIMINATE_GROUP_GLOBAL_EVENT_FLAGS
2 ELFG
 Eliminate Group Global Event Flags                               ELGF$
 
 FORTRAN Call:
 
     CALL ELGF ([group][,ids])
 
       group  =  Group number of flags to be eliminated.  If not specified,
 		 the protection UIC (H.CUIC+1) in the task's header is used.
 
       ids    =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     ELGF$    [group]
 
       group  =  Group number of flags to be eliminated.  If not specified,
 		 the protection UIC (H.CUIC+1) in the task's header is used.
 
2 ELIMINATE_VIRTUAL_TERMINAL
2 ELVT
 RSX-11M-PLUS only.
 
 Eliminate Virtual Terminal                                       ELVT$
 
 FORTRAN Call:
 
     CALL ELVT (iunum[,ids])
 
       iunum   =  Virtual terminal unit number
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     ELVT$   unum
 
       unum    =  Unit number of the virtual terminal to be eliminated
 
2 EMIT_STATUS
2 EMST
 Emit Status                                                      EMST$
 
 FORTRAN Call:
 
     CALL EMST ([rtname],istat[,ids])
 
       rtname  =  Name of task connected to issuing task to which the
                  status is to be emitted
 
       istat   =  A 16-bit quantity to be returned to the connected task
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     EMST$   [tname],status
 
       tname   =  Name of a task connected to the issuing task to which
                  the status is to be emitted
 
       status  =  A 16-bit quantity to be returned to the connected task
 
2 ENABLE_AST_RECOGNITION
2 ENAR
 Enable AST Recognition ($S form recommended)                    ENAR$S
 
 FORTRAN Call:
 
     CALL ENASTR [(ids)]
 
       ids  =  Directive status
 
 Macro Call:
 
     ENAR$S  [err]
 
       err  =  Error routine address
 
2 ENABLE_CHECKPOINTING
2 ENCP
 Enable Checkpointing ($S form recommended)                      ENCP$S
 
 FORTRAN Call:
 
     CALL ENACKP [(ids)]
 
  ids  =  Directive status
 
 Macro Call:
 
     ENCP$S  [err]
 
       err  =  Error routine address
 
2 EXIT
2 TASK_EXIT
 Task Exit ($S form recommended)                                 EXIT$S
 
 FORTRAN Call:
 
     Fortran tasks that terminate with the STOP statement result in  a
     message  that includes task name, a statement causing the task to
     stop, and an optional character  string  specified  in  the  STOP
     statement.   CALL  EXIT  terminates  with  the  message STOP THIS
     FORTRAN TASK.
 
 Macro Call:
 
     EXIT$S  [err]
 
       err  =  Error routine address
 
2 EXIT_IF
2 EXIF
 Exit If                                                          EXIF$
 
 FORTRAN Call:
 
     CALL EXITIF (efn[,ids])
 
       efn  =  Event flag number
 
       ids  =  Directive status
 
 Macro Call:
 
     EXIF$  efn
 
       efn  =  Event flag number
 
2 EXIT_WITH_STATUS
2 EXST
 Exit With Status                                                 EXST$
 
 FORTRAN Call:
 
     CALL EXST (istat)
 
       istat   =  A 16-bit quantity to be returned to parent task
 
 Macro Call:
 
     EXST$   status
 
       status  =  A 16-bit quantity to be returned to parent task
 
2 EXIT_STATUS_BLOCK
2 ESB
 
 The Exit Status Block (ESB) can be specified by a parent task when spawning
 or connecting to an offspring task.  The ESB receives exit-status information
 when the offspring task exits or emits status.  The format of the ESB is:
 
 	Word 0 		offspring task exit status
 
 	Word 1  	TKTN abort code (a secondary status return)
 
 	Words 2-7	Reserved
 
 The ESB defaults to a length of one word.  To receive more than one word of
 information, logically OR the event flag argument with SP.WX8 in the
 directive that establishes the connection to the offspring task.  Note that
 if this is done, all eight words of the ESB are expected to be available for
 returning information. 
2 EXTEND_TASK
2 EXTK
 Extend Task                                                      EXTK$
 
 FORTRAN Call:
 
     CALL EXTTSK ([inc][,ids])
 
       inc  =  A positive or negative number equal to the number of 32-word
               blocks by which the task size is to be extended or reduced.
               (If omitted, task size defaults to installed task size.)
 
       ids  =  Directive status
 
 Macro Call:
 
     EXTK$   [inc]
 
       inc  =  A positive or negative number equal to the number of 32-word
               blocks by which the task size is to be extended or reduced.
               (If omitted, task size defaults to installed task size.)
 
2 GET_COMMAND_FOR_COMMAND_INTERPRETER
2 GCCI
 Get Command for Command Interpreter                              GCCI$
 
 Fortran Call:
 
     CALL GTCMCI (icbf,icbfl,[iibuf],[iibfl],[iaddr],[incp][,ids])
 
       icbf  = Name of a byte array to receive the command
 
       icbfl = Integer containing the size of the icbf array in bytes
 
       iibuf = Name of an integer to receive the optional information buffer
 
       iibfl = Name of an integer containing the length of the optional
 	       information buffer
 
       iaddr = Name of an integer that contains the address in DSR of the
               command desired.  (This address was obtained by a previous
               call to GTCMCI with GC.CND specified.)
 
       incp  = Name of an integer containing a value indicating the action
               to take if there is no command queued
 
       ids   = Integer to receive the directive status word
 
 Macro Call:
 
     GCCI$ cbuf,cbfl,[ibuf],[ibfl],[addr],[ncp]
 
       cbuf  = Address of buffer to receive command string
 
       cbfl  = Length of buffer.  Maximum buffer size is 91. for RSX-11M
               and 266. for RSX-11M-PLUS.
 
       ibuf  = Address of buffer to receive information on issuing terminal
 
       ibfl  = Length of buffer to receive information
 
       addr  = Address of command
 
       ncp   = Action to take if no command buffer is present
 
                    GC.CCS (000) -- Return with carry set (default)
 
                    GC.CEX (001) -- Force CLI to exit instead of returning
 
                    GC.CST (002) -- Force CLI to stop instead of returning
 
                    GC.CND (200) -- Copy command into buffer but do not
                                    dequeue it from the list
2 GET_COMMAND_INTERPRETER_INFORMATION
2 GCII
 Get Command Interpreter Information                              GCII$
 
 FORTRAN Call:
 
     CALL GETCII (ibuf,ibfl,[icli],[idev],[iunit][,ids]
 
       ibuf  = Name of an integer array to receive the CLI information
 
       ibfl  = Length in bytes of the integer array to receive the CLI
               information
 
       icli  = Name of a two-word array element containing  the  RAD50
               name of the CLI
 
       idev  = Name  of  an  integer  containing  the  ASCII  name  of
               the terminal (default = TI:)
 
       iunit = Name of an integer containing the octal unit number  of
               the terminal
 
       ids   = Directive status
 
 Macro Call:
 
     GCII$ buf,bufl,[cli],[dev,unit]
 
       buf   = Address of buffer to receive information
 
       bufl  = Length of information buffer
 
       cli   = Name in RAD50 of the CLI that information is requested on
 
       dev   = ASCII name of terminal whose CLI should be used
 
       unit  = Octal unit number of terminal
 
 
2 GET_LUN_INFORMATION
2 GLUN
 Get LUN Information                                              GLUN$
 
 FORTRAN Call:
 
     CALL GETLUN (lun,dat[,ids])
 
       lun  =  Logical unit number
 
       dat  =  A 6-word integer array to receive LUN information
 
       ids  =  Directive status
 
 Macro Call:
 
     GLUN$  lun,buf
 
       lun  =  Logical unit number
 
       buf  =  Address of 6-word buffer that will receive the LUN information
 
2 GET_MCR_COMMAND_LINE
2 GMCR
 Get MCR Command Line                                             GMCR$
 
 FORTRAN Call:
 
     CALL GETMCR (buf[,ids])
 
       buf  =  An 80-byte array to receive command line
 
       ids  =  Directive status
 
 Macro Call:
 
     GMCR$
 
2 GET_MAPPING_CONTEXT
2 GMCX
 Get Mapping Context                                              GMCX$
 
 FORTRAN Call:
 
     CALL GMCX (imcx[,ids])
 
       imcx =  An integer array to receive the mapping  context.   The
               size  of  the  array is 8*n+1, where n is the number of
               window blocks in the task's header (The maximum size is
               8*8+1=65  on  RSX-11M  systems.   The  maximum  size is
               8*24+1=193 on RSX-11M-PLUS systems.)
 
       ids  =  Directive status
 
 Macro Call:
 
     GMCX$   wvec
 
       wvec =  The address of a vector of n Window Definition Blocks;
               n is the number of window blocks in the task's header.
 
 See AID EXECUTIVE WDB for information on the Window Definition Block.
 
2 GET_PARTITION_PARAMETERS
2 GPRT
 Get Partition Parameters                                         GPRT$
 
 FORTRAN Call:
 
     CALL GETPAR ([prt],buf[,ids])
 
       prt  =  Partition name
 
       buf  =  A 3-word integer array to receive partition parameters
 
       ids  =  Directive status
 
 Macro Call:
 
     GPRT$  [prt],buf
 
       prt  =  Partition name
 
       buf  =  Address of 3-word buffer
 
 Buffer format:
 
 	Word 0		Partition base address
 	Word 1		Partition size
 	Word 2		Partition flags word
 			0 = system-controlled partition
 			1 = user-controlled partition
 
2 GET_REGION_PARAMETERS
2 GREG
 Get Region Parameters                                            GREG$
 
 FORTRAN Call:
 
     CALL GETREG ([rid],buf[,ids])
 
       rid  =  Region id
 
       buf  =  A 3-word integer array to receive region parameters
 
       ids  =  Directive status
 
 Macro Call:
 
     GREG$   [rid],buf
 
       rid  =  Region ID
 
       buf  =  Address of 3-word buffer
 
 Buffer format:
 
 	Word 0		Region base address
 	Word 1		Region size
 	Word 2		Region flags word
 			0 = system-controlled partition
 			1 = user-controlled partition
2 GET_SENSE_SWITCHES
2 GSSW
 Get Sense Switches ($S form recommended)                        GSSW$S
 
 FORTRAN Call:
 
     CALL READSW (isw)
 
       isw  =  Integer to receive the console switch settings
 
 The following FORTRAN call allows a program to read state of a single switch:
 
     CALL SWITCH (ibt,ist)
 
       ibt  =  The switch to be tested (0 to 15)
 
       ist  =  Test results where:
 
               1  =  switch on
               2  =  switch off
 
 Macro Call:
 
     GSSW$S  [err]
 
       err  =  Error routine address
 
2 GET_TIME_PARAMETERS
2 GTIM
 Get Time Parameters                                              GTIM$
 
 FORTRAN Call:
 
     CALL GETTIM (ibfl[,ids])
 
       ibfl  = An 8-word integer array
 
       ids   = Directive status
 
 Macro Call:
 
     GTIM$   buf
 
       buf  =  Address of 8-word buffer
 
 Buffer format:
 
 	Word 0		Year (since 1900)
 	Word 1		Month (1-12)
 	Word 2		Day (1-31)
 	Word 3		Hour (0-23)
 	Word 4		Minute (0-59)
 	Word 5		Second (0-59)
 	Word 6		Tick of second
 	Word 7		Ticks per second
 
2 GET_TASK_PARAMETERS
2 GTSK
 Get Task Parameters                                              GTSK$
 FORTRAN Call:
 
     CALL GETTSK (buf[,ids])
 
       buf  =  A 16-word integer array to receive the task parameters
 
       ids  =  Directive status
 
 Macro Call:
 
     GTSK$   buf
 
       buf  =  Address of 16-word buffer
 
2 INHIBIT_AST_RECOGNITION
2 IHAR
 Inhibit AST Recognition ($S form recommended)                   IHAR$S
 
 FORTRAN Call:
 
     CALL INASTR  [(ids)]
 
       ids  =  Directive status
 
 Macro Call:
 
     IHAR$S  [err]
 
       err  =  Error routine address
 
2 MAP_ADDRESS_WINDOW
2 MAP
 Map Address Window                                                MAP$
 
 FORTRAN Call:
 
     CALL MAP (iwdb[,ids])
 
       iwdb =  An 8-word integer array containing a Window Definition Block
 
       ids  =  Directive status
 
 Macro Call:
 
     MAP$   wdb
 
       wdb  =  Window Definition Block address
 
 See AID EXECUTIVE WDB for information on the Window Definition Block.
 
2 MARK_TIME
2 MRKT
 Mark Time                                                        MRKT$
 
 FORTRAN Call:
 
     CALL MARK (efn,tmg,tnt[,ids])
 
       efn  =  Event flag number
 
       tmg  =  Time interval magnitude
 
       tnt  =  Time interval unit
 
       ids  =  Directive status
 
 The ISA standard call  for  delaying  a  task  for  a  specified  time
 interval is also included:
 
     CALL WAIT (tmg,tnt,ids)
 
       tmg  =  Time interval magnitude
 
       tnt  =  Time interval unit
 
       ids  =  Directive status
 
 Macro Call:
 
     MRKT$   [efn],tmg,tnt[,ast]
 
       efn  =  Event flag number
 
       tmg  =  Time interval magnitude
 
       tnt  =  Time interval unit
 
       ast  =  AST entry point address
 
 For CALL WAIT:
 
       tmg =  0 for ticks
 	      1 for milliseconds
 
 For CALL MARK and Macro call:
 
       tmg = 1 for ticks
 
 For all forms:
 
       tmg = 2 for seconds
 	     3 for minutes
 	     4 for hours
 
2 MAP_SUPERVISOR
2 MSDS
 
 RSX-11M-PLUS only.
 
 Map Supervisor D-Space to Supervisor I-Space                     MSDS$
 
 FORTRAN Call:
 
 Not supported.
 
 Macro Call:
 
     MSDS$    mask
 
       mask  = A 7-bit mask with one bit corresponding to each APR.  If  the
               bit is set, the APR is mapped to supervisor-mode I-space.  If
               the bit is clear the APR is mapped to user-mode D-space.  The
               7 bits are specified in bits 8 through 14 of the mask word.
 
2 MOVE_USER_SUPERVISOR_ID_SPACE
2 MVTS
 
 RSX-11M-PLUS only.
 
 Move to/from User/Supervisor I/D-Space                           MVTS$
 
 FORTRAN Call:
 
     Not supported.
 
 Macro Call:
 
     MVTS$    action,addr,val
                          buff
 
       action  =  One of the following:
                       MV.TUI -- Move to user I-space
                       MV.TUD -- Move to user D-space
                       MV.TSI -- Move to supervisor I-space
                       MV.TSD -- Move to supervisor D-space
                       MV.FUI -- Move from user I-space
                       MV.FUD -- Move from user D-space
                       MV.FSI -- Move from supervisor I-space
                       MV.FSD -- Move from supervisor D-space
 
       addr    =  Address of the location in the task
 
       buf     =  Buffer to receive the value fetched, for a "move from"
 
       val     =  Value to be stored in the location, for a "move to"
 
2 QUEUE_IO_REQUEST
2 QIO
 Queue I/O Request                                                 QIO$
 
 FORTRAN Call:
 
     CALL QIO (fnc,lun,[efn],[pri],[isb],[prl][,ids])
 
       fuc  =  I/O function code
 
       lun  =  Logical unit number
 
       efn  =  Event flag number
 
       pri  =  Priority;  ignored, but must be present
 
       isb  =  A 2-word integer array to receive final I/O status
 
       prl  =  A 6-word  integer  array containing device-dependent parameters
               to  be  placed  in parameter words 1 through 6 of the Directive
               Parameter Block (DPB).  Fill in word one of this array by using
               the GETADR routine.
 
       ids  =  Directive status
 
 Macro Call:
 
     QIO$    fnc,lun,[efn],[pri],[isb],[ast],[prl]
 
       fnc  =  I/O function code
 
       lun  =  Logical unit number
 
       efn  =  Event flag number
 
       pri  =  Priority;  ignored, but must be present
 
       isb  =  Address of I/O status block
 
       ast  =  Address of AST service routine entry point
 
       prl  =  Parameter list of the form <p1,...p6>
 
2 QUEUE_IO_REQUEST_AND_WAIT
2 QIOW
 Queue I/O Request And Wait                                       QIOW$
 
 FORTRAN Call:
 
     CALL WTQIO (fnc,lun,[efn],[pri],[isb],[prl][,ids])
 
       fnc  =  I/O function code
 
       lun  =  Logical unit number
 
       efn  =  Event flag number
 
       pri  =  Priority;  ignored, but must be present
 
       isb  =  A 2-word integer array to receive final I/O status
 
       prl  =  A 6-word integer array containing device dependent parameters
               to be placed in parameter words 1 through 6 of the DPB
 
       ids  =  Directive status
 
 Macro Call:
 
     QIOW$   fnc,lun,[efn],[pri],[isb],[ast][,prl]
 
       fnc  =  I/O function code
 
       lun  =  Logical unit number
 
       efn  =  Event flag number
 
       pri  =  Priority;  ignored, but must be present
 
       isb  =  Address of I/O status block
 
       ast  =  Address of AST service routine entry point
 
       prl  =  Parameter list of the form <p1,...p6>
 
2 RECEIVE_DATA_OR_STOP
2 RCST
 Receive Data Or Stop                                             RCST$
 
 FORTRAN Call:
 
     CALL RCST ([rtname],ibuf[,ids])
 
       rtname  =  Sender task name (If  not  specified,  data  may  be
                  received from any task.)
 
       ibuf    =  Address of 15-word buffer to receive the sender task
                  name and data
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     RCST$   [tname],buf
 
       tname   =  Sender Task name (If  not  specified,  data  may  be
                  received from any task.)
 
       buf     =  Address of a 15-word buffer to  receive  the  sender
                  task name and data
 
2 RECEIVE_DATA
2 RCVD
 Receive Data                                                     RCVD$
 
 FORTRAN Call:
 
     CALL RECEIV ([tsk],buf[,,ids])
 
       tsk  =  Sender task name (If not specified, data may be
                 received from any task.)
 
       buf  =  A 15-word integer array for received data
 
       ids  =  Directive status
 
 Macro Call:
 
     RCVD$  [tsk],buf
 
       tsk  =  Sender  task  name  (If  not  specified,  data  may  be
               received from any task.)
 
       buf  =  Address of 15-word buffer
 
2 RECEIVE_DATA_OR_EXIT
2 RCVX
 Receive Data Or Exit						RCVX$
 
 FORTRAN Call:
 
     CALL RECOEX ([tsk],buf[,,ids])
 
       tsk  =  Sender  task  name  (If  not  specified,  data  may  be
               received from any task.)
 
       buf  =  A 15-word integer array for received data
 
       ids  =  Directive status
 
 Macro Call:
 
     RCVX$ [tsk],buf
 
       tsk  =  Sender  task  name  (If  not  specified,  data  may  be
               received from any task.)
 
       buf  =  Address of 15-word buffer
2 READ_ALL_EVENT_FLAGS
2 RDAF
 Read All Event Flags                                             RDAF$
 
 FORTRAN Call:
 
     A FORTRAN task can only read a single event flag.  The call is:
 
     CALL READEF (efn[,ids])
 
       efn  =  Event flag number (1-64.)
 
       ids  =  Directive status
 
 Macro Call:
 
     RDAF$  buf
 
       buf  =  Address of 4-word buffer
 
 Buffer format:
 
 	Word 0		Task local flags 1-16
 	Word 1		Task Local flags 17-32
 	Word 2		Task common flags 33-48
 	Word 3		Task common flags 49-64
2 READ_EVENT_FLAG
2 RDEF
 
 RSX-11M-PLUS only.
 
 Read Event Flag                                                  RDEF$
 
 FORTRAN Call:
 
     CALL READEF    (iefn[,ids])
 
       iefn  =  Integer containing an event flag number
 
       ids  =  Integer variable to receive the Directive Status Word
 
 Macro Call:
 
     RDEF$    efn
 
       efn  =  Event flag number
 
2 READ_EXTENDED_EVENT_FLAGS
2 RDXF
 Read Extended Event Flags                                        RDXF$
 
 FORTRAN Call:
 
     A FORTRAN task can read only a single event flag.  The call is:
 
     CALL READEF (efn[,ids])
 
       efn  =  Event flag number (1-96.)
 
       ids  =  Directive status
 
 Macro Call:
 
     RDXF$  buf
 
       buf  =  Address of 6-word buffer
 
 Buffer format:
 
 	Word 0		Task local flags 1-16
 	Word 1		Task Local flags 17-32
 	Word 2		Task common flags 33-48
 	Word 3		Task common flags 49-64
 	Word 4		Task group global flags 65-80
 	Word 5		Task group global flags 81-96
2 REGION_DEFINITION_BLOCK
2 RDB
 Region Definition Block
 
 RDB Format
 
 	Word 0		R.GID	-- Region ID
 	Word 1		R.GIZ	-- Region size
 	Word 2-3	R.NAM	-- Region name (Radix-50)
 	Word 4-5	R.GPAR	-- Region's main partition name (Radix-50)
 	Word 6		R.GSTS	-- Region status word
 	Word 7		R.GPRO	-- Protection code of region
 
 R.GSTS bit definitions:
 
 
 RS.CRR=^O<100000>		;REGION WAS SUCCESSFULLY CREATED
 RS.UNM=^O<40000>		;ONE OR MORE WINDOWS WERE UNMAPPED ON A DETACH
 
 RS.MDL=^O<200>			;MARK REGION FOR DELETE ON LAST DETACH
 RS.NDL=^O<100>			;CREATED REGION IS NOT TO BE MARKED FOR DETACH
 RS.ATT=^O<40>			;ATTACH TO CREATED REGION
 RS.NEX=^O<20>			;CREATED REGION IS NOT EXTENDABLE
 RS.DEL=^O<10>			;DELETE ACCESS DESIRED ON ATTACH
 RS.EXT=^O<4>			;EXTEND ACCESS DESIRED ON ATTACH
 RS.WRT=^O<2>			;WRITE ACCESS DESIRED ON ATTACH
 RS.RED=^O<1>			;READ ACCESS DESIRED ON ATTACH
2 REMOVE_AFFINITY
2 RMAF
 
 RSX-11M-PLUS only.
 
 Remove Affinity ($S form recommended)                           RMAF$S
 
 FORTRAN Call:
 
     CALL RMAF  [(ids)]
 
       ids =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     RMAF$S
 
2 RPOI
 Request and Pass Offspring Information                           RPOI$
 
 FORTRAN Call:
 
     CALL RPOI (tname,[iugc],[iumc],[iparen],[ibuf],[ibfl],[isc],[idnam],
                [iunit],[itask],[ocbad][,ids])
 
       tname   = An array containing the actual name of the task to be
                 requested and optionally chained to
 
       iugc    = Integer containing the group code number for the  UIC
                 of the requested target chain task
 
       iumc    = Integer containing the member code number for the UIC
                 of the requested target chain task
 
       iparen  = Array (or I*4 integer) containing the RAD50  name  of
                 the  parent task (This is returned in the information
                 buffer of the GTCMCI subroutine.)
 
       ibuf    = Array that contains command line text for the chained task.
 
       ibfl    = Integer that contains the number of bytes in the command
 		 in the ibuf array
 
       isc     = Flag byte controlling the actions of this directive
                 request when executed.  
 
       idnam   = Integer containing the ASCII device name of the requested
                 task's TI: device
 
       iunit   = Integer containing the unit number of the requested task's
                 TI: device
 
       itask   = Array which contains the  RAD50  name  the  requested
                 task is to run under.  (Valid only for CLIs.)
 
       ocbad   = Integer containing the internal DSR address of the parent
                 OCB.  (Only a  CLI  can specify this argument because the
                 value  can  only be obtained in the information buffer of
                 the GTCMCI subroutine.)
 
       ids     = Integer to receive the directive status word
 
 Macro Call:
 
     RPOI$  tname,,,[ugc],[umc],[parent],[bufadr],[buflen],[sc],[dnam],
            [unit],[task],[ocbad]
 
       tname   = Name of task to be chained to
 
       ugc     = Group code for UIC of the requested task
 
       umc     = Member code for UIC of the requested task
 
       parent  = Name of issuing task's parent task whose OCB is to be
                 passed.  If not specified, all OCB's are passed.
 
       bufadr  = Address of buffer to be given to the requested task
 
       buflen  = Length of buffer to be given to requested task
 
       sc      = Flags byte:
 
                      RP.OEX -- (200) Force issuing task to exit
                      RP.OAL -- (1)   Pass all OCB's
 		      RP.ONX -- (2)   Pass the first connection in the queue,
 				      if there is one
 
       dnam    = ASCII device name for TI:
 
       unit    = Unit number of task TI:
 
       task    = RAD50 name of task to be started
 
       ocbad   = Address of OCB to pass (CLIs only)
 
2 REQUEST_TASK
2 RQST
 Request Task                                                     RQST$
 
 FORTRAN Call:
 
     CALL REQUES (tsk,[opt][,ids])
 
       tsk  =  Task name
 
       opt  =  A 4-word integer array
 
               opt(1)  =  Partition name first half; ignored, but must
                          be present
 
               opt(2)  =  Partition name second half; ignored, but must
                          be present
 
               opt(3)  =  Priority;  ignored, but must be present
 
               opt(4)  =  User Identification Code
 
       ids  =  Directive status
 
 Macro Call:
 
     RQST$  tsk,[prt],[pri][,ugc,umc]
 
       tsk  =  Task name
 
       prt  =  Partition name;  ignored, but must be present
 
       pri  =  Priority;  ignored, but must be present
 
       ugc  =  UIC group code
 
       umc  =  UIC member code
 
 
 
2 RECEIVE_BY_REFERENCE
2 RREF
 Receive By Reference                                             RREF$
 
 FORTRAN Call:
 
     CALL RREF (iwdb,[isrb][,ids])
 
       iwdb =  An 8-word integer array containing a Window Definition Block
 
       isrb =  A 10-word integer array to be used as the receive buffer
 
       ids  =  Directive status
 
 Macro Call:
 
     RREF$   wdb
 
       wdb  =  Window Definition Block
 
 See AID EXECUTIVE WDB for information on the Window Definition Block.
 
2 RESUME_TASK
2 RSUM
 Resume Task                                                      RSUM$
 
 FORTRAN Call:
 
     CALL RESUME (tsk[,ids])
 
       tsk  =  Task name
 
       ids  =  Directive status
 
 Macro Call:
 
     RSUM$  tsk
 
       tsk  =  Task name
 
2 RUN
 Run Task                                                          RUN$
 
 FORTRAN Call:
 
     CALL RUN (tsk,[opt],[smg],snt,[rmg],[rnt][,ids])
 
       tsk  =  Task name
 
       opt  =  A 4-word integer array
 
               opt(1)  =  Partition name  first  half;   ignored,  but
                          must be present
 
               opt(2)  =  Partition name second  half;   ignored,  but
                          must be present
 
               opt(3)  =  Priority;  ignored, but must be present
 
               opt(4)  =  User Identification Code
 
       smg  =  Schedule delta magnitude
 
       snt  =  Schedule delta unit
 
       rmg  =  Reschedule interval magnitude
 
       rnt  =  Reschedule interval unit
 
       ids  =  Directive status
 
 The ISA standard call for initiating a task is also included:
 
     CALL START (tsk,smg,snt[,ids])
 
       tsk  =  Task name
 
       smg  =  Schedule delta magnitude
 
       snt  =  Schedule delta unit
 
       ids  =  Directive status
 
 Macro Call:
 
     RUN$   tsk,[prt],[pri],[ugc],[umc],[smg],snt[,rmg,rnt]
 
       tsk  =  Task name
 
       prt  =  Partition name;  ignored, but must be present
 
       pri  =  Priority;  ignored, but must be present
 
       ugc  =  UIC group code
 
       umc  =  UIC member code
 
       smg  =  Schedule delta magnitude
 
       snt  =  Schedule delta unit
 
       rmg  =  Reschedule interval magnitude
 
       rnt  =  Reschedule interval unit
 
2 SUPERVISOR_CALL
2 SCAL
 
 RSX-11M-PLUS only.
 
 Supervisor Call ($$ form recommended)                           SCAL$S
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     SCAL$S   saddr,caddr
 
       saddr   =  Address of the called supervisor-mode routine
 
       caddr   =  Address of the completion routine for return to the caller
 
 				**NOTE WELL**
 
 	We strongly suggest using the Task Builder to resolve references to
 	supervisor mode routines rather than explicitly using the SCAL$S
 	directive.  Doing so allows you to take advantage of any new
 	techniques implemented in future releases automatically.
 
2 SET_COMMAND_LINE_INTERPRETER
2 SCLI
 Set Command Line Interpreter                                    SCLI$
 
 FORTRAN Call:
 
     CALL SETCLI (icli,idev,iunit[,ids])
 
       icli  = A two word array element containing the name of the CLI
               to which the terminal is to be set
 
       idev  = Integer containing the ASCII name of the terminal to be
               set (default = TI:)
 
       iunit = Integer containing the unit number of terminal
 
       ids   = Directive status
 
 Macro Call:
 
     SCLI$ cli,[dev],[unit]
 
       cli   =  Name of the CLI to which the terminal is to be set
 
       dev   =  ASCII name of the terminal to be set (default = TI:)
 
       unit  =  Unit number of terminal
 
2 SEND_DATA
2 SDAT
 Send Data                                                        SDAT$
 
 FORTRAN Call:
 
     CALL SEND (tsk,buf,[efn][,ids])
 
       tsk  =  Task name
 
       buf  =  A 13-word integer array of data to be sent
 
       efn  =  Event flag number
 
       ids  =  Directive status
 
 
 Macro Call:
 
     SDAT$  tsk,buf[,efn]
 
       tsk  =  Task name
 
       buf  =  Address of 13-word data buffer
 
       efn  =  Event flag number
 
2 SEND_DATA_REQUEST_AND_PASS_OFFSPRING_CONTROL_BLOCK
2 SDRP
 Send Data Request and Pass Offspring Control Block               SDRP$
 
 FORTRAN Call:
 
     CALL SDRP (task,ibuf,[ibfl],[iefn],[iflag],[iparen],[iocbad][,ids])
 
       task   = Name of an array (REAL, INTEGER,  I*4)  that  contains
                the RAD50 name of target task
 
       ibuf   = Integer array containing data to be sent
 
       ibfl   = Integer containing number of words (integers)  in  the
                array  to  be  sent (On RSX-11M systems, this argument
                must  be  13.,  and  on  RSX-11M-PLUS  systems,   this
                argument may be in the range 1 to 255.) (Default = 13.)
 
       iefn   = Integer containing the number of the event flag to  be
                set when this directive is executed successfully
 
       iflag  = Integer containing flags bits controlling the execution.
 
       iparen = Name of array containing the RAD50 name of the parent
                task whose OCB should be passed to the target task
 
       iocbad = Name of an integer containing internal pool address of
                the OCB to pass
 
       ids    = Integer to receive the contents of the Directive Status Word
 
 Macro Call:
 
     SDRP$ task,bufadr,buflen,efn,flag,parent,ocbad
 
       task   = Name of task to be chained to
 
       bufadr = Address of buffer to be given to the requested task
 
       buflen = Length of buffer to be given to requested task
 
       efn    = Event flag
 
       flag   = Flags byte 
 
       parent = Name of issuing task's parent task whose OCB is to be passed
 
       ocbad  = Address of OCB to pass (CLI's only)
 
2 SEND_REQUEST_AND_CONNECT
2 SDRC
 Send, Request And Connect                                        SDRC$
 
 FORTRAN Call:
 
     CALL SDRC (rtname,ibuf,[iefn],[iast],[iesb],[iparm][,ids])
 
       rtname  =  Target task name of the offspring task to be connected
 
       ibuf    =  Name of 13-word send buffer
 
       iefn    =  Event flag to be set when the offspring task exits or
                  emits status
 
       iast    =  Name of  an  AST  routine  to  be  called  when  the
                  offspring task exits or emits status
 
       iesb    =  Name of an 8-word status block to  be  written  when
                  the offspring task exits or emits status
 
       iparm   =  Name of a word to receive the status  block  address
                  when an AST occurs
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     SDRC$   tname,buf,[efn],[east],[esb]
 
       tname  =  Target task name of the offspring task to be connected
 
       buf    =  Address of a 13-word send buffer
 
       efn    =  The event flag to be cleared on issuance and when the
                 offspring task exits or emit status
 
       east   =  Address of an AST  routine  to  be  called  when  the
                 offspring task exits or emits status
 
       esb    =  Address of a 8-word status block to be  written  when
                 the offspring task exits or emits status
 
2 SET_EVENT_FLAG
2 SETF
 Set Event Flag                                                   SETF$
 
 FORTRAN Call:
 
     CALL SETEF (efn[,ids])
 
       efn  =  Event flag number
 
       ids  =  Directive status
 
 Macro Call:
 
     SETF$   efn
 
       efn  =  Event flag number
 
2 SPECIFY_FLOATING_POINT_EXCEPTION_AST
2 SEPA
 Specify Floating Point Exception AST                             SEPA$
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     SFPA$   [ast]
 
       ast  =  AST service routine entry point address
 
2 SEND_MESSAGE
2 SMSG
 Send Message                                                     SMSG$
 
 FORTRAN Call:
 
     CALL SMSG (itgt,ibuf,ibufl,iprm,iprml,ids)
 
       itgt  = Integer containing the target object
 
       ibuf  = Integer array containing the data to be  inserted  into
               the formatted data packet
 
       ibufl = Integer containing length of the ibuf array
 
       iprm  = Integer array containing any additional parameters
 
       iprml = Integer containing the number of parameters in the iprm array
 
       ids   = Optional integer to receive the directive status
 
 Macro Call:
 
     SMSG$ tgt,buf,len,<pri,...,prn>
 
       tgt          =  Target identifier
 
       buf          =  Address of optional data buffer
 
       len          =  Length in bytes of optional data buffer
 
       pri,...,prn  =  Target-specific parameter list:
 
     Parameter list for Error Logging
 
          SMSG$ SM.SER,buf,len,typ,sub,lun,mask>
 
            typ  = Error Log packet code
 
            sub  = Error Log packet subtype code
 
            lun  = Logical unit number of device
 
            msk  = Control mask word
 
2 SEND_NEXT_COMMAND
2 SNXC
 
 RSX-11M-PLUS only.
 
 Send Next Command                                                SNXC$
 
 FORTRAN Call:
 
     CALL SNXC ([dnam][,iunit][,ids])
 
 	dnam  = Device name (ASCII).  If not specified, TI: is used
 
 	iunit =	Unit number of terminal from which the command is to be sent
 
 	ids   =	Integer to receive the directive status word
 
 Macro call:
 
     SNXC$ [dnam][,unum]
 
 	dnam  =	Device name (ASCII).  If not specified, TI: is used
 
 	unum  =	Unit number of terminal from which the command is to be sent
 
2 SPECIFY_PARITY_ERROR
2 SPEA
 
 RSX-11M-PLUS only.
 
 Specify Parity Error AST                                         SPEA$
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     SPEA$ [ast]
 
       ast  =  AST services routine entry point address
 
2 SUSPEND
2 SPND
 Suspend ($S form recommended)                                   SPND$S
 
 FORTRAN Call:
 
     CALL SUSPND   [(ids)]
 
       ids  = Directive status
 
 Macro Call:
 
 
     SPND$S  [err]
 
       err  =  Error routine address
 
2 SPECIFY_POWER_RECOVERY_AST
2 SPRA
 Specify Power Recovery AST                                       SPRA$
 
 FORTRAN Call:
 
     EXTERNAL sub
 
     CALL PWRUP (sub)
 
       sub  =  Name of a subroutine to be executed upon power recovery.
               The PWRUP subroutine will effect the following:
 
               CALL sub (no arguments)
 
               The subroutine is called as a result of a power recovery AST,
               and therefore can be controlled at critical points by using
               the DSASTR (or INASTR) and ENASTR subroutine calls.
 
 To Remove an AST:
 
     CALL PWRUP
 
 Macro Call:
 
     SPRA$  [ast]
 
       ast  =  AST service routine entry point address
 
2 SPAWN
2 SPWN
 Spawn                                                            SPWN$
 
 FORTRAN Call:
 
     CALL SPAWN (rtname,[iugc],[iumc],[iefn],[iast],[iesb],[iparm],
                [icmlin],[icmlen],[iunit],[dnam][,ids])
 
       rtname  =  Name (RAD50) of the offspring task to be spawned
 
       iugc    =  Group code number for the UIC of the offspring task
 
       iumc    =  Member code number for the UIC of the offspring task
 
       iefn    =  Event flag to be set when the offspring  task  exits
                  or emits status
 
       iast    =  Name of  an  AST  routine  to  be  called  when  the
                  offspring task exits or emits status
 
       iesb    =  Name of an 8-word status block to  be  written  when
                  the offspring task exits or emits status
 
       iparm   =  Name of a word to receive the status  block  address
                  when the AST occurs
 
       icmlin  =  Name  of  a  command  line  to  be  queued  for  the
                  offspring task
 
       icmlen  =  Length of the command line (79.  characters maximum)
 
       iunit   =  Unit number of terminal to be used as the  TI:   for
                  the  offspring  task (If the optional dnam parameter
                  is not specified, this parameter must  be  the  unit
                  number  of a virtual terminal created by the issuing
                  task;  if a value of 0 is specified, the TI:  of the
                  issuing task is propagated.)
 
       dnam    =  Device name mnemonic (If not specified, the  virtual
                  terminal is used as TI:.)
 
       ids    =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     SPWN$   tname,,,[ugc],[umc],[efn],[east],[esb],[cmdlin],[cmdlen]
                  ,[unum],[dnam]
 
       tname   =  Name (RAD50) of the offspring task to be spawned
 
       ugc     =  Group code number for the UIC of the offspring task
 
       umc     =  Member code number for the UIC of the offspring task
 
       efn     =  The event flag to be cleared  on  issuance  and  set
                  when the offspring task exits or emits status
 
       east    =  Address of an AST routine  to  be  called  when  the
                  offspring task exits or emits status
 
       esb     =  Address of an 8-word status block to be written when
                  the offspring task exits or emits status
 
       cmdlin  =  Address of a command  line  to  be  queued  for  the
                  offspring task
 
       cmdlen  =  Length of the command line (maximum length is 79.)
 
 
       unum    =  Unit number of terminal to be used as the  TI:   for
                  the  offspring  task (If the optional dnam parameter
                  is not specified, this parameter must  be  the  unit
                  number  of a virtual terminal created by the issuing
                  task;  if a value of 0 is specified, the TI:  of the
                  issuing task is propagated.)
 
       dnam    =  Device name mnemonic (If not specified, the  virtual
                  terminal is used as TI:.)
 
                                       NOTE
 
                  1.  If neither unum nor dnam is specified, the
                      TI: of  the  issuing  task  is propagated.
 
                  2.  If only unum is specified, TI: is a virtual terminal.
 
2 SPECIFY_RECEIVE_DATA_AST
2 SRDA
 Specify Receive Data AST                                         SRDA$
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     SRDA$   [ast]
 
       ast  =  AST service routine entry point address
 
2 SREX
2 SREA
 Specify Requested Exit AST                                       SREA$
 
                                                                 SREX$
 
 FORTRAN Call:
 
     CALL SREA(ast[,ids])
 
 	ast   =	Name of the externally declared AST routine
 
 	ids   =	Name of an optional integer to receive Directive Status Word
 
     CALL SREX(ast,ipblk,ipblkl,[dummy][,ids])
 
 	ast   =	Name of the externally declared AST routine
 
 	ipblk =	Name of an integer array to receive trap-dependent parameters
 
 	ipblkl=	Number of parameters to be returned into the ipblk array
 
 	dummy = Reserved for future programmer
 
 	ids   = Name of an optional integer to receive Directive Status Word
 
 Macro Call:
 
     SREA$ [ast]
 
     SREX$ [ast][,dummy]
 
       ast   = AST service routine entry point address
 
       dummy = Reserved for future expansion
 
2 SEND_BY_REFERENCE
2 SREF
 Send By Reference                                                SREF$
 
 FORTRAN Call:
 
 
     CALL SREF (tsk,[efn],iwdb,[isrb][,ids])
 
       tsk  =  Receiver task name
 
       efn  =  Event flag number
 
       iwdb =  An 8-word integer array containing a Window Definition Block
 
       isrb =  An 8-word integer array containing additional information
 
       ids  =  Directive status
 
 Macro Call:
 
     SREF$   task,wdb[,efn]
 
       task =  Receiver task name
 
       wdb  =  Window Definition Block address
 
       efn  =  Event flag number
 
2 SPECIFY_RECEIVE_BY_REFERENCE_AST
2 SRRA
 Specify Receive-By-Reference AST                                 SRRA$
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     SRRA$  [ast]
 
       ast  =  AST service routine entry point address
 
2 SET_AFFINITY
2 STAF
 
 RSX-11M-PLUS only.
 
 Set Affinity                                                     STAF$
 
 FORTRAN Call:
 
     CALL STAF (iaff[,ids])
 
       iaff =  Affinity mask word
 
       ids  =  Integer to receive Directive Status Word
 
 Macro Call:
 
     STAF$ [cp!ub!ub...]
 
       cp  =  CPU selected (A through D)
 
       ub  =  UNIBUS run(s) selected (E through T)
 
2 SET_TIME
2 STIM
 Set System Time Directive                                        STIM$
 
 FORTRAN Call:
 
     CALL SETTIM (ibufn[,ibufp][,ids])
 
       ibufn = An 8-word integer array, new time specification buffer
 
       ibufp = An 8-word integer array, previous time buffer
 
       ids   = Directive status
 
 Macro Call:
 
      STIM$ bufn,[bufp]
 
       bufn  = Address of 8-word new time specification buffer
 
       bufp  = Address of 8-word buffer to receive the previous system
               time parameters
 
 See AID EXECUTIVE GET_TIME_PARAMETERS
2 STOP
2 TASK_STOP
 Stop ($S form recommended)                                      STOP$S
 
 FORTRAN Call:
 
     CALL STOP ([ids])
 
       ids  =  Integer to receive the Directive Status Word
 
 Macro Call:
 
 
     STOP$S
 
 
 
2 STOP_FOR_LOGICAL_OR_OF_EVENT_FLAGS
2 STLO
 Stop For Logical OR Of Event Flags                               STLO$
 
 FORTRAN Call:
 
     CALL STLOR (ief1,ief2,ief3, ...  ief(n))
 
       ief1 ...  ief(n)  =  List of event flag numbers
 
 Macro Call:
 
     STLO$   grp, msk
 
       grp  =  Desired group of event flags
 
       msk  =  A 16-bit mask word
 
2 STOP_FOR_SINGLE_EVENT_FLAG
2 STSE
 Stop For Single Event Flag                                       STSE$
 
 FORTRAN Call:
 
     CALL STOPFR (iefn[,ids])
 
       iefn =  Event flag number
 
       ids  =  Integer to receive Directive Status Word
 
 Macro Call:
 
     STSE$   efn
 
       efn  =  Event flag number
 
2 SPECIFY_SST_VECTOR_TABLE_FOR_DEBUGGING_AID
2 SVDB
 Specify SST Vector Table For Debugging Aid                       SVDB$
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     SVDB$  [adr][,len]
 
       adr  =  Address of SST vector table
 
       len  =  Length of (that is, number of entries in) table in words
 
2 SPECIFY_SST_VECTOR_TABLE_FOR_TASK
2 SVTK
 Specify SST Vector Table For Task                                SVTK$
 
 FORTRAN Call:
 
     Not supported
 
 Macro Call:
 
     SVTK$  [adr][,len]
 
       adr  =  Address of SST vector table
 
       len  =  Length of (that is, number of entries in) table in words
 
2 UNLOCK_GROUP_GLOBAL_EVENT_FLAGS
2 ULGF
 Unlock Group Global Event Flags ($$ form recommended)           ULGF$
 
 FORTRAN Call:
 
     CALL ULGF ([ids])
 
       ids = Directive status
 
 Macro Call:
 
     ULGF$S [err]
 
       err = Error routine address
 
2 UNMAP_ADDRESS_WINDOW
2 UNMAP
 Unmap Address Window                                            UNMAP$
 
 FORTRAN Call:
 
     CALL UNMAP (iwdb[,ids])
 
       iwdb =  An 8-word integer array containing a Window Definition Block
 
       ids  =  Directive status
 
 Macro Call:
 
     UMAP$   wdb
 
       wdb  =  Window Definition Block address
 
 See AID EXECUTIVE WDB for information on the Window Definition Block.
 
2 UNSTOP_TASK
2 USTP
 Unstop TASK                                                      USTP$
 
 FORTRAN Call:
 
     CALL USTP (rtname[,ids])
 
       rtname  =  Name of task to be unstopped
 
       ids     =  Integer to receive directive status information
 
 Macro Call:
 
     USTP$   tname
 
       tname   =  Name of task to be unstopped
 
2 VARIABLE_RECEIVE_DATA
2 VRCD
 
 RSX-11M-PLUS only.
 
 Variable Receive Data                                            VRCD$
 
 FORTRAN Call:
 
     CALL VRCD ([task],bufadr,[buflen][,ids])
 
       task    =  Sender task name
 
       bufadr  =  Address of buffer to receive the sender task name and data
 
       buflen  =  Length of buffer
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     VRCD$  [task],bufadr[,buflen]
 
       task    =  Sender task name
 
       bufadr  =  Buffer address
 
       buflen  =  Buffer size in words
 
 See also AID EXECUTIVE VRCS and AID EXECUTIVE VRCX
2 VARIABLE_RECEIVE_DATA_AND_STOP
2 VRCS
 
 RSX-11M-PLUS only.
 
 Variable Receive Data Or Stop                                    VRCS$
 
 FORTRAN Call:
 
     CALL VRCS ([task],bufadr,[buflen][,ids])
 
       task    =  Sender task name
 
       buf     =  Address of buffer to receive the sender task name and data
 
       buflen  =  Length of buffer
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     VRCS$      [task],bufadr[,buflen]
 
       task    =  Sender task name
 
       bufadr  =  Buffer address
 
       buflen  =  Buffer size in words
 
2 VARIABLE_RECEIVE_DATA_OR_EXIT
2 VRCX
 Variable Receive Data Or Exit                                    VRCX$
 
 FORTRAN Call:
 
     CALL VRCX ([task],bufadr,[buflen][,ids])
 
       task    =  Sender task name
 
       bufadr  =  Address of buffer to receive the sender task name and data
 
       buflen  =  Length of buffer
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     VRCX$      [task],bufadr[,buflen]
 
       task    =  Sender task name
 
       bufadr  =  Buffer address
 
       buflen  =  Buffer size in words
 
2 VARIABLE_SEND_DATA
2 VSDA
 
 RSX-11M-PLUS only.
 
 Variable Send Data                                               VSDA$
 
 FORTRAN Call:
 
     CALL VSDA ([task],bufadr,[buflen],[efn][,ids])
 
       task    =  Receiver task name
 
       bufadr  =  Address of buffer to receive the sender task name and data
 
       buflen  =  Length of buffer
 
       efn     =  Event flag number
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     VSDA$      [task],bufadr,[buflen][,efn]
 
       task    =  Receiver task name
 
       bufadr  =  Buffer address
 
       buflen  =  Buffer size in words
 
       efn     =  Event flag number
 
2 VARIABLE_SEND_REQUEST_AND_CONNECT
2 VSRC
 
 RSX-11M-PLUS only.
 
 Variable Send, Request and Connect                               VSRC$
 
 FORTRAN Call:
 
     CALL VSRC (rtname,ibuf,[ibufl],[iefn],[iast],[iesb],[iparm][,ids])
 
       rtname  =  Target task name of the offspring task to be connected
 
       ibuf    =  Name of 13-word send buffer
 
       ibufl   =  Length of buffer
 
       iefn    =  Event flag set when offspring task exits or emits status
 
       iast    =  Name of  an  AST  routine  to  be  called  when  the
                  offspring task exits or emits status
 
       iesb    =  Name of an 8-word status block to  be  written  when
                  the offspring task exits or emits status
 
       iparm   =  Name of a word to receive the status  block  address
                  when an AST occurs
 
       ids     =  Integer to receive the Directive Status Word
 
 Macro Call:
 
     VSRC$    tname,buf[,buflen],efn,east,esb
 
       tname   =  Target task name of the offspring task to be connected
 
       buf     =  Address of a send buffer
 
       buflen  =  Length of buffer
 
       efn     =  The event flag to be set when the offspring task exits 
 		  or emits status
 
       east    =  Address of an AST routine  to  be  called  when  the
                  offspring task exits or emits status
 
       esb     =  Address of a 8-word status block to be written  when
                  the offspring task exits or emits status
 
2 WAIT_FOR_SIGNIFICANT_EVENT
2 WSIG
 Wait For Significant Event ($S form recommended)                WSIG$S
 
 FORTRAN Call:
 
     CALL WFSNE
 
 Macro Call:
 
     WSIG$S  [err]
 
       err  =  Error routine address
 
2 WAIT_FOR_LOGICAL_OR_OF_EVENT_FLAGS
2 WTLO
 Wait For Logical OR Of Event Flags                               WTLO$
 
 FORTRAN Call:
 
     CALL WFLOR (efn1,efn2,...efnn)
 
       efn  =  List of event flag numbers taken as the set of flags to
               be specified in the directive
 
 Macro Call:
 
     WTLO$   grp,msk
 
       grp  =  Desired group of event flags
 
       msk  =  A 16-bit octal mask word
 
2 WAIT_FOR_SINGLE_EVENT_FLAG
2 WTSF
 Wait For Single Event Flag                                       WTSF$
 
 FORTRAN Call:
 
     CALL WAITFR (efn[,ids])
 
       efn  =  Event flag number
 
       ids  =  Directive status
 
 Macro Call:
 
     WTSE$  efn
 
       efn  =  Event flag number
 
2 WINDOW_DEFINITION_BLOCK
2 WDB
 
 Window Definition Block
 
 	Word 0	= W.NID		-- Window ID
 	Word 1	= W.NAPR	-- Base APR
 	Word 2 	= W.NBAS	-- Virtual base address (bytes)
 	Word 3  = W.NSIZ	-- Window size (32-word blocks)
 	Word 4	= W.NRID	-- Region ID
 	Word 5  = W.NOFF	-- Offset in partition (32-word blocks)
 	Word 6	= W.NLEN	-- Length to map (32-word blocks)
 	Word 7 	= W.NSTS	-- Window status word
 	Word 8	= W.NSRB	-- Send/Receive buffer virtual address (bytes)
 
 W.NSTS Bit Definitions
 
 WS.CRW=^O<100000>		;ADDRESS WINDOW WAS SUCCESSFULLY CREATED
 WS.UNM=^O<40000>		;ONE OR MORE WINDOWS WERE UNMAPPED IN
 				;CREATE ADDRESS WINDOW OR MAP.
 WS.ELW=^O<20000>		;ONE OR MORE WINDOWS WERE ELIMINATED IN
 				;CREATE ADDRESS WINDOW
 WS.RRF=^O<10000>		;REFERENCE WAS SUCCESSFULLY RECEIVED
 
 WS.BPS=^O<4000>		;DO NOT BYPASS CACHE ON MAP
 WS.NBP=^O<4000>		;DO NOT BYPASS CACHE ON CRAW
 WS.RES=^O<2000>		;MAP ONLY IF RESIDENT
 WS.NAT=^O<1000>		;CREATE ATT DESCR ONLY IF NECESSARY
 WS.64B=^O<400>			;64 BYTE ALIGNMENT ALLOWED
 WS.MAP=^O<200>			;MAP AFTER CREATE WINDOW OR RECEIVE BY REF
 WS.RCX=^O<100>			;EXIT IF NO REFERENCES TO RECEIVE
 WS.SIS=^O<40>			;CREATE WINDOW IN SUPERVISOR I SPACE
 WS.UDS=^O<20>			;CREATE WINDOW IN USER D SPACE
 WS.DEL=^O<10>			;SEND WITH DELETE ACCESS
 WS.EXT=^O<4>			;SEND WITH EXTEND ACCESS
 WS.WRT=^O<2>			;SEND WITH WRITE ACCESS OR MAP WITH 
 				;WRITE ACCESS
 WS.RED=^O<1>			;SEND WITH READ ACCESS
 WS.EDS= WS.SIS! WS.UDS		;EFFECTIVE DATA SPACE
 
2 DIC
 Directive Identification  Codes  (DICs)  are  used  to  identify  each
 directive.   The  DIC  appears  in the low byte of the first (or only)
 word in the Directive Parameter  Block  (DPB).   The  DPB  length  (in
 words)  appears  in  the  high byte of the first DPB word.  Thus, both
 bytes make up the word format shown below:
 
 This list can be used as a software debugging aid to quickly  identify
 directives  based  on  the octal value of the first word in a DPB.  
 
 Octal Value For     Directive           Decimal Values For
 DPB First Word     (Macro Call)         DIC     DPB Length
 
       433           CMKT$               27.         1.
       443           DECL$               35.         1.
       455           SPND$S              45.         1.
       462           WSIG$S              49.         1.
       463           EXIT$S              51.         1.
 
       537           DCSP$               95.         1.
       541           ENCP$S              97.         1.
       543           DSAR$S or IHAR$S    99.         1.
       545           ENAR$S             101.         1.
       563           ASTX$S             115.         1.
       575           GSSW$S             125.         1.
 
       603           STOP$S             131.         1.
       643           RMAF$              163.         1.
 
      1015           STAF$              161.         2.
      1025           SRRA$               21.         2.
      1035           EXST$               29.         2.
      1037           CLEF$               31.         2.
      1041           SETF$               33.         2.
      1047           RDAF$               39.         2.
      1051           WTSE$               41.         2.
      1065           EXIF$               53.         2.
      1067           CRRG$               55.         2.
      1071           ATRG$               57.         2.
      1073           DTRG$               59.         2.
      1075           GTIM$               61.         2.
      1077           GTSK$               63.         2.
 
      1121           RREF$               81.         2.
      1153           SRDA$              107.         2.
      1155           SPRA$              109.         2.
      1157           SFPA$              111.         2.
      1161           GMCX$              113.         2.
      1165           CRAW$              117.         2.
      1167           ELAW$              119.         2.
      1171           MAP$               121.         2.
      1173           UMAP$              123.         2.
 
      1207           STSE$              135.         2.
      1227           ELVT$              151.         2.
      1235           CRGF$              157.         2.
      1237           ELGF$              159.         2.
      1241           STAF$              161.         2.
      1245           SPEA$              165.         2.
      1247           SREA$              167.         2.
 
      1405           GLUN$                5.         3.
      1431           CSRQ$               25.         3.
      1433           CMKT$               27.         3.
      1447           RDXF$               39.         3.
      1453           WTLO$               43.         3.
      1457           RSUM$               47.         3.
      1475           STIM$               61.         3.
 
      1523           ABRT$               83.         3.
      1531           EXTK$               89.         3.
      1547           SVDB$              103.         3.
      1551           SVTK$              105.         3.
 
      1605           USTP$              133.         3.
      1611           STLO$              137.         3.
      1617           CNCT$              143.         3.
      1633           SCAL$S             155.         3.
      1647           SREX$              167.         3.
 
      2007           ALUN$                7.         4.
      2011           ALTP$                9.         4.
 
      2101           GPRT$ or GREG$      65.         4.
      2113           RCVD$               75.         4.
      2115           RCVX$               77.         4.
 
      2213           RCST$              139.         4.
      2223           EMST$              147.         4.
 
      2427           MRKT$               23.         5.
 
      2505           SREF$               69.         5.
      2507           SDAT$               71.         5.
 
      2625           CRVT$              149.         5.
 
      3113           VRCD$               75.         6.
      3115           VRCX$               77.         6.
 
      3213           VRCS$              139.         6.
 
      3413           RQST$               11.         7.
 
      3601           CINT$              129.         7.
      3615           SDRC$              141.         7.
 
      4107           VSDA$               71.         8.
 
      5421           RUN$                17.        11.
 
      6001           QIO$                 1.        12.
      6003           QIOW$                3.        12.
 
      6413           SPWN$               11.        13.
 
      7013           SPWN$               11.        14.
 
     12377           GMCR$              127.        41.
