Google
 

Trailing-Edge - PDP-10 Archives - BB-P363B-SM_1985 - mcb/nml/nmucom.req
There are 3 other files named nmucom.req in the archive. Click here to see a list.
! <BRANDT.DEVELOPMENT>NMUCOM.REQ.1 07-Sep-82 10:13:05, Edit by BRANDT
!
!   Make PROGRAM_ERROR cause the program to stop.  Before this edit
!   this was just a NOP.
!
! NET:<PECKHAM.DEVELOPMENT>NMUCOM.REQ.2 29-Jun-82 09:56:00, Edit by PECKHAM
!
! Changes for NMX command handling:
!  Add $NMU_NMX_* macros for optimimal implementation.
!
! <BRANDT.DEVELOPMENT>NMUCOM.REQ.1 01-Jun-82 10:13:05, Edit by BRANDT
!
!   Remove definition for NMU$TIMEOUT_CHECK.
!
! NET:<PECKHAM.DEVELOPMENT>NMUCOM.REQ.3 14-May-82 12:19:27, Edit by PECKHAM
!
! Add NMU$DLX_KNOWN_DEVICE and NMU$DLX_RETURN_CIRCUITS synonyms.
!
! NET:<PECKHAM.DEVELOPMENT>NMUCOM.REQ.9 28-Apr-82 13:52:10, Edit by PECKHAM
!
! Add $NMU_DLX_* macros. This is to help fix the MOP function timeout bug.
! Add NMU$K_MOP_RETRY_LIMIT for MOP retransmit limit.
!
! NET:<VOBA.NML.DEVELOPMENT>NMUCOM.REQ.4 25-Mar-82 17:55:39, Edit by VOBA
!
! Add new routine (global mapping) name NMU$QUEUE_LENGTH (alias UQ_LENGTH)
! for NMUQUE module.
!
! NET:<VOBA.NML.DEVELOPMENT>NMUCOM.REQ.3 19-Feb-82 12:41:10, Edit by VOBA
!
! Fix typo errors.
!
! NET:<VOBA.NML.DEVELOPMENT>NMUCOM.REQ.15 18-Feb-82 17:10:20, Edit by VOBA
!
! Clean up code and update copyright date.
!
! NET:<GROSSMAN>NMUCOM.REQ.3 26-Jan-82 06:53:41, Edit by GROSSMAN
!
! Fix definition of EVENT_BLOCK. This is need in order to have tasks wake up
! on multiple events.
!
! NET:<PECKHAM.DEVELOPMENT>NMUCOM.REQ.2 20-Jan-82 08:54:21, Edit by PECKHAM
!
! Fix NMU$SCHED_MANAGER macro to declare NMU$SCHED_WAIT as having a value.
!
! NET:<DECNET20-V3P1.NMLLIB>NMUCOM.REQ.3 03-Dec-81 14:31:00, Edit by THIGPEN
!
! Add definition for NMU$TIMEOUT_CHECK.
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.3 13-Jul-81 10:00:18, Edit by GUNN
!
! Add definition for NMU$FILE_INITIALIZE.
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.2  2-Jul-81 12:03:30, Edit by GUNN
!
! Add definitions for new module NMUUTL.
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.2 18-Jun-81 15:48:09, Edit by GUNN
!
!    Remove definition of DLX_TRANSFER.
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.2 12-Jun-81 13:36:30, Edit by JENNESS
!
!    Readability improvements.
!
! NET:<DECNET20-V3P1.BASELEVEL-2.MCB>NMUCOM.REQ.2 10-Jun-81 09:58:52, Edit by SROBINSON
!
!    Add Quota Queue Definitions
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.2 26-May-81 13:27:39, Edit by JENNESS
!
!    Add OUTPUT_POSITION to TEXT STATE BLOCK.
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.12  8-May-81 17:28:37, Edit by GUNN
!
!    Fix TASK_ERROR, TASK_INFO, and PROGRAM_ERROR to really handle
!    arguments like %STRING as advertised.
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.2 16-Apr-81 13:43:09, Edit by JENNESS
!
!    Add NMU$FILE and NMU$TABLE definitions
!
! NET:<DECNET20-V3P1.BASELEVEL-2.MCB>NMUCOM.REQ.2 30-Apr-81 14:07:55, Edit by SROBINSON
!
!    Fix Text Generation in MCB mode
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.36 18-Mar-81 11:23:31, Edit by JENNESS
!
!    Split debugging macros off into file DEBUG.REQ
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.3 10-Mar-81 11:26:21, Edit by JENNESS
!
!    Add debugging macros.
!
! NET:<DECNET20-V3P1.NMU>NMUCOM.REQ.3  9-Feb-81 10:33:38, Edit by JENNESS
!
!    Change text state block.  Remove FIELD_SUPPRESS.  Change FIELD_NOCOMPRESS
!    to FIELD_ZERO_SUPPRESS.  Makes code much(!!) clearer.
!
! NET:<DECNET20-V3P1.BASELEVEL-2.SOURCES>NMUCOM.REQ.16  4-Feb-81 17:41:37, Edit by GUNN
!
!    Update copyright date to 1981
%title 'NMUCOM -- Network Management Utilities Common Definitions'

!                    COPYRIGHT (c) 1980, 1981, 1982
!                    DIGITAL EQUIPMENT CORPORATION
!                        Maynard, Massachusetts
!
!     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: LSG DECnet Network Management
!
! Abstract: This file contains definitions for data base
!           formats and interesting values used when communicating
!           with the NMU utility routines.
!
! Environment: Bliss-36, Bliss-32 and Bliss-16.
!
! Author: Steven M. Jenness, Creation date: 10-Sep-80
!
!--
!
! Boolean value definitions
!

literal
       $TRUE = 1 eql 1,
       $FALSE = 1 eql 0;


! Semaphore block
!
!	A semaphore defined by this block is set/reset by
!	the macro calls LOCK/UNLOCK.
!
! macro:   SEMAPHORE_BLOCK	 Defines a semaphore block
! value:   SEMAPHORE_BLOCK_SIZE  Defines size of a semaphore block


$field SEMAPHORE_BLOCK_FIELDS =
    set
    SEMAPHORE = [$integer]              ! Interlock flag
    tes;

literal
       SEMAPHORE_BLOCK_SIZE = $field_set_size;

macro
     SEMAPHORE_BLOCK =
         block [SEMAPHORE_BLOCK_SIZE] field (SEMAPHORE_BLOCK_FIELDS) %;
%sbttl 'Queue Structure Definitions'

! These queue structure definitions are used with the routines contained
! in NMUQUE (Queue Manager).
!
! Queue entry definitions
!
! macro:   Q_ENTRY        Defines a queue entry
! value:   Q_ENTRY_SIZE  Defines size of queue entry header


$field Q_ENTRY_FIELDS =
    set
    Q_FORWARD = [$address],
    Q_REVERSE = [$address],
    Q_SEMAPHORE = [$sub_block (SEMAPHORE_BLOCK_SIZE)],
    Q_DATA = [$sub_block (0)]
    tes;

literal
       Q_ENTRY_SIZE = $field_set_size,
       Q_ENTRY_ALLOCATION = $field_set_units;

macro
     Q_ENTRY =
         block [Q_ENTRY_SIZE] field (Q_ENTRY_FIELDS) %;


! Queue header definitions
!
! macro:   Q_HEADER         Defines a queue header
! value:   Q_HEADER_SIZE  Defines size of queue header


literal
       Q_HEADER_SIZE = Q_ENTRY_SIZE,
       Q_HEADER_ALLOCATION = Q_ENTRY_ALLOCATION;

macro
     Q_HEADER =
         block [Q_HEADER_SIZE] field (Q_ENTRY_FIELDS) %;


! These tasking definitions are used with the tasking system contained
! in NMUSKD (Scheduler).
!
! Event data base definitions
!
! macro:   EVENT_BLOCK       Defines a event block
! value:   EVENT_BLOCK_SIZE  Defines size of a event block


$field EVENT_BLOCK_FIELDS =
    set
    EB_TASKS = [$address],
    EB_SEMAPHORE = [$sub_block (SEMAPHORE_BLOCK_SIZE)],
    EB_NOINT = [$bit]
    tes;

literal
       EVENT_BLOCK_SIZE = $field_set_size,
       EVENT_BLOCK_ALLOCATION = $field_set_units;

macro
     EVENT_BLOCK =
         block [EVENT_BLOCK_SIZE] field (EVENT_BLOCK_FIELDS) %;


! Scheduling queue header definitions
!
! macro:   SQ_HEADER       Defines a queue header block
! value:   SQ_HEADER_SIZE  Defines size of queue header block


$field SQ_HEADER_FIELDS =
    set
    Q_QUEUE = [$sub_block (Q_HEADER_SIZE)],
    Q_EVENT = [$sub_block (EVENT_BLOCK_SIZE)]
    tes;

literal
       SQ_HEADER_SIZE = $field_set_size,
       SQ_HEADER_ALLOCATION = $field_set_units;

macro
     SQ_HEADER =
         block [SQ_HEADER_SIZE] field (SQ_HEADER_FIELDS) %;


! macro:   QQ_HEADER       Defines a quota queue header block
! value:   QQ_HEADER_SIZE  Defines size of quota queue header block


$field QQ_HEADER_FIELDS =
    set
    QQ_SQUEUE = [$sub_block (SQ_HEADER_SIZE)],
    QQ_IEVENT = [$sub_block (EVENT_BLOCK_SIZE)],
    QQ_QUOTA = [$short_integer],
    QQ_CURRENT = [$short_integer]
    tes;

literal
       QQ_HEADER_SIZE = $field_set_size,
       QQ_HEADER_ALLOCATION = $field_set_units;

macro
     QQ_HEADER =
         block [QQ_HEADER_SIZE] field (QQ_HEADER_FIELDS) %;
%sbttl 'Tasking Definitions'

! macro: TASK_ERROR
!
!		This macro signals that the currently running
!		task has encountered a fatal error.  The supplied
!		string is associated with the task crash.  The
!		system specific recovery procedure is started.
!
!	TASK_ERROR (ERROR_STRING)
!
!	where ERROR_STRING is either a pointer to a string
!	or a literal message string as for %STRING.


macro
     TASK_ERROR [] =
         begin
         %if $MCB
         %then external routine NMU$SCHED_COMPLETE;
               NMU$SCHED_COMPLETE ();
         %else external routine NMU$SCHED_ERROR;
               NMU$SCHED_ERROR (%if %isstring (%remove (%remaining))
                                %then ch$asciz (%remaining)
                                %else %remaining
                                %fi);
         %fi
         end %;


! macro: TASK_INFO
!
!		This macro is used by a task that wishes to
!		output an informational message.  Hopefully
!		to an operators console, log, or controlling
!		terminal.
!
!	TASK_INFO (INFO_MESSAGE)
!
!	where INFO_MESSAGE is either a pointer to a string
!	or a literal message string as for %STRING.


macro
     TASK_INFO [] =
         %if not $MCB
         %then begin
               external routine SS_MESSAGE;     ! System specific routine

               %if %isstring (%remove (%remaining))
               %then SS_MESSAGE (ch$asciz (%remaining))
               %else SS_MESSAGE (%remaining)
               %fi
               end
         %fi %;


! macro: PROGRAM_ERROR
!
!		This macro is used when a unrecoverable error
!		has been detected in the multi-tasking environment.
!
!	PROGRAM_ERROR (INFO_MESSAGE)
!
!	where INFO_MESSAGE is either a pointer to a string
!	or a literal message string as for %STRING.


macro
     PROGRAM_ERROR [] =
         %if not $MCB
         %then begin
               external routine SS_MESSAGE;     ! System specific routine
	       DECLARE_JSYS (HALTF);

               SS_MESSAGE (ch$asciz ('?FATAL PROGRAM ERROR: '));
               %if %isstring (%remove (%remaining))
               %then SS_MESSAGE (ch$asciz (%remaining));
               %else SS_MESSAGE (%remaining);
               %fi
	       while $true do $$HALTF ();	! HALTF for KL
               end
	 %else begin
               external routine NMU$FA;     	! System specific routine
	       NMU$FA ();			! Execute IOT for MCB
	       end
         %fi %;
%sbttl 'Network Logical Link Definitions'

! These definitions are used with the task to task logical link
! interface contained in NMUNET (Network Interface).
!
! Connect block definition


$field CONNECT_BLOCK_FIELDS =
    set
!
!   Fields common to source and target links
!
    CB_HOST = [$pointer],		! Host name
    CB_HOST_LENGTH = [$integer],
    CB_OBJECT = [$integer],		! DECnet object type code
    CB_TASK = [$pointer],		! Task name
    CB_TASK_LENGTH = [$integer],
!
! Access control info
!	supplied on source links
!	returned on target links
!
    CB_USERID = [$pointer],		! User id
    CB_USERID_LENGTH = [$integer],
    CB_DATA = [$pointer],		! Optional data
    CB_DATA_LENGTH = [$integer],
    CB_ACCOUNT = [$pointer],            ! Account
    CB_ACCOUNT_LENGTH = [$integer],
    CB_PASSWORD = [$pointer],           ! Password
    CB_PASSWORD_LENGTH = [$integer],
!
! Fields for source links only
!
    CB_DESCRIPTOR = [$pointer],         ! Object descriptor
    CB_DESCRIPTOR_LENGTH = [$integer],
    CB_REJECT_CODE = [$integer],	! Reject code
!
! Fields for target links only
!
    CB_HOST_BUFFER = [$bytes (9)],	! Host id at other end of link
        $align (fullword)
    CB_TASK_BUFFER = [$bytes(17)],
        $align (fullword)
    CB_USERID_BUFFER = [$bytes (17)],
        $align (fullword)
    CB_PASSWORD_BUFFER = [$bytes (17)],
        $align (fullword)
    CB_ACCOUNT_BUFFER = [$bytes (17)],
        $align (fullword)
    CB_DESCRIPTOR_BUFFER = [$bytes (17)],
!
! Connect data buffer
!
        $align (fullword)
    CB_DATA_BUFFER = [$bytes (17)]
    tes;

literal
       CONNECT_BLOCK_SIZE = $field_set_size,
       CONNECT_BLOCK_ALLOCATION = $field_set_units;

macro
     CONNECT_BLOCK =
         block [CONNECT_BLOCK_SIZE] field (CONNECT_BLOCK_FIELDS) %;

$literal
        TARGET_LINK = 1,                ! Code for target link (passive)
        SOURCE_LINK = 2;                ! Code for source link (active)

!
! Link status block
!

$field LINK_STATUS_BLOCK_FIELDS =
    set
    LSB_FLAGS = [$bits (9)],            ! Link status bits
        $overlay (LSB_FLAGS)
    LSB_PREV_CONNECT = [$bit],          ! Link was previously connected
    LSB_INTERRUPT = [$bit],             ! Link has interrupt data waiting
    LSB_CLOSED = [$bit],                ! Link has been closed normally
    LSB_ABORTED = [$bit],               ! Link has been aborted
    LSB_EOM = [$bit],                   ! Link has full message to read
    LSB_CCWAIT = [$bit],                ! Link is waiting for connect confirm
    LSB_CIWAIT = [$bit],                ! Link is waiting for connect
    LSB_SERVER = [$bit],                ! Link is a server
    LSB_CONNECTED = [$bit],             ! Link is connected flag
        $continue
    LSB_REASON = [$byte]		! Link abort reason
    tes;

literal
       LINK_STATUS_BLOCK_SIZE = $field_set_size,
       LINK_STATUS_BLOCK_ALLOCATION = $field_set_units;

macro
     LINK_STATUS_BLOCK =
         block [LINK_STATUS_BLOCK_SIZE] field (LINK_STATUS_BLOCK_FIELDS) %;
%sbttl 'Text Processing Definitions'

!
! Provide interface to NMU text facility.
!


!	$NMU$TEXT (DPTR, N, PPTR {,ARG}...)
!
!	    Interpret DPTR as a pointer to a destination string. Interpret
!           N as a value which represents the length of the destination
!           string. Interpret PPTR as a character sequence pointer to an
!           ASCIZ string pattern format string. Interpret ARG as zero or
!           more arguments to be used as specified by the pattern format
!           string.
!

macro
     $NMU$TEXT (DST, DST_SIZE, PAT) =
         begin
         %if not %null(%remaining)
         %then local ARGLIST: vector[%length-3];
               $$TEXT_ARG (ARGLIST,%remaining);
         %fi

         NMU$TEXT (DST,
                   DST_SIZE,
                   %if %isstring (%remove(PAT))
                   %then CH$ASCIZ(%remove(PAT))
                   %else PAT %fi,
                   (%length-3),
                   %if not %null(%remaining)
                   %then ARGLIST
                   %else 0
                   %fi)
         end %;

! Inner macro to process argument list for $NMU$TEXT

macro
     $$TEXT_ARG (VNAME) [ARG] =
         VNAME[%count] = ARG %;

!
! Text state block
!

$field TEXT_BLOCK_FIELDS =
    set
    STATE = [$integer],			! Current state of pattern parser
    PARAMETER_LIST = [$address],        ! Start of parameter list
    PARAMETER_NEXT = [$address],        ! Next parameter to use
    PARAMETER_COUNT = [$integer],       ! Number of parameters left on list
    PATTERN_START = [$pointer],		! Start of pattern
    PATTERN_PTR = [$pointer],		! Current pointer into pattern
    PATTERN_CHECKPOINT = [$pointer],	! Checkpoint into pattern
    OUTPUT_ROUTINE = [$address],        ! Character output routine
    OUTPUT_START = [$pointer],		! Pointer to start of output
    OUTPUT_PTR = [$pointer],		! Current pointer into output
    OUTPUT_CHECKPOINT = [$integer],     ! Checkpoint into output
    OUTPUT_COUNT = [$integer],		! Characters already output
    OUTPUT_MAX = [$integer],		! Maximum characters for output
    OUTPUT_POSITION = [$integer],       ! Horizontal position on line
    FIELD_COUNT = [$integer],		! Characters already output to field
    FIELD_WIDTH = [$integer],		! Max characters for field
    FIELD_JUSTIFY = [$integer],		! Justification type for field
    FIELD_REPEAT = [$integer],		! Number of times to repeat field
    FIELD_RADIX = [$integer],		! Radix for a numeric field
    FIELD_DEFAULT = [$bit],             ! Repeat default flag
    FIELD_NOWIDTH = [$bit],             ! No width field given
    FIELD_SIGNED = [$bit],              ! Field is a signed value
    FIELD_ZERO_SUPPRESS = [$bit],       ! Suppress leading zeros
    FIELD_OVERFLOW = [$bit],		! Field overflowed width
    NULL_SUPPRESS = [$bit]              ! Suppress "free" null at end
    tes;

literal
       TEXT_BLOCK_SIZE = $field_set_size,
       TEXT_BLOCK_ALLOCATION = $field_set_units;

macro
     TEXT_STATE_BLOCK =
         block [TEXT_BLOCK_SIZE] field (TEXT_BLOCK_FIELDS) %;

literal					! Values for TEXT_STATE_BLOCK [STATE]
       TEXT_COPY = 1,			! Copying from pattern to output
       DIRECTIVE_START = 2,		! Start of directive seen
       REPT_PARM = 3,			! Field repeat set from parameter list
       REPT_VALUE = 4,			! Field repeat accumulated from pattern
       WIDTH_START = 5,			! Start of width field seen
       WIDTH_PARM = 6,			! Width set from parameter list
       WIDTH_VALUE = 7,			! Width accumulated from pattern
       JUSTIFY_FIELD = 8,               ! Field justify character seen
       WIDTH_END = 9,			! End of width field seen
       DONE = 10,                       ! Interpretation successfull completion
       ABORT = 11,                      ! Unprocessable directive
       BUFFER_OVERFLOW = 12;		! Output buffer overflow

literal
       STATE_MIN = TEXT_COPY,           ! Minimum state value
       STATE_MAX = WIDTH_END;           ! Maximum state value

literal                                 ! Values for TEXT_STATE_BLOCK [FIELD_JUSTIFY]
       NO_FILL = 1,			! No justify and no fill
       LEFT_JUSTIFY = 2,                ! Left justify and fill on right
       RIGHT_JUSTIFY = 3,               ! Right justify and left fill
       CENTER_FILL = 4;			! Center and fill both ends
%sbttl 'Direct Line Access Definitions'

literal                                 ! DLX open reasons
       DLX_LOAD = 1,                    !  Loading
       DLX_DUMP = 2,                    !  Dumping
       DLX_LOOP = 3,                    !  Loop back test
       DLX_OTHER = 4,                   !  What ever

                                        ! DLX read/write reasons
       DLX_SECONDARY = 5,               !  Secondary bootstrap
       DLX_DATA = 6;                    !  MOP data message

!
! File system definitions
!

literal                                 ! File types
       FILE_PERMANENT_DATA_BASE = 0,
       FILE_SYSTEM_IMAGE = 1,
       FILE_DUMP_IMAGE = 2,
       FILE_SECONDARY_LOADER = 3,
       FILE_TERTIARY_LOADER = 4,
       FILE_SECONDARY_DUMPER = 5,
       MAX_FILE_TYPE = 5;
%sbttl 'Global Name Mappings'

!
! Queue manager (NMUQUE)
!

macro
     NMU$QUEUE_RESET = UQ_RESET %,
     NMU$QUEUE_INSERT = UQ_INSERT %,
     NMU$QUEUE_REMOVE = UQ_REMOVE %,
     NMU$QUEUE_EXTRACT = UQ_EXTRACT %,
     NMU$QUEUE_LENGTH = UQ_LENGTH %,
     NMU$QUEUE_SCAN = UQ_SCAN %,
     NMU$QUEUE_SCAN_EXTRACT = UQ_SEXTRACT %,

     NMU$QUEUE_MANAGER =
         NMU$QUEUE_RESET : novalue,     ! Reset a queue to null
         NMU$QUEUE_INSERT,              ! Insert an entry to queue end
         NMU$QUEUE_REMOVE,              ! Remove an entry from front of queue
         NMU$QUEUE_EXTRACT,		! Remove specific entry from queue
         NMU$QUEUE_LENGTH,              ! Return the length of queue
         NMU$QUEUE_SCAN,                ! Operate on queue sequentially
	 NMU$QUEUE_SCAN_EXTRACT : novalue ! Extract entry while scanning
     %;

!
! Memory Manager (NMUMEM)
!

macro
     NMU$MEMORY_RESET = UM_RESET %,
     NMU$MEMORY_GET = UM_GET %,
     NMU$MEMORY_RELEASE = UM_RELEASE %,
     NMU$MEMORY_INITIALIZE = UM_INITIALIZE %,

     NMU$MEMORY_MANAGER =
         NMU$MEMORY_RESET : novalue,       ! Reset free pool to empty
         NMU$MEMORY_INITIALIZE : novalue,  ! Add memory to free pool
         NMU$MEMORY_GET,                   ! Get block from free pool
         NMU$MEMORY_RELEASE : novalue      ! Release block to free pool
     %;

!
! Page allocator (NMUPAG)
!

macro
     NMU$PAGE_INITIALIZE = UMP_INIT %,
     NMU$PAGE_GET = UMP_GET %,
     NMU$PAGE_RELEASE = UMP_RELEASE %,

     NMU$PAGE_ALLOCATOR =
         NMU$PAGE_INITIALIZE : novalue, ! Reset page allocator
         NMU$PAGE_GET,                  ! Allocate a page
         NMU$PAGE_RELEASE : novalue     ! Release an allocated page
     %;

!
! Scheduler (NMUSKD)
!

macro
     NMU$SQUEUE_INSERT = US_INSERT %,
     NMU$SQUEUE_REMOVE = US_REMOVE %,
     NMU$SQUEUE_RESET = US_QRESET %,
     NMU$QQUEUE_INSERT = US_QQINS %,
     NMU$QQUEUE_REMOVE = US_QQREM %,
     NMU$QQUEUE_RESET = US_QQSET %,
     NMU$QQUEUE_EXTRACT = US_QQEXT %,
     NMU$SCHED_EVENT = US_EVENT %,
     NMU$SCHED_WAIT = US_WAIT %,
     NMU$SCHED_FLAG = US_FLAG %,
     NMU$SCHED_CREATE = US_CREATE %,
     NMU$SCHED_ABORT = US_ABORT %,
     NMU$SCHED_FINI = US_FINI %,
     NMU$SCHED_SLEEP = US_SLEEP %,
     NMU$SCHED_CURRENT = US_CURRENT %,
     NMU$SCHED_DESCHEDULE = US_DESCHEDULE %,
     NMU$SCHED_COMPLETE = US_COMPLETE %,
     NMU$SCHED_ERROR = US_ERROR %,

     NMU$SCHED_MANAGER =
         NMU$SCHED_CREATE,              ! Create a new task
         NMU$SCHED_ABORT : novalue,     ! Abort a task
	 NMU$SCHED_FINI : novalue,	! Finish a task's execution
         NMU$SCHED_COMPLETE : novalue,  ! Complete a task's execution
         NMU$SCHED_ERROR : novalue,     ! Print an error message, complete task
         NMU$SQUEUE_INSERT : novalue,   ! Insert entry in a scheduling queue
         NMU$SQUEUE_REMOVE,             ! Remove an entry, blocking if needed
         NMU$SQUEUE_RESET : novalue,    ! Reset a scheduling type queue
         NMU$QQUEUE_INSERT : novalue,   ! Insert entry in a quota queue
         NMU$QQUEUE_REMOVE,             ! Remove a quota queue entry, blocking if needed
         NMU$QQUEUE_RESET : novalue,    ! Reset a quota type queue
         NMU$QQUEUE_EXTRACT,            ! Extract entry from quota type queue
         NMU$SCHED_EVENT : novalue,     ! Reset a event block
         NMU$SCHED_WAIT,                ! Wait for any event
         NMU$SCHED_FLAG : novalue,      ! Flag event occurance
         NMU$SCHED_SLEEP : novalue,     ! Put task to sleep for specified time
	 NMU$SCHED_CURRENT,		! Return current task block address
	 NMU$SCHED_DESCHEDULE : novalue	! Task descheduler
     %;

!
! IPCF Manager (NMUIPC)
!

macro
     NMU$IPCF_INITIALIZE = UI_INIT %,
     NMU$IPCF_FIND_PID = UI_FIND %,
     NMU$IPCF_INFO = UI_INFO %,
     NMU$IPCF_ORION = UI_ORION %,
     NMU$IPCF_CREATE = UI_CREATE %,
     NMU$IPCF_DESTROY = UI_DESTROY %,
     NMU$IPCF_ALLOW = UI_ALLOW %,
     NMU$IPCF_DISALLOW = UI_DISALLOW %,
     NMU$IPCF_TRANSMIT = UI_TRANSMIT %,
     NMU$IPCF_RECEIVE = UI_RECEIVE %,
     NMU$IPCF_MAP_ID = UI_MAP %,

     NMU$IPCF_MANAGER =
         NMU$IPCF_INITIALIZE : novalue, ! Initialize the IPCF system
         NMU$IPCF_FIND_PID,             ! Return of PID of given name
         NMU$IPCF_INFO,                 ! Return PID of [SYSTEM]INFO
         NMU$IPCF_ORION,                ! Return PID of ORION
         NMU$IPCF_CREATE,               ! Make a pid for this process
         NMU$IPCF_DESTROY,              ! Destroy pid and data bases
         NMU$IPCF_ALLOW,                ! Allow pid to send to us
         NMU$IPCF_DISALLOW,             ! Disallow pid from sending to us
         NMU$IPCF_TRANSMIT,             ! Transmit a message
         NMU$IPCF_RECEIVE,              ! Receive a message
         NMU$IPCF_MAP_ID                ! Map a NMU$IPCF id to a IPCF PID
     %;

!
! Network logical link interface (NMUNET)
!

macro
     NMU$NETWORK_INITIALIZE = UN_INIT %,
     NMU$NETWORK_LOCAL = UN_LOCAL %,
     NMU$NETWORK_OPEN = UN_OPEN%,
     NMU$NETWORK_ACCEPT = UN_ACCEPT %,
     NMU$NETWORK_REJECT = UN_REJECT %,
     NMU$NETWORK_READ = UN_READ %,
     NMU$NETWORK_WRITE = UN_WRITE %,
     NMU$NETWORK_ABORT = UN_ABORT %,
     NMU$NETWORK_CLOSE = UN_CLOSE %,
     NMU$NETWORK_STATUS = UN_STATUS %,
     NMU$NETWORK_VALIDATE = UN_VALIDATE %;

macro
     NMU$NETWORK_UTILITIES =
         NMU$NETWORK_INITIALIZE : novalue,      ! Initialize network interface
         NMU$NETWORK_LOCAL,             ! Get pointer to local node id
         NMU$NETWORK_OPEN,		! Open a logical link
         NMU$NETWORK_ACCEPT,		! Accept an incoming connection on link
         NMU$NETWORK_REJECT,		! Reject incoming connection
         NMU$NETWORK_READ,		! Read data from link
         NMU$NETWORK_WRITE,		! Write data to link
         NMU$NETWORK_ABORT,		! Abort link
         NMU$NETWORK_CLOSE,		! Close link normally
         NMU$NETWORK_STATUS,		! Read link's status
         NMU$NETWORK_VALIDATE		! Validate system specific access info
     %;

!
! File system interface (NMUFIL)
!

macro
     NMU$FILE_INITIALIZE = UF_INI %,
     NMU$FILE_OPEN = UF_OPEN %,
     NMU$FILE_READ = UF_READ %,
     NMU$FILE_WRITE = UF_WRITE %,
     NMU$FILE_SKIP = UF_SKIP %,
     NMU$FILE_SEEK = UF_SEEK %,
     NMU$FILE_CLOSE = UF_CLOSE %,

     NMU$FILE_ROUTINES =
         NMU$FILE_OPEN,                 ! Open file
         NMU$FILE_READ,                 ! Read record from file
         NMU$FILE_WRITE,		! Write record to file
         NMU$FILE_SKIP,                 ! Skip over bytes in a file
         NMU$FILE_SEEK,                 ! Seek to specified byte in file
         NMU$FILE_CLOSE                 ! Close file
     %;

!
! Table data base manager (NMUTBL)
!

macro
     NMU$TABLE_CLEAR = UT_CLEAR %,
     NMU$TABLE_INSERT = UT_INSERT %,
     NMU$TABLE_FETCH = UT_FETCH %,
     NMU$TABLE_DELETE = UT_DELETE %,
     NMU$TABLE_CHANGE = UT_CHANGE %,
     NMU$TABLE_MAX = UT_MAX %,

     NMU$TABLE_ROUTINES =
         NMU$TABLE_CLEAR : novalue,     ! Clear a table
         NMU$TABLE_INSERT,              ! Insert entry into table
         NMU$TABLE_FETCH,               ! Fetch value from table
         NMU$TABLE_DELETE,              ! Delete entry from table
         NMU$TABLE_CHANGE,              ! Change entry value
         NMU$TABLE_MAX                  ! Maximum table index
     %;

!
! Direct line access routines (NMUDLX)
!

literal
    NMU$K_MOP_RETRY_LIMIT = 5;          ! MOP retransmit limit

macro
    $NMU_DLX_OPEN (USAGE, CIRCUIT_ID, RSP_PTR) =
	begin
	external routine NMU$DLX_OPEN;
	NMU$DLX_OPEN (USAGE, CIRCUIT_ID, RSP_PTR)
	end %,
%if $MCB
%then
    $NMU_DLX_READ (ID, USAGE, PTR, CNT, TIMEOUT, RSP_PTR) =
	begin
	external routine NMU$DLX_TIMED_READ;
	NMU$DLX_TIMED_READ (ID, USAGE, PTR, CNT, TIMEOUT + 0, RSP_PTR)
	end %,
%else
    $NMU_DLX_READ (ID, USAGE, PTR, CNT, TIMEOUT, RSP_PTR) =
	begin
	external routine NMU$DLX_READ;
	NMU$DLX_READ (ID, USAGE, PTR, CNT, RSP_PTR)
	end %,
%fi
    $NMU_DLX_WRITE (ID, USAGE, PTR, CNT, RSP_PTR) =
	begin
	external routine NMU$DLX_WRITE;
	NMU$DLX_WRITE (ID, USAGE, PTR, CNT, RSP_PTR)
	end %,
    $NMU_DLX_TYPE (ID) =
	begin
	external routine NMU$DLX_TYPE;
	NMU$DLX_TYPE (ID)
	end %,
    $NMU_DLX_INITIALIZE (ID, RSP_PTR) =
	begin
	external routine NMU$DLX_INITIALIZE;
	NMU$DLX_INITIALIZE (ID, RSP_PTR)
	end %,
    $NMU_DLX_CLOSE (ID) =
	begin
	external routine NMU$DLX_CLOSE;
	NMU$DLX_CLOSE (ID)
	end %;

macro
     NMU$DLX_CLOSE = UD_CLOSE %,
     NMU$DLX_INITIALIZE = UD_INIT %,
     NMU$DLX_KNOWN_DEVICE = UD_CHK %,
     NMU$DLX_OPEN = UD_OPEN %,
     NMU$DLX_READ = UD_READ %,
     NMU$DLX_RETURN_CIRCUITS = UD_RET %,
     NMU$DLX_TIMED_READ = UD_TREAD %,
     NMU$DLX_TYPE = UD_TYPE %,
     NMU$DLX_WRITE = UD_WRITE %,

     NMU$DLX_ROUTINES =
         NMU$DLX_OPEN,                  ! Open link
         NMU$DLX_READ,                  ! Read MOP message on link
         NMU$DLX_WRITE,                 ! Write MOP message on link
         NMU$DLX_TYPE,                  ! Returns circuit MOP device type
         NMU$DLX_INITIALIZE,            ! Initialize protocol on link
         NMU$DLX_CLOSE                  ! Close link
     %;

!
! NMX access routines (NMUMCB)
!

macro
    $NMU_NMX_READ_EVENT (BUF_PTR, BUF_LEN) =
	begin
	external routine NMU$NMX_IO;
	NMU$NMX_IO (IO$RLB + 0, BUF_PTR, BUF_LEN)
	end %,
    $NMU_NMX_READ_COMMAND (BUF_PTR, BUF_LEN) =
	begin
	external routine NMU$NMX_IO;
	NMU$NMX_IO (IO$RLB + 1, BUF_PTR, BUF_LEN)
	end %,
    $NMU_NMX_RESPOND_COMMAND (BUF_PTR, BUF_LEN) =
	begin
	external routine NMU$NMX_IO;
	NMU$NMX_IO (IO$WLB + 1, BUF_PTR, BUF_LEN)
	end %;

macro
     NMU$NMX_IO = SS$NMX %;

!
! Interrupt manager (NMUINT)
!

macro
     NMU$INTERRUPT_INITIALIZE = UX_INIT %;

!
! Utility routines (NMUUTL)
!

macro
     NMU$UTILITY_BUFFER_TEXT = UU_FBT %;

!
! TEXT processing (NMUTXT)
!

macro
     NMU$TEXT = UT_TEXT %,

     NMU$TEXT_MANAGER =
         NMU$TEXT                       ! Directive driven text formatting
     %;
%title ''
%sbttl ''

!
! [End of NMUCOM.REQ]