.TITLE	RST -- RSX TO RSTS REMOTE TERMINAL
	.IDENT	/X01.04/
;*
;*	LAST EDIT:	WOLERY		2 JULY 80
;
; COPYRIGHT (C) 1979
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
; OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
; VERSION X01.00
; M.L. SPENCE
;	MODIFIED FROM RVT PROGRAM, BY	R. E. CALDWELL	15-DEC-79/11-JAN-80
;
;
; REMOTE VIRTUAL TERMINAL
;
; THIS PROGRAM RUNS ON A LOCAL NODE (M/M-PLUS ONLY) TO ALLOW A TERMINAL
; TO APPEAR TO BE LOCALLY ATTACHED TO A REMOTE RSTS/E NODE.
; THE USER INTERFACE AND THE PROTOCOL OF THE DECNET/E "NET" TASK ARE USED.
;
; ALL I/O IS INITIATED WITHIN AST'S; ALL I/O HAS COMPLETION AST'S DECLARED.
;

	.SBTTL	MACRO CALLS AND LOCAL PARAMETERS
;
; MACRO LIBRARY CALLS
; 
	.MCALL	DIR$,ASTX$S,EXST$S,DSAR$S
	.MCALL	QIOW$S,QIO$S,STSE$S
	.MCALL	CLEF$S,WSIG$S
	.MCALL	GNDW$S,CLSW$S
	.MCALL	MRKT$S
	.MCALL	NETDF$,CRBDF$,TTSYM$,FILIO$,SPCIO$

	NETDF$			; DEFINE NET SYMBOLICS
	CRBDF$			; DEFINE CON BLOCK SYMBOLICS
	TTSYM$			; DEFINE TT SYMBOLICS
	FILIO$			; DEFINE NORMAL I/O SYMBOLICS
	SPCIO$			; DEFINE SPECIAL I/O SYMBOLICS

	.MACRO	CALLR A
	JMP	A
	.ENDM

	.PSECT	$$CODE,RO,I
;*
;* IF THE FOLLOWING PARAMETER IS DEFINED, CALLS TO A NETWORK
;* MESSAGE-TRACING PACKAGE WILL BE INSERTED IN THE INITIALIZATION,
;* LINK RECEIVE, AND LINK TRANSMIT SECTIONS.
;*
MTRACE=1		;TRACE MESSAGES SENT AND RECEIVED 

	.SBTTL	$RST -- MAIN ROUTINE FOR RSX/RSTS NETWORK TERMINAL
;+
; $RST -- MAIN ROUTINE FOR RSX/RSTS NETWORK TERMINAL
;
; NETWORK TERMINAL FROM RSX TO RSTS/E SYSTEMS --
; USES PROTOCOL AND USER INTERFACE OF RECEIVING SYSTEM.
;
; THIS ROUTINE SETS THE LINK UP, DOES ALL PROCESSING
; WITH AST'S, AND EXITS WHEN THE USER REQUESTS OR
; THE OTHER END DISCONNECTS.
;
;-

$RST::				; REFERENCE LABEL
	CALL	SETUP		; SETUP LINK AND TERMINAL
	BCS	60$		; IF CS, SETUP FAILED
	CLEF$S	#3		; CLEAR EFN
	MOV	#$BFLVL,R5	; BUFFERING LEVEL

10$:	CALL	LNKRCV		; HANG A LINK READ
	SOB	R5,10$		; PRIME ALL BUFFERS

	TSTB	HTRFLG		; IS USER ON AN RSX NETWORK TERMINAL?
	BEQ	20$		; NO -- PROCEED WITH NORMAL OPERATION

	MOV	#RM.MAXLEN,R1	; MAXIMUM LENGTH MESSAGE WE SEND
	CALL	GETBUF		; GET A BUFFER FOR TERMINAL INPUT
	BCS	60$		; IF ERROR, SOMETHING IS VERY WRONG
	CALL	TRMRD		; HANG A READ ON THE NETWORK TERMINAL

20$:	STSE$S	#3		; STOP - ALL FURTHER PROCESSING IS
				; ASYNCHRONOUS

60$:	DSAR$S			; DISABLE AST RECOGNITION
	TSTB	LNKFLG		; LINK EXIST ?
	BEQ	90$		; IF EQ, NO

	CLSW$S	#NDATA,#1	; CLOSE NETWORK

	.IF DF MTRACE	;MESSAGE-TRACE DEBUGGING PACKAGE
	CALL	TRCCLS		; CLOSE TRACE FILE
	.ENDC

	DIR$	#QIOKIL		; DUMP ANY LEFTOVER TERMINAL I/O
	MOV	XSTAT,-(SP)	; SAVE LASTEST EXIT STATUS
	CALL	ERR18		; INDICATE CONTROL HAS RETURNED TO LOCAL NODE
	MOV	(SP)+,XSTAT	; RESTORE EXIT STATUS
	QIOW$S	#IO.DET,#TERM,#2,,IOSB	; DETACH TERMINAL

90$:	EXST$S	XSTAT		; EXIT WITH WORST STATUS

	.SBTTL	GETBUF - ALLOCATE AN IOSB AND DATA BUFFER
;+
; <GETBUF>
;
;	THIS ROUTINE GETS A BUFFER FROM THE POOL.
;
;  INPUT:	R1 = BYTE COUNT DESIRED FOR DATA AREA OF BUFFER.
;
;  OUTPUT:	R1 = POINTER TO IOSB (START OF POOL AREA)
;		R0 = POINTER TO DATA AREA ( = R1 + 4)
;		CARRY = CLEAR IF BUFFER OK,
;			SET IF UNABLE TO ALLOCATE
;-
GETBUF::
	MOV	R2,-(SP)	; SAVE R2
	MOV	R3,-(SP)	; AND R3

	MOV	#POOL,R0	; ADDRESS OF LISTHEAD
;;
;;	ADD	#10,R1		; OVERHEAD FOR LINKS AND IOSB
;;DEBUG:
	MOV	#$MXMSG+10,R1	;SET BUFFER SIZE TO MAX VALUE
;;
	CALL	$RQCB		; ALLOCATE A BUFFER
	BCS	60$		; IF ERROR, GO RETURN STATUS

20$:	MOV	R0,R1		; COPY BUFFER ADDRESS
	ADD	#4,R0		; R0 = DATA ADDRESS, R1 = IOSB ADDRESS
	CLC			; RETURN GOOD STATUS

60$:	MOV	(SP)+,R3	; RESTORE R3
	MOV	(SP)+,R2	; AND R2
	RETURN

	.SBTTL	RELBUF - RELEASE BUFFER BACK TO POOL
;+
; <RELBUF>
;
;	THIS ROUTINE PUTS A BUFFER BACK INTO THE POOL.
;
;  INPUT:	R0 = POINTER TO IOSB (START OF ALLOCATED BUFFER)
;		R1 = BYTE COUNT FOR DATA AREA OF BUFFER
;
;  OUTPUT:	R0 = DESTROYED
;-
RELBUF::
	MOV	R2,-(SP)	; SAVE R2

	MOV	R0,R2		; COPY BUFFER ADDRESS
;;
;;	ADD	#10,R1		; ADD OVERHEAD FOR LINKS AND IOSB
;;DEBUG:
	MOV	#$MXMSG+10,R1	;SET BUFFER SIZE TO MAX VALUE
;;
	MOV	#POOL,R0	; POINT TO POOL LISTHEAD
	CALL	$RLCB		; RELEASE THIS BUFFER

	MOV	(SP)+,R2	; RESTORE R2

	RETURN

	.SBTTL	MSGSND - SEND CANNED MESSAGE TO HOST
;+
; <MSGSND>
;
;	THIS ROUTINE MOVES A CANNED MESSAGE FOR THE REMOTE HOST
;	INTO A BUFFER, AND SENDS IT OUT OVER THE LINK.
;
; INPUT:	R2 = LENGTH OF CANNED MESSAGE
;		R3 = POINTER TO CANNED MESSAGE
;
; OUTPUT:	ALL REGS CHANGED
;		SEND ISSUED FOR LINK
;-
MSGSND::
	MOV	#RM.MAXLEN,R1	; MAXIMUM LENGTH MESSAGE WE SEND
	CALL	GETBUF		;GET A TRANSMISSION BUFFER FOR THE MESSAGE
	BCC	10$		;PROCEED IF OK
	CALL	ERR15		;INDICATE ERROR TO USER
	BR	90$		;RETURN

10$:	MOV	R2,R4		;COPY LENGTH OF MESSAGE
	MOV	R0,R5		;COPY POINTER TO DATA AREA

20$:	MOVB	(R3)+,(R5)+	;MOVE MESSAGE TO TRANSMISSION BUFFER
	SOB	R4,20$		;LOOP THROUGH MESSAGE

	CALL	LNKWRT		;SEND MESSAGE TO HOST

90$:	RETURN		; RETURN TO CALLING ROUTINE

	.SBTTL	UNSAST - UNSOLICITED AST HANDLER
;+
; <UNSAST>
;
; UNSAST - UNSOLICITED AST HANDLER
;
;
;	THIS ROUTINE ALLOCATES A BUFFER FOR THE TERMINAL INPUT DATA,
;	AND HANGS A READ TO THE TERMINAL.
;
;*	FOR RSTS, ASSUME FULL-DUPLEX TERMINAL DRIVER WITH TYPE-AHEAD.
;*	THEN CHARACTER IS NOT AVAILABLE NOW, BUT MAY BE OBTAINED
;*	FROM THE TYPE-AHEAD BUFFER BY HANGING A READ.
;
;-
UNSAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	2(SP),R0	; GET DATA FOR AST
	MOV	R1,-(SP)	; SAVE R1
	MOV	R2,-(SP)	; AND R2
	MOV	R3,-(SP)	; AND R3
	MOV	R4,-(SP)	; AND R4
	MOV	R5,-(SP)	; AND R5

	TSTB	HTRFLG		; IS THIS AN RSX NETWORK TERMINAL?
	BEQ	50$		; IF NOT, HANG A READ TO GET ALL UNS. CHARS
;*
;* IF THIS IS A SINGLE ^P CHARACTER, START SPECIAL LOCAL PROCESSING.
;*
	BIC	#177400,R0	; ISOLATE BYTE WHICH CAUSED AST
	CMPB	#CTLP,R0	; IS THIS A LOCAL CONTROL INTERRUPT?
	BNE	40$		; NO -- GO SEND IT TO THE HOST

	INCB	LOCFLG		; SET FLAG FOR LOCAL COMMAND DIALOGUE
	CALL	TRMRD		; ISSUE A READ-AFTER-PROMPT
	BR	90$		; RETURN

40$:	MOVB	R0,UNSCHR	; GET CHARACTER THAT TRIGGERED THE AST
	MOV	#UNSLEN,R2	; LENGTH OF SINGLE-CHARACTER MESSAGE FOR HOST
	MOV	#UNSMSG,R3	; POINT TO UNSOLICITED-CHARACTER MESSAGE
	CALL	MSGSND		; SEND IT TO THE HOST
	BR	90$		; EXIT -- DON'T BOTHER TO HANG READ
;;	BCS	90$		; EXIT IF CAN'T SEND BECAUSE NO BUFFERS
;
; NORMAL UNSOLICITED CHARACTER PROCESSING -- READ TYPEAHEAD BUFFER
;
50$:	MOV	#RM.MAXLEN,R1	; MAXIMUM LENGTH MESSAGE WE SEND
	CALL	GETBUF		; ALLOCATE A BUFFER FOR TERMINAL INPUT
	BCS	80$		; KLUDGE IF ERROR
	CALL	TRMRD		; HANG A READ TO THE TERMINAL
	BR	90$		; RETURN
;
; KLUDGE TO GET BACK TO HANG A READ LATER,
;	WHEN SOMEBODY MIGHT HAVE RELEASED A BUFFER.
;
80$:	MRKT$S	,#1,#1,#TRMAST	; WAIT A TICK, COME BACK

90$:	MOV	(SP)+,R5	; RESTORE R5
	MOV	(SP)+,R4	; AND R4
	MOV	(SP)+,R3	; AND R3
	MOV	(SP)+,R2	; AND R2
	MOV	(SP)+,R1	; AND R1
	MOV	(SP)+,R0	; AND R0
	TST	(SP)+		; CLEAN UP STACK

99$:	ASTX$S			; EXIT AST

	.SBTTL	TRMAST - RETRY READ FROM TERMINAL
;+
; <TRMAST>
;
;	THIS ROUTINE RETRIES A TERMINAL READ WHICH FAILED
;	BECAUSE A BUFFER WAS NOT AVAILABLE.
;
;-
TRMAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	R1,-(SP)	; R1
	MOV	R2,-(SP)	; AND R2
	MOV	R3,-(SP)	; AND R3
	MOV	R4,-(SP)	; AND R4

	MOV	#RM.MAXLEN,R1	; MAXIMUM LENGTH MESSAGE WE SEND
	CALL	GETBUF		; ALLOCATE A BUFFER FOR TERMINAL INPUT
	BCS	80$		; KLUDGE IF ERROR
	CALL	TRMRD		; HANG A READ TO THE TERMINAL
	BR	90$		; RETURN
;
; KLUDGE TO GET BACK TO HANG A READ LATER,
;	WHEN SOMEBODY MIGHT HAVE RELEASED A BUFFER.
;
80$:	MRKT$S	,#1,#1,#TRMAST	; WAIT A TICK, COME BACK

90$:	MOV	(SP)+,R4	; RESTORE REGISTERS
	MOV	(SP)+,R3	;
	MOV	(SP)+,R2	; RESTORE REGISTERS
	MOV	(SP)+,R1	;
	MOV	(SP)+,R0	;
	TST	(SP)+		; CLEAN UP STACK (EVENT FLAG NUMBER)

99$:	ASTX$S			; EXIT AST

	.SBTTL	CTCAST - CONTROL/C AST
;+
; <CTCAST>
;
;	THIS ROUTINE TRAPS A CONTROL-C FROM THE TERMINAL,
;	AND SENDS IT TO THE REMOTE HOST.
;
;-
CTCAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	R1,-(SP)	; R1
	MOV	R2,-(SP)	; AND R2
	MOV	R3,-(SP)	; AND R3
	MOV	R4,-(SP)	; AND R4

	MOV	#CTCLEN,R2	; LENGTH OF MESSAGE WITH CONTROL/C
	MOV	#CTCMSG,R0	; POINTER TO MESSAGE WITH CONTROL/C
	MOV	#CTCIOS,R1	; POINTER TO CONTROL/C MESSAGE IOSB
	CALL	LNKWRT		; SEND CONTROL-C MESSAGE TO HOST
	BCS	80$		; KLUDGE IF ERROR

	DIR$	#QIOCTC		; ECHO ^C<CR><LF>
	BR	90$		; RETURN
;
; KLUDGE TO GET BACK TO SEND A CONTROL-C LATER,
;	WHEN SOMEBODY MIGHT HAVE RELEASED A BUFFER.
;
80$:	MRKT$S	,#1,#1,#CTCAST	; WAIT A TICK, COME BACK

90$:	MOV	(SP)+,R4	; RESTORE REGISTERS
	MOV	(SP)+,R3	;
	MOV	(SP)+,R2	; RESTORE REGISTERS
	MOV	(SP)+,R1	;
	MOV	(SP)+,R0	;
	TST	(SP)+		; CLEAN UP STACK

99$:	ASTX$S			; EXIT AST

	.SBTTL	LRAST - NETWORK RECEIVE AST
;+
; <LRAST>
;
; LINK RECEIVE AST HANDLER
;
;	THIS ROUTINE DISPATCHES TO MESSAGE-HANDLING ROUTINES
;	BASED ON THE TYPE OF MESSAGE RECEIVED FROM THE HOST.
;	IT HANGS ANOTHER RECEIVE WHEN PROCESSING IS COMPLETE.
;	IF THE RECEIVE FAILED, THE BUFFER IS RELEASED.
;
;	INPUT:
;		R0 = ADDRESS OF IOSB AND BUFFER
;-
LRAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	2(SP),R0	; R0 = ADDRESS OF IOSB AND BUFFER
	MOV	R1,-(SP)	; SAVE MORE REGISTERS
	MOV	R2,-(SP)	;
	MOV	R3,-(SP)	;
	MOV	R4,-(SP)	;
	MOV	R5,-(SP)	;

	TSTB	(R0)		; SUCCESS ?
	BGT	10$		; IF GT, YES

	CMPB	#IE.ABO,(R0)	; ABORT ?
	BEQ	90$		; IF EQ, LET MAILBAOX HANDLE
	CMPB	#IE.NLN,(R0)	; NO LINK ?
	BEQ	90$		; IF EQ, LINK HAS BEEN ABORTED

	MOV	#$MXMSG,R1	; MAXIMUM LENGTH MESSAGE RSTS SENDS US
	CALL	RELBUF		; RELEASE THIS BUFFER
	CALL	ERR16		; INDICATE LINK ERROR
	BR	40$		; PROCEED

10$:	ADD	#4,R0		; POINT TO MESSAGE

	.IF DF MTRACE	;MESSAGE-TRACE DEBUGGING PACKAGE
	CALL	TRCRCV		;RECORD RECEIVED NETWORK MESSAGE
	.ENDC

	MOVB	R.TYP(R0),R1	;* R1 = MESSAGE TYPE
	BIC	#177770,R1	;* ELIMINATE ILLEGAL MESSAGE TYPES
	ASL	R1		;* MAKE R1 A WORD INDEX
	MOV	TYPTB(R1),R1	;* POINT TO ROUTINE WHICH HANDLES THIS MSG
	CALL	@R1		;* DISPATCH THIS ONE
	BCS	90$		;* DON'T HANG RECEIVE IF FATAL ERROR

40$:	CALL	LNKRCV		; DO ANOTHER LINK RECEIVE
	BCC	90$		; EXIT IF RECEIVE OK
;
; KLUDGE TO GET BACK TO HANG RECEIVE LATER,
;	WHEN SOMEBODY MIGHT HAVE RELEASED A BUFFER.
;
80$:	MRKT$S	,#1,#1,#RCVAST	; WAIT A TICK, COME BACK

90$:	MOV	(SP)+,R5	; RESTORE REGISTERS
	MOV	(SP)+,R4	;
	MOV	(SP)+,R3	;
	MOV	(SP)+,R2	;
	MOV	(SP)+,R1	;
	MOV	(SP)+,R0	;
	TST	(SP)+		; CLEAN UP STACK 
	ASTX$S			; EXIT THE AST

	.SBTTL	RCVAST - RETRY LINK RECEIVE
;+
; <RCVAST>
;
;	THIS ROUTINE RETRIES A LINK RECEIVE THAT FAILED
;	DUE TO LACK OF BUFFERS.
;-
RCVAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	R1,-(SP)	; SAVE MORE REGISTERS
	MOV	R2,-(SP)	;
	MOV	R3,-(SP)	;
	MOV	R4,-(SP)	;
	MOV	R5,-(SP)	;

40$:	CALL	LNKRCV		; DO ANOTHER LINK RECEIVE
	BCC	90$		; EXIT IF RECEIVE OK
;
; KLUDGE TO GET BACK TO HANG RECEIVE LATER,
;	WHEN SOMEBODY MIGHT HAVE RELEASED A BUFFER.
;
80$:	MRKT$S	,#1,#1,#RCVAST	; WAIT A TICK, COME BACK

90$:	MOV	(SP)+,R5	; RESTORE REGISTERS
	MOV	(SP)+,R4	;
	MOV	(SP)+,R3	;
	MOV	(SP)+,R2	;
	MOV	(SP)+,R1	;
	MOV	(SP)+,R0	;
	TST	(SP)+		; CLEAN UP STACK (EVENT FLAG NUMBER)
	ASTX$S			; EXIT THE AST

	.SBTTL	LWAST - NETWORK TRANSMIT AST
;+
; <LWAST>
;
; LINK XMIT (WRITE) AST HANDLER
;
;	THIS ROUTINE RELEASES THE BUFFER WHICH CONTAINED
;	THE DATA JUST SENT TO THE REMOTE HOST.
;
; INPUT:
;	TOP OF STACK = POINTER TO IOSB
;
;-

LWAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	2(SP),R0	; R0 = ADDRESS OF IOSB

	CMP	#CTCIOS,R0	; WAS THIS A CONTROL/C MESSAGE?
	BEQ	90$		; BUFFER WAS NOT IN POOL -- DON'T RELEASE

	MOV	#RM.MAXLEN,R1	; MAXIMUM LENGTH MESSAGE WE SEND
	CALL	RELBUF		; RELEASE BUFFER

90$:	MOV	(SP)+,R0	;
	TST	(SP)+		; CLEAN UP STACK

	ASTX$S			; EXIT THE AST

	.SBTTL	RDAST - TERMINAL READ COMPLETE AST
;+
; <RDAST>
;
; AST HANDLER FOR COMPLETED TERMINAL READ
;
; INPUT:
;	TOP OF STACK = POINTER TO IOSB AND BUFFER
;-
RDAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	2(SP),R0	; R0 = ADDRESS OF IOSB AND BUFFER
	MOV	R1,-(SP)	; SAVE R1
	MOV	R2,-(SP)	; AND R2
	MOV	R3,-(SP)	; AND R3
	MOV	R4,-(SP)	; AND R4

	MOV 	R0,R1		; COPY IOSB ADDRESS
	MOVB	1(R1),-(SP)	; SAVE TERMINATING CHARACTER
	BIC	#177400,(SP)	; CLEAR HIGH-ORDER BYTE
	ADD	#4,R0		; POINT TO BUFFER

	MOVB	#RT.DAT,R.TYP(R0)	;* SET MESSAGE TYPE
	MOV	2(R1),R2	;* GET BYTE COUNT INPUT FROM TERMINAL
	INC	R2		;* ADD ONE FOR TERMINATING CHARACTER
	MOVB	R2,R.DLN(R0)	;* STORE LENGTH OF DATA

	ADD	#RM.HLEN,R2	;* ADD MESSAGE HEADER INFO
	INC	R2		;* ADD ONE FOR DATA LENGTH BYTE
	MOVB	R2,R.LEN(R0)	;* STORE LOW-ORDER BYTE OF COUNT
	SWAB	R2		;* SETUP HIGH-ORDER BYTE
	MOVB	R2,R.LEN+1(R0)	;* STORE LENGTH OF MESSAGE
	SWAB	R2		;* RESET TO TOTAL MESSAGE LENGTH

	MOV	R0,R4		; COPY BUFFER POINTER
	ADD	R2,R4		; POINT TO FIRST BYTE AFTER END OF MESSAGE
	MOVB	(SP),-1(R4)	; STORE TERMINATING CHARACTER FOR HOST
	DECB	TTREAD		; DECREMENT COUNT OF OUTSTANDING READS
;*
;* IF THIS IS A SINGLE ^P CHARACTER, START SPECIAL LOCAL PROCESSING.
;*
	CMPB	#CTLP,R.DAT(R0)	; IS THIS A LOCAL CONTROL INTERRUPT?
	BNE	50$		; NO -- GO SEND IT TO THE HOST

	MOV	R1,R0		; COPY POINTER TO IOSB
	MOV	#RM.MAXLEN,R1	; MAXIMUM LENGTH MESSAGE WE SEND
	CALL	RELBUF		; RELEASE THE BUFFER WITH THE CONTROL-P
	INCB	LOCFLG		; SET FLAG FOR LOCAL COMMAND DIALOGUE
	CALL	TRMRD		; ISSUE A READ-AFTER-PROMPT
	BR	70$		; RETURN

50$:	TSTB	MODE		; IN ODT (SINGLE-CHARACTER) MODE?
	BNE	60$		; IF NE, YES -- HOST WILL EDIT/ECHO
	CALL	TREDIT		; PERFORM LOCAL EDITING AND SPECIAL ECHOING

60$:	CALL	LNKWRT		; ISSUE LINK WRITE

70$:	TST	(SP)+		; CLEAN UP TERMINATING CHARACTER
	MOV	(SP)+,R4	; RESTORE R4
	MOV	(SP)+,R3	; RESTORE R3
	MOV	(SP)+,R2	; AND R2
	MOV	(SP)+,R1	; AND R1
	MOV	(SP)+,R0	; AND R0
	TST	(SP)+		; CLEAN UP STACK
	ASTX$S			; EXIT THE AST

	.SBTTL	RPRAST - TERMINAL READ-AFTER-PROMPT COMPLETE AST
;+
; <RPRAST>
;
;	THIS ROUTINE RECEIVES LOCAL CONTROL COMMANDS FROM THE USER
;	AND EXECUTES THEM AS APPROPRIATE.
;
; INPUT:
;	TOP OF STACK = POINTER TO IOSB "LOCSB"
;	LOCINP = BUFFER CONTAINING INPUT
;-
RPRAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	2(SP),R0	; R0 = ADDRESS OF IOSB "LOCSB"
	MOV	R1,-(SP)	; SAVE R1
	MOV	R2,-(SP)	; AND R2
	MOV	R3,-(SP)	; AND R3
	MOV	R4,-(SP)	; AND R4
	MOV	R5,-(SP)	; AND R5

	MOV	2(R0),R1	; GET BYTE COUNT INPUT FROM TERMINAL
	BEQ	50$		; IF NO INPUT, RE-ISSUE READ

	MOVB	LOCINP,R1	; GET FIRST INPUT BYTE
	BIC	#177400,R1	; CLEAR HIGH-ORDER BITS
	MOVB	CVTLUP(R1),LOCINP	; CONVERT TO UPPER CASE
	MOVB	LOCINP+1,R1	; GET SECOND INPUT BYTE
	BIC	#177400,R1	; CLEAR HIGH-ORDER BITS
	MOVB	CVTLUP(R1),LOCINP+1	; CONVERT TO UPPER CASE

	MOV	LOCINP,R1	; GET FIRST TWO INPUT CHARACTERS
	MOV	#CMDTAB,R5	; POINT TO COMMAND INTERPRETER TABLE
	MOV	CMDTLN,R4	; NUMBER OF ENTRIES IN TABLE
10$:	CMP	(R5)+,R1	; DOES COMMAND MATCH TABLE ENTRY?
	BEQ	30$		; YES - GO PROCESS IT
	TST	(R5)+		; SKIP PAST PROCESSING ADDRESS
	SOB	R4,10$		; CONTINUE THROUGH TABLE

	MOV	#CMDERR,R0	; POINT TO INPUT ERROR PROCESSING
	BR	40$		; NO MATCH FOR USER COMMAND IN TABLE

30$:	MOV	(R5),R0		; POINT TO COMMAND PROCESSING ROUTINE

40$:	CALL	@R0		; EXECUTE USER COMMAND
	BCS	90$		; IF SET, SHUT DOWN LOCAL PROCESSING
50$:	CALL	TRMRD		; HANG ANOTHER READ-AFTER-PROMPT

90$:	MOV	(SP)+,R5	; RESTORE R5
	MOV	(SP)+,R4	; AND R4
	MOV	(SP)+,R3	; AND R3
	MOV	(SP)+,R2	; AND R2
	MOV	(SP)+,R1	; AND R1
	MOV	(SP)+,R0	; AND R0
	TST	(SP)+		; CLEAN UP STACK
	ASTX$S			; EXIT THE AST

	.SBTTL	WTAST - TERMINAL WRITE COMPLETE AST
;+
; <WTAST>
;
; AST HANDLER FOR COMPLETED TERMINAL WRITES
;
;	THIS ROUTINE RELEASES THE BUFFER WHICH CONTAINED THE DATA
;	JUST WRITTEN TO THE TERMINAL.
;
;	INPUT:
;		TOP OF STACK = IOSB ADDRESS
;-

WTAST::
	MOV	R0,-(SP)	; SAVE R0
	MOV	2(SP),R0	; R0 = ADDRESS OF IOSB AND BUFFER

	MOV	#$MXMSG,R1	; MAXIMUM LENGTH MESSAGE RSTS SENDS US
	CALL	RELBUF		; RELEASE BUFFER JUST USED

	MOV	(SP)+,R0	; RESTORE R0
	TST	(SP)+		; CLEAN UP STACK
	ASTX$S			; EXIT THE AST

	.SBTTL	NDAST - NETWORK DATA AST
;+
; <NDAST>
;
; NDAST - NETWORK DATA AST HANDLER
;
; EVERYTHING EXCEPT DISCONNECT AND ABORT MESSAGES IS DISPATCHED
; TO AN ERROR ROUTINE.
;
;-
NDAST::
	GNDW$S	#NDATA,#4,#NIOSB,,<#MBX,#MBXLEN> ; GET NET DATA
	MOV	R0,-(SP)	; SAVE R0
	MOV	R1,-(SP)	; R1
	MOV	R2,-(SP)	; AND R2
	MOVB	NIOSB+1,R0	; R0 = MAILBOX ID
	BNE	10$		; IF NE, OK
	IOT			; DEBUG
10$:
	ASL	R0		; MAKE WORD INDEX
	CALL	@NETDSP(R0)	; DISPATCH THE FUNCTION
	MOV	(SP)+,R2	; RESTORE R2
	MOV	(SP)+,R1	; RESTORE R1
	MOV	(SP)+,R0	; RESTORE R0
	ASTX$S			; EXIT AST


NDSC::				; DISCONNECT RECEIVED
	CALL	ERR11		; ISSUE DISCONNECT MESSAGE
	MOV	#EX$SUC,XSTAT	; SET EXIT STATUS
	CALLR	SETFR		; WAKE UP

NABT::				; REMOTE RECEIVER ABORT
	CALL	ERR12		; ISSUE REMOTE ABORT MESSAGE
	MOV	#EX$SUC,XSTAT	; SET STATUS
	CALLR	SETFR		; WAKE UP

NABO::				; NETWORK ABORT
	CALL	ERR13		; ISSUE MESSAGE
	MOV	#EX$SUC,XSTAT	; SET EXIT STATUS
	CALLR	SETFR		; WAKE UP

SETFR::				; SET EVENT FLAG TO FORCE A WAKE UP 
				; AND THUS A TASK EXIT
	DIR$	#SETEXI		; WAKE UP
	RETURN			; RETURN TO CALLER


	.SBTTL	ERRXX - ERROR AND MESSAGE HANDLERS
;
; ERROR & MESSAGE HANDLER
;
ERR21::	INC	ERCNT		; FORCED TO ODT MODE FROM HT: DEVICE
ERR20::	INC	ERCNT		; CONNECTION ESTABLISHED TO NODE
ERR19::	INC	ERCNT		; INSUFFICIENT TTDRV SUPPORT
ERR18::	INC	ERCNT		; RETURN TO LOCAL
ERR17::	INC	ERCNT		; PROTOCOL NOT SUPPORTED BY REMOTE
ERR16::	INC	ERCNT		; LINK I/O ERROR
ERR15::	INC	ERCNT		; FAILED TO ALLOCATE BUFFER FOR I/O
ERR14::	INC	ERCNT		; INSUFFICIENT DYNAMIC MEMORY
ERR13::	INC	ERCNT		; NETWORK ABORT
ERR12::	INC	ERCNT		; REMOTE RECEIVER ABORT
ERR11::	INC	ERCNT		; REMOTE DISCONNECT
ERR10::	INC	ERCNT		; UNEXPECTED MAILBOX ENTRY
ERR9::	INC	ERCNT		; FAILED TO SEND INITIALIZE MESSAGE
ERR8::	INC	ERCNT		; FAILED TO RECEIVE CONF MESSAGE
ERR7::	INC	ERCNT		; FAILED TO SEND CONFIGURATION MESSAGE
ERR6::	INC	ERCNT		; FAILED TO ATTACH TERMINAL
ERR5::	INC	ERCNT		; FAILED TO ACCESS NODE
ERR4::	INC	ERCNT		; FAILED TO ACCESS NET DATA QUEUE
ERR3::	INC	ERCNT		; FAILED TO ACCESS NETWORK
ERR2::	INC	ERCNT		; FAILED TO GET NODE NAME
ERR1::	INC	ERCNT		; FAILED TO GET COMMAND LINE

	MOV	ERCNT,R1	; R1=ERROR NUMBER
	ASL	R1		; MAKE WORD INDEX
	MOV	MSGTB(R1),R0	; R0=ADDRESS OF MESSAGE
	MOV	#ERMSG+2,R2	; POINT TO AREA TO INSERT TEXT
	MOV	#RSTN,R3	; POINT TO LOCAL NODE/TASK NAME
	MOV	#RSTNLN-1,R4	; GET LENGTH OF NODE/TASK NAME STRING
10$:	MOVB	(R3)+,(R2)+	; MOVE STRING TO OUTPUT AREA
	SOB	R4,10$		; REPEAT (SKIP ">" AT END OF STRING)
	MOVB	#' ,(R2)+	; INSERT BLANK
	MOVB	#'-,(R2)+	; INSERT -
	MOVB	#'-,(R2)+	; INSERT -
	MOVB	#' ,(R2)+	; INSERT BLANK

20$:	MOVB	(R0)+,(R2)+	; INSERT MESSAGE TEXT
	BNE	20$		; LOOP TO END OF ASCIZ STRING
	MOVB	#15,(R2)+	; TERMINATE WITH <CR>
	MOVB	#12,(R2)+	;  AND <LF>

	SUB	#ERMSG,R2	;COMPUTE LENGTH OF MESSAGE
30$:	QIOW$S	#IO.WBT,#TERM,#2,,#IOSB,,<#ERMSG,R2>
	BCC	40$		; SKIP IF OK
	WSIG$S			; WAIT FOR EVENT
	BR	30$		; RETRY ON ERROR

40$:	CLR	ERCNT		; RESET ERROR COUNTER
	MOV	#EX$SEV,XSTAT	; SET EXIT STATUS
	SEC
	RETURN
	.PAGE
	.END	$RST