github.com/PDP-10.stacken
1
0
Fork 0
mirror of https://github.com/PDP-10/stacken.git synced 2026-05-05 15:54:16 +00:00
Code Issues Projects Releases Wiki Activity
Files
6e18f5ebefd9acb0d718ef31a08f33a60fc9fca2
PDP-10.stacken/files/stacken-tape-backup/dskb:10_7/anf10/dnnsp.p11
Lars Brinkhoff 6e18f5ebef Extract files from tape images. 
Some tapes could not be extracted.
2021-01-29 10:47:33 +01:00

1898 lines
59 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
.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
Reference in New Issue View Git Blame Copy Permalink