.PAGE
	.SBTTL	***** SPECIAL PROCESSING ROUTINE FOR MAIN-LINE *****
;
	.GLOBL	SAVE,RSTOR,CONFDP,CONCMD,PROST,DISTAT,SPSTAT,CM15,CM16
	.GLOBL	GPBUF
	.GLOBL	UNLOCK
	.GLOBL	BFSATF,CMBFST	;			    *
CMBFMF=1			;Conditional assembly flag  *
;
;	(NOTES LATER)
;
	.SBTTL	SPECIAL MESSAGES PROCESSOR
;
	.GLOBL	VALID
;
CONFDP:		;**** SPECIAL MSG'S DISPATCHER ****
	.GLOBL	B77TMO,CM2,PN1,POOLN,B77TMR
RPTMO=7777	;REPEAT TIME FOR TIME-OUT MSG
	JSR	PC,SAVE	;SAVE REG'S
	MOV	#60,R0	;SET FOR TRUNK A
	CMPB	B77TMO,#1	;NEED MSG????
	BNE	2$	;NO
	CMPB	#CONSOL,POOLN-BUFLEN+WQ  ;ALREADY ACTIVE??
	BEQ	2$	;YES - WAIT FOR OTHER TRUNK TO CLEAR OUT
	INCB	B77TMO	;NO - SEND MSG ONCE
	BR	5$
2$:
	INC	R0	;SET FOR TRUNK B
	CMPB	#1,B77TMO+1	;NEED MSG????
	BNE	20$	;NO
	CMPB	#CONSOL,POOLN-BUFLEN+WQ  ;BUFFER ACTIVE??
	BEQ	20$	;YES - WAIT TILL IT CLEARS
	INCB	B77TMO+1	;NO - SEND MESSAGE ONCE
5$:
	MOVB	R0,PN1	;SET TRUNK PCB NUMBER INTO MSG
	MOV	#CM2,R0	;GET MSG ADR
	MOV	#POOLN-BUFLEN+PDATA,R1   ;GET LAST PORT BUFFER (RESERVED)
	MOVB	(R0)+,R2	;GET COPY SIZE
10$:
	MOVB	(R0)+,(R1)+	;COPY MSG TO BUFFER
	SOB	R2,10$
	MOVB	CM2,R0	;GET SIZE OF MSG
	ADD	#2+PDATA-TDATA,R0   ;ADD HEADER/TRAILER LENGTHS
	MOV	#POOLN-BUFLEN,R1	;GET BUFFER ADR
	MOVB	R0,SZ(R1)	;SET SIZE INTO BUFFER
	MOVB	#CONSOL,WQ(R1)  ;QUEUE BUFFER FOR CONSOLE DISPLAY
	.IF DF,BDCAST	;BRAODCAST TIME-OUT MSG
	MOVB	PN1,R2	;GET TRUNK NUMBER
	BIC	#60,R2	;CONVERT TO BINARY NUMBER AGAIN
	MOVB	R2,BCC(R1)	;STORE IN TIME-OUT MSG FOR CHECKS
	MOVB	#BDCAST,RQ(R1) ;SIGNAL AS BROADCAST MESSAGE
	.ENDC
20$:
	CMPB	#1,B77TMO	;MESSAGE TIMER ACTIVE (TRK 0)??
	BGE	21$		;NO
	INC	B77TMR		;YES - COUNT REPETITION
	CMP	#RPTMO,B77TMR	;TIME TO REPEAT MSG??
	BHI	21$		;NO
	CLRB	B77TMO		;YES - RESET FLAG
	CLR	B77TMR		;AND TIMER
21$:
	CMPB	#1,B77TMO+1	;MESSAGE TIMER ACTIVE (TRK 1)??
	BGE	22$		;NO
	INC	B77TMR+2	;YES - COUNT REPETITION
	CMP	#RPTMO,B77TMR+2	;TIME TO REPEAT MSG??
	BHI	22$		;NO
	CLRB	B77TMO+1	;YES - RESET FLAG
	CLR	B77TMR+2	;AND TIMER
22$:
.IF	DF CMBFMF			;		    *
BFMTIM=177				;		    *
	TSTB	BFSATF			;Buffer saturated?  *
	BEQ	24$			;	No, exit    *
	TSTB	POOLN-BUFLEN-BUFLEN+WQ	;Buffer active?	    *
	BGE	25$			;	Yes, wait   *
	DECB	BFSTMR			;Time for next msg? *
	BNE	25$			;	No, wait    *
	MOVB	#BFMTIM,BFSTMR		;Reset timer	    *
	MOV	#CMBFST,R0		;Message pointer    *
	MOVB	(R0)+,R2		;Message size	    *
	MOV	#POOLN-BUFLEN-BUFLEN,R1	;Set up the msg bfr *
	MOVB	#BDCAST,(R1)+		;Read flag for      *
					;	broadcast   *
	MOVB	#CONSOL,(R1)+		;Write flag to      *
					;	console     *
	MOV	R2,R3			;Message size       *
	ADD	#2+PDATA-TDATA,R3	;Add header/trailer *
					;	length      *
	MOVB	R3,(R1)+		;Buffer size	    *
	TSTB	(R1)+			;Skip active flag   *
	CLRB	(R1)			;Reset BCC compu-   *
					;tation for checks  *
	ADD	#PDATA-4,R1		;Skip to msg area   *
23$:	MOVB	(R0)+,(R1)+		;Put the msg in the *
					;buffer             *
	SOB	R2,23$
	BR	25$			;Exit               *
24$:					;		    *
	MOVB	#1,BFSTMR		;Set to send at once*
					;if saturated	    *
	.ENDC				;		    *

;	LATER, DO BROADCAST STUFF HERE
25$:
	JSR	PC,RSTOR	;RESET REG'S
	RTS	PC		;AND EXIT
BFSATF:	.BYTE	0		;Buffer saturated flag      *
BFSTMR:	.BYTE	1		;Buffer message timer       *
;
	.SBTTL	CONSOLE COMMAND DECODING ROUTINE
;
CONCMD:		;**** CONSOLE COMMAND DECODER ****
	.GLOBL	CCMD,CMDBUF,HALTFL,PCB,CONFLG,HLTPRO,START,CONF
	.GLOBL	STDISP,MSG,PROXIT,CONWRI,POLTAB,STDFLG
;
	JSR	PC,SAVE		;SAVE REGISTERS
	MOV	CMDBUF,R0	;GET PCB ADR
	BEQ	17$	;**** NO COMMAND TO PROCESS ****
	MOV	P.RBFA(R0),R1	;COMPUTE READ BUFFER
	ADD	#PDATA,R1	;COMMAND PTR
	MOV	#NCMD,R2	;SET # CMD'S
	MOV	#CCMD,R3	;SET CMD TABLE PTR
10$:
	CMPB	2(R1),(R3)	;1ST CHAR MATCH?
	BNE	20$		;NO
	CMPB	3(R1),1(R3)	;2ND CHAR?
	BNE	20$		;NO
	CMPB	4(R1),2(R3)	;3RD CHAR?
	BNE	20$		;NO
	CMPB	5(R1),3(R3)	;4TH CHAR?
	BNE	20$		;NO
	JSR	PC,@4(R3)	;YES - EXECUTE RTN FOR CMD
	BCS	17$		; DON'T RE-HANG READ
15$:
	MOVB	#PS.TMO,P.RST(R0)	;RE-ISSUE THE
	BISB	#PS.RF,P.PST(R0)	; READ BUFFER
17$:
	CLR	CMDBUF		; RESET FLAG
	JSR	PC,RSTOR	;RESET REG'S
	RTS	PC		; AND EXIT
20$:
	ADD	#CMDL+2,R3	;NEXT COMMAND ENTRY
	SOB	R2,10$		;;IF MORE
	MOVB	#CR,(R1)	;SIGNAL COMMAND ENTERED
	MOVB	#LF,1(R1)	;WAS NOT VALID
	MOVB	#'!,2(R1)	;OVER-LAY
	MOVB	#'!,3(R1)	;INVALID COMMAND
	MOVB	#'!,4(R1)	;AS FLAG SINCE THE CONSOLE
	MOVB	#'!,5(R1)	;PRESUMABLY HAD ECHO OF LINE
	MOVB	#CONSOL,WQ-PDATA(R1)  ;SET TO RETURN TO CONSOLE
	MOVB	#PS.OK,P.RST(R0) ;SIGNAL READ WAS
	BISB	#PS.RF,P.PST(R0) ;SUCCESSFULLY COMPLETED
	BR	17$	;GO EXIT GRACEFULLY
;
	.SBTTL	'HALT' COMMAND PROCESSOR
;
HLTPRO:		; HALT COMMAND PROCESSING
	INCB	HALTFL	;SET FLAG
	CLC		; RE-ISSUE RD
	RTS	PC
;
	.SBTTL	'PROC' COMMAND PROCESSOR
;
START:		; START CMD PROCESSING
	MOV	R0,-(SP)	; SAVE R0
	MOV	#PCB,R0	; GET PCB PTR
10$:
	TSTB	P.SOU(R0)	; PORT DEFINED?
	BLT	20$	; NO
	CMPB	P.SOU(R0),#CONSOL  ;IS THIS THE CONSOLE?
	BEQ	20$	;YES - READ TAKEN CARE OF ALREADY
	TST	P.RBFA(R0)	; READ HUNG?
       BEQ     15$        ;NO
        MOVB    #PS.TMO,P.RST(R0) ;YES - SIMULTAE READ TIMEOUT
        BISB    #PS.RF,P.PST(R0)  ; TO RE-START THE READ
        BR      20$
15$:
	BISB	#PS.RB,P.PST(R0) ; NO - BUT SOON
20$:
	ADD	#PCBLEN,R0	; NEXT PCB
	.GLOBL	POLTAB
	CMP	#POLTAB,R0	; FINISHED?
	BHI	10$		; NOT YET
	.GLOBL TWBPCB,CONFLG
	MOV	R1,-(SP)   ;SAVE R1
	MOV	#MAXPRT,R0    ;SET LOOP INDEX
	MOV	#TWBPCB,R1	;SET Q TABLE PTR
30$:
	CLR	(R1)+	;KILL ALL Q'D BUFFER PTRS
	SOB	R0,30$	;TO RE-START THIS THING
	MOV	#401,CONFLG	;SET AS IF IN CONTENTION
	CLR	VALID		;Reset validation flags
	MOV	(SP)+,R1	;RESET R1
	CLRB	HALTFL		; LET'S
	MOV	(SP)+,R0	;GO
	CLC			;PROCESS
	RTS	PC		;TRAFFIC
;
;
CONF:			; CONFIGURATION PROCESS INIT
	.GLOBL	CONFLA,STDFLG
;       TSTB    HALTFL    ; AREWE IN HALT MODE??
;        BNE     10$       ;YES, CONTINUE
        CLC         ; NO - IGNOR THE CONF COMMAND
        RTS     PC
10$:
;	INCB	CONFLA	;SET FLAG
;       CLC      ; THEN 
;         RTS    PC    ; CONTINUE
;
	.SBTTL	'STAT' DISPLAY HEADER ROUTINE
;
STDISP:
	.GLOBL POLTAB,BRTAB,CUMTAB,GPBUF,CM15,SAVE,RSTOR
	JSR	PC,GPBUF	;GET PORT BUFFER
	MOV	(SP)+,STHOLD	;SAVE IT
	BNE	10$	;IF WE GOT IT
5$:
	CLC	;EXIT
	RTS	PC
10$:
	INCB	STDFLG	;SET FLAG
	CLR	STCNT	;START @ PCB 0
	MOV	STHOLD,R2  ;GET BUFFER ADR
	MOVB	#CONSOL,RQ(R2) ; FROM CONSOLE
;		FOR NOW
	MOV	#CONSOL,STATPD  ;TO CONSOLE
;
	MOVB	STATPD,WQ(R2)  ;TO DESTINATION
	MOV	#CM15,R5    ;HEADING ADDRESS
	MOVB	(R5),R1	;GET SIZE
	ADD	#PDATA-TDATA+1,R1  ;ADJUST FOR OUTPUT
	MOVB	R1,SZ(R2)	;INTO BUFFER
	MOVB	(R5)+,R1	;GET SIZE FOR COPY
20$:
	MOVB	(R5)+,PDATA(R2)  ;COPY
	INC	R2	;HEADING INTO BUFFER
	SOB	R1,20$
	BR	5$	;THEN EXIT
;
	.SBTTL	'UNLK ##' PROCESSOR
;
UNLOCK:			;FREE THE SPECIFIED PORT
	JSR	PC,RDPORT	;GET THE PORT NUMBER
	BCS	PRTERR		;INVALID ENTRY
	.IF	DF,BDCAST
	CMPB	R2,#BDCAST	;ALL PORTS?
	BEQ	START		;	YES, GO TO THE PROC HANDLER
	.ENDC
	CMPB	R2,#CONSOLE	;AT THE CONSOLE?
	BEQ	20$		;YES, READ READY SET
	ADD	#PCB,R3		;PCB ADDRESS
	TST	P.RBFA(R3)	;READ HUNG?
	BEQ	15$		;	NO
	BISB	#PS.RF,P.PST(R3);	YES, SIMULATE READ TIMEOUT
	MOVB	#PS.TMO,P.RST(R3);		TO REASTART THE READ
	BR	20$		;CONTINUE ON
;
15$:
	BISB	#PS.RB,P.PST(R3);NO, BUT SOON
;
20$:
	ROL	R2		;WORD INDEX
	CLR	TWBPCB(R2)	;CLEAR THE QUEUED BUFFER POINTER
	CLC			;SET RETURN FLAG
	RTS	PC		;RETURN TO COMMAND PROCESSOR
;
	.SBTTL	DECIPHER PORT NUMBER ENTRY
;
RDPORT:		;READ PORT NUMBER ENTRY
	;ON ENTRY R0 IS CONSOLE PCB ADDRESS
	;	  R1 IS INPUT BUFFER ADDRESS
	;ON EXIT  R2 IS THE PORT NUMBER
	;	  R3 IS THE PORT INDEX TO THE PCB ARRAY
	;	  C BIT CLEAR - ENTRY VALID
	;         C BIT SET   - ENTRY ERROR
;
	BISB	#PS.RB,P.PST(R0)	; ASK FOR NEW CONSOLE RD
       MOVB    #CR,(R1)  ;INSERT CR/LF
        MOVB    #LF,1(R1)  ; TO AVOID PROBLEMS
        ADD     #CMDL+3,R1 ; POSITION TO PCB #
	.IF DF,BDCAST	;BROADCAST MESSAGES
	CMPB	(R1),#'*	;BROADCAST??
	BNE	5$	;NO
	CMPB	1(R1),#'*	;MAYBE
	BNE	5$	;NO
;
;	TRIGGER BROADCAST OF THIS MESSAGE HERE
;
;
	MOVB	#40,(R1)	;BLANK THE '**'
	MOVB	#40,1(R1)	;FLAG IN BUFFER
	MOV	#BDCAST,R2	;SHOW ALL PORTS ENTRY
	BR	17$	;GO EXIT CLEANLY
	.ENDC
5$:
	MOVB	(R1),R2	;GET HO OCTAL DIGIT
	MOVB	#'?,(R1)+   ; AND RESET IT
	SUB	#60,R2		;CONVERT IT
	BLT	20$		;ERROR
	MOV	R2,R3	;SAVE H.O. DIGIT
	MUL	#10.,R3	;SHIFT TO PROPER POSITION
	MOVB	(R1),R2		;GET LO OCTAL DIGIT
	MOVB	#'?,(R1)+	;RESET IT
	SUB	#60,R2		;CONVERT FINAL
	BLT	20$		;SHOW ERROR
	ADD	R3,R2	;COMBINE BOTH DIGITS
	CMP	#MAXPRT-1,R2	;IN RANGE?
	BLT	20$		;NO
	CMP	#CONSOL,R2	;TRUNK?
	BGT	20$		;YES - ERROR
15$:
	MOV	R2,R3	;CONVERT PCB # INTO
	MUL	#PCBLEN,R3	;COMPUTE PCB OFFSET
	TSTB	PCB+P.SOU(R3)  ; IS THIS PORT DEFINED?
	BLT	20$	;NO - FLAG AS AN ERROR
       MOVB    #40,-(R1)  ;RESET THE ?'S IN BUFFER
        MOVB    #40,-(R1)  ;FROM THE PCB # CONVERSION NOW
17$:
	CLC			;SHOW VALID ENTRY
	RTS	PC		;RETURN
20$:
	SEC			;SHOW INVALID ENTRY
	RTS	PC		;RETURN
PRTERR:
	MOV	#CONSOL,R2	;QUEUE IT FOR
	BR	PRTECO		;CONSOLE WRITE
;
	.SBTTL	'MESS ##' PROCESSOR
;
MSG:				;MESSAGE TO PORT PROCESSOR
	JSR	PC,RDPORT	;GET THE PORT NUMBER
	BCS	PRTERR		;INVALID INPUT
	.IF	DF,BDCAST
	CMP	R2,#BDCAST	;BROADCAST REQUESTED?
	BNE	PRTECO		;	NO, SEND AT ONCE
	MOV	P.RBFA(R0),R1	;INPUT BUFFER ADDRESS
	MOVB	#BDCAST,RQ(R1)	;FLAG AS BROADCAST
	MOVB	#CONSOL,WQ(R1)	;START WITH CONSOLE
	ADD	#PDATA+CMDL+3,R1;POINT PAST THE ** AREA
	.ENDC
PRTECO:				;SEND MESSAGE TO PORT
        CMPB    #CR,(R1)+   ;LOOK FOR THE ENDING CR
        BEQ     19$     ;GOT IT
        CMPB    #ESC,-1(R1) ;MAYBE IT WAS AN ESCAPE??
	BNE	PRTECO	;NO - KEEP LOOKING (DANGEROUS LOOP)
        MOVB    #CR,(R1)+  ;INSERT A CR IN THIS CASE
        INCB    P.RC(R0)   ;TO PRETTRY UP THE OUTPUT
19$:
        MOVB    #LF,(R1)   ;INSERT THE LF CHAR TO PREVENT
	MOV	P.RBFA(R0),R1	;GET BUFFER
	MOVB	R2,WQ(R1)	; Q FOR WRITE
	MOVB	P.RC(R0),SZ(R1)	; TO THE
18$:
	CLRB	AFL(R1)		;PORT REQUESTED
	CLR	P.RBFA(R0)	; FREE PORT
	SEC			; DON'T RE-ISSUE READ
	RTS	PC
;
	.SBTTL	'EXIT' PROCESSOR
;
PROXIT:			; EXIT AFTER HALT MODE
	.GLOBL  BOMB
        .GLOBL   ISRTAB,CONSAV
         .MCALL    .EXIT
         TSTB    HALTFL   ; ARE WE HALTED??
         BNE     10$      ;YES
         CLC        ;NO
         RTS     PC
10$:
         MOV     ISRTAB+2,R0   ;GET CONSOLE VECTOR ADR
         MOV     #CONSAV,R1    ;SET VECTOR PTR
         MOV     #4,R2         ;SET LOOP INDEX
20$:
         MOV     (R1)+,(R0)+    ;RESET SYSTEM'S ISR ENTRY PTS
         SOB     R2,20$
	.MCALL	.PRINT
	.PRINT	#XMSG	;SAY GOODBYE
         .EXIT         ;RETURN CONTROL TO SYSTEM
;
XMSG:	.ASCIZ  /** BMUX EXIT TO RT-11 **/
	.EVEN
;
	.SBTTL	(LATER)
;
;
;
PROST:		;**** BURROUGHS STATS REQUEST PROCESSOR ****
;		T.B.D.
       CLC
	RTS	PC
;
	.SBTTL	'STAT' DISPLAY LINE PROCESSOR
;
DISTAT:		;**** CONSOLE STATUS DISPLAY PROCESSOR ****
	.GLOBL CM16,CM16PN,CM16P1,CM16P2,CM16TY,CM16BD,CM16TF,CM16ER,CM16BS
	.GLOBL CM16ST,STATPD,PCB,TTYPE,POLTAB,CUMTAB
	TSTB	STDFLG    ;FLAG SET??
	BNE	10$	;YES
	RTS	PC	;NO
10$:
	JSR	PC,SAVE	;SAVE REG'S
	TST	STRDY  ;READY FOR ANOTHER BUFFER??
	BNE	50$	;NOT YET
	MOV	#CM16+1,R0	;YES
15$:
	MOVB	#40,(R0)+   ;BLANK ENTIRE BUFFER STAGING AREA
	CMP	#CM16BS,R0  ;DONE??
	BHI	15$	;NOT YET
	INC	STRDY	;SET FLAG FOR PROCESSING STAGING AREA
	MOV	STCNT,R0	;GET PCB #
	CMP	#MAXPRT,R0   ;LINK BUFFER??
	BNE	29$	;NO
	JMP	70$	;YES
29$:
	ASH	#5,R0	;TIMES PCBLEN OF 40
	ADD	#PCB,R0   ;NOW PCB ADR IN R0
	MOVB	P.SOU(R0),R1	;GET PCB #
	BLT	55$	;** NOT DEF'D **
	MOV	#CM16PN,R2  ;OUTPUT ADR
	MOV	#2,R3	;AND SIZE
	JSR	PC,B2A	;CONVERT AND STORE
	MOVB	P.SOU(R0),R1 ;COMPUTE
	ROL	R1	;POLTAB OFFSET
	MOVB	POLTAB(R1),CM16P1 ;STORE IT (1ST BYTE)
	MOVB	POLTAB+1(R1),CM16P1+1 ;IN HEADING
	MOVB	#40,CM16BS+2  ;NULL TRUNK Q FLAG VALUE
	.GLOBL	TWBPCB
	TST	TWBPCB(R1)	;HOST TFC Q'D FOR THIS PCB???
	BEQ	16$		;NO
	MOVB	#'Q,CM16BS+2	;YES - FLAG ON DISPLAY AS 'Q'
16$:
	MOVB	P.DST(R0),R1   ;GET TRUNK #
	BLT	17$	;NONE
	BIS	#60,R1  ;CONVERT TO ASCII
	MOVB	R1,CM16P2 ;AND STORE IT
17$:
	MOV	#CM16TY,R2  ;OUTPUT ADR
	MOV	#6,R3    ;AND SIZE
	MOVB	P.SOU(R0),R1  ;GET PCB #
	MUL	#6,R1   ;COMPUTE TTYPE
	ADD	#TTYPE,R1 ;TABLE PTR
20$:
	MOVB	(R1)+,(R2)+  ;STORE TERMINAL TYPE
	SOB	R3,20$	;INTO THE STAGING AREA
	MOV	#CM16BD,R2   ;OUTPUT AREA
	MOV	#5,R3    ;AND SIZE
	MOVB	P.SOU(R0),R1  ;COMPUTE BRTAB
	MUL	#5,R1	;TABLE PTR
	ADD	#BRTAB,R1	;FOR STORAGE
30$:
	MOVB	(R1)+,(R2)+   ;STORE BAUD RATE
	SOB	R3,30$	;INTO STAGING AREA
	MOVB	P.SOU(R0),R1	;COMPUTE
	ROL	R1		;THE
	ROL	R1		;CUMTAB TABLE
	ADD	#CUMTAB,R1	;PTR
	MOV	R1,-(SP)	;AND SAVE IT
	MOV	(R1),R1		;GET ERROR COUNT
	MOV	#CM16ER,R2	;OUTPUT ADR
	MOV	#6,R3		;AND SIZE
	JSR	PC,B2A		;CONVERT AND STORE
	MOV	(SP)+,R1	;RETRIEVE PTR
	MOV	2(R1),R1	;GET TFC COUNT
	MOV	#CM16TF,R2	;OUTPUT ADR
	MOV	#6,R3		;AND SIZE
	JSR	PC,B2A		;CONVERT AND STORE
	MOVB	P.PST(R0),R1	;GET CURRENT STATUS OF PORT
	MOV	#CM16ST,R2	;OUTPUT ADR
	MOV	#2,R3		;AND SIZE
	JSR	PC,B2A		;CONVERT AND STORE
	MOVB	#40,CM16BS	;BLANK BUFFER
	MOVB	#40,CM16BS+1	;FLAGS
	TST	P.RBFA(R0)	;READ BUFFER??
	BEQ	40$	;NO
	MOVB	#'R,CM16BS	;YES
40$:
	TST	P.WBFA(R0)	;WRITE BUFFER??
	BEQ	50$	;NO
	MOVB	#'W,CM16BS+1 	;YES
50$:
	MOV	#CM16,R5	;GET STAGING ADR
	JSR	PC,CONCPY	;COPY TO BUFFER
	BCS	60$		;ERROR - ASSUME NO BUFFER
55$:
	CLR	STRDY	;RESET STAGING FLAG
	INC	STCNT	;NEXT PCB
	CMP	#MAXPRT,STCNT	;DONE??
	BGE	60$	;NOT YET
	CLR	STDFLG	;YES
60$:
	JSR	PC,RSTOR ;RESET REG'S
	RTS	PC
;
70$:
	.GLOBL	PROTO,PADR
	.GLOBL	CONFLG
	MOVB	PROTO,R1	;GET PROTOCOL ERROR COUNT (TRK0)
	MOV	#3,R3		;OUTPUT SIZE AND
	MOV	#LNKPRO,R2	;ADDRESS
	JSR	PC,B2A		;CONVERT AND STORE
	MOVB	PROTO+1,R1	;GET PROTOCOL ERROR COUNT (R1)
	MOV	#3,R3		;OUTPUT SIZE AND
	MOV	#LNKPRO+4,R2	;ADDRESS
	JSR	PC,B2A		;CONVERT AND STORE
	MOVB	PADR,R1		;GET POLL ADR ERROR COUNT (TRUNK 0)
	MOV	#3,R3		;SET SIZE AND
	MOV	#LNKPOL,R2	;ADDRESS
	JSR	PC,B2A		;CONVERT AND STORE
	MOVB	PADR+1,R1	;GET POLL ADR ERR CNT (TRK1)
	MOV	#3,R3		;SET SIZE AND 
	MOV	#LNKPOL+4,R2	;ADDRESS
	JSR	PC,B2A		;CONVERT AND STORE
	MOVB	#40,LNKC1	;PRESET CONTENTION
	MOVB	#40,LNKC2	;FLAGS
	TSTB	CONFLG	;1ST TRUNK IN CONTENTION??
	BEQ	75$	;NO
	MOVB	#'1,LNKC1  ;YES - SET FLAG
75$:
	TSTB	CONFLG+1 ;2ND TRUNK IN CONTENTION??
	BEQ	76$	;NO
	MOVB	#'2,LNKC2  ;YES - SET FLAG
76$:
	MOV	#LNKMSG,R5  ;SET LINK MSG ADR IN R5
	JSR	PC,CONCPY   ;MAKE TO A BUFFER IF POSSIBLE
	BCS	60$	;NO BUFFER AVAILABLE
	BR	55$	;FINISHED
;
LNKMSG:	.BYTE	67.,CR,LF
	.ASCII /** LINK:   PRO ERR: /
LNKPRO: .ASCII /000 000  POLL ADR ERR: /
LNKPOL: .ASCII /000 000  CONTEN: /
LNKC1:  .ASCII /  /
LNKC2:  .ASCII / /
	.BYTE CR,LF
	.EVEN
;
	.SBTTL	SUPPORT ROUTINES
;
CONCPY:
	MOV	#PCB+PCBLEN+PCBLEN,R0  ;CONSOLE PCB PTR
	JSR	PC,GPBUF    ;GET A BUFFER
	MOV	(SP)+,R1   ;HOLD IT
	BNE	10$	;GOT OBNE
	SEC		;ERROR
	RTS	PC
10$:
	MOV	R5,-(SP)	;SAVE PTR
	MOVB	(R5)+,R4	;GET SIZE
	MOV	R1,-(SP)	;SAVE BUFFER ADR
20$:
	MOVB	(R5)+,PDATA(R1)	;COPY THE STAGING AREA
	INC	R1		;INTO
	SOB	R4,20$		;THE BUFFER
	MOV	(SP)+,R1	;RESTORE BUFFER ADR
	MOVB	STATPD,WQ(R1)	;Q FOR DESTINATION PCB
	MOV	(SP)+,R5	;RESTORE PTR
	MOVB	(R5),R5		;GET SIZE
	ADD	#PDATA-TDATA+1,R5 ;ADJUST FOR HEADER
	MOVB	R5,SZ(R1)	;AND STORE IN BUFFER
	CLRB	AFL(R1)		;CLEAR ACTIVE FLAG
	CLC			; THEN
	RTS	PC		;EXIT
;
STRDY:	.WORD 0	;STAGING FLAG
STCNT:	.WORD 0	;PCB PTR
STHOLD:	.WORD	0	;HOLD AREA
STATPD:	.WORD 0	;DESTINATION PCB #
;
B2A:		;BINARY TO ASCII CONVERSION R1=VAL, R2=OUT, R3=SIZE
;			R4/R5 DESTROYED HERE
	MOV	R1,R4	;SET FOR
	ADD	R3,R2	;CONVERSION
10$:
	MOV	R4,R5	;SET FOR NEXT DIGIT'S
	CLR	R4	;ISOLATION
	DIV	#10.,R4	;ISOLATE IT NOW
	BIS	#60,R5	;MAKE IT ASCII
	MOVB	R5,-(R2); STORE IT
	SOB	R3,10$	;UNTIL FINISHED
	RTS	PC
;
;
;
;
SPSTAT:		;**** STATS DISK SPOOLER WAIT RTN ****
;		T.B.D.
       CLC
	RTS	PC
;
;
;
	.END