Google
 

Trailing-Edge - PDP-10 Archives - BB-KL11J-BM_1990 - t20src/mxncom.r36
There are 13 other files named mxncom.r36 in the archive. Click here to see a list.
!	COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1985, 1989.
!	ALL RIGHTS RESERVED.
!
!	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 THAT 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_SEMAPHORE = [$integer],
    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 : novalue;
               NMU$SCHED_COMPLETE ();
         %else external routine NMU$SCHED_ERROR : novalue;
               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
            %if $TOPS20
            %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
            %else
               begin
               external routine log;

               %if %isstring (%remove (%remaining))
               %then LOG (uplit(%asciz %remaining),0)
               %else LOG (%remaining,0)
               %fi
               end
            %fi
         %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

               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 STOP_PROGRAM;
               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'
!
! Circuit data block definition
!

$field
    CD_BLOCK_FIELDS =
    set
	CD_LINK = [$sub_block (Q_ENTRY_SIZE)],	! Link to other blocks
	$align (fullword)
	CD_NAME = [$bytes(17)],			! Name of this circuit
	CD_USAGE = [$byte],			! Type of usage
	CD_TYPE = [$byte],			! Type of device
	CD_CONTROLLER = [$byte],		! Controller number
	CD_DEVICE = [$byte],			! Device number
	CD_STATION = [$byte],			! Station number
	CD_DSB = [$sub_block ()],		! Start of device service block
	$overlay (CD_DSB)
	    CD_DTE_DSB = [$sub_block ()],	! DTE device service block
	    CD_DTE_SYSID = [$integer],		! System DTE identifier
	    %if $TOPS10
	    %then
		CD_DTE_CHAN = [$byte],		! I/O channel number
		CD_DTE_PSI = [$byte],		! PSI channel number
		CD_DTE_EVB = [$sub_block (EVENT_BLOCK_SIZE)], ! PSI event block
		CD_DTE_OBUF = [$sub_block (3)],	! Output buffer header block
		CD_DTE_IBUF = [$sub_block (3)],	! Input buffer header block
	    %fi
	    CD_DTE_PAGE0 = [$address],		! First page of extracted dump
	    CD_DTE_PAGE1 = [$address],		! Second page of extracted dump
	    CD_DTE_DADDR = [$integer],		! Current DN20 dump address
	    CD_DTE_DCNT = [$integer],		! Count of PDP-11 words remaining
	    CD_DTE_DPTR = [$pointer],		! Pointer into dump data
	$continue
	$overlay (CD_DSB)
	    CD_KLNI_DSB = [$sub_block ()],	! KLNI device service block
            CD_KLNI_PHYADR = [$pointer],        ! Node Physical Address
            CD_KLNI_HRDWADR = [$pointer],       ! ETHERNET Hardware Address
            CD_KLNI_PROTYP = [$bytes(2)],       ! Protocol type
            CD_KLNI_PRTLID = [$integer],        ! Portal Id
            CD_KLNI_RCV_PSI = [$byte],          ! NI Receive Interrupt channel
            CD_KLNI_XMT_PSI = [$byte],          ! NI Transmit Interrupt channel
            CD_KLNI_STS_PSI = [$byte],          ! NI Status Interrupt channel
            CD_KLNI_CHAN = [$byte],             ! I/O channel number
            CD_KLNI_EADDR = [$sub_block (3)],	! Destination Ethernet Address
            CD_RCV_BID = [$integer],            ! Receive Buffer Id (for NI%)
            CD_KLNI_REQNO = [$integer],         ! Request Number
            CD_KLNI_MULTICAST = [$bit],         ! Received Multicast Msg flag
            CD_MORE_MOP_RESPONSES = [$bit]       ! More LOOP responses pending
	$continue
    tes;

literal
    CD_BLOCK_SIZE = $field_set_size;
       
macro
    CD_BLOCK =
	block [CD_BLOCK_SIZE] field (CD_BLOCK_FIELDS) %;

literal                                 ! DLX open usage reasons
       DLX_PROTOCOL = 1,		!  Starting/stopping protocol
       DLX_LOAD = 2,                    !  Loading
       DLX_DUMP = 3,                    !  Dumping
       DLX_LOOP = 4,                    !  Loop back test
       DLX_TRIGGER = 5,                 !  Triggering
       DLX_LDA = 6,                     !  LOAD/DUMP ASSISTANCE

					! DLX read/write reasons
       DLX_DATA = 5,                    !  MOP data message
       DLX_SECONDARY = 6,		!  Loading secondary bootstrap
       DLX_OTHER = 7;                   !  Other read/write

!
! 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_NEXT = UQ_NEXT %,

     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
         NMU$QUEUE_NEXT
     %;

!
! 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_PAUSE = US_PAU %,

     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
         NMU$SCHED_PAUSE: novalue	! Allow other tasks to run
     %;

!
! 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 %,
     %if $TOPS10
     %then
        NMU$FILE_BUILD_BUFFERS = UF_BLD %,
        NMU$FILE_KILL_BUFFERS = UF_KIL %,
     %fi
     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
         %if $TOPS10
         %then
             NMU$FILE_BUILD_BUFFERS,	! Allocate I/O buffer ring
             NMU$FILE_KILL_BUFFERS: novalue,	! Deallocate I/O buffer ring
         %fi
         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_INITIALIZE =
	begin
	external routine NMU$DLX_INITIALIZE: novalue;
	NMU$DLX_INITIALIZE
	end %,
    $NMU_DLX_OPEN (USAGE, ENTITY_TYPE, ENTITY_ID, PHY_ADDR, RCV_PSI,
                   XMT_PSI, STS_PSI, RSP_PTR) =
	begin
	external routine NMU$DLX_OPEN;
        %if $MCB
        %then NMU$DLX_OPEN (USAGE, ENTITY_TYPE, ENTITY_ID, %(PHY_ADDR, 
                            RCV_PSI, XMT_PSI, STS_PSI,)% RSP_PTR)
        %else NMU$DLX_OPEN (USAGE, %(ENTITY_TYPE,)% ENTITY_ID, PHY_ADDR, 
                            RCV_PSI, XMT_PSI, STS_PSI, RSP_PTR)
        %fi
	end %,
    $NMU_DLX_CLOSE (ID) =
	begin
	external routine NMU$DLX_CLOSE;
	NMU$DLX_CLOSE (ID)
	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_START_PROTOCOL (ID, RSP_PTR) =
	begin
	external routine NMU$DLX_START_PROTOCOL;
	NMU$DLX_START_PROTOCOL (ID, RSP_PTR)
	end %,
    $NMU_DLX_STOP_PROTOCOL (ID, RSP_PTR) =
	begin
	external routine NMU$DLX_STOP_PROTOCOL;
	NMU$DLX_STOP_PROTOCOL (ID, RSP_PTR)
	end %,
    $NMU_DLX_DECNET_RUNNING (ID, RSP_PTR) =
        begin
        external routine NMU$DLX_DECNET_RUNNING;
        NMU$DLX_DECNET_RUNNING (ID, RSP_PTR)
        end %,
    $NMU_DLX_KNOWN_DEVICE (ID) =
	begin
	external routine NMU$DLX_KNOWN_DEVICE;
	NMU$DLX_KNOWN_DEVICE (ID)
	end %,
    $NMU_DLX_FRONT_END_DEVICE (ID) =
	begin
	external routine NMU$DLX_FRONT_END_DEVICE;
	NMU$DLX_FRONT_END_DEVICE (ID)
	end %,
    $NMU_DLX_DEVICE_TYPE (ID) =
        begin
        external routine NMU$DLX_DEVICE_TYPE;
        NMU$DLX_DEVICE_TYPE (ID)
        end %,
    $NMU_DLX_ENABLE_MULTICAST (ID, RSP_PTR) =
        begin
        external routine NMU$DLX_ENABLE_MULTICAST;
        NMU$DLX_ENABLE_MULTICAST (ID, RSP_PTR)
        end %;


macro
    NMU$DLX_INITIALIZE = UD_INIT %,
    NMU$DLX_OPEN = UD_OPEN %,
    NMU$DLX_CLOSE = UD_CLOSE %,
    NMU$DLX_READ = UD_READ %,
    NMU$DLX_WRITE = UD_WRITE %,
    NMU$DLX_START_PROTOCOL = UD_STP %,
    NMU$DLX_STOP_PROTOCOL = UD_SPP %,
    NMU$DLX_DECNET_RUNNING = UD_DPR %,
    NMU$DLX_KNOWN_DEVICE = UD_KDV %,
    NMU$DLX_FRONT_END_DEVICE = UD_FED %,
    NMU$DLX_DEVICE_TYPE = UD_DTY %,
    NMU$DLX_ENABLE_MULTICAST = UD_ENA %,

    NMU$DLX_ROUTINES =
	NMU$DLX_INITIALIZE: novalue,	! Initialize data base
	NMU$DLX_OPEN,			! Open link
	NMU$DLX_CLOSE,			! Close link
	NMU$DLX_READ,			! Read MOP message on link
	NMU$DLX_WRITE,			! Write MOP message on link
	NMU$DLX_START_PROTOCOL,		! Start protocol on link
	NMU$DLX_STOP_PROTOCOL,		! Stop protocol on link
        NMU$DLX_DECNET_RUNNING,         ! Check if DECnet protocol is running
	NMU$DLX_KNOWN_DEVICE,		! Device existence predicate
	NMU$DLX_FRONT_END_DEVICE,	! Check if circuit is to front end
        NMU$DLX_DEVICE_TYPE,            ! Return circuit's device type
        NMU$DLX_ENABLE_MULTICAST        ! Enable Multicast Address
     %;

!
! NMU DTE service routines (NMUDTE)
!

macro
    NMU$DTE_OPEN = UE_OPEN %,		! Open DTE
    NMU$DTE_CLOSE = UE_CLOSE %,		! Close DTE
    NMU$DTE_READ = UE_READ %,		! Read MOP data
    NMU$DTE_WRITE = UE_WRITE %,		! Write MOP data
    NMU$DTE_START_PROTOCOL = UE_STP %,	! Start protocol
    NMU$DTE_STOP_PROTOCOL = UE_SPP %,	! Stop protocol
    NMU$DTE_DECNET_RUNNING = UE_DPR %;  ! Check if DECnet protocol is running

macro
    NMU$DTE_ROUTINES =
	NMU$DTE_OPEN,			! NMU$DLX_OPEN call
	NMU$DTE_CLOSE,			! NMU$DLX_CLOSE call
	NMU$DTE_READ,			! NMU$DLX_READ call
	NMU$DTE_WRITE,			! NMU$DLX_WRITE call
	NMU$DTE_START_PROTOCOL,		! NMU$DLX_START_PROTOCOL call
	NMU$DTE_STOP_PROTOCOL,          ! NMU$DLX_STOP_PROTOCOL call
        NMU$DTE_DECNET_RUNNING          ! NMU$DLX_DECNET_RUNNING call
    %;

!
! NMU KLNI service routines (NMUKNI)
!

macro
    NMU$KLNI_OPEN = UK_OPEN %,		  ! Open KLNI
    NMU$KLNI_CLOSE = UK_CLOSE %,          ! Close KLNI
    NMU$KLNI_READ = UK_READ %,            ! Read MOP data
    NMU$KLNI_WRITE = UK_WRITE %,          ! Write MOP data
    NMU$KLNI_ENABLE_MULTICAST = UK_ENA %; ! Enable Multicast Address

macro
    NMU$KLNI_ROUTINES =
	NMU$KLNI_OPEN,			! NMU$DLX_OPEN call
	NMU$KLNI_CLOSE,			! NMU$DLX_CLOSE call
	NMU$KLNI_READ,			! NMU$DLX_READ call
	NMU$KLNI_WRITE,                 ! NMU$DLX_WRITE call
        NMU$KLNI_ENABLE_MULTICAST %;    ! NMU$DLX_ENABLE_MULTICAST call

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