Google
 

Trailing-Edge - PDP-10 Archives - BB-X140B-BB_1986 - 10,7/703anf/dnnsp.p11
There are 3 other files named dnnsp.p11 in the archive. Click here to see a list.
.SBTTL	1.0 DNNSP 0.0 -- DECNET COMPATIBLE CODE  28 MAR 79
.IF NE,FTDCP1

VRNSP==011				;FILE EDIT NUMBER

;***********************************************************************
;
;
;	DNNSP 0.0 10-MAY-76 -- DECNET COMPATIBLE CODE	  
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
;  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
;COPYRIGHT (C) 1976,1977,1978,1979,1980,1981,1984 BY DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;***********************************************************************


	.SBTTL	    1.1  NSPDEF 0.0 12-MAY-76 -- SYMBOL DEFINITIONS


;***********************************************************************
;
;	NSPDEF 0.0 12-MAY-76 -- SYMBOL DEFINITIONS	  
;
;***********************************************************************


	.SBTTL	         1.1.1  LEDEF 0.0 12-MAY-76 -- LINK ENTRY DEFS


;***********************************************************************
;
;	LEDEF 0.0 12-MAY-76 -- LINK ENTRY DEFS	  
;
;***********************************************************************


	BLOCK	LE
	XX	NSP			;NSP LINK ADDRESS
	XX	CON			;CONVERTED NCL LINK ADDRESS
	X	NCL			;NCL LINK ADDRESS
	XX	STS			;STATUS BITS
		LES.DV=B7		;DEVICE CONNECTION
		LES.WD=B6		;WAITING FOR DISCONNECT CONFIRM
		LES.FL=B5		;FLUSH OUTPUT TO NSP
		LES.SD=B4		;SEND DISCONNECT CONFIRM TO NSP
		LES.SL=B3		;SEND 0 LINK STATUS
	X	SIZ,0			;SIZE OF LINK TABLE ENTRY

LEPCNK=CNKSIZ/LE.SIZ			;NUMBER OF LINK ENTRIES PER CHUNK
NSPINT=B3				;INTERRUPT BIT IN MSGFLG
NSPCM=B1				;MESSAGE IS CM IF 1

	.SBTTL	    1.2  NSPDAT 0.0 10-MAY-76 -- DATA AREAS


;***********************************************************************
;
;	NSPDAT 0.0 10-MAY-76 -- DATA AREAS	  
;
;***********************************************************************



NSPCNT:	.WORD	0			;COUNT OF NCL SUBMESSAGE
NSPCVL:	.WORD	0			;VALUE OF COUNT (FOR LATER FILL-IN)
NSPMSG:	.WORD	0			;ADDRESS OF MESSAGE FOR NSP
NSPLB:	.WORD	0			;ADDRESS OF LINE BLOCK FOR DCP LINE
NSPMML:	.WORD	0			;MAXIMUM NSP DATA LENGTH
NSPFLG:	.BYTE	0			;FLAG BITS
NSPREA:	.BYTE	0			;STORAGE FOR REASON CODE

	NSP.ST=B7			;A ONE INDICATES WE ARE STRIPPING COUNT/TYPE FROM NCL DATA

NSPNCT:	.BYTE	0			;NCL NCT STORED HERE
NSPSRC:	.BYTE	0			;NSP SOURCE LINK ADDRESS
NSPDST:	.BYTE	0			;NSP DESTINATION LINK ADDRESS
NSPOPT:	.BYTE	0			;OPTIONAL DATA

	.EVEN

	.SBTTL	    1.3  NSPRSS 0.0 12-MAY-76 -- START ON LINE


;***********************************************************************
;
;	NSPRSS 0.0 12-MAY-76 -- START ON LINE	  
;
;***********************************************************************


; STACK LOOKS LIKE:
;	0	DDCMP RETURN ADDR

NSPRSS:					;HERE FROM DDCMP WHEN IT STARTS LINE
	MOV	LB.SCB(J),SB		;IS AN SCB ALREADY ATTACHED TO LINE?
	BEQ	10$			;NO, BRANCH
	CLR	LB.LCT(J)		;CLEAR LINK COUNT
	CLR	LB.LLE(J)		;CLEAR LAST POINTER ALSO
	MOV	LB.LKT(J),R0		;GET CHUNK ADDRESS
	BEQ	8$			;IF NONE, DONE
	JSR	PC,FRECKS		;FREE CHUNKS
	CLR	LB.LKT(J)		;CLEAR POINTER TO LINK TABLE
8$:					;HERE WHEN DONE CLEANING OUT LINK TABLE
	CLR	LB.SCB(J)		;YES, DETACH IT
	JSR	PC,ROUTE		;RE-ROUTE WITH THIS STATION MISSING
	JSR	PC,SNDNGH		;TELL EVERYONE HE IS NOW GONE
10$:
	JSR	PC,MAKSCB		;FIND A FREE SCB
.IF NE,DGUTS
	BCC	20$			;CONTINUE IF SUCCESSFUL
30$:
	BIC	#LS.XRP!LS.NRP!LS.STK,(J);CLEAR  ALL THE BITS DDCMP JUST SET
	BIS	#LS..ST,(J)		;MAKE LINE DO STARTS AGAIN
	RTS	PC			;AND RETURN TO TRY AGAIN LATER
20$:
.ENDC; NE,DGUTS
	MOVB	LB.NNM(J),R0		;GET NODE NUMBER TO USE FOR LIST LINE
	BIC	#177400,R0		;CLEAR HIGH ORDER BITS
	MOV	SB,-(SP)		;SAVE SCB ADDRESS
	JSR	PC,FNDSCB		;SEE IF A NODE WITH THIS NUMBER ALREADY EXISTS
	BEQ	40$			;NO, BRANCH; PHEW!
;HERE WHEN A NODE ALREADY EXISTS WITH THE NODE NUMBER ASSEMBLED FOR THIS DCP LINE
.IF NE,DGUTS
	TWIDDLE				;COUNT HOW OFTEN IT HAPPENDS
	BR	30$			;AND GO BACK TO STARTING THE LINE
.IFF; NE,DGUTS
	TRAP				;SOMEBODY GOOFED!
.ENDC; NE,DGUTS
40$:					;HERE IF NODE NUMBER OK
	MOV	(SP)+,SB		;GET BACK SCB ADDRESS
	MOV	SB,LB.SCB(J)		;POINT TO IT IN THE LINE BLOCK
	MOV	R0,SB.NNM(SB)		;SAVE NODE NUMBER IN THE SCB
	SAVE	<R0,R1,R2,R3>		;SAVE SOME REGISTERS
.IF NE,SNMSIZ				;IF LENGTH OF FIELD IS NOT ZERO
	JSR	PC,NSPCPY		;COPY STATION NAME
	.WORD	LB.SNM			;LINE BLOCK DISPLACEMENT
	.WORD	SB.SNM			;STATIONC CONTROL BLOCK DISPLACEMENT
	.WORD	SNMSIZ			;NUMBER OF BYTES TO COPY
.ENDC; NE,SNMSIZ
.IF NE,SIDSIZ				;IF FIELD LENGTH NOT ZERO
	JSR	PC,NSPCPY		;COPY STATION IDENTIFICATION TO SCB
	.WORD	LB.SID
	.WORD	SB.SID
	.WORD	SIDSIZ
.ENDC; NE,SIDSIZ
.IF NE,DATESZ				;IF FIELD LENGTH IS NOT ZERO
	JSR	PC,NSPCPY		;COPY DATA FROM LINE BLOCK TO SCB
	.WORD	LB.DAT
	.WORD	SB.DAT
	.WORD	DATESZ
.ENDC; NE,DATESZ
	RESTOR	<R3,R2,R1,R0>		;RESTORE THE REGISTERS
	BIS	#<SF.HID!SF.NSP!SBF.IC!SBF.IU!SBF.SQ>,(SB);SET BITS IN SCB: IN CONTACT, HAVE ID, IN USE, NSP LINE, AND SEQUENTIAL NODE
;	MOV	J,SB.LBA(SB)		;SAVE LINE FOR ROUTING
	CLR	LB.NSS(J)		;NO STATUS BITS YET
	JSR	PC,ADDSQN		;ADD A SEQUENTIAL NODE
	JSR	PC,ROUTE		;DO ROUTING
	JSR	PC,SNDNGH		;TELL EVERYONE ABOUT NEW NODE
	RTS	PC			;EXIT

	.SBTTL	    1.4  NSPOUT 0.0 10-MAY-76 -- SEND MSG TO NSP


;***********************************************************************
;
;	NSPOUT 0.0 10-MAY-76 -- SEND MSG TO NSP	  
;
;***********************************************************************


; STACK LOOKS LIKE:
;	0	DDQDAT + ? (DDCMP RETURN)
;	2	#JRSTR
;	4	J VALUE
;	6	NCR.10 + ? (NCL RETURN)
;	10	SB VALUE

; REGISTERS
;	R0	ADDRESS OF FIRST CHUNK OF NCL MESSAGE
;	R2	THE CHARACTER SOH (DDCMP PUT IT THERE)
;	SB	CONTAINS DNA VALUE (I.E. THE DCP SCB)
;	J	CONTAINS LINE BLOCK FROM SB.LBA(SB)

NSPOUT:					;DO OUTPUT TO NSP
	SAVE	<R5,R4,R2,R0>		;SAVE SOME REGISTERS

; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

	MOV	J,NSPLB			;SAVE LINE BLOCK ADDRESS
	MOV	CN.NCT(R0),R1		;GET NCT
	MOVB	R1,NSPNCT		;SAVE IT FOR LATER
	BIC	#^C7,R1			;CLEAR ALL BUT MESSAGE TYPE
	BNE	NSPBAD			;IF NOT NUMBERED CONTROL OR DATA, BRANCH
	MOV	CN.CNT(R0),R2		;RESTORE MESSAGE COUNT FOR NCL MESSAGE
	JSR	PC,GETEXN		;GET DLA
	TST	R0			;TEST FOR ZERO
	BEQ	NSPOCM			;YES, SEND A CONTROL MESSAGE
	BR	NSPODM			;NO, MUST BE DATA


; NCL SHOULD NEVER SEND START/STACK/ACK/NAK/REP/NODEID 
; TO A SEQUENTIAL NODE WITH HID ON. WE SHOULD NEVER GET HERE.

	.SBTTL	         1.4.1  NSPBAD 0.0 10-MAY-76 -- BAD MESSAGE


;***********************************************************************
;
;	NSPBAD 0.0 10-MAY-76 -- BAD MESSAGE	  
;
;***********************************************************************


NSPBAD:					;NCL SENT A MESSAGE WE CANNOT HANDLE
.IF NE,DGUTS
	TWIDDLE				;COUNT OCCURENCE
	BR	NSPOFL			;FLUSH MESSAGE
.IFF; NE,DGUTS
	TRAP				;HALT
.ENDC; NE,DGUTS

;HERE TO DECREMENT NCL'S RECEIVED MESSAGE COUNT, SO THIS
; NUMBERED MESSAGE WILL EVENTUALLY APPEAR AGAIN.

NSPORT:					;CAUSE RETRANSMISSION (BY SENDER) OF MESSAGE

; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

	MOV	20(SP),SB		;RESTORE WINDOW POINTER
	DECB	SB.RMN(SB)		;DE-COMMIT THIS MESSAGE

;HERE TO FLUSH A MESSAGE FROM NCL

	.SBTTL	         1.4.2  NSPOFL 0.0 10-MAY-76 -- FLUSH OUTPUT MESSAGE


;***********************************************************************
;
;	NSPOFL 0.0 10-MAY-76 -- FLUSH OUTPUT MESSAGE	  
;
;***********************************************************************


NSPOFL:					;FLUSH OUTPUT MESSAGE

; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

	MOV	(SP)+,R0		;RESTORE START OF NCL MESSAGE
	JSR	PC,NCLODN		;GIVE THE MESSAGE BACK TO NCL
	MOV	(SP)+,R2		;RESTORE R2
.IF NE,FT.CHK
	CMP	R2,#SOH			;IT BETTER BE SOH
	BEQ	10$			;YES, BRANCH
	TRAP				;NO, HALT
10$:					;HERE WHEN R2 CONTENTS OK
.ENDC; NE,FT.CHK
	MOV	(SP)+,R4		;RESTORE R4
	MOV	(SP)+,R5		;RESTORE R5
	ADD	#4,SP			;SKIP OVER DDCMP RETURN, AND #JRSTR
	MOV	(SP)+,J			;RESTORE J
	RTS	PC			;GO BACK TO NCL

	.SBTTL	         1.4.3  NSPODM 0.0 10-MAY-76 -- OUTPUT A DATA MESSAGE


;***********************************************************************
;
;	NSPODM 0.0 10-MAY-76 -- OUTPUT A DATA MESSAGE	  
;
;***********************************************************************


; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

NSPODM:					;WRITE OUT A DATA MESSAGE
	JSR	PC,NSPFDL		;FIND DLA (RETURNS LINK ENTRY POINTER IN R1)
	BEQ	NSPBAD			;DATA MESSAGE WHEN NO LINK?
	MOVB	LE.NSP(R1),NSPDST	;SAVE DESTINATION LINK ADDRESS
	MOVB	LE.CON(R1),NSPSRC	;SAVE SOURCE LINK ADDRESS
	MOV	LB.MML(J),NSPMML	;GET MAX MESSAGE LENGTH
	JSR	PC,NSPFST		;SET STRIP BIT IN NSPFLG
	JSR	PC,NSPBMG		;START OUTPUT MESSAGE
	CLR	R0			;MAKE MSGFLG FIELD
	BITB	#NCFINT,NSPNCT		;WAS NCL MESSAGE AN INTERRUPT MESSAGE?
	BEQ	10$			;NO, CONTINUE
	BIS	#NSPINT,R0		;SET INTERRUPT BIT IN MSFLG
	MOV	#11.,NSPMML		;SHORTEN MAX DATA LENGTH
10$:					;MSGFLG IN R0
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	NSPDST,R0		;GET DESTINATION LINK ADDRESS
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	NSPSRC,R0		;GET SOURCE LINK ADDRESS
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	CLR	NSPCNT			;CLEAR COUNTER (FOR STRIPPING)
20$:					;DATA COPYING LOOP
	TST	R2			;ANY MORE DATA IN NCL MESSAGE?
	BEQ	NSPOQU			;NO, BRANCH WHEN DONE
	BITB	#NSP.ST,NSPFLG		;ARE WE STRIPPING COUNT AND TYPE FIELDS?
	BEQ	25$			;NO, CONTINUE
	TST	NSPCNT			;CHECK COUNT OF SUB-MESSAGE
	BNE	25$			;IF MORE TO GO, BRANCH
	JSR	PC,GETEXN		;GET NEXT COUNT FIELD
	DEC	R0			;SUBTRACT ONE FOR TYPE BYTE
	MOV	R0,NSPCNT		;SAVE COUNT
	JSR	PC,GETBYT		;THROW AWAY TYPE
	BR	20$			;AND TRY AGAIN (IN CASE NO DATA)
25$:					;HERE FOR REAL DATA BYTE
	CMP	R4,NSPMML		;HAVE WE PUT ENOUGH INTO NSP MESSAGE YET?
	BHIS	NSPOVF			;YES, HANDLE MESSAGE OVERFLOW
	JSR	PC,GETBYT		;GET DATA BYTE
	DEC	NSPCNT			;DECREMENT SUB-MESSAGE BYTE COUNTER
	JSR	PC,NSPPBY		;STORE BYTE IN NSP MESSAGE
	BCS	NSPOFF			;IF NO MORE ROOM, BRANCH
	BR	20$			;CONTINUE LOOPING ON DATA

	.SBTTL	         1.4.4  NSPOQU 0.0 12-MAY-76 -- QUEUE OUTPUT TO DDCMP


;***********************************************************************
;
;	NSPOQU 0.0 12-MAY-76 -- QUEUE OUTPUT TO DDCMP	  
;
;***********************************************************************


NSPOQU:					;HERE WHEN DONE COPYING DATA INTO NSP MESSAGE
	MOV	NSPMSG,R0		;POINT TO BEGINNING OF MESSAGE
	MOV	R4,CN.LEN(R0)		;STORE LENGTH IN 1ST CHUNK
	MOV	(SP)+,R0		;GET NCL MESSAGE START BACK
	JSR	PC,NCLODN		;GIVE IT BACK TO NCL (HE WILL THROW AWAY UNLESS FROM SEQUENTIAL NODE)
	MOV	(SP)+,R2		;RESTORE R2
.IF NE,FT.CHK
	CMP	#SOH,R2			;MAKE SURE IT'S GOOD
	BEQ	36$			;OK, CONTINUE
	TRAP				;PROGRAMMING ERROR
36$:					;HERE AFTER R2 CHECKED
.ENDC; NE,FT.CHK
	MOV	(SP)+,R4		;RESTORE R4
	MOV	(SP)+,R5		;RESTORE R5
	MOV	NSPMSG,R0		;POINT TO NEW MESSAGE
	RTS	PC			;RETURN TO DDCMP
NSPOVF:					;HERE WHEN MESSAGE OVERFLOWS NSP MAX DATA LENGTH
	TRAP

NSPOFF:					;HERE WHEN WE RUN OUT OF CHUNKS BUILDING MESSAGE
	MOV	NSPMSG,R0		;GET START OF MESSAGE
	JSR	PC,FRECKS		;FREE THE CHUNKS
	JMP	NSPORT			;GET MESSAGE RETRANSMITTED LATER

	.SBTTL	         1.4.5  NSPOCM 0.0 17-MAY-76 -- OUTPUT A CONTROL MESSAGE


;***********************************************************************
;
;	NSPOCM 0.0 17-MAY-76 -- OUTPUT A CONTROL MESSAGE	  
;
;***********************************************************************


NSPOCM:					;SEND A CONTROL MESSAGE TO NSP
; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

;  REGISTERS:
;
;	R2	CONTAINS COUNT FOR NCL MESSAGE
;	R3	CONTAINS BYTE POINTER FOR NCL MESSAGE (AFTER DLA)
;	J	CONTAINS LINE BLOCK ADDRESS ON ENTRY
;	SB	CONTAINS SCB FOR DCP ON ENTRY
;
;  USAGE
;
;	R1	POINTER TO LINK ENTRY
;	R4	COUNT FOR OUTPUT MESSAGE
;	R5	BYTE POINTER FOR OUTPUT MESSAGE
	JSR	PC,GETEXN		;GET COUNT
	DEC	R0			;SUBTRACT ONE FOR TYPE
	MOV	R0,NSPCNT		;SAVE IT FOR LATER
	JSR	PC,GETBYT		;GET TYPE
	CMP	R0,#1			;CONNECT?
	BEQ	NSPOCN			;YES, SEND CONNECT
	CMP	R0,#2			;DISCONNECT?
	BNE	.+6			;SKIP AROUND JMP
	JMP	NSPODC			;SEND DISCONNECT MESSAGE OR DUMMY DATA
	CMP	R0,#4			;REQUEST CONFIGURATION?
	BNE	10$			;NO, CONTINUE LOOKING
	BIS	#NS.CNF,LB.NSS(J)	;YES, SET NEED TO SEND CONFIG BIT
	JSR	PC,NSPQ			;WAKE NSP LOW LEVEL
	BR	20$			;AND FLUSH MESSAGE
10$:					;HERE IF NOT REQUEST CONFIGURATION
	CMP	R0,#6			;DATA REQUEST?
	BNE	20$			;SKIP AROUND JUMP
	JMP	NSPOLS			;SEND LINK STATUS MESSAGE
20$:					;HERE TO SEE IF NEIGHBORS MESSAGE
	CMP	R0,#3			;IS IT NEIGHBORS?
	BNE	30$			;NO, FLUSH IT
22$:					;YES, HAVE TO CHECK IF OUR BUDDY DISAPPEARED
	TST	R2			;ANY MORE LEFT IN MESSAGE?
	BEQ	25$			;NO, HE WENT AWAY
	JSR	PC,GETEXN		;GET NODE NUMBER
	CMPB	R0,LB.DNA(J)		;IS IT OUR FRIEND?
	BEQ	30$			;YES, FLUSH REST OF MESSAGE
	JSR	PC,GETBYT		;GET LINK LVL TO THROW AWAY
	BR	22$			;KEEP LOOKING
25$:					;HERE WHEN OUR PARTNER HAS DISAPPEARED
	TST	LB.LCT(J)		;ANY LINKS?
	BEQ	30$			;NO, DOESN'T MATTER
	BIS	#LS..ST,@J		;YES, RESTART LINE SO HE KNOWS
;HERE IF A CONTROL TYPE SENT WHICH SHOULD BE IGNORED (LIKE CONFIGURATION)
30$:					;FLUSH MESSAGE
	JMP	NSPOFL			;FLUSH MESSAGE

	.SBTTL	         1.4.6  NSPOCN 0.0 12-MAY-76 -- SEND A CONNECT MESSAGE


;***********************************************************************
;
;	NSPOCN 0.0 12-MAY-76 -- SEND A CONNECT MESSAGE	  
;
;***********************************************************************


NSPOCN:					;SEND A CONNECT MESSAGE
; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

;  REGISTERS:
;
;	R2	CONTAINS COUNT FOR NCL MESSAGE
;	R3	CONTAINS BYTE POINTER FOR NCL MESSAGE (AFTER DLA)
;	J	CONTAINS LINE BLOCK ADDRESS ON ENTRY
;	SB	CONTAINS SCB FOR DCP ON ENTRY
;
;  USAGE
;
;	R1	POINTER TO LINK ENTRY
;	R4	COUNT FOR OUTPUT MESSAGE
;	R5	BYTE POINTER FOR OUTPUT MESSAGE

	JSR	PC,NSPBMG		;START A MESSAGE
	MOV	#NSPCM,R0		;MSGFLG WITH CM BIT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#1,R0			;TYPE FOR CONNECT MESSAGE
	JSR	PC,NSPPBY		;STORE IN MESSAGE
	JSR	PC,GETEXN		;GET DLA
	TST	R0			;CHECK FOR ZERO (I.E. INITIATE)
	BNE	NSPCNC			;NO, MUST BE CONFIRM; BRANCH
	JSR	PC,GETEXN		;GET SLA
	JSR	PC,NSPCLE		;CREATE A LINK ENTRY (R1 CONTAINS ADDRESS)
	MOV	R0,LE.NCL(R1)		;PUT NCL ADDRESS INTO IT
	JSR	PC,NSPBCO		;BUILD ONE-BYTE LINK FOR NSP
	CLR	R0			;SUB-TYPE (INITIATE)
	JSR	PC,NSPPBY		;STORE IN MESSAGE
	MOVB	LE.NSP(R1),R0		;GET DESTADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.CON(R1),R0		;GET SRCADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,GETBYT		;GET OBJECT TYPE
	CMP	#11,R0			;TASK?
	BEQ	40$			;YES, GO COPY IN NAME
	MOV	R0,-(SP)		;SAVE OBJECT TYPE FOR LATER
	CLR	R0			;OBJECT TYPE FOR TASK
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	BIS	#LES.DV,LE.STS(R1)	;SET DEVICE BIT IN LINK ENTRY
	MOV	#'O!200,R0		;PUT TASK NAME OBJOON INTO MESSAGE
					;WHERE "OO" IS OBJECT TYPE, "N" IS NUMBER
	JSR	PC,NSPPBY		;PUT "O" INTO MESSAGE
	MOV	#'B!200,R0		;GET "B"
	JSR	PC,NSPPBY		;PUT "B" INTO MESSAGE
	MOV	#'J!200,R0		;GET "J"
	JSR	PC,NSPPBY		;PUT "J" INTO MESSAGE
	MOV	(SP),R0			;GET OBJECT TYPE
	ROR	R0			;SHIFT
	ROR	R0			; SECOND DIGIT
	ROR	R0			;  TO CORRECT PLACE
	BIC	#177770,R0		;CLEAR EXTRA BITS
	ADD	#260,R0		;MAKE INTO EXTENDED ^^ASCII\\ NUMBER
	JSR	PC,NSPPBY		;PUT 1ST DIGIT OF OBJECT TYPE INTO NAME
	MOV	(SP)+,R0		;GET OBJECT TYPE BACK
	BIC	#177770,R0		;CLEAR EXTRANEOUS BITS
	ADD	#260,R0			;MAKE INTO NUMBER
	JSR	PC,NSPPBY		;STORE IN MESSAGE
	JSR	PC,GETBYT		;GET UNIT NUMBER
	BIC	#177770,R0		;CLEAR EXTRA
	ADD	#60,R0			;MAKE INTO NUMBER
	JSR	PC,NSPPBY		;PUT UNIT NUMBER INTO MESSAGE
	CLR	R0			;ZERO 
	JSR	PC,NSPPBY		; GROUP
	JSR	PC,NSPPBY		;  AND USER
	BR	43$			;CONTINUE

40$:					;HERE WHEN DESTINATION IS TASK
	JSR	PC,NSPEXC		;COPY TASK NAME AND PUT 0 GROUP AND USER ON
43$:					;HERE FOR SECOND NAME
	JSR	PC,GETBYT		;GET SOURCE OBJECT TYPE (TO THROW AWAY)
	JSR	PC,NSPEXC		;COPY REST OF SOURCE
	BIT	#LES.DV,LE.STS(R1)	;WAS THIS A DEVICE?
	BEQ	47$			;NO, DON'T PUT OPTIONAL DATA IN
45$:					;HERE TO PROCESS MML AND FEA FIELDS
	JSR	PC,GETEXN		;PROCESS MML FIELD (TO SKIP OVER IT)
46$:					;LOOP FOR COPYING FEATURES
	TST	R2			;ANY MORE LEFT IN MESSAGE?
	BEQ	47$			;NO, STOP
	JSR	PC,GETBYT		;GET NEXT BYTE
	JSR	PC,NSPPBY		;PUT INTO OPTIONAL DATA
	BR	46$			;CONTINUE LOOKING
47$:					;HERE WHEN DONE BUILDING NSP CONNECT
	JMP	NSPOQU			;QUEUE IT TO DDCMP

NSPCNC:					;HERE TO HANDLE CONNECT CONFIRM
	JSR	PC,NSPFDL		;FIND LINK ENTRY FROM DLA
	JSR	PC,GETEXN		;GET SLA
	MOV	R0,LE.NCL(R1)		;SAVE IN LINK ENTRY TABLE
	JSR	PC,NSPBCO		;MAKE A UNIQUE ADDRESS TO USE FOR NSP
	MOV	#1,R0			;CODE FOR CONFIRM
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.NSP(R1),R0		;DESTADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.CON(R1),R0		;SRCADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,GETBYT		;GET OBJECT TYPE
	CMP	R0,#11			;SHOULD BE TASK
	BEQ	55$			;YES, CONTINUE
	TRAP				;BAD!!!!
55$:					;HERE IF OBJECT TYPE OK
	JSR	PC,NSPEXC		;COPY PROCESS NAME
	JSR	PC,GETBYT		;GET SOURCE OBJECT TYPE
	CMP	R0,#11			;IS IT TASK?
	BNE	56$			;NO, HANDLE DEVICE CASE
	JSR	PC,NSPEXC		;YES, COPY IT
	BR	57$			;CONTINUE
56$:					;HERE TO HANDLE NON-TASK SRCNAME
	JSR	PC,NSPPBY		;PUT OBJECT TYPE
	JSR	PC,GETBYT		;GET UNIT
	JSR	PC,NSPPBY		;PUT IT INTO MESSAGE AS WELL
57$:					;HERE WHEN DONE WITH CONNECT CONFIRM
	JMP	NSPOQU			;GO QUEUE IT TO DDCMP

	.SBTTL	         1.4.7  NSPODC 0.0 12-MAY-76 -- SEND DISCONNECT


;***********************************************************************
;
;	NSPODC 0.0 12-MAY-76 -- SEND DISCONNECT	  
;
;***********************************************************************


NSPODC:					;
; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

;  REGISTERS:
;
;	R2	CONTAINS COUNT FOR NCL MESSAGE
;	R3	CONTAINS BYTE POINTER FOR NCL MESSAGE (AFTER DLA)
;	J	CONTAINS LINE BLOCK ADDRESS ON ENTRY
;	SB	CONTAINS SCB FOR DCP ON ENTRY
;
;  USAGE
;
;	R1	POINTER TO LINK ENTRY
;	R4	COUNT FOR OUTPUT MESSAGE
;	R5	BYTE POINTER FOR OUTPUT MESSAGE

	JSR	PC,NSPBMG		;START MESSAGE
	JSR	PC,GETEXN		;GET DLA
	JSR	PC,NSPFDL		;FIND LINK ENTRY FOR IT
	BITB	#LES.DV,LE.STS(R1)	;IS THIS A DEVICE?
	BNE	NSPODD			;YES, DO SPECIAL HANDLING
NSPOD1:					;START OF DISCONNECT MESSAGE
	MOV	#NSPCM,R0		;MSGFLG WITH CM BIT ON
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#2,R0			;TYPE FOR DISCONNECT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,GETEXN		;GET SLA
	MOV	LE.NCL(R1),R0		;
	MOV	#4,-(SP)		;ASSUME INITIATE SUB-TYPE
	TST	R0			;WAS SLA 0?
	BNE	12$			;NO, OUR ASSUMPTION WAS GOOD
	MOV	#33,(SP)		;ASSUME REJECT SUBTYPE
	BR	13$			;AND CONTINUE
12$:					;HERE TO TEST FOR POSSIBLILITY OF DISCONNECT CONFIRM
	BITB	#LES.WD,LE.STS(R1)	;WERE WE WAITING FOR DISCONNECT CONFIRM
	BEQ	13$			;NO, WE WERE RIGHT BEFORE
	MOV	#5,(SP)			;YES, SO IT SHOULD BE DISCONNECT CONFIRM
13$:					;HERE WHEN WE HAVE DECIDED TYPE OF DISCONNECT
	MOVB	(SP),R0			;GET SUBTYPE AND REASON
	JSR	PC,NSPPBY		;STORE IN MESSAGE
	JSR	PC,GETBYT		;GET REASON (THROW IT AWAY)
	MOVB	LE.NSP(R1),R0		;GET DESTADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.CON(R1),R0		;GET SRCADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	CMP	(SP)+,#4		;WAS IT INITIATE?
	BEQ	15$			;YES, BRANCH
	JSR	PC,NSPDLE		;NO, DELETE LINK ENTRY
14$:					;HERE TO QUEUE MESSAGE OUT
	JMP	NSPOQU			;SEND IT TO DDCMP
15$:					;HERE WHEN DISCONNECT INITIATE
	BISB	#LES.WD,LE.STS(R1)	;SET WAITING FOR DISCONNECT CONFIRM BIT
	BR	14$			;GO QUEUE MESSAGE

	.SBTTL	         1.4.10  NSPODD 0.0 02-JUN-76 -- OUTPUT DUMMY DISCONNECT


;***********************************************************************
;
;	NSPODD 0.0 02-JUN-76 -- OUTPUT DUMMY DISCONNECT	  
;
;***********************************************************************


NSPODD:					;FOR DEVICES, SEND DATA MESSAGE WITH NO DATA INSTEAD OF DISCONNECT
; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

	TST	LE.NCL(R1)		;IS SOURCE NOT DEFINED?
	BEQ	NSPOD1			;YES, SEND REGULAR DISCONNECT REJECT
	BISB	#LES.WD,LE.STS(R1)	;SHOW WE ARE WAITING
	MOV	#NSPINT,R0		;MSGFLG FOR INTERRUPT DATA MESSAGE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.NSP(R1),R0		;DESTADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.CON(R1),R0		;SRCADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,NSPFST		;SET STRIP BIT IF STRIPPING DESIRED
	BITB	#NSP.ST,NSPFLG		;ARE WE STRIPPING?
	BNE	10$			;YES, LEAVE OFF COUNT AND TYPE
	MOV	#1,R0			;COUNT = 1
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#2,R0			;TYPE = DATA WITH EOR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
10$:					;HERE WHEN DONE CONSTRUCTING DUMMY MESSAGE
	JMP	NSPOQU			;SEND MESSAGE OUT

	.SBTTL	         1.4.11  NSPOLS 0.0 12-MAY-76 -- SEND LINK STATUS


;***********************************************************************
;
;	NSPOLS 0.0 12-MAY-76 -- SEND LINK STATUS	  
;
;***********************************************************************


NSPOLS:					;SEND A LINK STATUS FOR DATA REQUESTS
; STACK LOOKS LIKE:
;	0	R0
;	2	R2
;	4	R4
;	6	R5
;	10	DDQDAT + ? (DDCMP RETURN)
;	12	#JRSTR
;	14	J VALUE
;	16	NCR.10 + ? (NCL RETURN)
;	20	SB VALUE

;  REGISTERS:
;
;	R2	CONTAINS COUNT FOR NCL MESSAGE
;	R3	CONTAINS BYTE POINTER FOR NCL MESSAGE (AFTER DLA)
;	J	CONTAINS LINE BLOCK ADDRESS ON ENTRY
;	SB	CONTAINS SCB FOR DCP ON ENTRY
;
;  USAGE
;
;	R1	POINTER TO LINK ENTRY
;	R4	COUNT FOR OUTPUT MESSAGE
;	R5	BYTE POINTER FOR OUTPUT MESSAGE

	JSR	PC,GETEXN		;GET DLA
	JSR	PC,NSPFDL		;FIND LINK ENTRY
	JSR	PC,GETEXN		;GET DATA REQUEST COUNT
	MOV	R0,-(SP)		;SAVE DATA REQUEST COUNT
	JSR	PC,NSPBMG		;START MESSAGE
	MOV	#NSPCM,R0			;MSGFLG WITH CM BIT ON
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#3,R0			;TYPE IS LINK STATUS
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.NSP(R1),R0		;DESTADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.CON(R1),R0		;SRCADDR
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	(SP)+,R0		;GET REQUEST COUNT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JMP	NSPOQU			;QUEUE MESSAGE OUT

	.SBTTL	    1.5  NSPINP 0.0 15-MAY-76 -- NSP INPUT ROUTINES


;***********************************************************************
;
;	NSPINP 0.0 15-MAY-76 -- NSP INPUT ROUTINES	  
;
;***********************************************************************


NSPINP:					;HERE WHEN WE RECEIVE NSP MESSAGE
; REGISTERS
;
;	R0	POINTER TO FIRST CHUNK OF MESSAGE
;	J	POINTER TO LINE BLOCK FOR DCP
; STACK LOOKS LIKE:
;	0	RETURN TO DDCMP
	MOV	J,NSPLB			;SAVE POINTER TO LINE BLOCK
	MOV	R0,-(SP)		;SAVE START OF MESSAGE
; STACK LOOKS LIKE:
;	0	START OF MESSAGE (R0)
;	2	RETURN TO DDCMP
	MOV	CN.LEN(R0),R2		;GET LENGTH
	MOV	R0,R3			;POINT TO FIRST CHUNK
	ADD	#CN.NCT,R3		;NOW MAKE THAT FIRST DATA
	JSR	PC,NSPBMG		;START A MESSAGE
	CLRB	NSPNCT			;ZERO NCT
	JSR	PC,GETBYT		;GET NCT
	BIT	#NSPCM,R0		;WAS THIS A CONTROL MESSAGE?
	BNE	NSPICM			;YES, HANDLE CONTROL MESSAGE
	BIT	#NSPINT,R0		;WAS THIS INTERRUPT MESSAGE?
	BEQ	10$			;NO, CONTINUE
	BISB	#NCFINT,NSPNCT		;YES, SET INTERRUPT BIT IN NCT
10$:					;
	JSR	PC,NSPBNC		;PUT NCL HEADER IN MESSAGE
	JSR	PC,GETEXN		;GET DESTADDR
	JSR	PC,NSPFDA		;FIND IT
	JSR	PC,GETEXN		;GET SR(CADDR
	CMPB	LE.NSP(R1),R0		;COMPARE WITH LINK ENTRY
	BEQ	15$			;BRANCH IF EQUAL
	TRAP				;ERROR SOMEWHERE!
15$:					;HERE TO PUT DLA INTO NCL MESSAGE
	MOV	LE.NCL(R1),R0		;GET DLA
	JSR	PC,NSPPEX		;PUT INTO MESSAGE
	JSR	PC,NSPFST		;SET STRIP BIT
	BIT	#NSP.ST,NSPFLG		;ARE WE STRIPPING?
	BEQ	20$			;NO, JUST COPY DATA
	MOV	R2,R0			;GET LENGTH
	INC	R0			;AUGMENT FOR TYPE
	JSR	PC,NSPPEX		;STORE COUNT
	MOV	#2,R0			;TYPE IS DATA  [mco 9695]
	JSR	PC,NSPPBY		;STORE TYPE
20$:					;HERE TO COPY DATA BYTES
	TST	R2			;ANY MORE TO COPY?
	BEQ	30$			;NO, FINISH UP
	JSR	PC,GETBYT		;GET NEXT BYTE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	BR	20$			;KEEP LOOKING FOR DATA
30$:					;HERE TO PUT LENGTH INTO MESSAGE
	MOV	NSPMSG,R0			;PUT TO FIRST CHUNK OF NCL MESSAGE
	MOV	R4,CN.LEN(R0)		;PUT COUNT INTO APPROPRIATE PLACE
	BR	NSPNCL
NSPNCL:					;HERE WHEN DONE BUILDING DATA MESSAGE
	MOV	(SP)+,R0		;GET START OF NCL MESSAGE
	JSR	PC,FRECKS		;FREE ITS CHUNKS
	MOV	NSPMSG,R0		;GET START OF NCL MESSAGE
	PJMP	NCLIN1			;PASS IT TO NCL  [mco 9696]

	.SBTTL	         1.5.1  NSPICM 0.0 15-MAY-76 -- RECEIVED NSP CONTROL MSG


;***********************************************************************
;
;	NSPICM 0.0 15-MAY-76 -- RECEIVED NSP CONTROL MSG	  
;
;***********************************************************************


NSPICM:					;HERE TO HANDLE NSP CONTROL MESSAGE
	JSR	PC,GETBYT		;GET MESSAGE TYPE
	CMP	R0,#4			;IS IT BIGGER THAN MAX?
	BGT	20$			;YES, ERROR BRANCH
	ASL	R0			;SHIFT LEFT FOR DISPATCH
	JMP	@10$(R0)		;GO TO RIGHT ROUTINE
10$:					;DISPATCH TABLE FOR MESSAGE TYPES
	.WORD	20$			;0 SHOULDN'T HAPPEN
	.WORD	NSPICN			;WHERE TO GO FOR CONNECT
	.WORD	NSPIDC			;DISCONNECT
	.WORD	NSPILS			;LINK STATUS
	.WORD	NSPIER			;ERROR
20$:					;HERE WHEN ILLEGAL MESSAGE TYPE IS FOUND
	TRAP				;BUT IT CAN'T BE ANYTHING ELSE!

	.SBTTL	         1.5.2  NSPICN 0.0 15-MAY-76 -- NSP CONNECT MESSAGE


;***********************************************************************
;
;	NSPICN 0.0 15-MAY-76 -- NSP CONNECT MESSAGE	  
;
;***********************************************************************


NSPICN:					;HERE TO PROCESS CONNECT MESSAGE
	JSR	PC,GETBYT		;GET SUB-TYPE
	CMP	R0,#2			;IS IT GREATER THAN MAX?
	BGT	20$			;YES, BRANCH ON ERROR
	ASL	R0			;SHIFT FOR DISPATCH
	JMP	@10$(R0)		;GO TO PROPER ROUTINE
10$:					;DISPATCH TABLE FOR CONNECT SUB-TYPES
	.WORD	NSPICI			;CONNECT INITIATE
	.WORD	NSPICC			;CONNECT CONFIRM
	.WORD	NSPLMB			;CONNECT REJECT IS LIKE DISCONNECT REJECT
20$:					;HERE IF BAD CONNECT SUB-TYPE
	TRAP				;WHAT ELSE?

	.SBTTL	         1.5.3  NSPICI 0.0 15-MAY-76 -- NSP CONNECT INITIATE


;***********************************************************************
;
;	NSPICI 0.0 15-MAY-76 -- NSP CONNECT INITIATE	  
;
;***********************************************************************



NSPICI:					;HERE ON CONNECT INITIATE
	JSR	PC,GETBYT		;GET DESTADDR
	TST	R0			;CHECK RESULTS
	BEQ	5$			;BETTER NOT BE ANY
	TRAP				;BAD CONNECT INITIATE MESSAGE
5$:					;HERE IF DESTADDR OK
	JSR	PC,GETBYT		;GET SRCADDR
	JSR	PC,NSPFDA		;SEARCH FOR IT IN LINK TABLE
	BEQ	10$			;BETTER NOT BE THERE!
	TRAP				;WE HAVE THIS LINK ALREADY.
10$:					;HERE IF SRCADDR IS KOSHER
	JSR	PC,NSPCLE		;CREATE A LINK TABLE ENTRY
	MOVB	R0,LE.NSP(R1)		;STORE NSP LINK ADDRESS
	JSR	PC,NSPBNC		;PUT NCL HEADER INTO MESSAGE
	JSR	PC,NSPPBY		;PUT 0 DLA
	MOV	R5,NSPCNT		;SAVE POINTER TO COUNT
	JSR	PC,NSPPEX		;2-BYTE COUNT (TO BE FILLED IN LATER)
	MOV	R4,NSPCVL		;SAVE CURRENT COUNT VALUE
	MOV	#1,R0			;CONNECT TYPE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	CLR	R0			;DLA IS ZERO
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
NSPIC1:					;COMMON CODE FOR INITIATE AND CONFIRM
	MOVB	LE.NSP(R1),R0		;GET SLA
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,GETBYT		;GET DESTINATION OBJECT TYPE
	TST	R0			;SEE IF IT IS TASK
	BNE	20$			;NO, PUT IT INTO MESSAGE
	MOV	#11,R0			;YES, PUT TASK NCL OBJECT TYPE
20$:					;PUT DEST OBJ TYPE INTO MESSAGE
	JSR	PC,NSPPBY		;PUT DEST OBJ TYPE INTO MESSAGE
30$:	JSR	PC,GETBYT		;GET PID BYTE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	BIT	#200,R0			;WAS THAT LAST?
	BNE	30$			;NO, CONTINUE
	JSR	PC,GETEXN		;THROW AWAY GROUP
	JSR	PC,GETEXN		;AND USER
	JSR	PC,GETBYT		;GET SOURCE OBJECT TYPE
	TST	R0			;CHECK IF TASK
	BNE	40$			;NO, CONTINUE
	BIT	#LES.DV,LE.STS(R1)	;IS THIS DEVICE ? (CONFIRM ONLY)
	BEQ	35$			;NO, PROCEED NORMALLY
	JSR	PC,GETBYT		;YES, GET "O"
	JSR	PC,GETBYT		;GET "B"
	JSR	PC,GETBYT		;GET "J"
	JSR	PC,GETBYT		;GET HIGH ORDER DIGIT OF OBJECT TYPE
	BIC	#177770,R0		;CLEAR EXTRA BITS
	ROL	R0			;SHIFT
	ROL	R0			; INTO CORRECT
	ROL	R0			;  POSITION
	MOV	R0,-(SP)		;SAVE FOR LATER
	JSR	PC,GETBYT		;GET LOW ORDER DIGIT OF OBJECT TYPE
	BIC	#177770,R0		;CLEAR EXTRA BITS
	ADD	(SP)+,R0		;MAKE OBJECT TYP
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,GETBYT		;GET UNIT NUMBER
	BIC	#177770,R0		;CLEAR EXTRA BITS
	JSR	PC,NSPPBY		;PUT UNIT NUMBER INTO MESSAGE
	BR	42$			;GO THROW AWAY GROUP AND USER
35$:					;HERE IF IT REALLY WAS A TASK
	MOV	#11,R0			;NCL OBJECT TYPE FOR TASK
40$:					;HERE IF SOURCE OBJ TYPE IS GOOD
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
41$:					;LOOP TO COPY PID EXTENSIBLE STRING
	JSR	PC,GETBYT		;GET NEXT BYTE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	BIT	#200,R0			;WAS THAT LAST?
	BNE	41$			;NO, KEEP GOING
42$:					;HERE TO FLUSH GROUP AND USER
	JSR	PC,GETEXN		;YES, GET GROUP
	JSR	PC,GETEXN		;AND USER (FOR WASTEBASKET)
	MOV	J,-(SP)			;SAVE J
	MOV	NSPLB,J			;GET LINE BLOCK ADDRESS
	MOV	LB.MML(J),R0		;GET MAXIMUM MESSAGE LENGTH FOR LINE
	MOV	(SP)+,J			;RESTORE J
	JSR	PC,NSPPEX		;PUT INTO MESSAGE
50$:					;LOOP PUTTING IN OPTIONAL DATA
	TST	R2			;ANY MORE IN SOURCE MESSAGE
	BEQ	NSPICX			;NO, EXIT
	JSR	PC,GETBYT		;GET NEXT BYTE
	JSR	PC,NSPPBY		;COPY INTO TARGET MESSAGE
	BR	50$			;AND KEEP LOOKING
NSPICX:					;HERE WHEN DONE BUILDING NCL MESSAGE
	MOV	NSPMSG,R0		;PUT TO START OF MESSAGE
	MOV	R4,CN.LEN(R0)		;PUT COUNT INTO CHUNK
	SUB	NSPCVL,R4		;GET COUNT FOR NCL
	MOV	R4,R0			;COPY INTO CORRECT REGISTER
	MOV	NSPCNT,R5		;PUT POINTER BACK
	JSR	PC,NSPPEX		;2-BYTE COUNT INTO MESSAGE
	JMP	NSPNCL			;GIVE MESSAGE TO NCL

	.SBTTL	         1.5.4  NSPICC 0.0 15-MAY-76 -- NSP CONNECT CONFIRM


;***********************************************************************
;
;	NSPICC 0.0 15-MAY-76 -- NSP CONNECT CONFIRM	  
;
;***********************************************************************


NSPICC:					;HERE WHEN WE RECEIVE AN NSP CONNECT CONFIRM
	JSR	PC,GETBYT		;GET DESTADDR
	BEQ	10$			;ERROR IF ZERO
	JSR	PC,NSPFDA		;FIND LINK IN TABLE
	BEQ	10$			;ERROR IF NOT THERE
	JSR	PC,GETBYT		;GET SRCADDR
	MOVB	R0,LE.NSP(R1)		;SAVE IT IN LINK TABLE
	CLRB	NSPNCT			;INITIALIZE NCT
	JSR	PC,NSPBNC		;START MESSAGE
	JSR	PC,NSPPBY		;DLA OF 0
	MOV	R5,NSPCNT		;SAVE POINTER FOR COUNT
	JSR	PC,NSPPEX		;PUT A ZERO COUNT FOR NOW
	MOV	R4,NSPCVL		;SAVE COUNT ALSO
	MOV	#1,R0			;CONNECT TYPE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	LE.NCL(R1),R0		;GET DLA
	JSR	PC,NSPPEX		;PUT INTO MESSAGE
	BIS	#LES.SL,LE.STS(R1)	;INDICATE WE NEED TO SEND LINK STATUS
	JSR	PC,NSPQ			;QUEUE LINE BLOCK
	JMP	NSPIC1			;AND CONTINUE
10$:					;HERE ON ERROR
	TRAP				;PROTOCOL ERROR

	.SBTTL	         1.5.5  NSPIDC 0.0 17-MAY-76 -- NSP DISCONNECT


;***********************************************************************
;
;	NSPIDC 0.0 17-MAY-76 -- NSP DISCONNECT	  
;
;***********************************************************************


NSPIDC:					;HERE WHEN WE RECEIVE NSP DISCONNECT
	JSR	PC,GETBYT		;GET SUB-TYPE
	MOVB	R0,NSPREA		;SAVE FOR REASON
	JSR	PC,GETBYT		;GET DESTADDR
	MOVB	R0,NSPDST		;SAVE IT
	JSR	PC,NSPFDA		;FIND LINK TABLE ENTRY
	BNE	9$			;IF THERE, CONTINUE
	JMP	NSPIBD			;ELSE, FLUSH MESSAGE
9$:					;HERE WHEN LINK TABLE ENTRY FOUND
	JSR	PC,GETBYT		;GET SRCADDR
	MOVB	R0,NSPSRC		;SAVE FOR LATER
	MOVB	NSPREA,R0		;GET BACK SUB-TYPE AND REASON
	BIC	#177770,R0		;MASK OUT REASON
	SUB	#3,R0			;MAKE ZERO ORIGIN
	BMI	20$			;IF NEGATIVE, CODE WAS TOO LOW
	CMP	R0,#3			;SEE IF TOO HIGH
	BGT	20$			;YES, ERROR
	ASL	R0			;SHIFT FOR DISPATCH
	JMP	@10$(R0)		;DISPATCH ON TYPE TO PROPER ROUTINE
10$:					;DISPATCH TABLE FOR NSP DISCONNECT TYPES
	.WORD	NSPDCR			;DISCONNECT REJECT
	.WORD	NSPDCI			;DISCONNECT INITIATE
	.WORD	NSPDCC			;DISCONNECT CONFIRM
	.WORD	NSPDCI			;DISCONNECT ABORT (HANDLED EXACLTLY LIKE INITIATE)
20$:					;HERE IF BAD DISCONNECT TYPE
	TRAP				;BETTER STOP

	.SBTTL	         1.5.6  NSPDCR 0.0 17-MAY-76 -- NSP DISCONNECT REJECT


;***********************************************************************
;
;	NSPDCR 0.0 17-MAY-76 -- NSP DISCONNECT REJECT	  
;
;***********************************************************************


NSPLMB:	JSR	PC,GETBYT		;GET DEST ADDR
	TST	R0			;CHECK RESULTS
	BNE	10$			;BETTER HAVE DEST ADDR
	TRAP				;ERROR IF ZERO
10$:	JSR	PC,NSPFDA		;FIND LINK IN TABLE
	BNE	20$			;CHECK RESULTS
	TRAP				;ERROR IF ZERO
20$:	CLRB	NSPREA			;USE 0 ERROR CODE
NSPDCR:					;HERE WHEN WE HAVE DISCONNECT REJECT FROM NSP
	TSTB	LE.NSP(R1)		;WAS CONNECTION COMPLETED?
	BEQ	NSPDCO			;NO, BRANCH
	BISB	#LES.FL!LES.WD,LE.STS(R1);YES, WE'LL HAVE TO WAIT FOR DISCONNECT FROM NCL
NSPDCO:					;HERE AFTER DETERMINING IF CONNECTION COMPLETE
	CLRB	NSPNCT			;ZERO NCT
	JSR	PC,NSPBNC		;START MESSAGE
	JSR	PC,NSPPBY		;PUT IN 0 DLA
	MOV	R5,NSPCNT		;SAVE POINTER
	JSR	PC,NSPPEX		;PUT A ZERO COUNT FOR NOW
	MOV	R4,NSPCVL		;SAVE COUNT
	MOV	#2,R0			;DISCONNECT TYPE = 2
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	LE.NCL(R1),R0		;DLA
	JSR	PC,NSPPEX		;PUT INTO MESSAGE
	MOVB	LE.NSP(R1),R0		;SLA
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	NSPREA,R0		;GET REASON AND SUBTYPE
	ASR	R0			;SHIFT
	ASR	R0			; OUT
	ASR	R0			;  SUB-TYPE BITS
	CLR	-(SP)			;START WITH DEFAULT 0 REASON CODE
	BITB	#LES.DV,LE.STS(R1)	;IS THIS A DEVICE CONNECTION?
;	BEQ	15$			;NO, LEAVE 0 DEFAULT
	INC	(SP)			;YES, MAKE 1 DEFAULT
15$:					;HERE AFTER DECIDING DEFAULT REASON
	CMP	R0,#3			;WAS IT NO SUCH PROCESS?
	BNE	20$			;NO, TRY NEXT
	BITB	#LES.DV,LE.STS(R1)	;IS IT A DEVICE?
	BNE	22$			;YES, USE DEFAULT
	MOV	#4,(SP)			;PUT PROCESS NOT THERE REASON CODE INTO MESSAGE
	BR	22$			;DONE
20$:					;HERE TO TRY ANOTHER CODE
	CMP	R0,#6			;WAS IT NODE SHUTTING DOWN?
	BNE	22$			;NO, PUT INTO MESSAGE
	MOV	#2,(SP)			;USE NCL TOO MANY CONNECTS TO NODE
22$:					;HERE WHEN DONE DECIDING NCL REASON
	MOV	(SP)+,R0		;GET REASON
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
30$:					;HERE TO COPY OPTIONAL DATA INTO NCL MESSAGE
	TST	R2			;ANY LEFT?
	BEQ	40$			;NO, DONE
	JSR	PC,GETBYT		;YES, GET A BYTE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	BR	30$			;AND LOOK FOR NEXT
40$:					;HERE WHEN DONE BUILDING NCL DISCONNECT
	BITB	#LES.WD,LE.STS(R1)	;ARE WE WAITING FOR A RESPONSE?
	BNE	45$			;YES, BRANCH
	JSR	PC,NSPDLE		;NO, DELETE LINK TABLE ENTRY
45$:					;HERE TO FINISH UP AND GIVE TO NCL
	JMP	NSPICX			;PUT IN COUNT AND GIVE TO NCL

	.SBTTL	         1.5.7  NSPDCI 0.0 17-MAY-76 -- NSP DISCONNECT INITIATE


;***********************************************************************
;
;	NSPDCI 0.0 17-MAY-76 -- NSP DISCONNECT INITIATE	  
;
;***********************************************************************


NSPDCI:					;HERE TO PROCESS NSP DISCONNECT INITIATE
	BITB	#LES.DV,LE.STS(R1)	;IS THIS A DEVICE?
	BNE	10$			;YES, GO HANDLE IT
5$:					;HERE WHEN NOT DEVICE LINK, OR WHEN NOT IN DUMMY DISCONNECT STATE
	TSTB	LE.NSP(R1)		;IS LINK COMPLETED?
	BNE	6$			;YES, CONTINUE
	TRAP				;PROTOCOL ERROR
6$:					;HERE ON VALID DISCONNECT INITIATE
	BISB	#LES.WD,LE.STS(R1)	;INDICATE WE SHOULD WAIT FOR CONFIRM
	BR	NSPDCO			;AND HANDLE AS DISCONNECT REJECT
10$:					;HERE IF LINK IS A DEVICE
	BITB	#LES.WD,LE.STS(R1)	;HAVE WE SENT DUMMY DISCONNECT?
	BEQ	5$			;NO, GO DO NORMAL THINGS
	BISB	#LES.SD,LE.STS(R1)	;YES, INDICATE THAT WE MUST SEND DISCONNECT CONFIRM OURSELVES
	JSR	PC,NSPQ			;WAKE UP NSP LOW LEVEL
					;IT WILL SEND IT, AND THEN DELETE LINK TABLE ENTRY
	BR	NSPDCO			;AND SEND DISCONNECT TO NCL

	.SBTTL	         1.5.10  NSPDCC 0.0 17-MAY-76 -- NSP DISCONNECT CONFIRM


;***********************************************************************
;
;	NSPDCC 0.0 17-MAY-76 -- NSP DISCONNECT CONFIRM	  
;
;***********************************************************************


NSPDCC:					;HERE ON NSP  DISCONNECT CONFRIM
	BITB	#LES.WD,LE.STS(R1)	;WERE WE WAITING FOR A CONFIRM?
	BNE	10$			;YES, CONTINUE
	TRAP				;NO, THAT IS BAD
10$:					;HERE ON VALID DISCONNECT CONFIRM
	BICB	#LES.WD,LE.STS(R1)	;CLEAR WAITING BIT (TO CAUSE LINK ENTRY TO DISAPPEAR)
	BR	NSPDCO			;AND GO TO COMMON CODE

	.SBTTL	         1.5.11  NSPILS 0.0 17-MAY-76 -- NSP LINK STATUS


;***********************************************************************
;
;	NSPILS 0.0 17-MAY-76 -- NSP LINK STATUS	  
;
;***********************************************************************


NSPILS:					;HERE ON NSP LINK STATUS
	JSR	PC,GETBYT		;GET DESTADDR
	JSR	PC,NSPFDA		;FIND A LINK TABLE ENTRY
	BEQ	NSPIBD			;NONE!! BAD MESSAGE
	JSR	PC,GETBYT		;GET SRCADDR
	CMPB	R0,LE.NSP(R1)		;BETTER BE THE SAME
	BNE	NSPIBD			;IT WASN'T, SO BRANCH
	JSR	PC,GETBYT		;GET REQUEST COUNT
	TST	R0			;CHECK FOR 0
	BNE	10$			;NON-ZERO, SO BRANCH
;HERE WHEN WE GET A NULL LINK STATUS MESSAGE
NSPIBD=.				;FLUSH INPUT AND OUTPUT MESSAGES
	MOV	NSPMSG,R0		;POINT TO BEGINNING OF NCL MESSAGE
	JSR	PC,FRECKS		;FREE IT
	MOV	(SP)+,R0		;GET START OF NSP MESSAGE
	JSR	PC,FRECKS		;FREE IT ALSO
	RTS	PC			;AND RETURN TO DDCMP

10$:					;HERE ON REAL LINK STATUS
	MOV	R0,-(SP)		;SAVE DATA REQUEST COUNT
	CLRB	NSPNCT			;ZERO  NCT
	JSR	PC,NSPBNC		;START MESSAGE
	JSR	PC,NSPPBY		;PUT IN 0 DLA
	MOV	#4,R0			;COUNT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#6,R0			;TYPE = DATA REQUEST
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	LE.NCL(R1),R0		;GET DLA
	JSR	PC,NSPPEX		;PUT INTO MESSAGE
	MOV	(SP)+,R0		;GET REQUEST COUNT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	NSPMSG,R0		;GET START OF NCL MESSAGE
	MOV	R4,CN.LEN(R0)		;PUT LENGTH INTO CHUNK
	JMP	NSPNCL			;AND SEND IT ON ITS WAY

	.SBTTL	         1.5.12  NSPIER 0.0 17-MAY-76 -- NSP ERROR MESSAGE


;***********************************************************************
;
;	NSPIER 0.0 17-MAY-76 -- NSP ERROR MESSAGE	  
;
;***********************************************************************


NSPIER:					;HERE ON NSP ERROR MESSAGE
	TRAP				;SHOULDN'T HAPPEN

	.SBTTL	    1.6  NSPODN 0.0 12-MAY-76 -- OUTPUT DONE ROUTINE


;***********************************************************************
;
;	NSPODN 0.0 12-MAY-76 -- OUTPUT DONE ROUTINE	  
;
;***********************************************************************


NSPODN:					;HERE WHEN OUTPUT DONE
	JSR	PC,FRECKS		;THROW MESSAGE AWAY
	RTS	PC			;RETURN


	.SBTTL	    1.7  NSPCHK 0.0 19-MAY-76 -- CHECK FOR ACTION


;***********************************************************************
;
;	NSPCHK 0.0 19-MAY-76 -- CHECK FOR ACTION	  
;
;***********************************************************************


NSPCHK:					;HERE TO CHECK NSP QUEUE
	CMP	NS.PTR,NS.TKR		;ANYTHING IN QUEUE?
	BEQ	NSPCHR			;NO, RETURN
	CMP	NS.TKR,#<NS.QUE+NS.SIZ>	;TAKER PAST END?
	BLO	.+10			;NO, SKIP NEXT INSTRUCTION
	MOV	#NS.QUE,NS.TKR		;POINT IT BACK TO BEGINNING
	MOV	@NS.TKR,J		;GET LINE BLOCK ADDRESS
	ADD	#2,NS.TKR		;ADVANCE TAKER
	BIC	#NS.NSQ,LB.NSS(J)	;CLEAR QUEUED BIT
	SAVE	<SB>			;SAVE POINTER TO SCB
	MOV	LB.SCB(J),SB		;GET OUR SCB
	BIT	#NS.CNF,LB.NSS(J)	;DO WE HAVE TO SEND CONFIGURATION?
	BEQ	10$			;NO, TRY INDIVIDUAL LINKS
	JSR	PC,NSPSCF		;YES, SEND CONFIGURATION
10$:					;HERE TO LOOP OVER LINKS
	MOV	LB.LKT(J),R1		;GET POINTER TO LINK TABLE
	ADD	#2,R1			;ADJUST TO FIRST LINK
	MOV	LB.LCT(J),R3		;GET COUNT OF LINKS
	BEQ	30$			;IF NONE, WE ARE DONE
15$:					;LOOP THROUGH LINKS
	BITB	#LES.SL,LE.STS(R1)	;NEED TO SEND ZERO LINK STATUS TO NSP?
	BEQ	20$			;NO, KEEP LOOKING
	JSR	PC,NSPSLS		;YES, DO IT
20$:					;CHECK OTHER ACTIVITY
	BITB	#LES.SD,LE.STS(R1)	;DO WE NEED TO SEND DISCONNECT CONFIRM TO NSP?
	BEQ	25$			;NO, ADVANCE TO NEXT LINK
	JSR	PC,NSPSDC		;YES, DO IT
25$:					;COUNT OUT LINKS
	ADD	#LE.SIZ,R1
	SOB	R3,15$			;KEEP LOOPING TILL ALL LINKS EXHAUSTED
30$:					;HERE WHEN FINISHED WITH LINE
	RESTOR	<SB>			;RESTOR REGISTER
NSPCHR:					;RETURN TO CALLER
	RTS	PC

	.SBTTL	         1.7.1  NSPSCF 0.0 17-MAY-76 -- SEND CONFIG


;***********************************************************************
;
;	NSPSCF 0.0 17-MAY-76 -- SEND CONFIG	  
;
;***********************************************************************


NSPSCF:					;SEND CONFIGURATION
	SAVE	<R1,R3,J>		;SAVE REGS
	MOV	#NSPCFS,R2		;SIZE OF CONFIGURATION SECTION IN LINE BLOCK
	CLRB	NSPNCT			;ZERO NCT
	JSR	PC,NSPBMG		;START A MESSAGE
	JSR	PC,NSPBNC		;AND PUT HEADER INTO IT
	JSR	PC,NSPPBY		;PUT DLA=0
	MOV	R5,NSPCNT		;SAVE POINTER
	JSR	PC,NSPPEX		;PUT 0 EXTENSIBLE COUNT
	MOV	R4,NSPCVL		;SAVE COUNT VALUE
	MOV	#5,R0			;TYPE = CONFIG
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	NSPLB,R3		;GET ADDRESS OF LINE BLOCK
	ADD	#LB.CNF,R3		;POINT TO CONFIG AREA
10$:					;HERE TO COPY CONFIGURATION
	TST	R2			;ANY MORE LEFT?
	BEQ	20$			;NO, DONE
	MOVB	(R3)+,R0		;GET OBJECT TYPE
	BEQ	20$			;IF ZERO, DONE
	JSR	PC,NSPPBY		;PUT OBJECT TYPE IN
	MOVB	(R3)+,R0		;GET COUNT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	CLR	R0			;ZERO PID
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	SUB	#2,R2			;WE HAVE USED UP TWO BYTES IN AREA
	BR	10$			;KEEP LOOKING
20$:					;HERE WHEN DONE COPYING CONFIG
	MOV	NSPMSG,R0		;POINT TO MESSAGE
	MOV	R4,CN.LEN(R0)		;STORE LENGTH
	MOV	NSPCNT,R5		;POINT BACK TO COUNT
	MOV	R4,R0			;GET CURRENT COUNT
	SUB	NSPCVL,R0		;SUBTRACT PREVIOUS
	JSR	PC,NSPPEX		;PUT INTO MESSAGE
	MOV	NSPMSG,R0		;GET MESSAGE POINTER
	JSR	PC,NCLIN1		;GIVE TO NCL  [mco 9696]
	RESTOR	<J>			;GET LINE BLOCK POINTER BACK
	BIC	#NS.CNF,LB.NSS(J)	;NO LONGER NEED TO SEND CONFIGURATION
	RESTOR	<R3,R1>			;RESTORE REST OF THE REGS
	RTS	PC			;AND RETURN

	.SBTTL	         1.7.2  NSPSDC 0.0 17-MAY-76 -- SEND DISCONNECT TO NSP


;***********************************************************************
;
;	NSPSDC 0.0 17-MAY-76 -- SEND DISCONNECT TO NSP	  
;
;***********************************************************************


NSPSDC:					;SEND DISCONNECT CONFIRM TO NSP
	SAVE	<J,R3,R1>		;SAVE REGS
	JSR	PC,NSPBMG		;START A MESSAGE
	MOV	#NSPCM,R0		;MSGFLG
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#2,R0			;TYPE = DISCONNECT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#5,R0			;SUBTYPE = 5 (CONFIRM),  REASON = 0
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,NSPSAD		;PUT ADDRESSES INTO MESSAGE
	JSR	PC,NSPDLE		;DELETE LINK TABLE ENTRY
	MOV	(SP),R1			;GET LINK ENTRY POINTER BACK
	BICB	#LES.SD,LE.STS(R1)	;WE HAVE SENT IT, SO CLEAR BIT
NSPSND:					;HERE TO SEND MESSAGE TO NSP
	MOV	NSPMSG,R0		;POINT TO BEGINNING OF MESSAGE
	MOV	R4,CN.LEN(R0)		;STORE LENGTH IN CHUNK
	MOV	NSPLB,J			;POINT TO LINE BLOCK
	MOV	LB.SCB(J),SB		;ALSO SCB
	MOV	SB,DNA			;STORE DESTINATION WHERE DDCMP WANTS IT
	MOV	#SOH,R2			;DDCMP WANTS STARTING CHAR IN R2
	JSR	PC,DDQNSP		;QUEUE IT UP
	RESTOR	<R1,R3,J>		;RESTORE REGS
	RTS	PC			;AND RETURN

	.SBTTL	         1.7.3  NSPSLS 0.0 17-MAY-76 -- SEND LINK STATUS


;***********************************************************************
;
;	NSPSLS 0.0 17-MAY-76 -- SEND LINK STATUS	  
;
;***********************************************************************


NSPSLS:					;SEND 0 LINK STATUS TO NSP
	SAVE	<J,R3,R1>		;SAVE REGS
	JSR	PC,NSPBMG		;START MESSAGE
	MOV	#NSPCM,R0		;MSGFLG
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#3,R0			;TYPE = LINK STATUS
	JSR	PC,NSPPBY		;PUT INTO MESSGE
	JSR	PC,NSPSAD		;PUT LINK ADDRESSES INTO MESSAGE
	CLR	R0			;ZERO FOR DATA REQUEST COUNT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	(SP),R1			;GET LINK ENTRY POINTER BACK
	BICB	#LES.SL,LE.STS(R1)	;WE HAVE SENT IT, SO CLEAR BIT
	PBRNCH	NSPSND			;AND SEND IT OFF

	.SBTTL	         1.7.4  NSPSAD 0.0 17-MAY-76 -- SEND ADDRESSES TO NSP


;***********************************************************************
;
;	NSPSAD 0.0 17-MAY-76 -- SEND ADDRESSES TO NSP	  
;
;***********************************************************************


NSPSAD:					;SEND DESTADDR AND SRCADDR
	MOVB	LE.NSP(R1),R0		;GET DESTINATION (NSP) ADDRESS
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOVB	LE.CON(R1),R0		;GET SOURCE (NCL CONVERTED) ADDRESS
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	RTS	PC

	.SBTTL	    1.10  NSPSUB 0.0 10-MAY-76 -- SUBROUTINES


;***********************************************************************
;
;	NSPSUB 0.0 10-MAY-76 -- SUBROUTINES	  
;
;***********************************************************************


	.SBTTL	         1.10.1  NSPCPY 0.0 10-MAY-76 -- COPY FROM LB TO SCB


;***********************************************************************
;
;	NSPCPY 0.0 10-MAY-76 -- COPY FROM LB TO SCB	  
;
;***********************************************************************


NSPCPY:					;COPY FROM LINE BLOCK TO SCB

; THIS SUBROUTINE DESTROYS R0, R1, R2, AND R3
;
; IT IS CALLED BY
;
;	JSR	PC,NSPCPY
;	.WORD	LBDISP			;LINE BLOCK DISPLACEMENT
;	.WORD	SCBDSP			;STATION CONTROL BLOCK DISPLACEMENT
;	.WORD	COUNT			;NUMBER OF BYTES TO COPY
;   --> ONLY RETURN

	MOV	@SP,R0			;GET RETURN PC INTO R0
	MOV	(R0)+,R1		;GET LINE BLOCK DISPLACEMENT
	ADD	J,R1			;MAKE INTO ADDRESS
	MOV	(R0)+,R2		;GET SCB DISPLACEMENT
	ADD	SB,R2			;MAKE INTO ADDRESS
	MOV	(R0)+,R3		;GET COUNT
	MOV	R0,@SP			;UPDATE RETURN PC
10$:					;LOOP TO COPY BYTES
	MOVB	(R1)+,(R2)+		;COPY BYTE FROM LB TO SCB
	SOB	R3,10$			;DECREMENT COUNTER, AND LOOP IF NOT DONE
	DEC	R2			;BACK UP DESTINATION POINTERONE
	BICB	#200,@R2		;CLEAR EXTENSIBLE BIT (IN CASE SOMEONE FORGOT)
	RTS	PC			;RETURN


	.SBTTL	         1.10.2  NSPEXC 0.0 15-MAY-76 -- COPY PROCESS NAME INTO MSG


;***********************************************************************
;
;	NSPEXC 0.0 15-MAY-76 -- COPY PROCESS NAME INTO MSG	  
;
;***********************************************************************


NSPEXC:					;WILL PUT OBJ-TYPE=0, PROCESS NAME, GROUP=0, USER=0 INTO OUTPUT MESSAGE
	CLR	R0			;OBJECT-TYPE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	MOV	#20$,10$+2		;POINT TO CHARACTER GET SUBROUTINE
	CLR	-(SP)			;ZERO COUNTER
10$:					;LOOP PUTTING IN BYTES OF EXTENSIBLE FIELD
	JSR	PC,20$			;GET NEXT BYTE
	CMP	(SP),#6			;CHECK IF ENOUGH
	BEQ	11$			;YES, JUST SKIP BYTES
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	INC	(SP)			;INCREMENT COUNTER
11$:					;HERE TO CHECK IF END OF EXTENSIBLE STRING
	BIT	#200,R0			;WAS EXTENSIBLE BIT ON?
	BNE	10$			;YES, KEEP LOOKING FOR MORE
	TST	(SP)+			;CLEAN UP STACK
	BICB	#200,-1(R5)		;CLEAR EXTENSIBLE BIT IN STRING
	CLR	R0			;GROUP=0
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	JSR	PC,NSPPBY		;PUT ZERO USER CODE INTO MESSAGE ALSO
	RTS	PC			;RETURN TO CALLER
20$:					;HERE TO GET NEXT CHARACTER TO PUT INTO STRING
	JSR	PC,GETBYT		;GET BYTE FROM MESSAGE
	MOV	R0,-(SP)		;SAVE IT ON STACK
	BIC	#177600,R0		;CLEAR EXTENSIBLE BIT
	CMP	#133,R0			;WAS IT "["?
	BNE	30$			;NO, SKIP
	MOV	(SP),R0			;YES, GET REAL CHARACTER BACK,
	MOV	#240,(SP)		;REPLACE WITH BLANK,
	MOV	#40$,10$+2		;AND POINT TO NEW CHARACTER GET ROUTINE
25$:					;LOOP TO FLUSH EXTRA CHARACTERS
	BIT	#200,R0			;WAS EXTENSIBLE BIT ON?
	BEQ	30$			;NO, DONE
	JSR	PC,GETBYT		;GET NEXT CHARACTER
	BR	25$			;AND CHECK IT TOO
30$:					;HERE TO PASS CHARACTER TO CALLER
	MOV	(SP)+,R0		;GET CHARACTER BACK
	RTS	PC			;AND RETURN
40$:					;HERE AFTER "[" SEEN
	MOV	#240,R0			;GET AN EXTENDED BLANK
	CMP	2(SP),#6		;HAS COUNT REACHED LIMIT YET?
	BLT	45$			;NO, BRANCH
	BIC	#200,R0			;YES, CLEAR EXTENSIBLE BIT
45$:					;HERE TO PASS CHARACTER BACK
	RTS	PC			;RETURN


	.SBTTL	         1.10.3  NSPFST 0.0 12-MAY-76 -- SET STRIP BIT


;***********************************************************************
;
;	NSPFST 0.0 12-MAY-76 -- SET STRIP BIT	  
;
;***********************************************************************


NSPFST:					;SEE IF THIS LINK WANTS STRIP COUNT/DATA
	CLRB	NSPFLG			;CLEAR FLAG BITS
	BIT	#LES.DV,LE.STS(R1)	;IS THIS A DEVICE?
	BNE	5$			;YES, DON'T STRIP
	BISB	#NSP.ST,NSPFLG		;NO, SET STRIP BIT
5$:					;HERE WHEN STRIP BIT OK
	RTS	PC			;RETURN

	.SBTTL	         1.10.4  NSPBMG 0.0 10-MAY-76 -- START OUTPUT MESSAGE


;***********************************************************************
;
;	NSPBMG 0.0 10-MAY-76 -- START OUTPUT MESSAGE	  
;
;***********************************************************************


NSPBMG:					;BEGIN AN OUTPUT MESSAGE
; THIS SUBROUTINE STARTS AN OUTPUT MESSAGE BY GETTING A CHUNK,
; AND INITIALIZING THE BYTE POINTER REGISTER (R5) AND THE
; COUNT REGISTER (R4).
;
; DESTROYS R0, R4, AND R5.
;
; CALL IS:
;
;	JSR	PC,NSPBMG
;   --> ONLY RETURN
;
; IF RETURN IS UNSUCCESSFUL, CARRY BIT IS SET.; ELSE CLEAR.
; UPON SUCCESSFUL RETURN, R4 CONTAINS 0 AND R5 POINTS TO FIRST
; BYTE OF MESSAGE.
	SEC				;ASSUME BAD RETURN
	JSR	PC,GETCNK		;GET A CHUNK
	BEQ	10$			;IF NONE, RETURN
	CLC				;SET GOOD RETURN CODE
	MOV	R0,NSPMSG		;SAVE START OF MESSAGE
	CLR	R4			;CLEAR COUNT REGISTER
	MOV	R0,R5			;PUT START ADDRESS INTO BYTE POINTER REGISTER
	CLR	CN.MLK(R5)		;CLEAR MESSAGE LINK
.IIF NE,DEVN,	CLR	CN.DDB(R5)	;AND DDB LINK
	ADD	#CN.NCT,R5		;POINT TO FIRST DATA BYTE
10$:					;HERE TO EXIT
	RTS	PC			;RETURN

	.SBTTL	         1.10.5  NSPPEX 0.0 10-MAY-76 -- PUT EXTENSIBLE FIELD INTO MSG


;***********************************************************************
;
;	NSPPEX 0.0 10-MAY-76 -- PUT EXTENSIBLE FIELD INTO MSG	  
;
;***********************************************************************


NSPPEX:					;SUBROUTINE TO PUT EXTENSIBLE NUMBER IN OUTPUT MESAGE
	MOV	R0,-(SP)		;SAVE VALUE
	JSR	PC,NSPEXB		;PUT BYTE WITH EXTENSIBLE BIT ON
	MOV	(SP)+,R0		;GET VALUE BACK
	ASL	R0			;SHIFT HIGH ORDER BIT OF LOW BYTE INTO HIGH BYTE
	SWAB	R0			;SWITCH BYTES
	BIC	#200,R0			;CLEAR EXTENSIBLE BIT
	PBRNCH	NSPPBY			;PUT BYTE INTO MESSAGE

NSPEXB:					;TURN ON EXTENSIBLE BIT AND PUT INTO MESSAGE
	BIS	#200,R0			;TURN ON EXTENSIBLE BIT
;	PJMP	NSPPBY			;PUT INTO MESSAGE

	.SBTTL	         1.10.6  NSPPBY 0.0 10-MAY-76 -- PUT BYTE INTO OUTPUT MESSAGE


;***********************************************************************
;
;	NSPPBY 0.0 10-MAY-76 -- PUT BYTE INTO OUTPUT MESSAGE	  
;
;***********************************************************************


NSPPBY:					;PUT A BYTE INTO OUTPUT MESSAGE
	CLC				;CLEAR ERROR INDICATOR
	MOVB	R0,(R5)+		;PUT BYTE AT POINTER AND ADVANCE POINTER
	INC	R4			;INCREMENT BYTE COUNT
	BIT	#CNKSIZ-1,R5		;IS IT NOW POINTING PAST END?
	BNE	20$			;NO, EXIT
	MOV	R0,-(SP)		;SAVE DATA ON STACK
	SEC				;ASSUME BAD RETURN
	JSR	PC,GETCNK		;GET A CHUNK
	BEQ	10$			;NONE, SO EXIT
	CLC				;CLEAR BAD RETURN INDICATOR
	MOV	R0,-CNKSIZ(R5)		;LINK NEW CHUNK TO OLD
	MOV	R0,R5			;POINT TO NEW CHUNK
	CLR	(R5)+			;CLEAR ITS FOWARD LINK
10$:					;HERE TO CLEAN STACK AND EXIT
	MOV	(SP)+,R0		;RESTORE DATA
20$:					;HERE TO EXIT
	RTS	PC			;RETURN

	.SBTTL	         1.10.7  NSPCLE 0.1 20-MAY-76 -- CREATE LINK ENTRY


;***********************************************************************
;
;	NSPCLE 0.1 20-MAY-76 -- CREATE LINK ENTRY	  
;
;***********************************************************************


NSPCLE:					;CREATE A LINK ENTRY
;  THIS SUBROUTINE CREATES A NEW LINK ENTRY, LEAVING
; THE ADDRESS OF THE ZEROED ENTRY IN R1.
;
;  IT EXPECTS THAT THE LINE BLOCK ADDRESS BE IN NSPLB.
;  IT ONLY MODIFIES R1 TO RETURN THE ADDRESS OF THE
; LINK ENTRY, OR 0 IF NO ENTRIES WERE AVAILABLE.
;
; CALL IS:
;
;	JSR	PC,NSPCLE
;	BEQ	FAIL
;
	SAVE	<R4,R3,R2,R0>		;SAVE SOME REGISTERS
	MOV	#LE.SIZ,R3		;GET SIZE OF LINK ENTRY
	MOV	NSPLB,R2		;GET LINE BLOCK ADDRESS
	MOV	R2,R0			;COPY IT
	ADD	#LB.LKT,R0		;POINT TO ADDRESS OF TABLE
	MOV	LB.LLE(R2),R1		;GET LAST USED ENTRY
	BEQ	5$			;NONE, SO GET ONE
	MOV	R1,R0			;COPY ENTRY ADDRESS
	BIC	#CNKSIZ-1,R0		;GET BEGINNING OF CHUNK
	ADD	#LE.SIZ*2,R1		;POINT TO PAST END OF NEW ENTRY
	ADD	#CNKSIZ,R0		;POINT PAST END OF CHUNK
	CMP	R1,R0			;COMPARE THE TWO
	BLOS	10$			;BRANCH IF IT WILL FIT
	SUB	#CNKSIZ,R0		;ELSE POINT TO BEGINNING OF CHUNK AGAIN
5$:					;HERE TO GET A CHUNK, CHAIN TO PREVIOUS
	MOV	R0,R4			;SAVE CURRENT CHUNK ADDRESS
	CLR	R1			;ASSUME THE WORST
	JSR	PC,GETCNK		;GET ANOTHER
	BEQ	20$			;EGADS, NO CHUNKS!
	MOV	R0,@R4			;POINT  LAST ONE AT THIS ONE
	CLR	@R0			;MAKE SURE NEW ONE POINTS NOWHERE
	MOV	R0,R1			;COPY CHUNK ADDRESS
	ADD	#LE.SIZ+2,R1		;ADD 2 FOR LINK PLUS ENTRY SIZE
10$:					;R1 POINTS TO NEW ENTRY + 1
	SUB	R3,R1			;BACK TO START OF ENTRY
	MOV	NSPLB,R0		;GET LINE BLOCK ADDRESS
	INC	LB.LCT(R0)		;INCREMENT COUNT OF LINKS ACTIVE
	MOV	R1,LB.LLE(R0)		;SAVE LAST ENTRY ADDRESS
	MOV	R1,R0			;COPY START OF ENTRY
15$:					;LOOP TO CLEAR OUT LINK ENTRY
	CLRB	(R0)+			;CLEAR THIS BYTE
	SOB	R3,15$			;LOOP TILL DONE
20$:					;HERE TO RESTORE REGS AND EXIT
	RESTOR	<R0,R2,R3,R4>		;CLEAN UP STACK
	TST	R1			;SET CONDITION FOR RETURN
	RTS	PC			;RETURN TO CALLER

	.SBTTL	         1.10.10  NSPDLE 0.0 20-MAY-76 -- DELETE LINK ENTRY


;***********************************************************************
;
;	NSPDLE 0.0 20-MAY-76 -- DELETE LINK ENTRY	  
;
;***********************************************************************


NSPDLE:					;DELETE LINK TABLE ENTRY
	SAVE	<R3,R2,R0>		;SAVE SOME REGISTERS
	MOV	NSPLB,R2		;GET LINE BLOCK ADDRESS
	MOV	LB.LLE(R2),R0		;GET LAST ENTRY
	ASSERT	NE			;BETTER NOT BE 0
	TST	LB.LCT(R2)		;GET COUNT OF ENTRIES
	ASSERT	NE			;BETTER BE SOME
	MOV	#LE.SIZ,R3		;GET SIZE OF ENTRY
10$:					;HERE TO COPY LAST INTO  DELETE ENTRY
	MOVB	(R0)+,(R1)+		;COPY ONE BYTE
	SOB	R3,10$			;LOOP TILL COUNT EXHAUSTED
	SUB	#LE.SIZ+2,R0		;CHECK IF THIS WAS FIRST ONE IN CHUNK
	BIT	#CNKSIZ-1,R0		;BEGINNING OF CHUNK?
	BNE	30$			;NO, JUST DECREMENT
	MOV	R2,R1			;POINT TO
	ADD	#LB.LKT,R1		;AND ADDRESS OF FIRST CHUNK
20$:					;LOOP LOOKING FOR NEXT TO LAST CHUNK
	TST	@(R1)			;IS NEXT CHUNK'S LINK 0?
	BEQ	21$			;YES, DONE
	MOV	@R1,R1			;NO, GET NEXT CHUNK
	BR	20$			;AND KEEP LOOKING
21$:					;HERE WITH R1 = NEXT TO LAST CHUNK
					;(OR POINTER IN LINE BLOCK IF ONLY 1)
	ASSERT	R0,EQ,@R1		;MAKE SURE IT IS CONSISTENT
	CLR	@R1			;DE-LINK FROM PREVIOUS
	JSR	PC,FRECKS		;FREE CHUNK
	MOV	#<LE.SIZ-2>,R0		;IN CASE NO MORE CHUNKS EXIST
	TST	LB.LKT(R2)		;DID WE FREE LAST CHUNK?
	BEQ	30$			;YES, DECREMENT COUNT (TO 0) AND EXIT
	MOV	R1,R0			;NO, COPY BEGINNING OF NEW LAST CHUNK
	ADD	#<<LEPCNK+1>*LE.SIZ>,R0	;POINT 2 BEFORE ENTRY AFTER LAST ENTRY
30$:					;HERE WHEN ENTRY MOVED
	DEC	LB.LCT(R2)		;ONE LESS ENTRY
	SUB	#<LE.SIZ-2>,R0		;ADJUST TO START OF LINK ENTRY
	MOV	R0,LB.LLE(R2)		;POINT TO NEW LAST ENTRY
	RESTOR	<R0,R2,R3>		;RESTORE REGISTERS
	RTS	PC			;RETURN TO CALLER

	.SBTTL	         1.10.11  NSPLES 0.1 20-MAY-76 -- SEARCH LINK ENTRIES


;***********************************************************************
;
;	NSPLES 0.1 20-MAY-76 -- SEARCH LINK ENTRIES	  
;
;***********************************************************************


NSPLES:					;SEARCH LINK ENTRIES
;  THIS SUBROUTINE SEARCHES THROUGH THE LINK ENTRIES THAT
; ARE ACTIVE FOR A DCP LINE.
;
;  IT RETURNS THE ADDRESS OF THE LINK ENTRY MATCHING
; THE CRITERION IN R1, OR 0 IF NONE IS FOUND.
;  IT MODIFIES NO OTHER REGISTER.
;
;
;  IT IS EXPECTED THAT THE VALUE TO BE COMPARED AGAINST IS IN R0,
; AND THAT THE COMPARING INSTRUCTION IS THEREFORE ONLY 2 WORDS
; LONG.
;
; THE CALL IS:
;
;	JSR	PC,NSPLES		;CALL ROUTINE
;	CMP	R0,LE.XXX(R1)		;THIS IS THE COMPARE INSTRUCTION
;	RTS	PC			;EVENTUAL RETURN IS TO HERE

	SAVE	<R3,R2,J>		;SAVE SOME REGISTERS
	MOV	NSPLB,J			;GET LINE BLOCK ADDRESS
	MOV	LB.LCT(J),R3		;GET COUNT OF ACTIVE ENTRIES
	MOV	LB.LKT(J),R2		;GET POINTER TO START OF ENTRIES
	BEQ	16$			;NONE, SO WE ARE FINISHED
	INC	R3			;ADD ONE TO COUNT
	BR	12$			;DO INITIAL CHUNK ADJUSTMENTS
10$:					;LOOP TO EXAMINE ENTRIES
	JSR	PC,@6(SP)		;DO COMPARISON
	BEQ	20$			;IF EQUAL, WE HAVE FOUND IT
	ADD	#LE.SIZ,R1		;OTHERWISE, POINT TO NEXT
	CMP	R1,R2			;ARE WE PAST END?
	BLO	15$			;NO, CONTINUE
	SUB	#CNKSIZ,R2		;YES, POINT TO BEGINNING OF CHUNK
	MOV	@R2,R2			;GET LINK
12$:					;ADJUST REG VALUES AT BEGINNING OF CHUNK
	MOV	R2,R1			;COPY START OF CHUNK
	ADD	#CNKSIZ,R2		;POINT TO END OF CHUNK IN R2
	ADD	#2,R1			;POINT TO FIRST ENTRY WITHIN CHUNK IN R1
15$:					;COUNT OUT LINK ENTRIES
	SOB	R3,10$			;DECREMENT COUNT AND TRY AGAIN
16$:					;HERE IF NOT FOUND
	CLR	R1			;ZERO RETURN REGISTER
20$:					;HERE TO RETURN
	RESTOR	<J,R2,R3>		;RESTORE REGISTERS
	ADD	#4,@SP			;UPDATE PC FOR RETURN
	TST	R1			;SET CONDITION
	RTS	PC			;RETURN

	.SBTTL	         1.10.12  NSPFDL 0.1 20-MAY-76 -- FIND NSP DLA


;***********************************************************************
;
;	NSPFDL 0.1 20-MAY-76 -- FIND NSP DLA	  
;
;***********************************************************************


NSPFDL:					;FIND DLA AS NSP ADDRESS
	JSR	PC,NSPLES		;DO SEARCH
	CMPB	R0,LE.NSP(R1)		;WITH THIS COMPARE ROUTINE
	RTS	PC			;RETURN (BOTH FOR COMPARE ROUTINE AND FINAL EXIT)

	.SBTTL	         1.10.13  NSPFDA 0.1 20-MAY-76 -- FIND NCL DESTADDR


;***********************************************************************
;
;	NSPFDA 0.1 20-MAY-76 -- FIND NCL DESTADDR	  
;
;***********************************************************************


NSPFDA:					;FIND DESTADRR AS CONVERTED NCL ADDRESS
	JSR	PC,NSPLES		;DO SEARCH
	CMPB	R0,LE.CON(R1)		;WITH THIS COMPARE ROUTINE
	RTS	PC			;RETURN (BOTH FOR COMPARE ROUTINE AND FINAL EXIT)

	.SBTTL	         1.10.14  NSPBCO 0.0 15-MAY-76 -- MAKE UNIQUE NCL LINK ADDR


;***********************************************************************
;
;	NSPBCO 0.0 15-MAY-76 -- MAKE UNIQUE NCL LINK ADDR	  
;
;***********************************************************************


NSPBCO:					;BUILD CONVERTED NCL LINK ADDRESS
	MOV	R1,-(SP)		;SAVE LINK ENTRY ADDRESS
	MOV	LE.NCL(R1),R0		;PICK UP NCL LINK ADDRESS
	BIC	#^C277,R0		;CLEAR UPPER BYTE
	JSR	PC,NSPFDA		;SEARCH FOR THIS IN TABLE
	BNE	20$			;WAS ALREADY THERE, WE HAVE TO LOOP
10$:					;HERE WHEN WE FOUND A UNIQUE VALUE FOR LE.CON
	MOV	(SP)+,R1		;RESTORE LINK ENTRY POINTER
	MOVB	R0,LE.CON(R1)		;SAVE VALUE
	RTS	PC			;RETURN TO CALLER
20$:					;HERE TO LOOP THROUGH POSSIBLE VALUES
	MOV	#1,R0			;INITIAL VALUE
30$:					;LOOP TO CHECK IF VALUE ALREADY IN TABLE
	BIT	#277,R0			;HAVE WE PAST ONE BYTE?
	BEQ	10$			;YES, NO UNIQUE VALUE
	JSR	PC,NSPFDA		;CHECK THIS VALUE
	BEQ	10$			;NO ENTRY, SO WE ARE DONE
	INC	R0			;MAKE NUMBER ONE HIGHER
	BR	30$			;AND CONTINUE LOOP

	.SBTTL	         1.10.15  NSPBNC 0.0 16-MAY-76 -- MAKE NCL HEADER


;***********************************************************************
;
;	NSPBNC 0.0 16-MAY-76 -- MAKE NCL HEADER	  
;
;***********************************************************************


NSPBNC:					;SUBROUTINE TO PUT NCL HEADER INTO MESSAGE
	MOV	#NCFSEQ+NCFSNA,R0	;PROTOTYPE NCT
	MOVB	NSPNCT,-(SP)		;GET NCT SKELETON
	ADD	(SP)+,R0		;ADD SKELETON BITS TO R0 VALUE
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	ADD	#LB.DNA,NSPLB		;POINT TO DESTINATION NODE ADDRESS
	MOVB	@NSPLB,R0		;GET IT
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	DEC	NSPLB			;POINT TO LB.NNM (WHICH IMMEDIATELY PRECEDS LB.DNA)
	MOVB	@NSPLB,R0		;AND GET NSP NODE NUMBER
	JSR	PC,NSPPBY		;PUT INTO MESSAGE
	SUB	#LB.NNM,NSPLB		;RESTORE THIS TO LINE BLOCK ADDRESS
	CLR	R0			;ZERO FOR NCA AND NCN
	JSR	PC,NSPPBY		;PUT NCA INTO MESSAGE
	JSR	PC,NSPPBY		;PUT NCN INTO MESSAGE
	RTS	PC			;RETURN TO CALLER

	.SBTTL	         1.10.16  NSPQ 0.0 17-MAY-76 -- WAKE NSP UP


;***********************************************************************
;
;	NSPQ 0.0 17-MAY-76 -- WAKE NSP UP	  
;
;***********************************************************************


NSPQ:					;QUEUE A REQUEST TO NSP
	SAVE	<J,R2>			;SAVE REGS
	MOV	NSPLB,J			;POINT TO LINE BLOCK
	PIOFF				;TURN OFF INTERRUPTS
	BIT	#NS.NSQ,LB.NSS(J)	;ALREADY SOMETHING QUEUED?
	BNE	10$			;YES, EXIT
	BIS	#NS.NSQ,LB.NSS(J)	;NO, INDICATE THAT NOW THERE IS
	CMP	NS.PTR,#<NS.QUE+NS.SIZ>	;IS PUTTER PAST END?
	BLO	5$			;NO, BRANCH
	MOV	#NS.QUE,NS.PTR		;YES, RESET TO BEGINNING
5$:					;HERE TO ACTUALLY PUT DATA INTO QUEUE
	MOV	J,@NS.PTR		;LINE BLOCK ADDRESS AT PUTTER
	ADD	#2,NS.PTR		;ADVANCE PUTTER
10$:					;HERE WHEN DONE
	PION				;ALLOW INTERRUPTS AGAIN
	RESTOR	<R2,J>			;RESTORE REGS
	RTS	PC			;RETURN

.ENDC; NE,FTDCP1