Google
 

Trailing-Edge - PDP-10 Archives - T10_704_DECNET_3-31-88 - 10,7/netgen/ngnprm.mac
There are 7 other files named ngnprm.mac in the archive. Click here to see a list.
;	TITLE	NGNPRM - NETGEN Parsing Parameters
;		======

	SEARCH	NGNMAC

	INIGEN (NGNPRM)			; Initialize GLXLIB assembly options
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED 
;  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
;COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1980,1981,1982,1985,1986.
;ALL RIGHTS RESERVED.
;
;
;MODULE NGNPRM
;
;	SUMMARY OF EDIT HISTORY - FOR FULL DETAILS SEE MODULE NETGEN.MAC
;
;	EDIT #		DATE
;	46.		24Oct82
; 4.1
;	1		03Nov82
;	2		23Nov82
;	4		08dec82
;      12               23Feb83
;      15               23Feb83
;      18.              01Mar83
;      20.              08Mar83
;      24.              07Apr83
;      27.              09Sep83
;      30.		30Jul84
;      31.		31Jul84
;      34.		26Nov84
;      35.		06Jan85
;      38.		15Jul85
;

	SUBTTL	Entity Blocks
;+
;   Entities
;
; The following blocks are used to handle the entity part of an action.
;
; $SET ,PRSENT,1		; This is an entity block.
; $SET ,ENTNUM,num		; Define the entity number.
; $SET ,ENTADR,adr		; Address of holding area for entity-id.
; $SET ENTDEF,,<PJRST adr>	; Routine for entity-id semantic parsing:
;  $SET ,PRSMIN,min		;  minimum value or string length.
;  $SET ,PRSMAX,max		;  maximum value or string length.
; $SET ENTKNO,,<PJRST adr>	; Routine to mark KNOWN entity.
; $SET ENTLIS,,<PJRST adr>	; Routine to list entity.
;-

KNOENT::$BUILD	ENTSIZ			; KNOWN
	$SET	,PRSENT,1
	$SET	ENTDEF,,<PJRST [
		$CALL	P$KEYW##
		MOVEM	S1,ENTBLK
		PJRST	ENTKNO(S1)]>
	$EOB
ENTLIN::$BUILD	ENTSIZ			; LINE line-id
	$SET	,PRSENT,1
	$SET	,ENTNUM,^D1
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,ENTADR,ENTNAM
	$SET	ENTDEF,,<PJRST GETENT>
	$SET	ENTKNO,,<$RETT>
	$SET	ENTLIS,,<PJRST LISKL>
	$EOB
ENTCIR::$BUILD	LSTSIZ			; CIRCUIT circuit-id
	$SET	,PRSENT,1
	$SET	,ENTNUM,^D3
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,ENTADR,ENTNAM
	$SET	ENTDEF,,<PJRST GETCIR>
	$SET	ENTKNO,,<$RETT>
	$SET	ENTLIS,,<PJRST LISKC>
	$SET	EMAX,,MXCIR##
	$SET	ECUR,,NUMCIR##
	$SET	,EADR,<Z X25CIR##(I2)>
	$SET	EINC,,4
	$SET	,EPRM,[
		EXP	XC1121,XC1122,XC1123,XC1120
		EXP	0]
	$EOB
ENTPRO::$BUILD	ENTSIZ			; PROCESS process-id
	$SET	,PRSENT,1
	$SET	,PRSPRV,1
	$SET	,ENTNUM,^D5
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D3
	$SET	ENTDEF,,<PJRST P$FLD##>
	$EOB
PAGE
;
;    NODE entity blocks
;
ENTEXE::$BUILD	ENTSIZ			; EXECUTOR
	$SET	,PRSENT,1
	$SET	,ENTNUM,^D0
	$SET	ENTDEF,,<$RETT>
	$SET	ENTLIS,,<PJRST LISN>
	$EOB
ENTNOD::$BUILD	ENTSIZ			; NODE node-address
	$SET	,PRSENT,1
	$SET	,PRSPRV,1
	$SET	,ENTNUM,^D0
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,ENTADR,ENTNAM
	$SET	ENTDEF,,<PJRST [
		$CALL	P$NUM##		; Get node number
		JUMPF	ENTNO1		; (if there is one)
		MOVEM	S1,NODNUM	; and store.
		$RETT			; Otherwise...
	ENTNO1: $CALL	P$FLD##		; Get name
		SETZM	NAMFLG##	; and
		AOJ	S1,
		$CALL	GETNOD##	; reformat.
		SETZM	NODNUM
		LOAD	T1,ENTNOD,ENTADR
		DMOVEM	S1,0(T1)	; Store it.
		$RETT]>
	$SET	ENTKNO,,<PJRST [
		SETOM	NODNUM		; Known = -1.
		$RETT]>
	$SET	ENTLIS,,<PJRST [
		SKIPLE	I1,NODNUM	; If specific node
		 PJRST	LISN		; then list it
		$CALL	LISN		; otherwise list executor.
		SKIPL	NODNUM		; If KNOWN
		 $RETT			; then
		SETZM	NODNUM		; start at bottom.
	ENTNO2:	AOS	I1,NODNUM	; Go on to next node
		CAMLE	I1,NTPNN##	; and if at end
		 $RETT			; then quit.
		CAMN	I1,NTPSLF##	; If not EXECUTOR
		 JRST	ENTNO2		; and
		SKIPE	@DNS14+PRMPTR	; there is something to show
		 $CALL	LISN		; then show it.
		JRST	ENTNO2]>
	$EOB
PAGE
;
;    LOGGING entity blocks
;
ENTLOG::$BUILD	ENTSIZ			; LOGGING logging-id
	$SET	,PRSENT,1
	$SET	,ENTNUM,^D2
	$SET	ENTDEF,,<$RETF>
	$SET	ENTKNO,,<$RETT>
	$SET	ENTLIS,,<PJRST LISLF>
	$EOB
LOGCON::$BUILD	ENTSIZ			; LOGGING CONSOLE
	$SET	,PRSENT,1
	$SET	,PRSPRV,1
	$SET	,ENTNUM,^D2
	$SET	ENTDEF,,<$RETT>
	$EOB
LOGFIL::$BUILD	ENTSIZ			; LOGGING FILE
	$SET	,PRSENT,1
	$SET	,ENTNUM,^D2
	$SET	ENTDEF,,<$RETT>
	$SET	ENTLIS,,<PJRST LISLF>
	$EOB
LOGMON::$BUILD	ENTSIZ			; LOGGING MONITOR
	$SET	,PRSENT,1
	$SET	,PRSPRV,1
	$SET	,ENTNUM,^D2
	$SET	ENTDEF,,<$RETT>
	$EOB
PAGE
;
;    MODULE entity blocks
;
KNOMOD::$BUILD	ENTSIZ			; KNOWN MODULES
	$SET	,PRSENT,1
	$SET	,PRSTYP,NX25##
	$SET	,ENTNUM,^D4
	$SET	ENTKNO,,<$RETT>
	$SET	ENTLIS,,<PJRST [
		$CALL	LISXSC
		$CALL	LISXPC
		PJRST	LISMC]>
	$EOB
ENTMOD::$BUILD	ENTSIZ			; MODULE module-id
	$SET	,PRSENT,1
	$SET	,ENTNUM,^D4
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	ENTDEF,,<$RETF>
	$SET	ENTKNO,,<$RETT>
	$SET	ENTLIS,,<PJRST LISMC>
	$EOB
MODXPR::$BUILD	ENTSIZ			; MODULE X25-PROTOCOL
	$SET	,PRSENT,1
	$SET	,PRSTYP,NX25##
	$SET	,ENTNUM,^D4
	$SET	ENTDEF,,<$RETT>
	$SET	ENTLIS,,<PJRST LISXPC>
	$EOB
MODXSR::$BUILD	ENTSIZ			; MODULE X25-SERVER
	$SET	,PRSENT,1
	$SET	,PRSTYP,NX25##
	$SET	,ENTNUM,^D4
	$SET	ENTDEF,,<$RETT>
	$SET	ENTLIS,,<PJRST LISXSC>
	$EOB
MODMCB::$BUILD	ENTSIZ			; MODULE MCB-EXECUTIVE
	$SET	,PRSENT,1
	$SET	,PRSPRV,1
	$SET	,ENTNUM,^D4
	$SET	ENTDEF,,<$RETT>
	$SET	ENTLIS,,<PJRST [
		SKIPE	@QUAPRO+PRMPTR
		 PJRST	LISMP
		PJRST	LISMC]>
	$EOB
MODRSX::$BUILD	ENTSIZ			; MODULE RSX-EXECUTIVE
	$SET	,PRSENT,1
	$SET	,PRSPRV,1
	$SET	,ENTNUM,^D4
	$SET	ENTDEF,,<$RETT>
	$SET	ENTLIS,,<PJRST LISRT>
	$EOB
	SUBTTL	Qualifier Blocks
;+
;   Qualifiers
;
;*******Describe qualifier block
;-

KNOQUA::$BUILD	ENTSIZ			; KNOWN
	$SET	,PRSQUA,1
	$SET	ENTDEF,,<PJRST [
		$CALL	P$KEYW##
		MOVEM	S1,QUABLK
		PJRST	ENTKNO(S1)]>
	$EOB
QUASIN::$BUILD	ENTSIZ			; SINK sink-id
	$SET	,PRSQUA,1
	$SET	,PRSPRV,1
	$SET	,ENTADR,QUANAM
	$SET	ENTKNO,,<PJRST [
		SETOM	@QUASIN+PRMPTR
		$RETT]>
	$EOB
QUADST::$BUILD	LSTSIZ			; DESTINATION destination-name
	$SET	,PRSQUA,1
	$SET	,PRSTYP,NX25##
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,ENTADR,QUANAM
	$SET	ENTDEF,,<PJRST GETQUA>
	$SET	ENTKNO,,<PJRST [
		SETOM	@QUADST+PRMPTR
		$RETT]>
	$SET	EMAX,,DSSIZ##
	$SET	ECUR,,NUMDES##
	$SET	,EADR,<Z DESNAM##(I2)>
	$SET	EINC,,4
	$SET	,EPRM,[
		EXP	XS350,XS332,XS351,XS352,XS354,XS340,XS331
		EXP	XS355,XS330,XS353
		EXP	0]
	$EOB
QUADTE::$BUILD	LSTSIZ			; DTE dte-address
	$SET	,PRSQUA,1
	$SET	,PRSTYP,NX25##
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,ENTADR,QUANAM
	$SET	ENTDEF,,<PJRST GETQUA>
	$SET	ENTKNO,,<PJRST [
		SETOM	@QUADTE+PRMPTR
		$RETT]>
	$SET	ECUR,,[NUMDUP##]
	$SET	,EADR,<Z DTEADR##(I2)>
	$SET	EINC,,4
	$EOB
QUAGRP::$BUILD	LSTSIZ			; GROUP Group Name
	$SET	,PRSQUA,1
	$SET	,PRSTYP,NX25##
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,ENTADR,QUANAM
	$SET	ENTDEF,,<PJRST GETQUA>
	$SET	ENTKNO,,<PJRST [
		SETOM	@QUAGRP+PRMPTR
		$RETT]>
	$SET	EMAX,,GRPSIZ##
	$SET	ECUR,,NUMGRP##
	$SET	,EADR,<Z GRPNAM##(I2)>
	$SET	EINC,,4
	$EOB
QUAPRO::$BUILD	LSTSIZ			; MODULE MCB-EXECUTIVE PROCESS process-id
	$SET	,PRSQUA,1
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D3
	$SET	,ENTADR,QUANAM
	$SET	ENTKNO,,<PJRST [
		SETOM	@QUAPRO+PRMPTR
		$RETF]>
	$SET	EMAX,,NUMPRC##
	$SET	ECUR,,PRCPTR##
	$SET	,EADR,<Z PRCNAM##(I1)>
	$SET	EINC,,1
	$SET	,EPRM,[
		EXP	MPS0,MPS1
		EXP	0]
	$EOB
QUATAS::$BUILD	LSTSIZ			; MODULE RSX-EXECUTIVE TASK task-id
	$SET	,PRSQUA,1
	$SET	,PRSPRV,1
	$SET	,ENTADR,QUANAM
	$SET	ENTKNO,,<PJRST [
		SETOM	@QUATAS+PRMPTR
		$RETF]>
	$SET	EMAX,,NUMPRC##
	$SET	ECUR,,RSTPTR##
	$SET	,EADR,<Z RSTNAM##(I2)>
	$SET	EINC,,2
	$SET	,EPRM,<[
		EXP	RTS0
		EXP	0]>
	$EOB
QUADRV::$BUILD	LSTSIZ			; MODULE RSX-EXECUTIVE DRIVER driver-id
	$SET	,PRSQUA,1
	$SET	,PRSPRV,1
	$SET	,ENTADR,QUANAM
	$SET	ENTKNO,,<PJRST [
		SETOM	@QUADRV+PRMPTR
		$RETF]>
	$SET	EMAX,,NUMPRC##
	$SET	ECUR,,RSDPTR##
	$SET	,EADR,<Z RSDNAM##(I1)>
	$SET	EINC,,1
	$EOB
;
;    Gather entity/qualifier identification into holding area
;
GETENT::SKIPA	LP,ENTBLK
GETQUA::MOVE	LP,QUABLK
	$SAVE	<T1,T2,T3,T4>
	$CALL	P$FLD##
	LOAD	T4,(LP),PRSMAX		; maximum number of characters,
	MOVEI	T2,1(S1)		; from address in (S1)+1
	HRLI	T2,(POINT 7,0)
	LOAD	T3,(LP),ENTADR		;  to the receiving area.
	HRLI	T3,(POINT 7,0)
GTNAM1:	MOVE	S2,T2			; Save pointer
	ILDB	T1,T2			;  and
	SKIPN	T1			;  if end of string
	 MOVE	T2,S2			;  then back it up.
	CAIL	T1,"a"			; Raise lower case
	 CAILE	T1,"z"
	  SKIPA
	   SUBI	T1,<"a"-"A">		;  and
	IDPB	T1,T3			;  store in entity name.
	SOJG	T4,GTNAM1		; Do for destination length.
	$RETT

GETCIR:	SETOM	DEVTYP##		; Assume X.25 circuit
	$CALL	P$KEYW##		; and if not device keyword
	JUMPF	GETENT			; then we have guessed right.
GETDEV:	MOVEM	S1,DEVTYP##		; Save device type.
	$CALL	@GETDE1(S1)		; Collect ctl/unt
	$RETIF				; and if successful,
	$CALL	DEVCHK##		; then check if valid.
	$RETIT
	JRST	FNDCI9
GETDE1:	$BUILD	DEVMAX
	$SET	DTE,,GETDE3
	$SET	DMC,,GETDE2
	$SET	DMR,,GETDE2
	$SET	KDP,,GETDE3
	$EOB
GETDE2:	$CALL	P$TOK##
	$CALL	P$NUM##
	MOVEM	S1,CTLNUM##
	SETOM	UNTNUM##
	$RETT
GETDE3:	$CALL	P$TOK##
	$CALL	P$NUM##
	MOVEM	S1,CTLNUM##
	$CALL	P$TOK##
	$CALL	P$NUM##
	MOVEM	S1,UNTNUM##
	$RETT
	SUBTTL	Parameter Blocks
;+
;  Parameters
;
;*******Describe parameter block
;-
PAGE
	SUBTTL	- Node Parameters
DN100::	$BUILD	PRMSIZ			; NODE IDENTIFICATION
	$SET	,PRMTXT,[ITEXT(Identification = ^T/@DN100+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D32
TOPS20<	$SET	,PRMINI,<[ASCIZ/DECnet-20 V3.0 Release          /]-1>>
TOPS10<	$SET	,PRMINI,<[ASCIZ/DECnet-10 V3.0 Release          /]-1>>
	$SET	,PRMADR,NODID##
	$SET	,PRMDFL,NOISTA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXT>
	$EOB
DN101::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Management Version = 3.0.0)]
	$EOB
DN150::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Loop Count = 1)]
	$EOB
DN151::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Loop Length = 127)]
	$EOB
DN152::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Loop With = Mixed)]
	$EOB
DN500::	$BUILD	PRMSIZ			; EXECUTOR NAME
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D6
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,NODNAM##
	$SET	,PRMDFL,NONSTA##
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET	PRMSTR,,<PJRST DEFNOD>
	$EOB
DN502::	$BUILD	PRMSIZ			; EXECUTOR ADDRESS
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMADR,NTPSLF##
	$SET	,PRMDFL,NTDSLF##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		STORE	S1,DN920,PRSMIN	;  set MAXIMUM ADDRESS minimum,  
		MOVE	S2,S1		;  copy to S2,
		CAMGE	S2,NTPNN##	; get max (S2, MAXIMUM ADDRESS)
		MOVE	S2,NTPNN##
		IMULI	S2,^D2		;  figure
		ADDI	S2,^D5		;   the routing message size,
		CAIGE	S2,^D290	;  get max (S2, 290),
		MOVEI	S2,^D290
		STORE	S2,DN931,PRSMIN	;  and set BUFFER SIZE minimum.
		PJRST	DEFNUM]>	;  and store the value.
	$EOB
DN510::	$BUILD	PRMSIZ			; EXECUTOR INCOMING TIMER
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Incoming Timer = ^D/@DN510+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D10
	$SET	,PRMADR,NTPITM##
	$SET	,PRMDFL,NTDITM##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN511::	$BUILD	PRMSIZ			; EXECUTOR OUTGOING TIMER
	$SET	,PRMTXT,[ITEXT(Outgoing Timer = ^D/@DN511+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D60
	$SET	,PRMADR,NTPOTM##
	$SET	,PRMDFL,NTDOTM##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN700::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(NSP Version = 3.2.0)]
	$EOB
DN710::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM LINKS
	$SET	,PRMTXT,[ITEXT(Maximum Links = ^D/@DN710+PRMPTR/)]
	$SET	,PRSMIN,^D3
	$SET	,PRSMAX,^D23
	$SET	,PRMINI,^D11
	$SET	,PRMADR,NTPTPT##
	$SET	,PRMDFL,NTDTPT##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN720::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Delay Factor = 2)]
	$EOB
DN721::	$BUILD	PRMSIZ			; EXECUTOR DELAY WEIGHT
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Delay Weight = ^D/@DN721+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D3
	$SET	,PRMADR,NTPWGT##
	$SET	,PRMDFL,NTDWGT##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN722::	$BUILD	PRMSIZ			; EXECUTOR INACTIVITY TIMER
	$SET	,PRMTXT,[ITEXT(Inactivity Timer = ^D/@DN722+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D30
	$SET	,PRMADR,NTPACT##
	$SET	,PRMDFL,NTDACT##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN723::	$BUILD	PRMSIZ			; EXECUTOR RETRANSMIT FACTOR
	$SET	,PRMTXT,[ITEXT(Retransmit Factor = ^D/@DN723+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D15
	$SET	,PRMINI,^D5
	$SET	,PRMADR,NTPRET##
	$SET	,PRMDFL,NTDRET##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN900::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Routing Version = 1.3.0)]
	$EOB
DN901::	$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Type = Routing)]
	$EOB
DN910::	$BUILD	PRMSIZ			; EXECUTOR ROUTING TIMER
	$SET	,PRMTXT,[ITEXT(Routing Timer = ^D/@DN910+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D60
	$SET	,PRMADR,NTPT1##
	$SET	,PRMDFL,NTDT1##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN920::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM ADDRESS
	$SET	,PRMTXT,[ITEXT(Maximum Address = ^D/@DN920+PRMPTR/)]
	$SET	,PRSMIN,^D2
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D255
	$SET	,PRMADR,NTPNN##
	$SET	,PRMDFL,NTDNN##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		MOVE	S2,NTPBLK	; Figure maximum address
		SUBI	S2,^D5		;  that fits into BUFFER SIZE
		IDIVI	S2,^D2
		CAMLE	S2,S1		; get min (S2, MAXIMUM ADDRESS),
		MOVE	S2,S1
		STORE	S2,DN502,PRSMAX	;  set ADDRESS maximum,
		STORE	S2,ENTNOD,PRSMAX ; NODE maximum
		MOVE	S2,S1		;  copy to S2,
		CAMGE	S2,NTPSLF##	; get max (S2, ADDRESS)
		MOVE	S2,NTPSLF##
		IMULI	S2,^D2		;  figure
		ADDI	S2,^D5		;   the routing message size,
		CAIGE	S2,^D290	;  get max (S2, 290),
		MOVEI	S2,^D290
		STORE	S2,DN931,PRSMIN	;  and set BUFFER SIZE minimum.
		PJRST	DEFNUM]>	;  and store the value.
	$EOB
DN921::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM CIRCUITS
	$EOB
DN922::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM COST
	$SET	,PRMTXT,[ITEXT(Maximum Cost = ^D/@DN922+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D1022
	$SET	,PRMINI,^D100
	$SET	,PRMADR,NTPMXC##
	$SET	,PRMDFL,NTDMXC##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DN923::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM HOPS
	$SET	,PRMTXT,[ITEXT(Maximum Hops = ^D/@DN923+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D30
	$SET	,PRMINI,^D16
	$SET	,PRMADR,NTPMXH##
	$SET	,PRMDFL,NTDMXH##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		STORE	S1,DN924,PRSMIN	; Set MAXIMUM VISITS minimum.
		PJRST	DEFNUM]>
	$EOB
DN924::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM VISITS
	$SET	,PRMTXT,[ITEXT(Maximum Visits = ^D/@DN924+PRMPTR/)]
	$SET	,PRSMIN,^D16
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D32
	$SET	,PRMADR,NTPMXV##
	$SET	,PRMDFL,NTDMXV##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		MOVE	S2,S1		; Copy to S2,
		CAILE	S2,^D30		;  get min (S2, 30),
		MOVEI	S2,^D30
		STORE	S2,DN923,PRSMAX	;  and set MAXIMUM HOPS maximum.
		PJRST	DEFNUM]>
	$EOB
DN930::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM BUFFERS
	$EOB
DN931::	$BUILD	PRMSIZ			; EXECUTOR BUFFER SIZE
	$SET	,PRMTXT,[ITEXT(Buffer Size = ^D/@DN931+PRMPTR/)]
	$SET	,PRSMIN,<<^D255*^D2>+^D5>
	$SET	,PRSMAX,^D576
	$SET	,PRMINI,^D576
	$SET	,PRMADR,NTPBLK##
	$SET	,PRMDFL,NTDBLK##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		MOVE	S2,S1		; copy to S2,
		STORE	S2,XP1140,PRSMAX ;Store in protocol def data
		STORE	S2,XP1150,PRSMAX ; Store in protocol max data
		SUBI	S2,^D5		; figure maximum node supported
		IDIVI	S2,^D2		;  for routing message this size,
		CAILE	S2,NUMNOD##	; get min (S2, NUMNOD)
		 MOVEI	S2,NUMNOD##
		SKIPN	PRVLDG## 	; If the user not privledged
		 CAIG	S2,^D255	; then get min (S2, 255),
		  SKIPA
		   MOVEI S2,^D255
		STORE	S2,DN920,PRSMAX	; set MAXIMUM ADDRESS maximum,
		CAMLE	S2,NTPNN##	; get min (S2, MAXIMUM ADDRESS),
		MOVE	S2,NTPNN##
		STORE	S2,DN502,PRSMAX	; and set ADDRESS maximum.
		PJRST	DEFNUM]>	;  and store the value.
	$EOB
DNS0::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM PHASE II LINKS
	$SET	,PRMTXT,[ITEXT(Maximum Phase II Links = ^D/@DNS0+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D40
	$SET	,PRMINI,^D20
	$SET	,PRMADR,NTPMXP##
	$SET	,PRMDFL,NTDMXP##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS1::	$BUILD	PRMSIZ			; NODE TRANSMIT PASSWORD
	$SET	,PRMTXT,[ITEXT(Transmit Password = ^T/@DNS1+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D8
	$SET	,PRMINI,<[ASCIZ/DECNET20/]-1>
	$SET	,PRMADR,XMTPSW##
	$SET	,PRMDFL,PSXSTA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
DNS2::	$BUILD	PRMSIZ			; NODE MANAGEMENT USER
	$SET	,PRMTXT,[ITEXT(Management User = ^T/@DNS2+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,USRSTR##
	$SET	,PRMDFL,USRSTA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
DNS3::	$BUILD	PRMSIZ			; NODE MANAGEMENT ACCOUNT
	$SET	,PRMTXT,[ITEXT(Management Account = ^T/@DNS3+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,ACTSTR##
	$SET	,PRMDFL,ACTSTA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
DNS4::	$BUILD	PRMSIZ			; NODE MANAGEMENT PASSWORD
	$SET	,PRMTXT,[ITEXT(Management Password = (password set))]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D8
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,PASSTR##
	$SET	,PRMDFL,PASSTA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
DNS5::	$BUILD	PRMSIZ			; NODE RECEIVE PASSWORD
	$SET	,PRMTXT,[ITEXT(Receive Password = ^T/@DNS5+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D8
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,RCVPSW##
	$SET	,PRMDFL,PSRSTA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
DNS6::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM MODULES
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D2
	$SET	,PRMINI,^D2
	$SET	,PRMADR,NTPNMO##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS7::	$BUILD	PRMSIZ			; EXECUTOR OPEN PORTS
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Open Ports = ^D/@DNS7+PRMPTR/)]
	$SET	,PRSMIN,^D2
	$SET	,PRSMAX,^D3
	$SET	,PRMINI,^D2
	$SET	,PRMADR,NTPOPN##
	$SET	,PRMDFL,NTDOPN##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS8::	$BUILD	PRMSIZ			; EXECUTOR SEGMENT SIZE
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Segment Size = ^D/@DNS8+PRMPTR/)]
	$SET	,PRSMIN,^D256
	$SET	,PRSMAX,^D512
	$SET	,PRMINI,^D256
	$SET	,PRMADR,NTPBUF##
	$SET	,PRMDFL,NTDBUF##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS9::	$BUILD	PRMSIZ			; EXECUTOR MAXIMUM RESERVED PORTS
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Maximum Reserved Ports = ^D/@DNS9+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D5
	$SET	,PRMINI,^D3
	$SET	,PRMADR,NTPTRS##
	$SET	,PRMDFL,NTDTRS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS10::	$BUILD	PRMSIZ			; EXECUTOR ROUTING DELAY
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Routing Delay = ^D/@DNS10+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D1
	$SET	,PRMINI,^D1
	$SET	,PRMADR,NTPT2##
	$SET	,PRMDFL,NTDT2##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS11::	$BUILD	PRMSIZ			; EXECUTOR CIRCUIT BUFFER QUOTA
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Circuit Buffer Quota = ^D/@DNS11+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D50
	$SET	,PRMADR,NTPLBQ##
	$SET	,PRMDFL,NTDLBQ##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS12::	$BUILD	PRMSIZ			; EXECUTOR NSP INPUT BUFFER QUOTA
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(NSP Input Buffer Quota = ^D/@DNS12+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D8
	$SET	,PRMADR,NTPEBQ##
	$SET	,PRMDFL,NTDEBQ##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS13::	$BUILD	PRMSIZ			; EXECUTOR NSP OUTPUT BUFFER QUOTA
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(NSP Output Buffer Quota = ^D/@DNS13+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D8
	$SET	,PRMADR,NTPIBQ##
	$SET	,PRMDFL,NTDIBQ##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DNS14::	$BUILD	PRMSIZ			; NODE FENCE
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Fence = ^D/@DNS14+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D0
	$SET	,PRMADR,<Z XPTMXA##-1(I1)>
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST [
		MOVE	I1,NODNUM	; Get node number,
		MOVE	T1,PRMBLK	; parameter block,
		MOVEM	S1,@PRMPTR(T1)	; and store the number.
		PJRST	KDEFDN]>
	$EOB
DNX2::	$BUILD	PRMSIZ			; GATEWAY ACCESS USER
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Access User = ^T/@DNX2+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMADR,USRSXR##
	$SET	,PRMDFL,USRSXA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
DNX3::	$BUILD	PRMSIZ			; GATEWAY ACCESS ACCOUNT
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Access Account = ^T/@DNX3+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMADR,ACTSXR##
	$SET	,PRMDFL,ACTSXA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
DNX4::	$BUILD	PRMSIZ			; GATEWAY ACCESS PASSWORD
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Access Password = ^T/@DNX4+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMADR,PASSXR##
	$SET	,PRMDFL,PASSXA##
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
PAGE
	SUBTTL	- Circuit Parameters
DC900::	$BUILD	PRMSIZ			; CIRCUIT COST
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Cost = ^D/T1/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D25
	$SET	,PRMINI,^D1
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		$CALL	CIRDEV		; Get device
		$RETIF			; (if there is one)
		MOVE	S2,DEVTYP##
		CAIN	S2,KDP
		 $CALL [MOVE	LNTYP##(I1)
			CAIN	^D5
			 $RETF
			$RETT]
		JUMPF	NMEPNA
		SKIPN	CSTVEC(S2)	; If supported
		 JRST	NMEPNA		; then
		MOVEM	S1,@CSTVEC(S2)	; set the cost.
		$RETT]>
	$EOB
	CSTVEC:	$BUILD	DEVMAX
		$SET	DTE,,<Z DTECST##>
		$SET	DMC,,<Z DMCCST##(I1)>
		$SET	DMR,,<Z DMRCST##(I1)>
		$SET	KDP,,<Z DUPCST##(I1)>
		$EOB
DKC906::$BUILD	PRMSIZ			; KNOWN CIRCUITS HELLO TIMER
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Hello Timer = ^D/@DKC906+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D10
	$SET	,PRMADR,NTPT3##
	$SET	,PRMDFL,NTDT3##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DKC907::$BUILD	PRMSIZ			; KNOWN CIRCUITS LISTEN TIMER
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Listen Timer = ^D/@DKC907+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D60
	$SET	,PRMADR,NTPT4##
	$SET	,PRMDFL,NTDT4##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DC1100::$BUILD	PRMSIZ
	$SET	,PRMTXT,[ITEXT(Owner = Node / ^D/NTPSLF/ / ^T/NODNAM/)]
	$EOB
XC1111::$BUILD	PRMSIZ			; CIRCUIT USAGE
	$SET	,PRMTXT,[ITEXT(Usage = ^T/@CIRUSA+0/)]
	$EOB
CIRUSA:	EXP	[ASCIZ/Permanent/]
	EXP	[ASCIZ/Incoming/]
	EXP	[ASCIZ/Outgoing/]
XC1112::$BUILD	PRMSIZ			; CIRCUIT TYPE (define/purge name)
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Type = ^T/@LINPRO(T1)/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMADR,[^D3]
	$SET	PRMDEF,,<$CALL [
                CALL P$NEXT##
		MOVEI S1,^D3
		$RETT]>
	$SET	PRMPUR,,<$CALL [
		CALL P$NEXT##
                MOVEI S1,^D4
                $RETT]>
	$SET	PRMSTR,,<PJRST CIRTYP>
	$EOB
XC1120::$BUILD	PRMSIZ			; CIRCUIT DTE
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		MOVEI	[ITEXT(DTE = (undefined))]
		SKIPE	DTECIR##(I2)
		 MOVEI	[ITEXT(DTE = ^T/@XC1120+PRMPTR/)]
		$RET]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DTECIR##(I2)>
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET    PRMPUR,,<MOVEI S1,0>
	$SET	PRMSTR,,<PJRST [
		$CALL	CHKXC		; Verify unique DTE/channel
		$RETIF
		PJRST	CIRFLD]>
	$EOB
XC1121::$BUILD	PRMSIZ			; CIRCUIT CHANNEL
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Channel = ^D/@XC1121+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D4095
	$SET	,PRMINI,^D0
	$SET	,PRMADR,<Z CIRCHP##(I1)>
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST [
		$CALL	CHKXC		; Verify unique DTE/channel
		$RETIF
		PJRST	CIRNUM
	CHKXC:	$RETT]>
	$EOB
XC1122::$BUILD	PRMSIZ			; CIRCUIT MAXIMUM DATA
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Data = ^D/@XC1122+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D128
	$SET	,PRMADR,<Z MXDATP##(I1)>
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST CIRNUM>
	$EOB
XC1123::$BUILD	PRMSIZ			; CIRCUIT MAXIMUM WINDOW
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Window = ^D/@XC1123+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D2
	$SET	,PRMADR,<Z MXWINP##(I1)>
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST CIRNUM>
	$EOB
PAGE
	SUBTTL	- Line Parameters
DL1100::$BUILD	PRMSIZ			; LINE DEVICE
	$SET	,PRMTXT,[ITEXT(Device = ^I/@DL1100+PRMPTR/)]
	$EOB
DL1105::$BUILD	PRMSIZ			; LINE RECEIVE BUFFERS
	$SET	,PRMTXT,[ITEXT(Receive Buffers = ^D/T1/)]
	$SET	PRMDEF,,<$CALL P$NUM##>
	$EOB
DL1110::$BUILD	PRMSIZ			; LINE CONTROLLER
	$SET	,PRMTXT,[ITEXT(Controller = ^T/@LINCON+0/)]
	$SET	PRMDEF,,<$CALL P$KEYW##>
	$EOB
LINCON:	EXP	[ASCIZ/Normal/]
	EXP	[ASCIZ/Loopback/]
DL1111::$BUILD	PRMSIZ			; LINE DUPLEX
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Duplex = ^T/@LINDUP(T1)/)]
	$SET	,PRMINI,^D0		;  default FULL
	$SET	PRMDEF,,<$CALL P$KEYW##>
	$SET	PRMSTR,,<PJRST [
		$CALL	LINDEV		; Get device typ
		$RETIF			; (if there is one)
		MOVE	S2,DEVTYP##
		SKIPN	DUPVEC(S2)	; If supported
		 JRST	NMEPNA		; then
		MOVEM	S1,@DUPVEC(S2)	; set the duplex.
		$RETT]>
	$EOB
	DUPVEC:	$BUILD	DEVMAX
		$SET	DMC,,<Z DMCDUP##(I1)>
		$SET	DMR,,<Z DMRDUP##(I1)>
		$SET	KDP,,<Z DUPDUP##(I1)>
		$EOB
LINDUP:	EXP	[ASCIZ/Full/]
	EXP	[ASCIZ/Half/]
DL1112::$BUILD	PRMSIZ			; LINE PROTOCOL
	$SET	,PRMTXT,[ITEXT(Protocol = ^T/@LINPRO(T1)/)]
	$SET	,PRMINI,^D4		;  default DDCMP-DMC
	$SET	PRMDEF,,<$CALL P$KEYW##>
	$SET	PRMSTR,,<PJRST [
		$CALL	LINDEV		; Get device typ
		$RETIF			; (if there is one)
		MOVE	S2,DEVTYP##
		SKIPN	LTYVEC(S2)	; If supported
		 JRST	NMEPNA		; then
		MOVEM	S1,@LTYVEC(S2)	; set the protocol.
		$RETT]>
	$EOB
	LTYVEC:	$BUILD	DEVMAX
		$SET	KDP,,<Z LNTYP##(I1)>
		$EOB
LINPRO:	EXP	[ASCIZ/DDCMP-Point/]
	EXP	[ASCIZ/DDCMP-Control/]
	EXP	[ASCIZ/DDCMP-Tributary/]
	EXP	[ASCIZ/X25/]
	EXP	[ASCIZ/DDCMP-DMC/]
	EXP	[ASCIZ/LAPB/]
DL1113::$BUILD	PRMSIZ			; LINE CLOCK
	$SET	,PRMTXT,[ITEXT(Clock = ^T/@LINCLO+0/)]
	$SET	PRMDEF,,<$CALL P$KEYW##>
	$EOB
LINCLO:	EXP	[ASCIZ/External/]
	EXP	[ASCIZ/Internal/]
DL1120::$BUILD	PRMSIZ			; LINE SERVICE TIMER
	$SET	,PRMTXT,[ITEXT(Service Timer = 3000)]
	$SET	PRMDEF,,<$CALL P$NUM##>
	$EOB
DL1121::$BUILD	PRMSIZ			; LINE RETRANSMIT TIMER
	$SET	,PRMTXT,[ITEXT(Retransmit Timer = ^D/@DL1121+PRMPTR/)]
	$SET	,PRMADR,[^D3000]
	$SET	PRMDEF,,<$CALL P$NUM##>
	$EOB
XKL121::				; KNOWN LINES RETRANSMIT TIMER
XL1121::$BUILD	PRMSIZ
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Retransmit Timer = ^D/@XL1121+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D3000
	$SET	,PRMADR,XTPIT1##
	$SET	,PRMDFL,XTDIT1##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XKL130::				; KNOWN LINES MAXIMUM BLOCK
XL1130::$BUILD	PRMSIZ
	$SET	,PRSTYP,NX25##
	$SET    PRMDSP,,[
			 MOVE	NTPBLK##
			 ADDI	<^D6+1>
			 ANDI	^-1
			 MOVEM	XTPBLK##
		         MOVEI  [ITEXT(Maximum Block = ^D/@XL1130+PRMPTR/)]
			 $RET]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D1024
	$SET	,PRMADR,XTPBLK##
	$SET	,PRMDFL,XTDBLK##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		MOVE	S2,S1		; copy to S2,
		SUBI	S2,^D3
		STORE	S2,XP1140,PRSMAX ; set DEFAULT DATA maximum
		STORE	S2,XP1150,PRSMAX ; set MAXIMUM DATA maximum
		PJRST	DEFNUM]>	;  and store the value.
	$EOB
XKL131::				; KNOWN LINES MAX RETRANSMIT
XL1131::$BUILD	PRMSIZ
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Retransmits = ^D/@XL1131+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D20
	$SET	,PRMADR,XTPIRC##
	$SET	,PRMDFL,XTDIRC##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XKL132::				; KNOWN LINES MAXIMUM WINDOW
XL1132::$BUILD	PRMSIZ
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Window = ^D/@XL1132+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D7
	$SET	,PRMADR,XTPWS##
	$SET	,PRMDFL,XTDWS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DL2650::$BUILD	PRMSIZ			; LINE CONTROLLER REGISTER
	$SET	,PRMTXT,[ITEXT(Controller Register = ^O/@DL2650+PRMPTR/)]
	$SET	,PRMADR,DMXCSR##
	$EOB
DL2651::$BUILD	PRMSIZ			; LINE UNIT REGISTER
	$SET	,PRMTXT,[ITEXT(Unit Register = ^O/@DL2651+PRMPTR/)]
	$SET	,PRMADR,DUPCSR#
	$EOB
DL2655::$BUILD	PRMSIZ			; LINE INTERRUPT VECTOR
	$SET	,PRMTXT,[ITEXT(Interrupt Vector = ^O/@DL2655+PRMPTR/)]
	$SET	,PRMADR,DMXINT##
	$EOB
DL2660::$BUILD	PRMSIZ			; LINE INTERRUPT PRIORITY
	$SET	,PRMTXT,[ITEXT(Interrupt Priority = ^O/@DL2660+PRMPTR/)]
	$SET	,PRMADR,DMXPRI#
	$EOB
DL2670::$BUILD	PRMSIZ			; LINE PAUSE TIMER
	$SET	,PRMTXT,[ITEXT(Pause Timer = ^D/@DL2670+PRMPTR/)]
	$SET	,PRMADR,[^D30]
	$EOB
DLS0::	$BUILD	PRMSIZ			; LINE BAUD RATE
	$SET	,PRSPRV,1
	$SET	,PRMTXT,[ITEXT(Baud Rate = ^D/LINRAT(T1)/)]
	$SET	PRMDEF,,<$CALL P$KEYW##>
	$SET	PRMSTR,,<PJRST [
		$CALL	LINDEV	 	; Get device type
		$RETIF			; (if there is one)
		MOVE	S2,DEVTYP##
		SKIPN	RATVEC(S2)	; If supported
		 JRST	NMEPNA		; then
		MOVEM	S1,@RATVEC(S2)	; set the baud rate.
		$RETT]>
	$EOB
	RATVEC:	$BUILD	DEVMAX
		$SET	KDP,,<Z DUPRAT##(I1)>
		$EOB
LINRAT:	$BUILD	(20)
	 $SET	(BD.12,,<^D1200>)
	 $SET	(BD.18,,<^D1800>)
	 $SET	(BD.192,,<^D19200>)
	 $SET	(BD.24,,<^D2400>)
	 $SET	(BD.36,,<^D3600>)
	 $SET	(BD.48,,<^D4800>)
	 $SET	(BD.72,,<^D7200>)
	 $SET	(BD.96,,<^D9600>)
	$EOB
;XT300:
	$BUILD	PRMSIZ			; LINE DTE COMMAND ADDRESS
	$SET	,PRSPRV,1
	$SET	,PRSTYP,NX25##
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D3
	$SET	,PRMINI,^D3
	$SET	,PRMADR,XTPDTC##
	$SET	,PRMDFL,XTDDTC##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
;XT310:
	$BUILD	PRMSIZ			; LINE DCE COMMAND ADDRESS
	$SET	,PRSPRV,1
	$SET	,PRSTYP,NX25##
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D3
	$SET	,PRMINI,^D1
	$SET	,PRMADR,XTPDCC##
	$SET	,PRMDFL,XTDDCC##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
;XT320:
	$BUILD	PRMSIZ			; LINE DTE RESPONSE ADDRESS
	$SET	,PRSPRV,1
	$SET	,PRSTYP,NX25##
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D3
	$SET	,PRMINI,^D1
	$SET	,PRMADR,XTPDTR##
	$SET	,PRMDFL,XTDDTR##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
;XT330:
	$BUILD	PRMSIZ			; LINE DCE RESPONSE ADDRESS
	$SET	,PRSPRV,1
	$SET	,PRSTYP,NX25##
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D3
	$SET	,PRMINI,^D3
	$SET	,PRMADR,XTPDCR##
	$SET	,PRMDFL,XTDDCR##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
PAGE
	SUBTTL	- Logging Parameters
LF201::	$BUILD	PRMSIZ			; LOGGING EVENT
	$SET	PRMDEF,,<$CALL [
	EVTMSK:	$SAVE	<T1,T2,T3,T4>
		SETOM	DEFRNG+0
		SETOM	DEFRNG+1
		$CALL	P$NUM##
		JUMPF	EVTMS9
		MOVEM	S1,DEFRNG+0
		$CALL	P$TOK##
		$CALL	P$TOK##
		JUMPT	EVTMS9
		SETZM	DEFRNG+1
	EVTMS1:	$CALL	P$NUM##
		MOVE	T1,S1
		MOVE	T2,S1
		$CALL	P$TOK##
		JUMPF	EVTMS2
		$CALL	P$NUM##
		MOVE	T2,S1
	EVTMS2:	MOVEI	T3,1
		SUB	T2,T1
		AOJLE	T2,[$DEFFAIL(Event type range not ascending)]
		LSH	T3,(T2)
		SOS	T3
		LSH	T3,(T1)
		ORM	T3,DEFRNG+1
		$CALL	P$COMMA##
		JUMPT	EVTMS1
	EVTMS9:	MOVEI	S1,DEFRNG
		$RETT]>
	$SET	PRMPUR,,<$CALL EVTMSK>
	$SET	PRMSTR,,<PJRST [
		DMOVE	T1,0(S1)
		JUMPE	T1,[$SEMFAIL(Event class ^D/T1/ cannot be changed)]
		CAILE	T1,6
		 JRST [	$SEMFAIL(Event class ^D/T1/ not supported)]
		MOVX	T4,^B11111111111111111111111111111111
		ORCAM	T4,GBLFLT##(T1)
		SKIPLE	DEFPUR#
		 ORB	T2,GBLFLT##(T1)
		SKIPGE	DEFPUR#
		 ANDCAB	T2,GBLFLT##(T1)
		AOSE	T2
		 ANDM	T4,GBLFLT##(T1)
		$RETT]>
	$EOB
PAGE
	SUBTTL	- Module X25-Protocol Parameters
XP1100::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL DTE
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Dte = ^T/@XP1100+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMADR,<Z DTEADR##(I2)>
	$EOB
XP1110::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL NETWORK
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		MOVEI	[ITEXT(Network = (undefined))]
		SKIPE	NETNAM##
		 MOVEI	[ITEXT(Network = ^T/@XP1110+PRMPTR/)]
		$RET]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,NETNAM##
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET	PRMSTR,,<PJRST DEFTXU>
	$EOB
XP1120::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL LINE
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		EXT	<DEVTXT,CTLNUM,UNTNUM,NUMKDP,KDPLNM>
		$SAVE	<T1,T2,T3,T4>
		MOVEM	I1,T3
		$CALL	DEVKDP## 	; Set device name
		SKIPG	T1,KDPNUM##
		 JRST	XLNA9
	XLNA1:	$CALL	DEVCTL##
		SKIPG	T2,KDPLNM(I1)	;ARE THERE ANY DUPS ON THIS LINE?
		 JRST	XLNA3		;NO - SKIP THIS KDP
		SETZM	UNTNUM##	; Start with unit #0
	XLNA2:	$CALL	DEVUNT##
		MOVEI	[ITEXT(Line = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/)]
		CAMN	I1,T3		; Is this the DUP?
		 $RET			; Yes, all done
		AOS	UNTNUM##	; On to the next unit.
		SOJG	T2,XLNA2
	XLNA3:	AOS	CTLNUM##	; On to the next controller.
		SOJG	T1,XLNA1
	XLNA9:	SETZ
		$RET]
	$EOB
XP1130::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL CHANNELS
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		MOVE	CHRAGH##(I1)
		CAMN	CHRAGL##(I1)
		 JRST [	MOVEI	[ITEXT(Channels = ^D/CHRAGL##(I1)/)]
			$RET]
		MOVEI	[ITEXT(Channels = ^D/CHRAGL##(I1)/-^D/CHRAGH##(I1)/)]
		SKIPGE	CHRAGL##(I1)
		 MOVEI	[ITEXT(Channels = (undefined))]
		$RET]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D4095
	$SET	,PRMINI,[EXP -1,0]
	$SET	,PRMADR,[
		Z CHRAGL##(I1)
		Z CHRAGH##(I1)]
	$SET	PRMDEF,,<$CALL [
		$CALL	P$NUM##
		MOVEM	S1,DEFRNG+0
		MOVEM	S1,DEFRNG+1
		$CALL	P$TOK##
		JUMPF	CH1
		$CALL	P$NUM##
		MOVEM	S1,DEFRNG+1
	CH1:	MOVEI	S1,DEFRNG
		MOVE	S2,0(S1)
		SUB	S2,1(S1)
		SKIPGE	S2
		 MOVN	S2,S2
		ADDI	S2,1
		CAMLE	S2,XTPLCN##
		 JRST	[$DEFFAIL(Channel range exceeds maximum channels)]
		LOAD	,XP1131,PRSMIN	; Adjust minumum channels
		CAML	S2
		$RETT
		STORE	S2,XP1131,PRSMIN
		$RETT]>
	$SET	PRMSTR,,<PJRST [
		$CALL	FNDQUA
		MOVE	S2,0(S1)
		MOVEM	S2,CHRAGL##(I1)
		MOVE	S2,1(S1)
		MOVEM	S2,CHRAGH##(I1)
		$RETT]>
	$EOB
XP1131::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL MAXIMUM CHANNELS
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Channels = ^D/@XP1131+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D20		; (4095)
	$SET	,PRMINI,^D20
	$SET	,PRMADR,XTPLCN##
	$SET	,PRMDFL,XTDLCN##
	$SET	PRMDEF,,<$CALL [
		$CALL	P$NUM##			;get number into S1
		CAMGE	S1,NCIR##
		 JRST [	$DEFWARN(Maximum channel number less than range of address already defined)]
		$RETT]>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1140::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL DEFAULT DATA
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Default Data = ^D/@XP1140+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D128
	$SET	,PRMADR,XTPDPS##
	$SET	,PRMDFL,XTDDPS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		MOVE	S2,S1		; copy to S2,
		ADDI	S2,^D3
		STORE	S2,XL1130,PRSMIN	; set MAXIMUM BLOCK minimum
		PJRST	DEFNUM]>	;  and store the value.
	$EOB
XP1141::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL DEFAULT WINDOW
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Default Window = ^D/@XP1141+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D2
	$SET	,PRMADR,XTPDWS##
	$SET	,PRMDFL,XTDDWS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1150::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL MAXIMUM DATA
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Data = ^D/@XP1150+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D65535
	$SET	,PRMINI,^D128
	$SET	,PRMADR,XTPMPS##
	$SET	,PRMDFL,XTDMPS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST [
		PJRST	DEFNUM]>	;  and store the value.
	$EOB
XP1151::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL MAXIMUM WINDOW
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Window = ^D/@XP1151+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D2
	$SET	,PRMADR,XTPMWS##
	$SET	,PRMDFL,XTDMWS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1152::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL MAXIMUM CLEARS
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Clears = ^D/@XP1152+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D6
	$SET	,PRMADR,XTPRCL##
	$SET	,PRMDFL,XTDRCL##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1153::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL MAXIMUM RESETS
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Resets = ^D/@XP1153+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D6
	$SET	,PRMADR,XTPRRE##
	$SET	,PRMDFL,XTDRRE##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1154::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL MAXIMUM RESTARTS
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Restarts = ^D/@XP1154+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D6
	$SET	,PRMADR,XTPRRS##
	$SET	,PRMDFL,XTDRRS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1160::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL CALL TIMER
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Call Timer = ^D/@XP1160+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D200
	$SET	,PRMADR,XTPTCA##
	$SET	,PRMDFL,XTDTCA##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1161::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL CLEAR TIMER
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Clear Timer = ^D/@XP1161+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D180
	$SET	,PRMADR,XTPTCL##
	$SET	,PRMDFL,XTDTCL##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1162::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL RESET TIMER
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Reset Timer = ^D/@XP1162+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D180
	$SET	,PRMADR,XTPTRE##
	$SET	,PRMDFL,XTDTRE##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1163::$BUILD	PRMSIZ			; MODULE X25-PROTOCOL RESTART TIMER
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Restart Timer = ^D/@XP1163+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D180
	$SET	,PRMADR,XTPTRS##
	$SET	,PRMDFL,XTDTRS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
XP1101::$BUILD  PRMSIZ
        $SET    ,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Group = ^T/@XP1101 + PRMPTR/)]
	$SET	,PRMADR,<Z GRPNAM##(I2)>
	$SET	PRMPUR,,<JFCL>
	$SET	PRMSTR,,<PJRST GRPPUR>
	$EOB
XP1170::$BUILD 	PRMSIZ
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(DTE = ^T/@XP1170 + PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z GRPDTE##(I2)>
	$SET	PRMDEF,,<$CALL UGDTE>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$EOB
XP1171::$BUILD 	PRMSIZ
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(NUMBER = ^D/@XP1171 + PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D99
	$SET	,PRMINI,^D0
	$SET	,PRMADR,<Z GRPNUM##(I1)>
	$SET	PRMDEF,,<$CALL UGNUM>
	$SET	PRMPUR,,<MOVEI S1,^D0>
	$SET	PRMSTR,,<$RETT>
  	$EOB
XP1172::$BUILD	PRMSIZ			; CIRCUIT TYPE (define/purge name)
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
			 SKIPE GRPTYP##(I1)
			 MOVEI [ITEXT(TYPE = BILATERAL)]
			 $RET]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMADR,[^D5]
	$SET	PRMDEF,,<$CALL [
                CALL P$NEXT##
		MOVEI S1,^D5
		$RETT]>
	$SET	PRMPUR,,<$CALL [
                MOVEI S1,^D0
                $RETT]>
	$SET	PRMSTR,,<PJRST UGTYP>
	$EOB
XPS0::	$BUILD	PRMSIZ			; MODULE X25-PROTOCOL MAXIMUM GROUPS
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Groups = ^D/@XPS0+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D20
	$SET	,PRMINI,^D0
	$SET	,PRMADR,XTPUGS##
	$SET	,PRMDFL,XTDUGS##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
PAGE
	SUBTTL	- Module X25-Server Parameters
XS300::	$BUILD	PRMSIZ			; MODULE X25-SERVER DESTINATION
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Destination = ^T/@XS300+PRMPTR/)]
	$SET	,PRMADR,<Z DESNAM##(I2)>
	$SET	PRMPUR,,<JFCL>
	$SET	PRMSTR,,<PJRST DSTPUR>
	$EOB
XS320::	$BUILD	PRMSIZ			; MODULE X25-SERVER NODE
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		MOVEI	[ITEXT(Node = (undefined))]
		SKIPE	DSNODE+1(I2)
		 MOVEI	[ITEXT(Node = 0 (^T/DSNODE+1(I2)/))]
		SKIPE	DSNODE(I2)
		 MOVEI	[ITEXT(Node = ^D/DSNODE(I2)/ ())]
		$RET]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D0
	$SET	,PRMADR,<Z DSNODE##(I2)>
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DSTNUM>
	$EOB
XS330::	$BUILD	PRMSIZ			; MODULE X25-SERVER USER
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(User = ^T/@XS330+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DSUSER##(I2)>
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTFLD>
	$EOB
XS331::	$BUILD	PRMSIZ			; MODULE X25-SERVER PASSWORD
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Password = (password set))]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DSPASS##(I2)>
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTFLD>
	$EOB
XS332::	$BUILD	PRMSIZ			; MODULE X25-SERVER ACCOUNT
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Account = ^T/@XS332+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DSACCT##(I2)>
	$SET	PRMDEF,,<$CALL P$TEXT##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTFLD>
	$EOB
XS340::	$BUILD	PRMSIZ			; MODULE X25-SERVER OBJECT
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		MOVEI	[ITEXT(Object = (undefined))]
		SKIPE	DSOBJN##(I1)
		 MOVEI	[ITEXT(Object = ^D/DSOBJN(I1)/)]
		SKIPE	DSOBJS##(I2)
		 MOVEI	[ITEXT(Object = ^T/DSOBJS(I2)/)]
		$RET]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,^D0
	$SET	PRMDEF,,<$CALL [
		$CALL	P$NUM##
		$RETIT
		$CALL	P$FLD##
		HRLI	S1,-1
		$RET]>
	$SET	PRMSTR,,<PJRST [
		$CALL	FNDDST		; Get destination index
		JUMPF	[$RETT]		;  if there is one...
		JUMPL	S1,OBJ1
		MOVEM	S1,DSOBJN##(I1)	; Save in table.
		SETZM	DSOBJS##(I2)
		$RETT
	OBJ1:	SETZM	DSOBJN##(I1)
		$SAVEC
		MOVE	S2,PRMBLK
		MOVEI	C5,DSOBJS##(I2)	;  to
		HRLI	C5,(POINT 7,0)	;  the receiving area.
		LOAD	C4,(S2),PRSMAX	;  maximum number of characters,
		MOVEI	C2,1(S1)	;  get argument
		HRLI	C2,(POINT 7,0)
		MOVE	C1,C4		;  src to dest
		EXTEND	C1,[MOVSLJ 0	; Move string left justified
				0]	;  with zero fill.
		 JFCL			; Ignore failure.
		$RETT]>
	$EOB
XS350::	$BUILD	PRMSIZ			; MODULE X25-SERVER PRIORITY
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		MOVEI	[ITEXT(Priority = ^D/@XS350+PRMPTR/)]
		$RET]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D255
	$SET	,PRMINI,^D0
	$SET	,PRMADR,<Z DSPRIO##(I1)>
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST DSTNUM>
	$EOB
XS351::	$BUILD	PRMSIZ			; MODULE X25-SERVER CALL MASK
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Call Mask = ^T/@XS351+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DSMASK##(I2)>
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTHEX>
	$EOB
XS352::	$BUILD	PRMSIZ			; MODULE X25-SERVER CALL VALUE
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Call Value = ^T/@XS352+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DSVAL##(I2)>
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTHEX>
	$EOB
XS353::	$BUILD	PRMSIZ			; MODULE X25-SERVER GROUP
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Group = ^T/@XS353+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DSGRUP##(I2)>
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTFLD>
	$EOB
XS354::	$BUILD	PRMSIZ			; MODULE X25-SERVER NUMBER
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Number = ^T/@XS354+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z DSNUM##(I2)>
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTFLD>
	$EOB
XS355::	$BUILD	PRMSIZ			; MODULE X25-SERVER SUBADDRESSES
	$SET	,PRSTYP,NX25##
	$SET	PRMDSP,,[
		SKIPGE	DSSUBL(I1)
		 $RET
		MOVE	DSSUBL(I1)
		CAMN	DSSUBH(I1)
		 JRST [	MOVEI	[ITEXT(Subaddress = ^D/DSSUBL##(I1)/)]
			$RET]
		MOVEI	[ITEXT(Subaddresses = ^D/DSSUBL##(I1)/-^D/DSSUBH##(I1)/)]
		$RET]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,^D99
	$SET	,PRMINI,[EXP -1,^D100]
	$SET	,PRMADR,[
		Z DSSUBL##(I1)
		Z DSSUBH##(I1)]
	$SET	PRMDEF,,<$CALL [
		$CALL	P$NUM##
		MOVEM	S1,DEFRNG+0
		MOVEM	S1,DEFRNG+1
		$CALL	P$TOK##
		JUMPF	SBR1
		$CALL	P$NUM##
		CAMGE	S1,DEFRNG+0
		 JRST [	$DEFFAIL(Subaddress range must be ascending)]
		MOVEM	S1,DEFRNG+1
	SBR1:	MOVEI	S1,DEFRNG
		$RETT]>
	$SET	PRMPUR,,<MOVEI S1,[EXP -1,^D100]>
	$SET	PRMSTR,,<PJRST [
		$CALL	FNDDST		; Get destination index
		JUMPF	[$RETT]		;  if there is one...
		MOVE	S2,PRMBLK	; Get parameter block
		MOVE	S2,PRMPTR(S2)
		MOVE	0(S1)
		MOVEM	@0(S2)		; Save low
		MOVE	1(S1)
		MOVEM	@1(S2)		;  and high.
		$RETT]>
	$EOB
XSS0::	$BUILD	PRMSIZ			; MODULE X25-SERVER MAXIMUM DESTINATIONS
	$SET	,PRSTYP,NX25##
	$SET	,PRMTXT,[ITEXT(Maximum Destinations = ^D/@XSS0+PRMPTR/)]
	$SET	,PRSMIN,^D0
	$SET	,PRSMAX,DSSIZ##
	$SET	,PRMINI,^D4
	$SET	,PRMADR,XTPDST##
	$SET	,PRMDFL,XTDDST##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB


XSS1::	$BUILD	PRMSIZ			; MODULE X25-SERVER MAXIMUM CIRCUITS
	$SET	,PRSTYP,NX25##
        $SET	,PRMTXT,[ITEXT(Maximum Circuits = ^D/@XSS1+PRMPTR/)]
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,DSSIZ##
	$SET	,PRMINI,^D8
	$SET	,PRMADR,XTDCKT##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB

PAGE
	SUBTTL	- Module MCB-Executive Parameters
DMS0::	$BUILD	PRMSIZ			; MCB-EXECUTIVE PROCESS
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D3
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z PRCNAM##(I1)>
	$SET	PRMDEF,,<$CALL KDEFMP>
	$SET	PRMPUR,,<$CALL KPURMP>
	$SET	PRMSTR,,<$RETT>
	$EOB
MPS0::	$BUILD	PRMSIZ			; MCB-EXECUTIVE PROCESS LLC
	$SET	,PRSPRV,1
	$SET	,PRMINI,-1
	$SET	,PRMADR,<Z PRCUSE##(I1)>
	$SET	PRMDEF,,<SETZ S1,>
	$SET	PRMPUR,,<SETZ S1,>
	$SET	PRMSTR,,<PJRST DSTNUM>
	$EOB
MPS1::	$BUILD	PRMSIZ			; MCB-EXECUTIVE PROCESS DRIVER
	$SET	,PRSPRV,1
	$SET	,PRSMIN,1
	$SET	,PRSMAX,2
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z PRCDRV##(I1)>
	$SET	PRMDEF,,<$CALL P$FLD##>
	$SET	PRMPUR,,<MOVEI S1,NULTXT-1>
	$SET	PRMSTR,,<PJRST DSTFLD>
	$EOB
DMS1::	$BUILD	PRMSIZ			; MCB-EXECUTIVE CCBS
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D20
	$SET	,PRSMAX,^D200
	$SET	,PRMINI,^D64
	$SET	,PRMADR,CCBNUM##
	$SET	,PRMDFL,CCBSTA##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
DMS2::	$BUILD	PRMSIZ			; MCB-EXECUTIVE RDBS
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D6
	$SET	,PRSMAX,^D200
	$SET	,PRMINI,^D64
	$SET	,PRMADR,RDBNUM##
	$SET	,PRMDFL,RDBSTA##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
PAGE
	SUBTTL	- Module RSX-Executive Parameters
DMS3::	$BUILD	PRMSIZ			; RSX-EXECUTIVE TASK
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D6
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z RSTNAM##(I2)>
	$SET	PRMDEF,,<PJRST KDEFRT>
	$SET	PRMPUR,,<PJRST KPURRT>
	$EOB
RTS0::	$BUILD	PRMSIZ			; RSX-EXECUTIVE TASK DELAY
	$SET	,PRSPRV,1
	$SET	,PRMINI,-1
	$SET	,PRMADR,<Z RSTUSE##(I1)>
	$EOB
DMS4::	$BUILD	PRMSIZ			; RSX-EXECUTIVE DRIVER
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D2
	$SET	,PRMINI,<NULTXT-1>
	$SET	,PRMADR,<Z RSDNAM##(I2)>
	$SET	PRMDEF,,<$CALL KDEFRD>
	$SET	PRMPUR,,<$CALL KPURRD>
	$SET	PRMSTR,,<$RETT>
	$EOB
PAGE
	SUBTTL	- Process DMC Parameters
DPD1::	$BUILD	PRMSIZ			; PROCESS DMC TRANSMIT BUFFERS
	$SET	,PRSPRV,1
	$SET	,PRSMIN,^D1
	$SET	,PRSMAX,^D16
	$SET	,PRMINI,^D7
	$SET	,PRMADR,DMCPXB##
	$SET	PRMDEF,,<$CALL P$NUM##>
	$SET	PRMSTR,,<PJRST DEFNUM>
	$EOB
	SUBTTL	Top Level Semantic Parser
;
;   Command semantic parser
;
ENTBLK::BLOCK	1			;Entity block address
PRMBLK::BLOCK	1			;Parameter block address
QUABLK::BLOCK	1			;Qualifier block address
NODNUM:	BLOCK	1			;Parsed node number
ENTNAM:	BLOCK	<<^D16+1+4>/5>		;Parsed entity name
QUANAM:	BLOCK	<<^D16+1+4>/5>		;Parsed qualifier name
;GRPNAM:BLOCK	<<^D16+1+4>/5>		;Parsed GROUP name
NULTXT:	ASCII	\\			;Null string for purges
DEFRNG:	BLOCK	2			;Range holding area

KDEF::	SETZM	DEFPUR#
	AOSA	DEFPUR#
KLIS::	SETZM	DEFPUR#
	SKIPA
KPUR::	SETOM	DEFPUR#
	SETZM	ENTBLK
	SETZM	PRMBLK
	SETZM	QUABLK
	SETZM	NODNUM			; Clear out holding areas
	SETZM	ENTNAM
	SETZM	QUANAM
	SETOM	DEVTYP##
KDEF1:	$CALL	P$KEYW##		; Get parse block.
	JUMPF	KDEF7			; If there is one
	JUMPE	S1,KDEF1		; then
	LOAD	TF,PRSFLG(S1)		; pick up flags.
	TXNE	TF,PRSENT		; Entity:
	 JRST [	MOVEM	S1,ENTBLK	;  Save entity block
		$CALL	ENTDEF(S1)	;  get individual entity
		JRST	KDEF1]
	TXNE	TF,PRSQUA		; Qualifier:
	 JRST [	MOVEM	S1,QUABLK 	;  save qualifier block
		$CALL	ENTDEF(S1)	;  get individual qualifier
		JRST	KDEF1]
	MOVEM	S1,PRMBLK		;Save parameter block
KDEF2:	$CALL	P$KEYW##
	JUMPT [	CAIN	S1,DEFSKP##
		 JRST	KDEF2
		$CALL	P$PREV##
		JRST	.+1]
	SETT
	MOVE	S1,PRMBLK
	SKIPLE	DEFPUR#
	 XCT	PRMDEF(S1)
	JUMPF	[$RETT]
	SKIPGE	DEFPUR#
	 XCT	PRMPUR(S1)
	JUMPF	[$RETT]
	SKIPE	DEFPUR#
	 MOVEM	S1,DEFARG#
	JRST	KDEF1			; Go back for more.
KDEF7:	$CALL	P$CFM##			; If not EOF,
	JUMPF [	$SEMFAIL(End of line not found)] ; complain.
	MOVE	T3,QUABLK
	MOVE	T2,PRMBLK
	MOVE	T1,ENTBLK
	JUMPE	T2,KDEF8		; If parameter
	LOAD	S1,(T2),PRSTYP		; is restricted,
	JUMPE	S1,KDEF8		; then
	CAME	S1,NODTYP##		; notify against node type.
	 $TEXT ,<%Parameter only applicable to a ^T/@NTYTXT(S1)/ node>
KDEF8:	MOVE	S1,DEFARG#
	SKIPN	DEFPUR#
	 PJRST	ENTLIS(T1)		; List or
	PJRST	PRMSTR(T2)		; Define/Purge.

NTYTXT:	EXP	0
	EXP	[ASCIZ/DN20/]
	EXP	[ASCIZ/DN200/]
	EXP	[ASCIZ/X25/]
	SUBTTL	General Define/Purge Semantic Processors
;
; DEFINE/PURGE	*	*	*	*	*	*	*
;
DEFNOD:	SETZM	NAMFLG##		;pad name with nulls [S.T. 28-Jan-81]
	AOJ	S1,			;point to string
	$CALL	GETNOD##		;EXTRACT NODE NAME INTO S1, S2
	MOVE	T1,PRMBLK		;Get parameter block
	MOVEI	T1,@PRMPTR(T1)		;for parameter address
	DMOVEM	S1,0(T1)		;REMEMBER IT
	JRST	KDEFDN

DEFNUM:	MOVE	S2,PRMBLK		; Get parameter block
	MOVEM	S1,@PRMPTR(S2)		;  and save in table.
	JRST	KDEFDN

DEFTXU:	MOVE	T1,PRMBLK		; Get parameter block
	LOAD	T4,(T1),PRSMAX		; maximum number of characters,
	MOVEI	T2,1(S1)		; from address in (S1)+1
	HRLI	T2,(POINT 7,0)
	MOVEI	T3,@PRMPTR(T1)		;  to the receiving area.
	HRLI	T3,(POINT 7,0)
DEFTX1:	MOVE	S2,T2			; Save pointer
	ILDB	T1,T2			;  and
	SKIPN	T1			;  if end of string
	 MOVE	T2,S2			;  then back it up.
	CAIL	T1,"a"			; Raise lower case
	 CAILE	T1,"z"
	  SKIPA
	   SUBI	T1,<"a"-"A">		;  and
	IDPB	T1,T3			;  store in destination.
	SOJG	T4,DEFTX1		; Do for parameter length.
	$RETT

DEFTXT:	$SAVEC
	MOVE	S2,PRMBLK		;Get parameter block
	LOAD	C1,(S2),PRSMAX		;MAXIMUM NUMBER OF CHARACTERS,
	MOVEI	C2,1(S1)		;FROM ADDRESS IN (S1)+1
	HRLI	C2,(POINT 7,0)
	MOVE	C4,C1			;  src and dest
	MOVEI	C5,@PRMPTR(S2)		;TO
	HRLI	C5,(POINT 7,0)		;THE RECEIVING AREA
	EXTEND	C1,[MOVSLJ 0		;MOVE STRING LEFT JUSTIFIED WITH
			0]		; ZERO FILL
	 JFCL				;ignore failre

KDEFDN:	MOVE	S1,PRMBLK		;Get parameter block
	LOAD	S1,(S1),PRMDFL
	SKIPE	S1
	 SETZM	0(S1)			;Indicate not defaulted anymore
	$RETT
	SUBTTL	Module MCB-Executive Semantic Processors
KDEFMP:	CALL	P$FLD##			;Get process name
	AOJ	S1,			;point to string
	SETZM	NAMFLG##		;pad w/nulls to 6 char [S.T. 28-Jan-81]
	$CALL	GETNOD##		;USE A COMMON ROUTINE TO GET MCB NAME
					;IGNORE ERROR RETURN
	AND	S1,[BYTE (7) 177,177,177] ;JUST THREE CHARACTERS
	CAMN	S1,[ASCII/MDT/]		;If the debugger,
	 JRST [	SETZM	PRCMDT##	;then special handling.
		$RETT]
	SETZ	T1,			;INITIALIZE SCAN COUNT
MCBPR1:	CAMLE	T1,PRCPTR##		;FINISHED SCAN?
	 JRST	MCBPR2			;YES - STORE NEW INFO
	CAMN	S1,PRCNAM##(T1)		;CHECK NAME
	 $RETT
	AOJA	T1,MCBPR1		;GO CHECK NEXT ENTRY
MCBPR2:	AOS	T1,PRCPTR##		;INCREMENT AND GET POINTER
	CAIL	T1,NUMPRC##		;ROOM FOR ANOTHER PROCESS?
	 JRST  [SOS PRCPTR##		;NO - CORRECT FOR AOS
		$SEMFAIL(No room for process)]
	MOVE	T2,PRMBLK		;Save
	STORE	T1,PRMPTR(T2)		;the index.
	MOVEM	S1,PRCNAM##(T1)		;New process
	SETOM	PRCUSE##(T1)		;not LLC
	SETZM	PRCDRV##(T1)		;and no driver.
	CALL	P$KEYW##		;If that is all
	 JUMPF [$RETT]			;then quit.
	MOVE	T2,PRMBLK		;Get then
	LOAD	T1,PRMPTR(T2)		;index back
	SETZM	PRCUSE##(T1)		;If is LLC
	 JUMPN S1,[$RETT]		;then done.
					;Get RSX driver name
	$RETT				;and return

KPURMP:	$CALL	P$FLD##			;get name
	AOJ	S1,			;point to name string
	SETZM	NAMFLG##		;pad w/nulls [S.T. 28-JAN-81]
	$CALL	GETNOD##		;USE S1 COMMON ROUTINE TO GET MCB NAME
					;IGNORE ERROR RETURN
	AND	S1,[BYTE (7) 177,177,177] ;JUST THREE CHARACTERS
	CAMN	S1,[ASCII/MDT/]		;If the debugger,
	 JRST [	SETOM	PRCMDT##	;then special handling.
		$RETT]
	SETZ	T1,			;INITIALIZE SCAN COUNT
MCBPR3:	CAMLE	T1,PRCPTR##		;FINISHED SCAN?
	 JRST  [$SEMFAIL(Unrecognized process)]
	CAME	S1,PRCNAM##(T1)		;CHECK NAME
	AOJA	T1,MCBPR3		;NO - GO CHECK NEXT ENTRY
MCBPR4:	CAMLE	T1,PRCPTR##		;DONE SHUFFLING?
	 JRST  [SOS PRCPTR##		;YES - ONE LESS PROCES
		$RETT]			;   AND WE ARE DONE
	MOVE	T2,PRCNAM##+1(T1) 	;NO GET NEXT PROCESS ON LIST
	MOVEM	T2,PRCNAM##(T1)		;AND SHUFFLE UP ONE
	MOVE	T2,PRCUSE##+1(T1)	;ITS USE
	MOVEM	T2,PRCUSE##(T1)		;SHUFFLE
	MOVE	T2,PRCDRV##+1(T1)	;THE DRIVER
	MOVEM	T2,PRCDRV##(T1)		;SHUFFLE
	AOJA	T1,MCBPR4		;BACK FOR NEXT PROCESS
	SUBTTL	Module RSX-Executive Semantic Processors
KDEFRT:	CALL	P$FLD##			;Get process name
	AOJ	S1,			;point to string
	SETOM	NAMFLG##		;pad w/blanks to 6 char
	$CALL	GETNOD##		;USE A COMMON ROUTINE TO GET RSX NAME
					;IGNORE ERROR RETURN
	CAMN	S1,[ASCII/NML  /] 	;If NML,
	 CAME	S2,[ASCII/ /]
	  SKIPA
	   JRST [SETZM	NMLTYP##	;then special handling.
		$RETT]
	CAMN	S1,[ASCII/NMS  /] 	;If NMS,
	 CAME	S2,[ASCII/ /]
	  SKIPA
	   JRST [SETZM	NMLTYP##	;then special handling.
		AOS	NMLTYP##
		$RETT]
	SETZB	T1,T2			;INITIALIZE SCAN COUNT
RSXTA1:	CAMLE	T1,RSTPTR##		;FINISHED SCAN?
	 JRST	RSXTA2			;YES - STORE NEW INFO
	CAMN	S1,RSTNAM##+0(T2)	;CHECK NAME
	 CAME	S2,RSTNAM##+1(T2)
	  SKIPA
	   $RETT
	ADDI	T2,2
	AOJA	T1,RSXTA1		;GO CHECK NEXT ENTRY
RSXTA2:	AOS	T1,RSTPTR##		;INCREMENT AND GET POINTER
	CAIL	T1,NUMPRC##		;ROOM FOR ANOTHER TASK?
	 JRST  [SOS RSTPTR##		;NO - CORRECT FOR AOS
		$SEMFAIL(No room for task)]
	SETOM	RSTUSE##(T1)		;not started
	ADD	T1,T1
	MOVEM	S1,RSTNAM##+0(T1)	;New task
	MOVEM	S2,RSTNAM##+1(T1)
	$RETT				;and return

KPURRT:	$CALL	P$FLD##			;get name
	AOJ	S1,			;point to string
	SETOM	NAMFLG##		;pad w/blanks to 6 char
	$CALL	GETNOD##		;USE A COMMON ROUTINE TO GET RSX NAME
					;IGNORE ERROR RETURN
	CAMN	S1,[ASCII/NML  /] 	;If NML,
	 CAME	S2,[ASCII/ /]
	  SKIPA
	   JRST [SKIPE	NMLTYP##
		 JRST	RSXTA3+1
		SETOM	NMLTYP##	;then special handling.
		$RETT]
	CAMN	S1,[ASCII/NMS  /] 	;If NMS,
	 CAME	S2,[ASCII/ /]
	  SKIPA
	   JRST [SKIPG	NMLTYP##
		 JRST	RSXTA3+1
		SETOM	NMLTYP##	;then special handling.
		$RETT]
	SETZB	T1,T2			;INITIALIZE SCAN COUNT
RSXTA3:	CAMLE	T1,RSTPTR##		;FINISHED SCAN?
	 JRST  [$SEMFAIL(Unrecognized task)]
	CAMN	S1,RSTNAM##+0(T2)	;CHECK NAME
	 CAME	S2,RSTNAM##+1(T2)
	  SKIPA
	   JRST	RSXTA4
	ADDI	T2,2
	AOJA	T1,RSXTA3		;GO CHECK NEXT ENTRY
RSXTA4:	CAMLE	T1,RSTPTR##		;DONE SHUFFLING?
	 JRST  [SOS RSTPTR##		;YES - ONE LESS TASK
		$RETT]			;   AND WE ARE DONE
	MOVE	S1,RSTNAM##+2(T2)	;NO GET NEXT TASK ON LIST
	MOVE	S2,RSTNAM##+3(T2)
	MOVEM	S1,RSTNAM##+0(T2)	;AND SHUFFLE UP ONE
	MOVEM	S2,RSTNAM##+1(T2)
	MOVE	S1,RSTUSE##+1(T1)	;ITS USE
	MOVEM	S1,RSTUSE##(T1)		;SHUFFLE
	ADDI	T2,2
	AOJA	T1,RSXTA4		;BACK FOR NEXT TASK
KDEFRD:	CALL	P$FLD##			;Get driver name
	AOJ	S1,			;point to string
	SETZM	NAMFLG##		;pad w/nulls to 2 char
	$CALL	GETNOD##		;USE A COMMON ROUTINE TO GET RSX NAME
					;IGNORE ERROR RETURN
	CAMN	S1,[ASCII/TT/] 		;If TT,
	 JRST [				;then special handling.
		$RETT]
	SETZ	T1,			;INITIALIZE SCAN COUNT
RSXDR1:	CAMLE	T1,RSDPTR##		;FINISHED SCAN?
	 JRST	RSXDR2			;YES - STORE NEW INFO
	CAMN	S1,RSDNAM##(T1)		;CHECK NAME
	 $RETT
	AOJA	T1,RSXDR1		;GO CHECK NEXT ENTRY
RSXDR2:	AOS	T1,RSDPTR##		;INCREMENT AND GET POINTER
	CAIL	T1,NUMPRC##		;ROOM FOR ANOTHER DRIVER?
	 JRST  [SOS RSDPTR##		;NO - CORRECT FOR AOS
		$SEMFAIL(No room for driver)]
	MOVEM	S1,RSDNAM##(T1)		;New driver
	$RETT				;and return

KPURRD:	$CALL	P$FLD##			;get name
	AOJ	S1,			;point to string
	SETZM	NAMFLG##		;pad w/nulls to 2 char
	$CALL	GETNOD##		;USE A COMMON ROUTINE TO GET RSX NAME
					;IGNORE ERROR RETURN
	CAMN	S1,[ASCII/TT/] 		;If TT,
	 JRST [				;then special handling.
		$RETT]
	SETZ	T1,			;INITIALIZE SCAN COUNT
RSXDR3:	CAMLE	T1,RSDPTR##		;FINISHED SCAN?
	 JRST  [$SEMFAIL(Unrecognized driver)]
	CAMN	S1,RSDNAM##(T1)		;CHECK NAME
	 $RETT
	AOJA	T1,RSXDR3		;GO CHECK NEXT ENTRY
RSXDR4:	CAMLE	T1,RSDPTR##		;DONE SHUFFLING?
	 JRST  [SOS RSDPTR##		;YES - ONE LESS DRIVER
		$RETT]			;   AND WE ARE DONE
	MOVE	S1,RSDNAM##+1(T1)	;NO GET NEXT DRIVER ON LIST
	MOVEM	S1,RSTNAM##(T1)		;AND SHUFFLE UP ONE
	AOJA	T1,RSXDR4		;BACK FOR NEXT DRIVER
	SUBTTL	Entity/Qualifier List Processing
;
;  Entity/Qualifier list processing
;

FNDENT::SKIPA	LP,ENTBLK
FNDQUA::MOVE	LP,QUABLK
	$SAVEC
	SETZB	I1,I2			; Start off at zero.
FNDLS1:	CAMN	I1,@ECUR(LP)		; For each defined item
	 $RETF
	SKIPN	EMAX(LP)
	 JRST [	SKIPN	@EPTR(LP)
		 JRST	FNDSL2
		JRST	.+1]
	LOAD	C1,(LP),PRSMAX		;  source length
	LOAD	C2,(LP),ENTADR		;  source pointer
	HRLI	C2,(POINT 7,0)		;   (entity name)
	MOVE	C4,C1			;  destination length
	MOVEI	C5,@EPTR(LP)		;  destination pointer
	HRLI	C5,(POINT 7,0)		;   (list name)
	EXTEND	C1,[CMPSN 0		; If equal
		    0,0]		;  then
	 $RETT				;  all done.
FNDSL2:	ADD	I2,EINC(LP)
	AOJA	I1,FNDLS1

SETQUA:	MOVE	LP,QUABLK
	$SAVEC
	LOAD	C1,(LP),PRSMAX
	MOVEI	C2,@EPTR(LP)
	HRLI	C2,(POINT 7,0)
	MOVE	C4,C1
	LOAD	C5,(LP),ENTADR
	HRLI	C5,(POINT 7,0)
	EXTEND	C1,[MOVSLJ 0
		    0]
	 JFCL
	$RET

ADDENT::SKIPA	LP,ENTBLK
ADDQUA::MOVE	LP,QUABLK
	$SAVEC
	SKIPN	EMAX(LP)
	 JRST [	$CALL	DEVUNT##
		JRST	ADDLS1]
	MOVE	I1,@ECUR(LP)
	MOVE	I2,I1
	IMUL	I2,EINC(LP)
	AOS	@ECUR(LP)		; One more item...
ADDLS1:	LOAD	C1,(LP),PRSMAX		;  source length
	LOAD	C2,(LP),ENTADR		;  source pointer
	HRLI	C2,(POINT 7,0)		;   (entity name)
	MOVE	C4,C1			;  destination length
	MOVEI	C5,@EPTR(LP)		;  destination pointer
	HRLI	C5,(POINT 7,0)		;   (list name)
	EXTEND	C1,[MOVSLJ 0		; Copy the string.
		    0]
	 JFCL
	LOAD	C5,(LP),EPRM
	JUMPE	C5,ADDLS9
	MOVE	C6,PRMBLK
ADDLS3:	SKIPN	S2,0(C5)		; For each parameter
	 JRST	ADDLS8
	MOVEM	S2,PRMBLK
	LOAD	S1,(S2),PRMINI		;  get the initial value
	SKIPE	PRMSTR(S2)		;  and
	 $CALL	PRMSTR(S2)		;  store it.
	AOJA	C5,ADDLS3
ADDLS8:	MOVEM	C6,PRMBLK
ADDLS9:	$RETT

LINDEV:	SKIPL	DEVTYP##
	 JRST	DEVUNT##
	$CALL	DEVPRS##
	JUMPF	FNDLI9
	$CALL	DEVCHK##
	JUMPT	DEVUNT##
FNDLI9:	$DEFFAIL(Line not defined)

CIRDEV:	SKIPL	DEVTYP##
	 JRST	DEVUNT##
	$CALL	DEVPRS##
	JUMPF	CIRDE8
	$CALL	DEVCHK##
	JUMPT	DEVUNT##
	PJRST	FNDCI9
CIRDE8:	$CALL	FNDENT
	JUMPF	FNDCI9
NMEPNA:	$DEFFAIL(Parameter not applicable)
	SUBTTL	X.25 Circuit Processors
;
;  X.25 Circuit Entity handlers
;
CIRNUM:	$CALL	FNDCIR			; Get circuit index
	JUMPF	[$RETT]			;  if there is one...
	PJRST	DEFNUM			; Store the number.

CIRFLD:	$CALL	FNDCIR			; Get circuit index
	JUMPF	[$RETT]			;  if there is one...
	PJRST	DEFTXT			; Copy the text.

CIRTYP:	CAIE	S1,^D3			; If not X25 circuit
	 PJRST	DELCIR			;  then delete the circuit.
	MOVE	T3,NODTYP##		; Otherwise
	CAIN	T3,NX25##		;  if allowed
	 PJRST	ADDCIR			;  then add it.
	$SEMFAIL(Only settable on a X25 node)

FNDCIR:	$CALL	DEVPRS##
	JUMPT [	$CALL	DEVCHK##
		JUMPT	NMEPNA
		JRST	FNDCI9]
	$CALL	FNDENT
	$RETIT
FNDCI9:	$DEFFAIL(Circuit not defined)

ADDCIR:	$CALL	FNDENT			; Add CIRCUIT.
	JUMPT [	$SEMFAIL(Circuit name already exists)]
	CAMN	I1,EMAX(LP)
	 JRST [	$SEMFAIL(Maximum number of circuits exceeded)]
	PJRST	ADDENT			; Use common code.

DELCIR:	$CALL	FNDCIR			; Delete CIRCUIT.
	JUMPF	[$RETT]
	$SAVEC
	SOS	@ECUR(LP)
DELCI1:	CAMN	I1,@ECUR(LP)
	 $RETT
	LOAD	C1,(LP),PRSMAX
	MOVE	C4,C1
	MOVEI	C5,@EPTR(LP)
	HRLI	C5,(POINT 7,0)
	MOVEI	C2,4(C5)
	HRLI	C2,(POINT 7,0)
	EXTEND	C1,[MOVSLJ 0
		    0]
	 JFCL
	MOVE	CIRCHP##+1(I1)
	MOVEM	CIRCHP##(I1)
	MOVE	MXDATP##+1(I1)
	MOVEM	MXDATP##(I1)
	MOVE	MXWINP##+1(I1)
	MOVEM	MXWINP##(I1)
	ADD	I2,EINC(LP)
	AOJA	I1,DELCI1
	SUBTTL	X.25 Destination Qualifier Processors
;
;  X.25 Destination Qualifier Handlers
;
DSTNUM:	$CALL	FNDDST			; Get destination index
	JUMPF	[$RETT]			;  if there is one...
	PJRST	DEFNUM			; Store number.

DSTFLD:	$CALL	FNDDST			; Get destination index
	JUMPF	[$RETT]			;  if there is one...
	PJRST	DEFTXT			; Store the text.

DSTHEX:	$CALL	FNDDST			; Get destination index
	JUMPF	[$RETT]			;  if there is one...
	PJRST	DEFTXU			; Store the text.

FNDDST:	MOVE	LP,QUABLK
	$SAVE	<S1,S2>
	LOAD	S1,(LP),ENTADR
	SKIPN	0(S1)
	 JRST [	MOVE	S1,@ECUR(LP)
		SOJN	S1,[$SEMFAIL(Destination not given)]
		SETZB	I1,I2
		PJRST	SETQUA]
	$CALL	FNDQUA			; Find DESTINATION.
	$RETIT
	CAME	I1,EMAX(LP)
	 CAML	I1,XTPDST##
	  JRST [$SEMFAIL(Maximum number of destinations exceeded)]
	$CALL	ADDQUA			; Use common code.
	PJRST	FNDQUA

DSTPUR:	MOVE	LP,QUABLK		; PURGE DESTINATION
	SKIPG	PRMPTR(LP)		; Was there a qualifier specfied?
	 PJRST	[SETZM	@ECUR(LP) 	;  Known destination purged.
		 $RETT]
DELDST:	$CALL	FNDQUA			; Delete DESTINATION.
	JUMPF	[$RETT]
	$SAVEC
	SOS	@ECUR(LP)
DELDS1:	CAMN	I1,@ECUR(LP)
	 $RETT
	MOVEI	C5,@EPTR(LP)
	HRLI	C5,(POINT 7,0)
	LOAD	C4,(LP),PRSMAX
	MOVE	C2,C5
	ADD	C2,EINC(LP)
	MOVE	C1,C4
	EXTEND	C1,[MOVSLJ 0
		    0]
	 JFCL
	MOVEI	C5,DSACCT##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSMASK##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSVAL##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSNUM##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSOBJS##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSPASS##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSUSER##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSNODE##(I1)
	$CALL	DCMPRS
	MOVEI	C5,DSGRUP##(I1)
	$CALL	DCMPRS
	MOVE    DSOBJN##+1(I1)
	MOVEM   DSOBJN##(I1)
	MOVE    DSSUBL##+1(I1)
	MOVEM   DSSUBL##(I1)
	MOVE    DSSUBH##+1(I1)
	MOVEM   DSSUBH##(I1)
	MOVE    DSPRIO##+1(I1)
	MOVEM   DSPRIO##(I1)
	ADD	I2,EINC(LP)
	AOJA	I1,DELDS1

DCMPRS: HRLI    C5,(point 7,0)	; Destination pointer
        MOVEI   C4,DSSSIZ##*5	; Maximum string size
  	MOVE    C2,C5
	ADDI	C2,DSSSIZ##	; Source pointer
	MOVE	C1,C4
	EXTEND  C1,[MOVSLJ 0
		    0]
	 JFCL
	$RETT

      SUBTTL  X.25 Group Qualifier Processors
DGRPI:	BLOCK	1
UGDTE:  $CALL	P$FLD			; Get the DTE address string
	$CALL	FNDDTE			; See if DTE id defined.
	 JUMPF	[$SEMFAIL(DTE not defined)]
	MOVEM	I1,DGRPI		; Remember DTE number.
	$CALL	FNDQUA			; Find the Group qualifier if existent.
	 JUMPT  GRPDT0			; Already there, to set up DTE address.
	CAME	I1,EMAX(LP)		; Is there room for another?
	 CAML	I1,XTPUGS##		; ---ditto---
	JRST	[$SEMFAIL(Maximum number of groups exceeded)]
	$CALL	ADDQUA			; Go add this one.
GRPDT0: $RETT				; Return okay.a

UGNUM:	$CALL	P$NUM			; Get the User Group Number
	$CALL	FNDQUA			; Find the Group. It must be there.
	SETZM	GRPTYP(I1)		; Initialize group type
	MOVE	I2,DGRPI
	IMULI	I2,NUMDUP
	ADD	I1,I2			; For proper DTE
	PJRST	DEFNUM			; Go store the group number.

UGTYP: $CALL   FNDQUA			; Find the Group. It must be there.
	MOVEM	S1,GRPTYP(I1)		; Store the Type
	$RETT				; Return 
GRPPUR: MOVE	LP,QUABLK	        ; Get qualifier block
	SKIPG	PRMPTR(LP)
	 PJRST	[SETZM	@ECUR(LP)
		 $RETT]
DELGRP:	$CALL	FNDQUA   		; Find the qualifier
	JUMPF	[$RETT]			; Not there, nothing to purge
	$SAVEC
	SOS	@ECUR(LP)		; One less qualifier
DELGR1:	CAMN	I1,@ECUR(LP)
	 $RETT
	MOVEI	C5,@EPTR(LP)
	HRLI	C5,(POINT 7,0)
	LOAD	C4,(LP),PRSMAX
	MOVE	C2,C5
	ADD	C2,EINC(LP)
	MOVE	C1,C4
	EXTEND	C1,[MOVSLJ 0
		    0]
	 JFCL
	MOVEI	C5,GRPDTE##(I1)
	$CALL	DCMPRS
	MOVE	GRPNUM##+1(I1)
	MOVEM	GRPNUM##(I1)
	MOVE	GRPTYP##+1(I1)
	MOVEM	GRPTYP##(I1)
	ADD	I2,EINC(LP)
	AOJA	I1,DELGR1

FNDDTE:	$SAVEC
	SETZB	I1,I2			; Zero pointers
DTENXT:	CAIN	I2,NUMDUP*4		; At end of DTEADR list yet?
	 $RETF				; Yes, not found
	MOVE	S2,PRMBLK
	LOAD	C1,(S2),PRSMAX		; Source length
	MOVEI	C2,1(S1)		; Source string address
	HRLI	C2,(POINT 7,0)		; Source string pointer
	MOVEI	C5,DTEADR(I2)		; Address in list
	HRLI	C5,(POINT 7,0)		; Pointer to entry in list
	SETZM	C3
	SETZM	C4
DTENX0:	ILDB	C3,C2
	ILDB	C4,C5
	SKIPN	C3
	JUMPE	C4,[$RETT]
	CAMN	C4,C3
	SOJG	C1,DTENX0
        ADDI	I2,4			; Index to next entry in list
	SKIPE	DTEADR(I2)		; 
	AOS	I1			; Keep track of DTE number
	JUMPA	DTENXT			; Continue looking
	SUBTTL	General List Processors
;
; LIST	*	*	*	*	*	*	*	*
;
; Display parameters from list of parameter blocks
;
LISLD:	SKIPN	T3,0(T4)		; Get parameter block
	 $RETT				;  (if there is one)
;	LOAD	T1,(T3),PRSPRV		;  and get privledged bit.
;	ANDCM	T1,PRVLDG		; Determine if
;	JUMPN	T1,LISLD9		;  not allowed.
	LOAD	T1,(T3),PRSTYP		; Determine
	JUMPE	T1,LISLD2		;  node type preference
	SKIPN	PRVLDG(T1)		;  and quit
	 JRST	LISLD9			;  if not enabled.
LISLD2:	LOAD	TF,(T3),PRMTXT		; Get text pointer
	MOVE	T1,@PRMPTR(T3)		;  and parameter.
	JUMPN	TF,LISLD3
	SKIPE	PRMDSP(T3)
	 $CALL	@PRMDSP(T3)
	JRST	LISLD4
LISLD3:	SKIPE	PRMPUR(T3)
	 JUMPE	T1,[SETZ TF,
		JRST LISLD4]
LISLD4:	SKIPE	T2,TF
	 $TEXT  ,<		  ^I/(T2)/>
LISLD9:	AOJA	T4,LISLD
	SUBTTL	List Node Processor
LISN:	$CALL	SETDFL##		;Make sure defaults are set
	SKIPG	I1,NODNUM
	 LOAD	I1,@DN502+PRMPTR
	CAMN	I1,@DN502+PRMPTR
	 $TEXT ,<^M^J		Executor Node = ^D/NTPSLF/ (^T/NODNAM/)^M^J>
	CAME	I1,@DN502+PRMPTR
	 $TEXT  ,<^M^J		Remote Node = ^D/NODNUM/ ()^M^J>
	MOVEI	T4,LDP
	SKIPN	PRVLDG##
	 MOVEI	T4,LDE
	CAME	I1,@DN502+PRMPTR
	 MOVEI	T4,LDN
	PJRST	LISLD
LDP:	EXP	DN100,DN101,DN150,DN151,DN152
	EXP	DN510,DN511
	EXP	DN700,DN710,DN720,DN721,DN722,DN723
	EXP	DN900,DN901,DN910,DN920,DN921,DN922,DN923,DN924,DN930,DN931
	EXP	DNS14,DNS0,DNS1,DNS5,DNS2,DNS3,DNS4,DNS7,DNS9,DNS8
	EXP	DNS10,DNS12,DNS13,DNS11
	EXP	0
LDE:	EXP	DN100,DN101,DN150,DN151,DN152
	EXP	DN510,DN511
	EXP	DN700,DN710,DN720,DN721,DN722,DN723
	EXP	DN900,DN901,DN910,DN920,DN921,DN922,DN923,DN924,DN930,DN931
	EXP	DNS1,DNS5
	EXP	0
LDN:	EXP	DNS14
	EXP	0
	SUBTTL	List Circuit Processors
LISKC:	$CALL	LISXC			; List Known Circuits
	PJRST	LISDC

LISXC:	SETZB	I1,I2			; Start off at zero.
LISXC1:	CAMN	I1,@ENTCIR+ECUR		; For each defined item
	 $RETT				;  all done.
	$TEXT  ,<^M^J		Circuit = ^T/X25CIR##(I2)/^M^J>
	MOVEI	T4,LDXC
	$CALL	LISLD
	ADD	I2,ENTCIR+EINC
	AOJA	I1,LISXC1
LDXC:	EXP	XC1111,XC1112,XC1120,XC1121,XC1122,XC1123
	EXP	0

	EXT	<DEVTXT,CTLNUM,UNTNUM>
	EXT	<DTENUM,DTECST>
	EXT	<DMCNUM,NUMDMC,DMCUSE,DMCCST>
	EXT	<DMRNUM,NUMDMR,DMRUSE,DMRCST>
	EXT	<KDPNUM,NUMKDP,KDPLNM,DUPUSE,LNTYP,DUPCST>
	EXT	<NTPT3,NTPT4,NTPSLF,NODNAM>
LISDC:	$CALL	SETDFL##		;Make sure defaults are set
	SKIPG	S2,DTENUM##
	 JRST	LKC1
	$CALL	DEVDTE##
	$TEXT  ,<^M^J		Circuit = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/^M^J>
	$TEXT  ,<		  Cost = ^D/DTECST/>
	$CALL	LISXPT
	$TEXT  ,<		  Line = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/>
LKC1:	SKIPG	P1,DMCNUM		;DO WE HAVE DMC11S?
	 JRST	LKC4			;NO - DON'T SAY ANYTHING ABOUT THEM
	$CALL	DEVDMC##
LKC2:	$CALL	DEVUNT##
	SKIPGE	DMCUSE##(I1)		;THIS DMC IN USE?
	 JRST	LKC3			;NO
	$TEXT  ,<^M^J		Circuit = ^T/DEVTXT/-^D/CTLNUM/^M^J>
	$TEXT  ,<		  Cost = ^D/DMCCST(I1)/>
	$CALL	LISXPT
	$TEXT  ,<		  Line = ^T/DEVTXT/-^D/CTLNUM/>
	$TEXT  ,<		  Type = DDCMP-DMC>
LKC3:	AOS	CTLNUM##
	SOJG	P1,LKC2			;DO ALL DMC11S
LKC4:	SKIPG	P1,DMRNUM##		;DO WE HAVE DMR11S?
	 JRST	LKC7			;NO - DON'T SAY ANYTHING ABOUT THEM
	$CALL	DEVDMR##
LKC5:	$CALL	DEVUNT##
	SKIPGE	DMRUSE##(I1)		;THIS DMR IN USE?
	 JRST	LKC6			;NO
	$TEXT  ,<^M^J		Circuit = ^T/DEVTXT/-^D/CTLNUM/^M^J>
	$TEXT  ,<		  Cost = ^D/DMRCST(I1)/>
	$CALL	LISXPT
	$TEXT  ,<		  Line = ^T/DEVTXT/-^D/CTLNUM/>
	$TEXT  ,<		  Type = DDCMP-DMC>
LKC6:	AOS	CTLNUM##
	SOJG	P1,LKC5			;DO ALL DMR11S
LKC7:	SKIPG	P1,KDPNUM		;DO WE HAVE KDP11S?
	 JRST	LKC12			;NO - DON'T SAY ANYTHING ABOUT THEM
	$CALL	DEVKDP##
LKC8:	$CALL	DEVCTL##
	SKIPG	P2,KDPLNM(I1)		;ARE THERE ANY DUPS ON THIS LINE?
	 JRST	LKC11			;NO - SKIP THIS KDP
	SETZM	UNTNUM##
LKC9:	$CALL	DEVUNT##
	SKIPGE	DUPUSE##(I1)		;THIS DUP IN USE?
	 JRST	LKC10			;NO
	MOVE	S1,LNTYP##(I1)
	CAIE	S1,^D4
	 JRST	LKC10
	$TEXT  ,<^M^J		Circuit = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/^M^J>
	$TEXT  ,<		  Cost = ^D/DUPCST(I1)/>
	$CALL	LISXPT
	$TEXT  ,<		  Line = ^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/>
	$TEXT  ,<		  Type = DDCMP-DMC>
LKC10:	AOS	UNTNUM##
	SOJG	P2,LKC9			;BACK FOR NEXT DUP WITHIN KDP
LKC11:	AOS	CTLNUM##
	SOJG	P1,LKC8			;BACK FOR NEXT KDP
LKC12:	$RETT

LISXPT:	$TEXT  ,<		  Hello Timer = ^D/NTPT3/>
	$TEXT  ,<		  Listen Timer = ^D/NTPT4/>
	$TEXT  ,<		  Owner = Node / ^D/NTPSLF/ / ^T/NODNAM/>
	$RET
	SUBTTL	List Line Processors
	EXT	<DEVTXT,CTLNUM,UNTNUM,DMXCSR,DMXINT>
	EXT	<DTENUM>
	EXT	<DMCNUM,NUMDMC,DMCUSE,DMCDUP>
	EXT	<DMRNUM,NUMDMR,DMRUSE,DMRDUP>
	EXT	<KDPNUM,NUMKDP,KDPLNM,DUPUSE,DUPRAT,LNTYP>
	EXT	<XTPIT1,XTPBLK,XTPIRC,XTPWS>
LISKL:	$CALL	SETDFL##		;Make sure defaults are set
	SKIPG	S1,DTENUM
	 JRST	LKL1
	$CALL	DEVDTE##
	LSH	S1,5			;Compute CSR address
	ADDI	S1,174400
	MOVEM	S1,@DL2650+PRMPTR	;Set controller register
	MOVN	S1,UNTNUM##
	LSH	S1,2			;Compute vector address
	ADDI	S1,774
	MOVEM	S1,@DL2655+PRMPTR	;Set interrupt vector
	MOVEI	^D7
	MOVEM	@DL2660+PRMPTR		;Set interrupt priority
	MOVEI	T4,LKDTE
	$CALL	LLPRM
LKL1:	MOVEI	160740			;STARTING CSR ADDRESS
	MOVEM	@DL2650+PRMPTR		;Set controller register
	MOVEI	670			;STARTING INTERRUPT VECTOR
	MOVEM	@DL2655+PRMPTR		;Set interrupt vector
	MOVEI	^D5
	MOVEM	@DL2660+PRMPTR		;Set interrupt priority
	SKIPG	P1,DMCNUM##		;DO WE HAVE DMC11S?
	 JRST	LKL4			;NO - DON'T SAY ANYTHING ABOUT THEM
	$CALL	DEVDMC##
LKL2:	$CALL	DEVUNT##
	SKIPGE	DMCUSE##(I1)		;THIS DMC IN USE?
	 JRST	LKL3			;NO
	MOVEI	[^D7]
	MOVEM	DL1105+PRMPTR		;Set receive buffers
	MOVEI	DMCDUP##(I1)
	MOVEM	DL1111+PRMPTR		;Set duplex
	MOVEI	[^D4]
	MOVEM	DL1112+PRMPTR		;Set protocol
	MOVEI	T4,LKDMX
	$CALL	LLPRM
LKL3:	MOVEI	S2,10
	ADDM	S2,@DL2650+PRMPTR
	ADDM	S2,@DL2655+PRMPTR
	AOS	CTLNUM##
	SOJG	P1,LKL2			;DO ALL DMC11S
LKL4:	SKIPG	P1,DMRNUM##		;DO WE HAVE DMR11S?
	 JRST	LKL7			;NO - DON'T SAY ANYTHING ABOUT THEM
	$CALL	DEVDMR##
LKL5:	$CALL	DEVUNT##
	SKIPGE	DMRUSE##(I1)		;THIS DMR IN USE?
	 JRST	LKL6			;NO
	MOVEI	[^D10]
	MOVEM	DL1105+PRMPTR		;Set receive buffers
	MOVEI	DMRDUP##(I1)
	MOVEM	DL1111+PRMPTR		;Set duplex
	MOVEI	[^D4]
	MOVEM	DL1112+PRMPTR		;Set protocol
	MOVEI	T4,LKDMX
	$CALL	LLPRM
LKL6:	MOVEI	S2,10
	ADDM	S2,@DL2650+PRMPTR
	ADDM	S2,@DL2655+PRMPTR
	AOS	CTLNUM##
	SOJG	P1,LKL5			;DO ALL DMR11S
LKL7:	SKIPG	P1,KDPNUM##		;DO WE HAVE KDP11S?
	 JRST	LKL12			;NO - DON'T SAY ANYTHING ABOUT THEM
	$CALL	DEVKDP##
LKL8:	$CALL	DEVCTL##
	SKIPG	P2,KDPLNM##(I1)		;ARE THERE ANY DUPS ON THIS LINE?
	 JRST	LKL11			;NO - SKIP THIS KDP
	SETZM	UNTNUM##
LKL9:	$CALL	DEVUNT##
	SKIPGE	DUPUSE##(I1)		;THIS DUP IN USE?
	 JRST	LKL10			;NO
	MOVEI	DUPDUP##(I1)
	MOVEM	DL1111+PRMPTR		;Set duplex
	MOVEI	LNTYP##(I1)
	MOVEM	DL1112+PRMPTR		;Set protocol
	MOVE	CTLNUM##		;Compute KMC CSR address
	LSH	3
	ADDI	160540
	MOVEM	@DL2650+PRMPTR		;Set controller register
	HRRZ	I1			;Compute DUP CSR address
	LSH	3
	ADDI	160300
	MOVEM	@DL2651+PRMPTR		;Set unit register
	MOVE	CTLNUM##		;Compute KMC vector address
	LSH	3
	ADDI	540
	MOVEM	@DL2655+PRMPTR		;Set interrupt vector
	MOVEI	^D5
	MOVEM	@DL2660+PRMPTR		;Set interrupt priority
	MOVEI	DUPRAT(I1)
	MOVEM	DLS0+PRMPTR		;Set baud rate
	MOVE	LNTYP(I1)
	MOVEI	T4,LKKDD
	CAIN	^D5
	 MOVEI	T4,LKKDX
	$CALL	LLPRM
LKL10:	AOS	UNTNUM##
	SOJG	P2,LKL9			;BACK FOR NEXT DUP WITHIN KDP
LKL11:	AOS	CTLNUM##
	SOJG	P1,LKL8			;BACK FOR NEXT KDP
LKL12:	$RETT
LKDTE:	EXP	DL1100,DL2650,DL2655,DL2660,DL2670
	EXP	0
LKDMX:	EXP	DL1100,DL1105,DL1110,DL1111,DL1112,DL1113,DL1120,DL1121
	EXP	DL2650,DL2655,DL2660
	EXP	0
LKKDD:	EXP	DL1100,DL1110,DL1111,DL1112,DL1113,DL1120,DL1121
	EXP	DL2650,DL2651,DL2655,DL2660,DLS0
	EXP	0
LKKDX:	EXP	DL1100,DL1110,DL1111,DL1112,DL1113,XL1121,XL1130,XL1131
	EXP	XL1132,DL2650,DL2651,DL2655,DL2660,DLS0
	EXP	0

LLPRM:	MOVEI	[ITEXT(^T/DEVTXT/-^D/CTLNUM/-^D/UNTNUM/)]
	SKIPGE	UNTNUM##
	 MOVEI	[ITEXT(^T/DEVTXT/-^D/CTLNUM/)]
	MOVEM	DL1100+PRMPTR
	$TEXT  ,<^M^J		Line = ^I/@DL1100+PRMPTR/^M^J>
	PJRST	LISLD
	SUBTTL	List Logging Processors
LISLF:	$TEXT  ,<^M^J		Logging = File^M^J>
	MOVEI	T4,7
	SETZB	I1,TF
LSLF1:	SKIPN	T1,GBLFLT##(I1)		; Get next class mask
	 JRST	LSLF6			; (if any are on).
	TXON	TF,1
	 $TEXT ,<		  Sink = (host)>
	$TEXT  ,<		  Events = ^D/I1/.^A>
	JUMPL	T1,[$TEXT  ,<*> 	; All types.
		JRST	LSLF6]
	SETZB	T2,T3
LSLF2:	HRRZ	S1,T3			; Find next bit on
	LSHC	T1,-1			; by shifting it from T1
	SKIPL	T2			; to T2.
	 AOJA	T3,LSLF2
LSLF3:	HRRZ	S2,T3			; Find next bit off
	LSHC	T1,-1			; by shifting it from T1
	SKIPG	T2			; to T2.
	 AOJA	T3,LSLF3
	TXOE	T3,1000000
	 $TEXT ,<,^A>
	CAMN	S1,S2			; Single flag
	 $TEXT ,<^D/S1/^A>
	CAME	S1,S2			; or range.
	 $TEXT ,<^D/S1/-^D/S2/^A>
	ADDI	T3,2			; Account for test bits
	JUMPN	T1,LSLF2		; and go on if more.
	$TEXT  ,<>
LSLF6:	AOS	I1			; On to next class.
	SOJG	T4,LSLF1
	$RETT
	SUBTTL	List Module MCB-Executive Processors
	EXT	<CCBNUM,RDBLEN>
LISMC:	SKIPN	PRVLDG##	        ; Don't list MCB-Exec if not
	 $RETT			        ;  privileged.
	$CALL	SETDFL##		;Make sure defaults are set
	$TEXT  ,<^M^J		Module = MCB-Executive^M^J>
	$TEXT  ,<		  CCBs = ^D/CCBNUM/>
	MOVE	S1,RDBNUM
	$TEXT  ,<		  RDBs = ^D/S1/^A>
	SKIPE	S2,BUFDIF##
	 JRST [	SUB	S1,S2
		$TEXT  ,<:^D/S1/^A>
		JRST	.+1]
	$TEXT  ,<^M^J		  RDB length = ^D/RDBLEN/>
	$RETT

	EXT	<PRCNAM,PRCDRV,PRCUSE>
LISMP:	$CALL	SETDFL##		;Make sure defaults are set
	$TEXT  ,<^M^J		Module = MCB-Executive^M^J>
	$TEXT  ,<		  Process = CEX, LLC>
	SKIPL	PRCMDT##
	 $TEXT  ,<		  Process = MDT>
	$TEXT  ,<		  Process = NDT>
	$TEXT  ,<		  Process = INI, LLC>
	$TEXT  ,<		  Process = NMX, NM:, LLC>
	$TEXT  ,<		  Process = SC, LLC>
	$TEXT  ,<		  Process = SC1>
	$TEXT  ,<		  Process = SCX, NS:, LLC>
	$TEXT  ,<		  Process = NSP, LLC>
	$TEXT  ,<		  Process = NS1>
	$TEXT  ,<		  Process = NS2>
	$TEXT  ,<		  Process = XPT, LLC>
	$TEXT  ,<		  Process = XPE>
	$TEXT  ,<		  Process = TLI>
	MOVE	S1,NODTYP##		;if not dn200,
	CAXE	S1,NDN200##		;then
	 $TEXT  ,<		  Process = TOP, LLC>
	MOVE	S1,NODTYP##			;if not x25
	CAIN	S1,NX25##			;then skip
	 JRST [	$TEXT  ,<		  Process = GAT>
		$TEXT  ,<		  Process = GAN>
		$TEXT  ,<		  Process = PLP>
		$TEXT  ,<		  Process = PLE>
		$TEXT  ,<		  Process = PLN>
		$TEXT  ,<		  Process = FLN>
		$TEXT  ,<		  Process = FLP>
		JRST	.+1]
	SETZ	T1,
LMP1:	CAMLE	T1,PRCPTR##
	 JRST	LMP2
	$TEXT  ,<		  Process = ^T/PRCNAM(T1)/^A>
	SKIPE	PRCDRV(T1)
	 $TEXT  ,<, ^T/PRCDRV(T1)/^A>
	SKIPL	PRCUSE(T1)
	$TEXT  ,<, LLC^A>
	$TEXT  ,< >
	AOJA	T1,LMP1
LMP2:	$RETT
	SUBTTL	List Module RSX-Executive Processors
LISR:	$CALL	P$KEYW##		;Get type of display
	JUMPE	S1,LISR			; and if this is it
	PJRST	0(S1)			; then go to display routine.

	EXT	<RSTNAM>
LISRT:	$TEXT  ,<^M^J		Module = RSX-Executive^M^J>
	SKIPN	NMLTYP##
	$TEXT  ,<		  Task = NML>
	SKIPLE	NMLTYP##
	$TEXT  ,<		  Task = NMS>
	MOVE	S1,NODTYP##		;if dn200,
	CAXN	S1,NDN200##		;then
	$TEXT  ,<		  Task = POSI, 3>
	SETZB	T1,T2
LRT1:	CAMLE	T1,RSTPTR##
	 JRST	LRT2
	$TEXT  ,<		  Task = ^T/RSTNAM(T2)/>
	ADDI	T2,2
	AOJA	T1,LRT1
LRT2:	$RETT
	SUBTTL	List Module X25-Protocol Processors
LISXPC:	$CALL	SETDFL##		;Make sure defaults are set
	MOVE	LP,QUABLK		; Get the qualifier
	SKIPN	LP			; Is there a qualfier?
	 JRST	LISXP0			; No
	SKIPE	T1,@PRMPTR(LP)
	 JRST	LISXPD
LISXP0:	$TEXT  ,<^M^J		Module = X25-Protocol^M^J>
	MOVEI	T4,LDXPC
	PJRST	LISLD
LDXPC:	EXP	XP1110,XP1140,XP1141,XP1150,XP1151,XP1152,XP1153,XP1154
	EXP	XP1160,XP1161,XP1162,XP1163,XPS0
	EXP	0

LISXPD:	AOSE	T1
	 JRST [	$CALL	FNDQUA
		JUMPF	[$SEMFAIL(DTE not defined)]
		JRST	.+1]
	$TEXT  ,<^M^J		Module = X25-Protocol^M^J>
	SETOM	KNOCNT#
	JUMPN	T1,LISDTE
	SETZB	I1,I2			; Start off at zero.
LISKD1:	CAMN	I1,@ECUR(LP)		; For each destination item
	 $RETT
	SKIPE	@EPTR(LP)		; Check if qualifier specified
	 $CALL	LISDTE			; There was, so do specific qualifier.
	ADD	I2,EINC(LP)
	AOJA	I1,LISKD1

LISDTE:	AOSE	KNOCNT#
	 $TEXT  ,<>
	MOVEI	T4,LDXPC1
	CAIE	LP,QUAGRP
	PJRST	LISLD
	MOVEI	T4,LDXPC2
	$CALL LISLD
	 $SAVE <T1,T2,T3,T4>
	SETZB	T1,T2
	SETZM	T3
LSGRST:	CAIN	T1,NUMDUP
	 $RET
	MOVE	T4,T3
	IMULI	T4,NUMDUP
	ADD	T4,I1
	SKIPN	DTEADR(T2)
	 JRST LSGRNX
	SKIPGE	GRPNUM(T4)
	 JRST	LSGR0
	$TEXT	,<		  DTE = ^T/DTEADR(T2)/>
	$TEXT	,<		  NUMBER = ^D/GRPNUM(T4)/>
LSGR0:	AOJ	T3,
LSGRNX:	ADDI	T2,4
	AOJA	T1,LSGRST


LDXPC1:	EXP	XP1100,XP1120,XP1130,XP1131
	EXP	0
LDXPC2:	EXP	XP1101,XP1172
	EXP	0
	SUBTTL	List Module X25-Server Processors
LISXSC:	$CALL	SETDFL##		;Make sure defaults are set
	MOVE	T1,NODTYP##		; If not
	CAIE	T1,NX25##		;  an X.25 node
	 $RETT				;  then this is all.
	MOVEI	LP,QUADST
	SKIPE	T1,@PRMPTR(LP)
	 JRST	LISXSD
	$TEXT  ,<^M^J		Module = X25-Server^M^J>
	MOVEI	T4,LDXSC
	PJRST	LISLD
LDXSC:	EXP	XSS0,XSS1,DNX2,DNX3,DNX4
	EXP	0

LISXSD:	AOSE	T1
	 JRST [	$CALL	FNDQUA
		JUMPF	[$SEMFAIL(Destination not defined)]
		JRST	.+1]
	$TEXT  ,<^M^J		Module = X25-Server^M^J>
	SETOM	KNOCNT#
	JUMPN	T1,LISDST
	SETZB	I1,I2			; Start off at zero.
LISKD3:	CAMN	I1,@ECUR(LP)		; For each destination item
	 $RETT
	$CALL	LISDST
	ADD	I2,EINC(LP)
	AOJA	I1,LISKD3
LISDST:	AOSE	KNOCNT#
	 $TEXT  ,<>
	MOVEI	T4,LDD1
	PJRST	LISLD			;  display destination parameters.
LDD1:	EXP	XS300,XS320,XS330,XS331,XS332,XS340,XS350
	EXP	XS351,XS352,XS353,XS354,XS355
	EXP	0

	END