.TITLE	RMPAGE - REMOTE NODE DISPLAY
	.IDENT	/V01.00/
	.NLIST	BEX
;
; COPYRIGHT (C) 1979, 1980 BY
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
; ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
; INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
; COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
; OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
; TRANSFERRED.
;
; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
; AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
; CORPORATION.
;
; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
;
;
; MODULE DESCRIPTION:
;
;	PERIODIC UPDATE PROCESSING FOR REMOTE NODE DISPLAY
;
;
;
; DISTRIBUTED SYSTEMS SOFTWARE ENGINEERING
;
; IDENT HISTORY:
;
; 1.00	20-MAR-80
;

	.SBTTL	GLOBAL MACROS

;
; GLOBAL MACROS
;

	.MCALL	UCBDF$,NSPIN$,RNBDF$,LLWDF$,PDVDF$,NSDDB$,HDRDF$
	.MCALL	DCBDF$,ANBDF$,ALUN$S,GTIM$S,CTRDF$,DVBDF$,MBXDF$


	DCBDF$				; DEFINE DCB OFFSETS AND SYMBOLS
	UCBDF$				; DEFINE UCB OFFSETS AND SYMBOLS
	NSPIN$				; DEFINE LOGICAL LINK TABLE OFFSETS
	RNBDF$				; DEFINE REMOTE NODE NAME BLOCK OFFSETS
	ANBDF$				; DEFINE ALIAS NAME BLOCK OFFSETS
	LLWDF$				; LOGICAL LINK WINDOW BLOCK OFFSETS
	PDVDF$				; DEFINE PDV OFFSETS AND SYMBOLS
	NSDDB$				; DEFINE NSP'S DDB OFFSETS AND SYMBOLS
	HDRDF$				; DEFINE THE TASK HEADER OFFSETS
	DVBDF$				; DEFINE VOLUME CONTROL BLOCK OFFSETS
	CTRDF$				; DEFINE NODE COUNTERS OFFSETS	
	MBXDF$				; DEFINE MAILBOX OFFSETS AND SYMBOLS

	.SBTTL	LOCAL MACROS

;
; LOCAL MACROS
;

	.MACRO	TEXT,STRNG
	.NCHR	SYM,<STRNG>
	.BYTE	SYM
	.ASCII	/STRNG/
	.ENDM

	.MACRO	MVN,FROM,TO,LEN
	MOV	FROM,R0		; SENDING STRING
	MOV	TO,R1		; ADDRESS OF POSITION IN SCREEN BUFFER
	MOV	LEN,R2		; LENGTH OF STRING
	CALL	MOVEON		; MOVE ONTO SCREEN
	.ENDM

	.MACRO	FLAG,DD		; FLAG CHARACTER AS CHANGED
	BISB	#200,DD
	.ENDM

	.SBTTL	ENTRY POINT DEFINITION

	.PSECT	PAGE,OVR,I,LCL

	.WORD	PAGE			; DEFINE ENTRY POINT

	.SBTTL	LOCAL SYMBOLS

	LNKMAX=30.		; MAXIMUM NUMBER OF LOGICAL LINKS TO DISPLAY

	.SBTTL	LOCAL DATA

; 
; LOCAL DATA
;
RMNSNM:	.BLKW	4			; NODE NAME STORAGE
TMPNOD:	.BLKB	6			; TEMPORARY NODE NAME STORAGE
RMLCNT:	.BLKW	1			; NUMBER OF LUNS TO DISPLAY
RMLNK:	.BLKB	6*LNKMAX		; STORAGE FOR TASK AND LUN INFORMATION
					; TASK NAME (RAD50), LUN, LLA
;
; NODE COUNTERS (THE COUNTERS ARE ORDER DEPENDENT)
;
RMCNT0:	.BLKW	1			; SECONDS SINCE LAST ZEROED
RMCNT1:	.BLKW	2			; BYTES RECEIVED
RMCNT2:	.BLKW	2			; BYTES SENT
RMCNT3:	.BLKW	2			; MESSAGES RECEIVED
RMCNT4:	.BLKW	2			; MESSAGES SENT
RMCNT5:	.BLKW	1			; CONNECTS RECEIVED
RMCNT6:	.BLKW	1			; CONNECTS SENT
RMCNT7:	.BLKW	1			; RESPONSE TIMEOUTS
RMCNT8:	.BLKW	1			; RECEIVECD CONNECT RESOURCE ERRORS
RMCNT9:	.BLKW	1			; NODE MAXIMUM LOGICAL LINKS ACTIVE

TIMBUF:	.BLKW	8.			; BUFFER FOR GTIM$ DIRECTIVE
EDTBUF:	.BLKW	20.			; EDIT CONVERSION BUFFER
SECOND=	TIMBUF+0			; TEMP STORAGE FOR SECS SINCE ZEROED
RMMAXL=	TIMBUF+2			; MAXIMUM NUMBER OF LINKS IN SYSTEM
RMULT=	TIMBUF+4			; ADDRESS OF CURRENT ULT
RMULTS=	TIMBUF+6			; STARTING ADDRESS OF USER LINK TABLE
;
; DISPLAY STRINGS
;
SELF:	.ASCIZ	/SELF/
NDNFND:	TEXT	<NODE NOT FOUND>
LOOPND:	TEXT	<LOOPBACK NODE>
NTNACC:	TEXT	<UNABLE TO ACCESS NETWORK> 
EXEOFF:	TEXT	<EXECUTOR STATE IS OFF>
	MESLMX=.-NTNACC-1		; LENGTH OF MAXIMUM DISPLAY STRING
	.EVEN

	.SBTTL	CLEAR FIELDS TABLES

;
; CLEAR FIELDS TABLES - THESE TABLES ARE USED BY THE CLRFLD ROUTINE
;       TO BLANK OUT THE SPECIFIED FIELD.  EACH ENTRY IN THE TABLE
;	CONSISTS OF TWO WORDS IN THE FOLLOWING FORMAT:
;	     LENGTH, ADDRESS IN SCREEN BUFFER
;	THE END OF THE TABLE IS INDICATED WITH A -1
;

;
; CLEAR FIELDS RELATED TO NODE INFORMATION
;
CALTBL:	.WORD	8.,$RMNDN		; CLEAR ALL INFORMATION
	.WORD	3.,$RMNDA		
CNDTBL:	.WORD	12.,$RMSTA
CURTBL:	.WORD	8.,$RMTYP
	.WORD	15.,$RMLIN
	.WORD	4.,$RMHOP
	.WORD	6.,$RMCOS
CCTTBL:	.WORD	5.,$RMCT0		; CLEAR COUNTERS
	.WORD	10.,$RMCT1
	.WORD	10.,$RMCT2
	.WORD	10.,$RMCT3
	.WORD	10.,$RMCT4
	.WORD	5.,$RMCT5
	.WORD	5.,$RMCT6
	.WORD	5.,$RMCT7
	.WORD	5.,$RMCT8
	.WORD	5.,$RMCT9
CLKTBL:					; CLEAR LINK INFORMATION
	COUNTR=0
	.REPT	LNKMAX
	.WORD	6.,$RMLNK+COUNTR+0
	.WORD	3.,$RMLNK+COUNTR+2
	.WORD	3.,$RMLNK+COUNTR+4
	COUNTR=COUNTR+6
	.ENDR
	.WORD	-1
;
; CLEAR MAXIMUM HOPS AND COST FIELDS
;
CHCTBL:	.WORD	4.,$RMHOP
	.WORD	6.,$RMCOS
	.WORD	-1
;
; CLEAR NODE NAME FIELD
;
CNMTBL:	.WORD	8.,$RMNDN
	.WORD	-1
;
; CLEAR NODE ADDRESS FIELD
;
CADTBL:	.WORD	3.,$RMNDA
	.WORD	-1

	.SBTTL	COUNTERS DISPLAY TABLE

;+
; 
; THIS TABLE IS USED TO DISPLAY THE NODE COUNTERS FOR THE CURRENT
; NODE.  EACH ENTRY CONSISTS OF TWO WORDS WITH THE FOLLOWING FORMAT:
;
;	SCREEN ADDRESS, FLAG (0 = 2 BYTE VALUE, 1 = 4 BYTE VALUE)
;
; THE END OF THE TABLE IS SIGNIFIED BY A 0.
;
;-

COUTBL:	.WORD	$RMCT0,0
	.WORD	$RMCT1,1
	.WORD	$RMCT2,1
	.WORD	$RMCT3,1
	.WORD	$RMCT4,1
	.WORD	$RMCT5,0
	.WORD	$RMCT6,0
	.WORD	$RMCT7,0
	.WORD	$RMCT8,0
	.WORD	$RMCT9,0
	.WORD	0

	.SBTTL	RMPAGE ENTRY POINT

;+
;
; PAGE - REMOTE NODE DISPLAY PAGE ENTRY POINT
;
; INPUTS:
;	$XCADD - NODE ADDRESS
;	$XCNOD - NODE NAME
;	$XCFLG - FLAGS WORD
;
; OUTPUTS:
;	THE DISPLAY IS UPDATED
;
;-

PAGE:	CLR	$RMFLG		; CLEAR FLAGS WORD
	BIS	#RM$NAC,$RMFLG	; ASSUME UNABLE TO ACCESS NETWORK
	ALUN$S	#$MLUN,#"NS	; ASSIGN THE MAILBOX LUN TO THE NETWORK
	BCS	10$		; BR IF UNABLE TO ACCESS NETWORK
	BIC	#RM$NAC,$RMFLG	; INDICATE NETWORK IS ACCESSIBLE
	MOV	$HEADR,R0	; GET TASK'S HEADER ADDRESS
	MOV	H.LUN+<<$MLUN-1>*4>(R0),R1 ; GET NS: UCB ADDRESS
	BIS	#RM$EXE,$RMFLG	; ASSUME EXECUTOR STATE IS OFF
	BITB	#US.MNT,U.STS(R1) ; IS THE EXECUTOR STATE ON?
	BNE	10$		; BR IF NO
	BIC	#RM$EXE,$RMFLG	; INDICATE EXECUTOR STATE IS ON
	CALL	FNDNOD		; DETERMINE IF NODE EXISTS
	BIT	#RM$LPB,$RMFLG	; IS THE NODE A LOOPBACK NODE?
	BNE	10$		; BR IF YES
	TST	$RMNNN		; DOES NODE EXIST?
	BEQ	10$		; BR IF NO
	CALL	RMFNSP		; GET NODE INFORMATION
	CALL	REACOU		; GET NODE COUNTERS
	CALL	FNDLNK		; GET LOGICAL LINK INFORMATION
10$:	CALL	UPDATE		; UPDATE THE SCREEN
	RETURN

	.SBTTL	FNDNOD - DETERMINE IF NODE EXISTS

;+
;
; FNDNOD - DETERMINE IF NODE SPECIFIED BY USER EXISTS
;
; INPUTS:
;	$XCFLG - INDICATES WHETHER A NODE NAME OR A NODE ADDRESS
;		 WAS SPECIFIED BY THE USER
;	$XCNOD - NODE NAME SPECIFIED BY USER
;	$XCADD - NODE ADDRESS SPECIFIED BY USER
;
; OUTPUTS:
;	RMNSNM - ASCIZ STRING CONTAINING NODE NAME
;	$RMNNN - NODE NUMBER (0 IF NODE NOT FOUND)
;
;-

FNDNOD:	BIT	#FL$NAM,$XCFLG		; DID USER SPECIFY A NODE NAME?
	BEQ	10$			; BR IF NO
	MOV	$XCNOD+0,TMPNOD+0	; COPY NODE NAME
	MOV	$XCNOD+2,TMPNOD+2	; ...
	MOV	$XCNOD+4,TMPNOD+4	; ...
	MOV	#TMPNOD,R0		; POINT TO NODE NAME
	CALL	MAPALI			; ATTEMPT TO MAP TO AN ALIAS NODE NAME
10$:	CALL	$SWSTK,80$		
	MOV	$XCFLG,R5		;; SAVE FLAGS WORD
	MOV	$XCADD,R4		;; SAVE NODE ADDRESS
	CLR	R3			;; NODE NUMBER (ASSUME NODE NOT FOUND)

	.IF	DF,M$$MGE
	MOV	@#KISAR5,-(SP)		;; SAVE CURRENT MAPPING
	MOV	$PBIAS,@#KISAR5		;; MAP TO NETWORK POOL
	.ENDC

	MOV	#$RNNHD,R0		;; POINT TO REMOTE NODE LIST
15$:	MOV	(R0),R0			;; GET NEXT REMOTE NODE BLOCK
	BNE	18$			;; BR IF ONE EXISTS
	BIT	#FL$NAM,R5		;; SEARCHING BY ADDRESS?
	BNE	60$			;; BR IF NO, NO SUCH NODE
	MOV	R4,R3			;; SET THE NODE ADDRESS
	MOVB	#40,RMNSNM		;; ZERO LENGTH NODE NAME
	BR	60$			;; FINISHED
	
18$:	.IF	DF,M$$MGE
	CMP	#140000,R0		;; MAPPED TO $PBIAS
	BHI	20$			;; BR IF NO
	BIC	#140000,R0		;; CLEAR OUT CURRENT MAPPING
	BIS	#120000,R0		;; MUST BE MAPPED TO APR5
20$:	.ENDC

	BIT	#FL$NAM,R5		;; DID USER SPECIFY NODE NAME?
	BNE	30$			;; BR IF YES
	CMP	R4,R.ADD(R0)		;; IS THIS THE NODE WE WANT?
	BNE	15$			;; BR IF NO
	BR	40$			;; BR IF THIS IS THE NODE WE WANT

30$:	CMP	TMPNOD+0,R.NAM+0(R0)	;; DOES THE NAME MATCH?
	BNE	15$			;; BR IF NO
	CMP	TMPNOD+2,R.NAM+2(R0)	;; NEXT TWO CHARACTERS MATCH?
	BNE	15$			;; BR IF NO
	CMP	TMPNOD+4,R.NAM+4(R0)	;; LAST TWO CHARACTERS MATCH?
	BNE	15$			;; BR IF NO
;
; FOUND A MATCH, SAVE NAME AND NUMBER
;
40$:	MOV	R.ADD(R0),R3		;; SET TO REAL NODE NUMBER
	MOV	#RMNSNM,R2		;; POINT TO LOCAL NODE NAME STORAGE
	ADD	#R.NAM,R0		;; POINT TO NODE NAME 
	MOV	#6,R1			;; NUMBER OF CHARACTERS IN NODE NAME
45$:	CMPB	#40,(R0)		;; END OF NAME?
	BEQ	50$			;; BR IF YES
	MOVB	(R0)+,(R2)+		;; SAVE THE NAME
	DEC	R1			;; MORE TO TRANSFER?
	BGT	45$			;; BR IF YES
50$:	CLRB	(R2)			;; MAKE IT AN ASCIZ STRING



60$:	.IF	DF,M$$MGE
	MOV	(SP)+,@#KISAR5		;; RESTORE MAPPING
	.ENDC

	MOV	R3,$RMNNN		;; SAVE THE NODE ADDRESS (IF ANY)
	BMI	70$			;; BR IF LOOPBACK NODE
	CMP	R3,$NSPNM		;; IS THIS THE LOCAL NODE?
	BNE	80$			;; BR IF NO
	BIS	#RM$LOC,$RMFLG		;; ELSE INDICATE LOCAL NODE
	BR	80$			;; FINISHED

70$:	BIS	#RM$LPB,$RMFLG		;; INDICATE LOOPBACK NODE

80$:	RETURN

	.SBTTL	REACOU - READ COUNTERS
;+
;
; REACOU - READ COUNTERS
;
; INPUTS:
;	$RMNNN - NODE NUMBER
;	$RMPDV - NSP'S PDV INDEX
;
; OUTPUTS:
;	THE NODE COUNTERS ARE STORED IN BINARY IN
;	THE CORRECT LOCATIONS (RMCNT0 - RMCNT9)
;
;-
 
REACOU:	MOV	#RMCNT0,R4			; POINT TO NODE COUNTERS STORAGE
;
; GET SECONDS SINCE MIDNIGHT
;
	CLR	R0				; NEED SECONDS SINCE MIDNIGHT
	CALL	ELTIME				; GET SECONDS/2
	MOV	R0,SECOND			; SAVE IT
;
; GET NODE COUNTERS
;
	MOV	$RMPDV,R0			; GET NSP'S PDV ADDRESS
	MOV	$RMNNN,R1			; GET NODE NUMBER TO LOOK FOR

	CALL	$SWSTK,30$			;; ENTER SYSTEM STATE

	.IF	DF,M$$MGE
	MOV	KISAR5,-(SP)			; SAVE CURRENT MAPPING
	.ENDC

	BIT	#ZF.COU,Z.FLG(R0)		;; ARE COUNTERS SUPPORTED ?
	BNE	13$				;; IF NE, YES .. GET THEM
	JMP	20$				;; ELSE, NO .. LEAVE
13$:	.IF	DF,M$$MGE
	MOV	Z.DSP(R0),KISAR5		;; MAP TO NSP PROCESS
	.ENDC

	MOV	Z.DAT(R0),R0			;; POINT TO NSP'S DATA BASE
	BNE	14$				;; IF NE, NSP LOADED
	JMP	20$				;; NSP NOT LOADED

14$:	.IF	DF,M$$MGE
	CMP	#140000,R0			;; IS ADDRESS IN POOL SPACE?
	BHI	15$				;; BR IF YES
	BIC	#140000,R0			;; MUST BE MAPPED THROUGH APR5
	BIS	#120000,R0			;; ...
	.ENDC

15$:	CALL	FNDECL				;; FIND THE ECL NODE COUNTERS
	BCS	20$				;; IF CS, NONE
;
; ECL COUNTERS
;
	SUB	E$NTIM(R0),SECOND		;; GET SECONDS/2 LAST ZEROED
	ASL	SECOND				;; GET SECONDS LAST ZEROED
	MOV	SECOND,(R4)+			;; STORE IT
	ADD	#E$NBR,R0			;; POINT TO BYTES RECEIVED
	MOV	2(R0),(R4)+			;; STORE IT
	MOV	(R0),(R4)+			;; ...
	ADD	#E$NBS-E$NBR,R0			;; POINT TO BYTES SENT
	MOV	2(R0),(R4)+			;; STORE IT
	MOV	(R0),(R4)+			;; ...
	ADD	#E$NMR-E$NBS,R0			;; POINT TO MESSAGES RECEIVED
	MOV	2(R0),(R4)+			;; STORE IT
	MOV	(R0),(R4)+			;; ...
	ADD	#E$NMS-E$NMR,R0			;; POINT TO MESSAGES SENT
	MOV	2(R0),(R4)+			;; STORE IT
	MOV	(R0),(R4)+			;; ...
	ADD	#E$NCR-E$NMS,R0			;; POINT TO CONNECTS RECEIVED
	MOV	(R0),(R4)+			;; STORE IT
	ADD	#E$NCS-E$NCR,R0			;; POINT TO CONNECTS SENT
	MOV	(R0),(R4)+			;; STORE IT
	ADD	#E$NRT-E$NCS,R0			;; POINT TO RESPONSE TIMEOUTS
	MOV	(R0),(R4)+			;; STORE IT
	ADD	#E$NIC-E$NRT,R0			;; POINT TO CONNECT RESOURCE ERRORS
	MOV	(R0),(R4)+			;; STORE IT
	ADD	#E$NML-E$NIC,R0			;; POINT TO MAX LOG LINKS ACTIVE
	MOV	(R0),(R4)+			;; STORE IT
 
20$:	.IF	DF,M$$MGE
	MOV	(SP)+,KISAR5			;; RESTORE PREVIOUS MAPPING
	.ENDC

30$:	RETURN					;; FINISHED

	.SBTTL	FNDECL - FIND ECL NODE DATA BASE

;+
;
; FNDECL - FIND AN ECL NODE DATA BASE
;
; INPUTS:
;	R0 = NSP'S DATA BASE ADDRESS
;	R1 = NODE ADDRESS TO LOOK FOR
;
; OUTPUTS:
;	C-BIT = SUCCESS/FAILURE
;	IF SUCCESS:
;		R0 = ADDRESS OF ECL COUNTER TABLE
;
;-

FNDECL:
	ADD	#N$ENC,R0			;; POINT TO ECL NODE COUNTERS
;
; SEARCH FOR GIVEN NODE'S COUNTER TABLE
;	
10$:	MOV	(R0),R0				;; GET NEXT ENTRY
	SEC					;; ASSUME END OF TABLES
	BEQ	20$				;; IF EQ, END OF TABLES

	.IF	DF,M$$MGE
	CMP	#140000,R0			;; IS ADDRESS IN POOL?
	BHI	15$				;; BR IF YES
	BIC	#140000,R0			;; FORCE APR5 MAPPING
	BIS	#120000,R0			;; ...
	.ENDC

15$:	CMP	E$NNOD(R0),R1			;; IS THIS THE RIGHT NODE ?
	BNE	10$				;; IF NE, NO .. KEEP LOOKING
	CLC					;; SUCCESS
20$:	RETURN

	.SBTTL	ELTIME - CACULATE ELAPSED TIME
;+
;
; ELTIME - CALCULATE ELAPSED TIME
;
; INPUTS:
;	R0 = START TIME GIVEN IN NUMBER OF 2 SECOND INTERVALS SINCE MIDNIGHT
;
; OUTPUT:
;	C-BIT = SUCCESS/FAILURE
;	R0 = TIME ELAPSED FROM START TIME TO CURRENT TIME. RESULT IS AN UNSIGNED
;	     16-BIT INTEGER.
;
;	ALL OTHER REGISTERS PRESERVED.
;
;-
 
ELTIME:	CALL	$SAVAL			; SAVE ALL REGISTERS
	MOV     #$TTNS-6,R4		; GET ADDRESS OF CURRENT HOUR
	MOV     (R4)+,R1		; TURN CURRENT HOURS INTO
	MOV     #60.,R0			; MINUTES ELAPSED SINCE MIDNIGHT
	CALL    $MUL			; ...
	ADD     (R4)+,R1		; CALCULATE TOTAL MINUTES SINCE MIDNIGHT
	ADC	R0			; ..IN DOUBLE PRECISION
	MOV	R1,R3			; SAVE LOW ORDER PART
	MOV	R0,R2			; SAVE HIGH ORDER PART
	MOV     #60.,R0			; TURN TOTAL MINUTES ELAPSED SINCE
	CALL    $DMUL			; ..MIDNIGHT INTO SECONDS
	ADD     (R4),R1			; ADD NUMBER OF SECONDS SINCE MIDNIGHT
	ADC	R0			; ..IN DOUBLE PRECISION
	ROR	R0			; CHANGE TO NUMBER OF 2 SECOND INTERVALS
	ROR     R1			; ..SINCE MIDNIGHT
	SUB     2(SP),R1		; CALCULATE ELAPSED TIME
	BCC	10$			; IF CC, CURRENT TIME > START TIME
	ADD     #43200.,R1		; ELSE, ADD 24 HOURS TO RESULT
10$:	CLC				; DON'T CORRUPT THE C-BIT!
	MOV	R1,2(SP)		; RESULT RETURNED IN R0
20$:	RETURN

	.SBTTL	FNDLNK - GET LOGICAL LINK INFORMATION

;+
;
; FNDLNK - GET LOGICAL LINK INFORMATION
;
; INPUTS:
;	$RMDDB - NSP'S DDB ADDRESS
;
; OUTPUTS:
;	RMLNK  - CONTAINS THE LINK INFORMATION
;	RMLCNT - THE NUMBER OF LINKS TO DISPLAY
;
;-

FNDLNK:	MOV	#RMLNK,R5		; POINT TO LINK BUFFER

	CALL	$SWSTK,50$		;; ENTER SYSTEM STATE
	MOV	$HEADR,R0		;; POINT TO TASK HEADER
	MOV	H.LUN-4+<4*$MLUN>(R0),R0 ;; POINT TO NS: UCB
	MOV	U.VCB(R0),R0		;; GET VCB ADDRESS
	BEQ	50$			;; BR IF NO VCB
	MOV	V.ULT(R0),R1		;; GET USER LINK TABLE ADDRESS
	BEQ	50$			;; BR IF NO USER LINK TABLE
	MOV	R1,RMULTS		;; SAVE START OF USER LINK ADDRESS TABLE
	ADD	#V.MBXQ,R0		;; POINT TO MAILBOX QUEUE LISTHEAD
	CLR	-(SP)			;; NUMBER OF LINKS COUNTER
;
; STEP THROUGH MAILBOXES
;
10$:	MOV	(R0),R0			;; GET NEXT MAILBOX
	BEQ	40$			;; BR IF DONE
	MOV	$RMDDB,R2		;; POINT TO NSP'S DDB
	MOV	N$LVC(R2),R2		;; GET MAXIMUM NUMBER OF LINKS
	MOV	R2,RMMAXL		;; SAVE IT
	MOV	RMULTS,R1		;; GET START OF USER LINK ADDRESS TABLE
;
; SEARCH FOR LINKS ASSOCIATED WITH CURRENT NODE
;
20$:	MOV	(R1)+,R3		;; GET NEXT USER LINK ADDR TABLE ENTRY
	BEQ	30$			;; ZERO => ENTRY NOT USED
	MOV	R3,RMULT		;; SAVE ULT ADDRESS
	CMP	W.MBOX(R3),R0		;; DOES IT BELONG TO CURRENT MAILBOX?
	BNE	30$			;; BR IF NO
	MOVB	W.LLA(R3),R3		;; GET LOGICAL LINK ADDRESS
	CMP	R3,RMMAXL		;; IN RANGE?
	BHIS	30$			;; BR IF NO
	MOV	$RMDDB,R4		;; POINT TO NSP'S DDB
	MOV	N$LVC+2(R4),R4		;; GET LLT POINTER TABLE
	BEQ	30$			;; BR IF NO LLT
	ASL	R3			;; CREATE WORD OFFSET
	ADD	R3,R4			;; POINT INTO LLT LIST
	MOV	(R4),R4			;; POINT AT AN LLT
	BEQ	30$			;; BR IF NONE
	BIT	#RM$PH2,$RMFLG		;; PHASE II NODE?
	BEQ	25$			;; BR IF NO
	CMP	$RMCHN,L.REM(R4)	;; DOES IT BELONG TO CURRENT NODE?
	BNE	30$			;; BR IF NO
	BR	27$			;; ELSE CONTINUE
25$:	CMP	$RMNNN,L.REM(R4)	;; DOES IT BELONG TO CURRENT NODE?
	BNE	30$			;; BR IF NO
27$:	INC	(SP)			;; UPDATE COUNT OF LOGICAL LINKS
	MOV	M.TASK(R0),R4		;; GET TASK'S TCB ADDRESS
	MOV	T.NAM+0(R4),(R5)+	;; STORE TASK NAME (RAD50)
	MOV	T.NAM+2(R4),(R5)+	;; ...
	MOV	RMULT,R3		;; POINT TO ULT
	MOVB	W.LUN(R3),(R5)+		;; STORE LOGICAL UNIT NUMBER
	MOVB	W.LLA(R3),(R5)+		;; GET LLA
30$:	DEC	R2			;; MORE LINKS?
	BGT	20$			;; BR IF YES
	CMP	(SP),#LNKMAX		;; SEEN ENOUGH LINKS?
	BLO	10$			;; BR IF NO
40$:	MOV	(SP)+,RMLCNT		;; GET NUMBER OF LINKS TO DISPLAY
50$:	RETURN 				;; FINISHED

	.SBTTL	UPDATE - UPDATE THE SCREEN

;+
;
; UPDATE - UPDATE THE SCREEN
;
; INPUTS:
;	$RMTYS - ADDRESS OF NODE TYPE STRING
;	$RMSTS - ADDRESS OF NODE STATE STRING
;	$RMMHC - MINIMUM HOPS, MINIMUM COST WORD
;
; OUTPUTS:
;	THE SCREEN IS UPDATED
;
;-
UPDATE:	GTIM$S	#TIMBUF		; GET TIME AND DATE
	TST	$RMDAT		; DO WE WANT DATE DISPLAYED?
	BEQ	10$		; BR IF NO
	MOV	#"  ,EDTBUF+8.	; IF DAY IS LESS THAN 10
	MOV	#EDTBUF,R0	; OUTPUT FROM CONVERSION
	MOV	#TIMBUF,R1	; INPUT BUFFER
	CALL	$DAT		; CONVERT DATE TO ASCII
	MVN	#EDTBUF,$RMDAT,#9. ; MOVE ONTO SCREEN

10$:	TST	$RMTIM		; DO WE WANT TIME DISPLAYED?
	BEQ	20$		; BR IF NO
	MOV	#"  ,EDTBUF+6	; IF TIME IS BEFORE 10 O'CLOCK
	MOV	#EDTBUF,R0	; OUTPUT CONVERSION BUFFER
	MOV	#TIMBUF+6,R1	; INPUT BUFFER
	MOV	#3,R2		; HH:MM:SS FORMAT
	CALL	$TIM		; CONVERT TIME TO ASCII
	MVN	#EDTBUF,$RMTIM,#8. ; MOVE ONTO SCREEN

20$:	BIT	#RM$NAC,$RMFLG	; WERE WE ABLE TO ACCESS THE NETWORK?
	BEQ	22$		; BR IF YES
	MOV	#NTNACC,R1	; POINT TO DISPLAY STRING
	BR	23$		; BRANCH TO DISPLAY MESSAGE
22$:	BIT	#RM$EXE,$RMFLG	; IS EXECUTOR STATE ON?
	BEQ	24$		; BR IF YES
	MOV	#EXEOFF,R1	; POINT TO DISPLAY STRING
23$:	CALL	STRMES		; MOVE THE MESSAGE ONTO THE SCREEN
	MOV	#CALTBL,R3	; GET ADDRESS OF TABLE OF FIELDS TO CLEAR
	CALL	CLRFLD		; CLEAR THE SPECIFIED FIELDS
	JMP	200$		; FINISH UP
	
24$:	TST	$RMNNN		; IS THE NODE NAME VALID?
	BNE	35$		; BR IF YES
	MOV	#NDNFND,R1	; GET NODE NOT FOUND STRING
	CALL	STRMES		; STORE THE MESSAGE IN THE SCREEN BUFFER
	BIT	#FL$NAM,$XCFLG	; WAS NODE NAME SPECIFIED?
	BNE	25$		; BR IF YES
	MOV	$XCADD,R1	; GET SPECIFIED NODE ADDRESS
	CALL	STRADD		; MOVE ADDRESS INTO SCREEN BUFFER
	MOV	#CNMTBL,R3	; POINT TO CLEAR NAME FIELD TABLE
	BR	30$		; CONTINUE
25$:	MOV	#$XCNOD,R1	; GET ADDRESS OF SPECIFIED NODE NAME
	CALL	STRNAM		; STORE SPECIFIED NODE NAME IN SCREEN BUFFER
	MOV	#CADTBL,R3	; POINT TO CLEAR NODE ADDRESS FIELD TABLE
30$:	CALL	CLRFLD		; BLANK OUT THE SPECIFIED FIELD
	MOV	#CNDTBL,R3	; POINT TO TABLE OF FIELDS TO CLEAR
	CALL	CLRFLD		; BLANK OUT THE SPECIFIED FIELDS
	JMP	200$		; FINISHED
;
; DISPLAY LOOPBACK NODE MESSAGE IF LOOPBACK NODE
;
35$:	BIT	#RM$LPB,$RMFLG	; LOOPBACK NODE?
	BEQ	36$		; BR IF NO
	MOV	#$XCNOD,R1	; POINT TO NODE NAME STRING
	CALL	STRNAM		; MOVE IT ONTO SCREEN
	MOV	#LOOPND,R1	; POINT TO DISPLAY MESSAGE
	CALL	STRMES		; MOVE ONTO SCREEN
	MOV	#CADTBL,R3	; POINT TO CLEAR ADDRESS FIELD TABLE
	CALL	CLRFLD		; BLANK OUT THE ADDRESS FIELD
	MOV	#CNDTBL,R3	; CLEAR REST OF SCREEN
	CALL	CLRFLD		; ...
	JMP	200$		; FINISHED
;
; DISPLAY NODE NAME
;
36$:	MOV	#EDTBUF,R0	; OUTPUT CONVERSION BUFFER
	MOV	R0,R1		; SAVE IT
	MOV	#MESLMX,R2	; MAXIMUM LENGTH OF DISPLAY MESSAGE
37$:	MOVB	#' ,(R1)+	; BLANK OUT THE DISPLAY MESSAGE
	DEC	R2		; MORE?
	BGT	37$		; BR IF YES
	MVN	#EDTBUF,$RMMES,#MESLMX ; MOVE ONTO SCREEN
	MOV	#RMNSNM,R1	; GET ADDRESS OF NODE NAME TO DISPLAY
	CALL	STRNAM		; STORE NODE NAME IN SCREEN BUFFER
;
; DISPLAY NODE ADDRESS
;
	MOV	$RMNNN,R1	; GET NODE ADDRESS
	CALL	STRADD		; STORE NODE ADDRESS IN SCREEN BUFFER
;
; DISPLAY NODE STATE
;
40$:	TST	$RMSTA		; DISPLAY NODE STATE?
	BEQ	45$		; BR IF NO
	MOV	$RMSTS,R0	; GET ADDRESS OF STATE STRING
	MOVB	(R0)+,R2	; GET LENGTH OF STRING
	MOV	$RMSTA,R1	; GET ADDRESS ON SCREEN TO DISPLAY STATE
	CALL	MOVEON		; MOVE ONTO SCREEN
45$:	CMP	#$RMRCH,$RMSTS	; IS NODE REACHABLE?
	BEQ	50$		; BR IF YES
	MOV	#CURTBL,R3	; GET TABLE OF FIELDS TO CLEAR
	CALL	CLRFLD		; CLEAR THE FIELDS
	JMP	200$		; DONE
;
; DISPLAY NODE TYPE
;
50$:	TST	$RMTYP		; DISPLAY NODE TYPE?
	BEQ	60$		; BR IF NO
	MOV	$RMTYS,R0	; GET ADDRESS OF TYPE STRING
	MOVB	(R0)+,R2	; GET LENGTH OF STRING
	MOV	$RMTYP,R1	; GET ADDRESS ON SCREEN TO DISPLAY TYPE
	CALL	MOVEON		; MOVE ONTO SCREEN
;
; DISPLAY LINE-ID
;
60$:	TST	$RMLIN		; DISPLAY LINE-ID?
	BEQ	70$		; BR IF NO
	MOV	#EDTBUF,R0	; OUTPUT CONVERSION BUFFER
	MOV	R0,R2		; SAVE IT
	MOV	#15.,R1		; MAXIMUM LENGTH OF LINE-ID
61$:	MOVB	#' ,(R2)+	; BLANK IT OUT
	DEC	R1		; MORE?
	BGT	61$		; BR IF YES
	BIT	#RM$LOC,$RMFLG	; IS THIS THE LOCAL NODE?
	BEQ	63$		; BR IF NO
	MOV	#SELF,R1	; ELSE DISPLAY "SELF" FOR LINE-ID
62$:	MOVB	(R1)+,(R0)+	; STORE DISPLAY STRING
	BNE	62$		; BR IF MORE TO STORE
	MOVB	#' ,-(R0)	; REPLACE NULL WITH SPACE
	BR	67$		; CONTINUE
63$:	MOV	$RMDEV,R1	; GET DEVICE NAME
	CALL	$C5TA		; CONVERT IT TO ASCII
	MOVB	#'-,(R0)+	; INSERT DASH
	CLR	R1		; 
	MOVB	$RMCTL,R1	; GET CONTROLLER NUMBER
	CLR	R2		; SUPPRESS ZEROES
	CALL	$CBDMG		; CONVERT IT TO ASCII
	CLR	R1		;
	MOVB	$RMUNT,R1	; GET UNIT NUMBER
	BMI	65$		; BR IF NOT MUX DEVICE
	MOVB	#'-,(R0)+	; STORE DASH
	CLR	R2		; SUPPRESS ZEROES
	CALL	$CBDMG		; CONVERT IT TO ASCII
65$:	CLR	R1		; 
	MOVB	$RMTRI,R1	; GET STATION NUMBER
	BMI	67$		; BR IF NOT MULTIPOINT DEVICE
	MOVB	#'.,(R0)+	; STORE PERIOD
	CLR	R2		; SUPPRESS ZEROES
	CALL	$CBDMG		; CONVERT IT TO ASCII
67$:	MVN	#EDTBUF,$RMLIN,#15. ; MOVE ONTO SCREEN

70$:	BIT 	#RM$LOC,$RMFLG	; ARE WE DISPLAYING THE LOCAL NODE?
	BNE	72$		; BR IF YES
	CMP	#$RMROU,$RMTYS	; ROUTING NODE?
	BEQ	75$		; BR IF YES
72$:	MOV	#CHCTBL,R3	; POINT TO TABLE OF FIELDS TO CLEAR
	CALL	CLRFLD		; BLANK OUT THE SPECIFIED FIELDS
	BR	90$		; CONTINUE
75$:	MOV 	$RMMHC,R3	; GET MINIMUM HOPS, MINIMUM COST
	TST	$RMHOP		; DISPLAY MINIMUM HOPS
	BEQ	80$		; BR IF NO
	MOV	R3,R1		; ISOLATE MINIMUM HOPS
	SWAB	R1		; GET HOPS INTO LOW BYTE
	ASR	R1		; RIGHT JUSTIFY
	ASR	R1		; ...
	BIC	#^C<37>,R1	; HOPS IS NOW IN LOW 5 BITS
	MOV	#EDTBUF,R0	; OUTPUT CONVERSION BUFFER
	MOV	#"  ,(R0)	; INITIALIZE HOPS STRING
	MOV	(R0),2(R0)	; ...
	CLR	R2		; SUPPRESS ZEROES
	CALL	$CBDMG		; CONVERT TO ASCII
	MVN	#EDTBUF,$RMHOP,#4 ; MOVE ONTO SCREEN

80$:	TST	$RMCOS		; DISPLAY MINIMUM COST?
	BEQ	90$		; BR IF NO
	MOV	R3,R1		; GET MINIMUM HOPS, MINIMUM COST
	BIC	#^C<1777>,R1	; ISOLATE COST
	MOV	#EDTBUF,R0	; OUTPUT CONVERSION BUFFER
	MOV	#"  ,(R0)	; INITIALIZE COST STRING
	MOV	(R0),2(R0)	; ...
	MOV	(R0),4(R0)	; ...
	CLR	R2		; SUPPRESS ZEROES
	CALL	$CBDMG		; CONVERT TO ASCII
	MVN	#EDTBUF,$RMCOS,#6 ; MOVE ONTO SCREEN
;
; NODE COUNTERS
;
90$:	MOV	#RMCNT0,R3	; POINT TO START OF COUNTERS
	MOV	#COUTBL,R4	; POINT TO COUNTERS DISPLAY TABLE
100$:	MOV	(R4)+,R5	; GET SCREEN ADDRESS
	BEQ	130$		; BR IF END OF TABLE
	MOV	#EDTBUF,R0	; POINT TO OUTPUT CONVERSION BUFFER
	MOV	#"  ,(R0)	; BLANK OUT COUNTER
	MOV	(R0),2(R0)	; ...
	MOV	(R0),4(R0)	; ...
	MOV	(R0),6(R0)	; ...
	MOV	(R0),10(R0)	; ...
	CLR	R2		; SUPPRESS ZEROES
	TST	(R4)+		; TWO BYTE COUNTER?
	BEQ	110$		; BR IF YES
	MOV	R3,R1		; POINT TO FOUR BYTE COUNTER
	CALL	$CDDMG		; CONVERT IT TO ASCII
	CMP	(R3)+,(R3)+	; UPDATE POINTER TO COUNTERS
	MOV	#10.,R2		; NUMBER OF CHARACTERS TO DISPLAY
	BR	120$		; CONTINUE
110$:	MOV	(R3)+,R1	; GET COUNTER VALUE
	CALL	$CBDMG		; CONVERT IT TO ASCII
	MOV	#5,R2		; NUMBER OF CHARACTERS TO DISPLAY
120$:	MOV	(R5),R1		; GET ADDRESS ON SCREEN TO DISPLAY IT
	BEQ	100$		; BR IF NOT TO BE DISPLAYED
	MOV	#EDTBUF,R0	; POINT TO OUTPUT BUFFER
	CALL	MOVEON		; MOVE ONTO SCREEN
	BR	100$		; GET NEXT COUNTER
;
; DISPLAY LOGICAL LINK INFORMATION
;
130$:	MOV	RMLCNT,R5	; GET NUMBER OF LINKS TO DISPLAY
	BEQ	160$		; BR IF NONE
	MOV	#$RMLNK,R4	; POINT TO LINK DISPLAY SCREEN ADRESS LIST
	MOV	#RMLNK,R3	; POINT TO LINK INFORMATION BUFFER
135$:	MOV	#EDTBUF,R0	; GET ADDRESS OF OUTPUT BUFFER
	MOV	#"  ,(R0)	; INITIALIZE TASK NAME TO BLANKS
	MOV	(R0),2(R0)	; ...
	MOV	(R0),2(R0)	; ...
	MOV	(R3)+,R1	; GET FIRST HALF OF TASK NAME
	CALL	$C5TA		; CONVERT IT TO ASCII
	MOV	(R3)+,R1	; GET SECOND HALF OF NAME
	CALL	$C5TA		; CONVERT IT TO ASCII
	MOV	(R4)+,R1	; GET NEXT TASK NAME DISPLAY SCREEN ADDRESS
	BEQ	140$		; BR IF NOT TO BE DISPLAYED
	MVN	#EDTBUF,R1,#6	; DISPLAY TASK NAME
	MOV	#2,-(SP)	; DISPLAY NEXT 2 FIELDS OF LINK INFORMATION
140$:	MOV	#EDTBUF,R0	; GET ADDRESS OF OUTPUT BUFFER
	MOV	#"  ,(R0)	; INITIALIZE LUN NUMBER TO BLANKS (FIRST PASS)
	MOV	(R0),2(R0)	;         OR LLA NUMBER TO BLANKS (SECOND PASS)
	CLR	R1		; GET LUN NUMBER (OR LLA)
	BISB	(R3)+,R1	; ...
	CLR	R2		; SUPPRESS LEADING ZEROES
	CALL	$CBDMG		; CONVERT IT TO ASCII
	MOV	(R4)+,R1	; GET NEXT LUN (OR LLA) DISPLAY SCREEN ADDRESS
	BEQ	150$		; BR IF NOT TO BE DISPLAYED
	MVN	#EDTBUF,R1,#3	; MOVE ONTO SCREEN
150$:	DEC	(SP)		; MORE?
	BGT	140$		; BR IF YES
	TST	(SP)+		; CLEAN UP STACK
	DEC	R5		; MORE LINKS TO DISPLAY?
	BGT	135$		; BR IF YES
160$:	MOV	RMLCNT,R0	; GET NUMBER OF LINKS TO DISPLAY
	MOV	#12.,R1		; GET INDEX INTO CLEAR LINK TABLE
	CALL	$MUL		; ...
	MOV	#CLKTBL,R3	; POINT TO CLEAR LINK TABLE
	ADD	R1,R3		; POINT TO ONE PAST LAST ONE DISPLAYED
	CALL	CLRFLD		; BLANK OUT THE REST
200$:	RETURN

	.SBTTL	STRNAM - STORE NAME IN SCREEN BUFFER

;+
;
; STRNAM - STORE NODE NAME IN SCREEN BUFFER
;
; INPUTS:
;	R1 - ADDRESS OF ASCII NODE NAME STRING
;
; OUTPUTS:
;	THE NODE NAME IS STORED IN THE SCREEN BUFFER
;	R0,R1,R2 DESTROYED
;
;-

STRNAM:	TST	$RMNDN		; DO WE WANT TO DISPLAY NODE NAME?
	BEQ	30$		; BR IF NO
	MOV	#EDTBUF,R0	; POINT TO OUTPUT CONVERSION BUFFER
	MOV	#"  ,(R0)	; BLANK OUT NODE NAME
	MOV	(R0),2(R0)	; ...
	MOV	(R0),4(R0)	; ...
	MOV	(R0),6(R0)	; ...
	CMPB	#' ,(R1)	; IS NODE NAME ALL BLANKS?
	BEQ	25$		; BR IF YES
	MOVB	#'(,(R0)+	; STORE LEFT PARENTHESES
	MOV	#6,R2		; MAXIMUM LENGTH OF NODE NAME
10$:	MOVB	(R1)+,(R0)+	; STORE NODE NAME
	BEQ	20$		; MAY BE ASCIZ STRING
	DEC	R2		; MORE TO STORE?
	BGT	10$		; BR IF YES
	INC	R0		; 
20$:	MOVB	#'),-(R0)	; STORE RIGHT PARENTHESES
25$:	MVN	#EDTBUF,$RMNDN,#8. ; MOVE ONTO SCREEN
30$:	RETURN

	.SBTTL	STRADD - STORE NODE ADDRESS IN SCREEN BUFFER

;+
;
; STRADD - STORE NODE ADDRESS IN SCREEN BUFFER
;
; INPUTS:
;	R1 = NODE ADDRESS (BINARY) TO DISPLAY
;
; OUTPUTS:
;	THE NODE ADDRESS IS STORED IN THE SCREEN BUFFER
;	R0,R1,R2 DESTROYED
;
;-

STRADD:	TST	$RMNDA		; DO WE WANT TO DISPLAY NODE ADDRESS
	BEQ	10$		; BR IF NO
	MOV	#EDTBUF,R0	; POINT TO OUTPUT BUFFER
	MOV	#"  ,(R0)	; BLANK OUT NODE ADDRESS
	MOV	(R0),2(R0)	; ...
	CLR	R2		; SUPPRESS ZEROES
	CALL	$CBDMG		; CONVERT IT TO ASCII
	MVN	#EDTBUF,$RMNDA,#3 ; MOVE ONTO SCREEN
10$:	RETURN

	.SBTTL	STRMES - STORE DISPLAY MESSAGE IN SCREEN BUFFER

;+
;
; STRMES - STORE DISPLAY MESSAGE IN SCREEN BUFFER
;
; INPUTS:
;	R1 - ADDRESS OF ASCII STRING TO DISPLAY (FIRST BYTE IS LENGTH)
;
; OUTPUTS:
;	THE DISPLAY STRING IS MOVED INTO THE SCREEN BUFFER
;	R0,R1,R2 DESTROYED
;
;-

STRMES:	TST	$RMMES		; DISPLAY THE MESSAGE?
	BEQ	30$		; BR IF NO
	MOV	#EDTBUF,R0	; OUTPUT CONVERSION BUFFER
	MOV	R1,-(SP)	; SAVE ADDRESS OF DISPLAY STRING
	MOV	#MESLMX,R1	; GET MAXIMUM LENGTH OF MESSAGE
	MOV	R0,R2		; GET ADDRESS OF OUTPUT BUFFER
10$:	MOVB	#' ,(R2)+	; BLANK OUT OUTPUT BUFFER
	DEC 	R1		; MORE TO STORE?
	BGT	10$		; BR IF YES
	MOV	(SP)+,R1	; RESTORE ADDRESS OF DISPLAY STRING
	MOVB	(R1)+,R2	; GET LENGTH OF STRING
20$:	MOVB	(R1)+,(R0)+	; STORE THE STRING
	DEC	R2		; MORE?
	BGT	20$		; BR IF YES
	MVN 	#EDTBUF,$RMMES,#MESLMX ; MOVE ONTO SCREEN
30$:	RETURN

	.SBTTL	MOVEON - MOVE ONTO SCREEN

;+
;
; MOVEON - MOVE SPECIFIED STRING ONTO THE SCREEN
;
; INPUTS:
;	R0 - ADDRESS OF BUFFER CONTAINING STRING TO DISPLAY
;	R1 - ADDRESS ON SCREEN TO DISPLAY STRING
; 	R2 - NUMBER OF CHARACTERS TO MOVE ONTO SCREEN
;
; OUTPUTS:
;	THE SPECIFIED STRING IS MOVED INTO THE SCREEN BUFFER AND
;	ANY NEW CHARACTERS ARE FLAGGED
;
;-
MOVEON:	CMPB	(R0)+,(R1)+	; HAS CHARACTER CHANGED?
	BEQ	10$		; BR IF NO
	MOVB	-1(R0),-1(R1)	; ELSE MOVE IT ONTO THE SCREEN
	FLAG	-1(R1)		; FLAG IT AS CHANGED
10$:	DEC	R2		; MORE?
	BGT	MOVEON		; BR IF YES
	RETURN			; FINISHED

	.SBTTL	MAPALI - MAP AN ALIAS NAME INTO A REMOTE NAME

;+
;
; MAPALI - MAP ALIAS NAME INTO REMOTE NAME
;
; THIS ROUTINE IS CALLED TO MAP A POTENTIAL ALIAS NAME INTO
; A REMOTE NAME. ALIASES ARE MATCHED ON TERMINAL SCOPE FIRST,
; THEN ON GLOBAL (IF NO MATCH ON TERMINAL IS FOUND).
;
; INPUTS:
;	R0 = POINTER TO 6 CHARACTER SPACE FILLED NAME
;
; OUTPUTS:
;	R0 = POINTER TO 6 CHARACTER SPACE FILLED NAME
;	     IF THE NAME WAS AN ALIAS, THE REMOTE NAME REPLACES IT
;
; REGISTERS:
;	ALL REGISTERS ARE PRESERVED.
;-

MAPALI:
	CALL	$SWSTK,30$		;; ENTER SYSTEM STATE

	.IF	DF,M$$MGE
	MOV	@#KISAR5,-(SP)		;; SAVE CURRENT MAPPING
	MOV	$PBIAS,@#KISAR5		;; MAP TO SINGLE WORD POOL
	.ENDC

	MOV	$TKTCB,R1		;; GET OUR TCB ADDRESS
	MOV	T.UCB(R1),R1		;; GET OUR TI: UCB ADDRESS
	CALL	FNDALI			;; TRY TO FIND A LOCAL ALIAS
	BCC	10$			;; IF CC, GOT IT
	CLR	R1			;; ELSE, DEFAULT SCOPE TO GLOBAL
	CALL	FNDALI			;; TRY TO FIND A GLOBAL ONE
	BCS	20$			;; IF CS, NO ALIAS

10$:	MOV	A.REM(R3),(R0)+		;; REPLACE ALIAS NAME WITH REMOTE
	MOV	A.REM+2(R3),(R0)+	;; ...
	MOV	A.REM+4(R3),(R0)	;; ...

20$:
	.IF	DF,M$$MGE
	MOV	(SP)+,@#KISAR5		;; RESTORE PREVIOUS MAPPING
	.ENDC

30$:	RETURN				;; BACK TO USER STATE AND RETURN

	.SBTTL	FNDALI - FIND A SPECIFIED ALIAS BLOCK

;+
;
; FNDALI - FIND A SPECIFIED ALIAS BLOCK
;
; THIS ROUTINE IS CALLED TO FIND AN ALIAS BLOCK MATCHING A
; SPECIFIED NAME AND SCOPE.
;
; INPUTS:
;	* NOTE * THIS ROUTINE MUST BE CALLED, MAPPED TO NAME POOL
;	R0 = POINTER TO 6 CHARACTER SPACE FILLED NAME
;	R1 = SCOPE TO MATCH
;
; OUTPUTS:
;	IF CC, BLOCK FOUND AND:
;	   R2 = ADDRESS OF PREVIOUS BLOCK
;	   R3 = ADDRESS OF MATCHING BLOCK
;	ELSE, NO MATCH FOUND
;
; REGISTERS:
;	R0, R1, R4, R5 ARE PRESERVED
;-

FNDALI:
	MOV	#$ANNHD,R2		;; POINT TO ALIAS NAME LISTHEAD
10$:	SEC				;; ASSUME NAME NOT FOUND
	MOV	(R2),R3			;; GET NEXT ALIAS BLOCK ADDRESS
	BEQ	40$			;; IF EQ, END OF LIST - RETURN

	.IF	DF,M$$MGE
	CMP	#140000,R3		;; IS THIS IN SINGLE WORD POOL?
	BHI	15$			;; BR IF NO
	BIC	#140000,R3		;; CLEAR APR 6 MAPPING
	BIS	#120000,R3		;; MUST BE MAPPED THROUGH APR5
15$:	.ENDC

	CMP	(R0),A.NAM(R3)		;; IS THIS A MATCH ON NAME ?
	BNE	20$			;; IF NE, NO
	CMP	2(R0),A.NAM+2(R3)	;; ...
	BNE	20$			;; ...
	CMP	4(R0),A.NAM+4(R3)	;; ...
	BNE	20$			;; ...
	CMP	A.UCB(R3),R1		;; ELSE, IS IT THE RIGHT SCOPE ?
	BEQ	30$			;; IF EQ, YES - USE IT
20$:	MOV	R3,R2			;; ELSE, COPY BLOCK ADDRESS
	BR	10$			;; AND LOOK AT NEXT ALIAS BLOCK

30$:	CLC				;; RETURN SUCCESS
40$:	RETURN				;; BACK TO USER STATE AND RETURN

	.SBTTL	CLRFLD - CLEAR SPECIFIED FIELDS

;+
;
; CLRFLD - CLEAR SPECIFIED FIELDS
;
; INPUTS:
;	R3 - ADDRESS OF TABLE CONTAINING FIELDS TO BLANK OUT
;	     (TWO WORDS PER ENTRY:  LENGTH,ADDRESS IN SCREEN BUFFER)
;
; OUPUTS:
;	THE SPECIFIED AREAS OF THE SCREEN BUFFER ARE CLEARED
;	R0,R1,R2 DESTROYED
;
;-
CLRFLD:	MOV	#EDTBUF,R1		; OUTPUT CONVERSION BUFFER
	MOV	#8.,R2			; NUMBER OF WORDS TO CLEAR
10$:	MOV	#"  ,(R1)+		; MOVE IN SPACES
	DEC	R2			; MORE?
	BGT	10$			; BR IF YES
20$:	MOV	#EDTBUF,R0		; POINT TO OUTPUT BUFFER
	MOV	(R3)+,R2		; GET LENGTH OF FIELD
	BMI	30$			; BR IF END OF TABLE
	MOV	(R3)+,R1		; GET ADDRESS OF SCREEN BUFFER ADDRESS
	MOV	(R1),R1			; GET ADDRESS TO STORE IN SCREEN BUFFER
	BEQ	20$			; BR IF NOT TO BE DISPLAYED
	CALL	MOVEON			; MOVE ONTO SCREEN
	BR	20$			; GET NEXT FIELD TO CLEAR
30$:	RETURN

	.END