.TITLE	PSEUDO-HANDLER

;	WRITTEN BY

;	GEORGE G. PRECKSHOT
;	UNIVERSITY OF ARIZONA

;	PERMISSION GRANTED FOR REPRODUCTION OR USE IF
;	CREDIT FOR AUTHORSHIP IS GIVEN.

;	THIS PSEUDO-HANDLER COMPRISES ONE HALF OF A COMMUNICATIONS
;	PAIR THAT TOGETHER MAKE UP A "MONITOR" IN THE SENSE
;	OF BRINCH-HANSEN. THE PSEUDO HANDLER IS ACTUALLY A DEVICE
;	HANDLER WITHOUT A DEVICE.  THE FOLLOWING PICTURE ILLUSTRATES
;	BETTER THAN THE FOLLOWING THOUSAND WORDS:

;	........      .......      ........           .......
;	.      .      .     .      .      .           .     .
;	.      .      .     .      .      .           .     .
;	. PROG .<---->.HAND .<---->. DEV1 .<--------->. DEV2.<--\
;	.      .      .     .      .      .           .     .   !
;	........      .......      ........           .......   !
;								!
;								!
;		.........	.........			!
;		.	.	.	.			!
;		.	.	.	.			!
;		. PROG2 .<----->. HAND2 .<----------------------/
;		.	.	.	.
;		.........	.........

;		FIGURE 1: NORMAL COMMNICATION VIA DEVICES


;	.........	.........	.........	.........
;	.	.	.	.	.	.	.	.
;	.	.	.	.	.	.	.	.
;	. PROG1 .<----->. PHAND .<----->. PHAND .<----->. PROG2 .
;	.	.	.	.	.	.	.	.
;	.........	.........	.........	.........

;		FIGURE 2: COMMUNICATION WITH DEVICES REMOVED


;	NOTICE THAT P HANDLERS COMMUNICATE WITH A CORRESPONDING P
;	HANDLER SO THAT WE USE THE OPERATING SYSTEM QUEUE MANAGER
;	TO SCHEDULE OUR COMMUNICATION.  THE OPERATING SYSTEM DOES
;	NOT NEED TO KNOW THAT NO ACTUAL PHYSICAL DEVICES ARE INVOLVED
;	AND,INDEED, IT IS PROBABLY BETTER THAT THE MONITOR REMAINS
;	IGNORANT.  WE OBTAIN SEVERAL ADVANTAGES FROM THIS.  FIRST,
;	WE ARE NOW INDEPENDENT OF THE SORT OF COMMUNICATION THAT
;	SYSTEM PROGRAMMERS HAVE PROVIDED FOR US BETWEEN CONCURRENTLY
;	EXECUTING TASKS.  SINCE THE OPERATING SYSTEM BELIEVES THAT
;	EACH TASK IS COMMUNICATING WITH SOME DEVICE, IT DOES NOT
;	BECOME CONFUSED AS TO WHAT TO DO BUT HANDLES MATTERS IN A NORMAL
;	(HOPEFULLY) STRAIGHT FORWARD MANNER. FURTHERMORE, WE ARE NOT
;	CONSTRAINED TO USE WHATEVER LIMITED FOREGROUND-BACKGROUND
;	COMMUNICATIONS ARE PROVIDED FOR US BUT CAN DESIGN OUR OWN
;	USING STANDARD DEVICE I/O. THE ADVANTAGES BECOME CLEARER WHEN
;	MORE THAN ONE CPU IS INVOLVED.  SUPPOSE THAT WE HAVE TWO
;	SATELLITE CPUS RUNNING UNDER DIRECTION OF ONE HOST CPU
;	MUCH IN THE MANNER THAT REMOTE-11 IS STRUCTURED (THAT IS,
;	THE SATELLITES HAVE ONLY A MINIMAL OPERATING SYSTEM THAT
;	ALLOWS COMMUNICATION WITH DEVICES, FILE STRUCTURED OR OTHERWISE,
;	AND ALLOWS FOR DOWNLOADS FROM HOST TO SATELLITE.  MOST OF
;	THE SYSTEM INTELLIGENCE IS IN THE HOST.). THEN ONE SATELLITE
;	CAN COMMUNICATE WITH ANOTHER BY COMMUNICATING WITH A P HANDLER
;	IN THE HOST.  THE OTHER SATELLITE, OF COURSE, CONNECTS WITH
;	THE MATING P HANDLER.  THE DUTIES OF THE HOST OPERATING SYSTEM
;	IN THIS CASE ARE MERELY TO PASS INFORMATION TO THE HANDLERS IN
;	THE NORMAL WAY AND COMMUNICATION BETWEEN SATELLITES RUNNING
;	UNDER THE SAME FOREGROUND TASK IS ESTABLISHED WITH MINIMAL
;	INVOLVEMENT OF THE FOREGROUND TASK.

;	WE ALSO NOW HAVE A WAY OF COMMUNICATING DIRECTLY BETWEEN TWO
;	FOREGROUND TASKS (IN A SYSTEM WITH MULTIPLE FOREGROUNDS) WITH
;	MINIMAL INVOLVEMENT OF THE MAIN OPERATING SYSTEM.

;	THE QUEUE MANAGER PROVIDES THE WAY WE GET PROPER ORDER AMONG
;	CONCURRENT TASKS, AS IN BRINCH-HANSEN'S MONITOR.  SINCE OUR
;	REQUESTS ARE QUEUED ON A FIFO BASIS, AND THE P HANDLERS WILL
;	NOT DISMISS UNTIL AN APPROPRIATE CONNECTION HAS OCCURRED, WE
;	GET STRICT ORDERING OF COMMUNICATIONS REQUESTS.  SINCE BOTH
;	P-HANDLERS OF A PAIR MUST BE IN THE SAME CPU'S MEMORY SPACE,
;	AND ADDITIONALLY EXECUTED BY THE SAME CPU, OUR PSEUDO TEST-
;	AND-SET INSTRUCTION, TO BE DEFINED IN THE MACRO DEFINITION
;	SECTION UPCOMING, ENSURES THAT PROPER CO-ORDINATION OF BOTH
;	P-HANDLERS OF A PAIR OCCURS REGARDLESS OF WHAT ORDER TASKS
;	DISPATCH UNDER THE MAIN OPERATING SYSTEM.  WITH A REAL TEST-
;	AND-SET INSTRUCTION WE CAN RELAX THE REQUIREMENT THAT THE P
;	HANDLER PAIR BE EXECUTED BY THE SAME CPU, BUT AT SOME ADDITIONAL
;	COMPLEXITY.

;	CONDITIONAL ASSEMBLY PARAMETERS:

;	$TRAP---$TRAP GE 0	=>SIGNAL=TRAP
;		$TRAP GE 1	INCLUDES TRAP CODE

;	$HALT---RETURNS HARD ERROR ON .PROTECT FAILURE

;	PROT$---IF DF, CAUSES .PROTECT CALL

;	PSW$----IF NDF, DOES JSR PC,@TPS TO PUT PSW
;		IF DF, USES .MTPS,.MFPS SYSTEM MACROS

;	DEBUG$--0	PRINTS DEBUG MESSAGES
;		2	DUMPS REGISTERS AS WELL

;	NO$LSI--IF DF, PRODUCES SIMPLER .MTPS,.MFPS

;	EOF$----PRODUCES EOF ON ^Z
.PAGE
	.MCALL	.REGDEF,..V2..,.INTEN
	.MCALL	.DRBEG,.DRAST,.DREND,.DRFIN,.FORK,.QELDF
.IIF DF,PSW$	.MCALL	.MTPS,.MFPS
	.MCALL	.PROTECT
	.REGDEF
	..V2..
	.MCALL	.FORK

;VECTOR AND DEVICE REGISTER ADDRESSES-EDIT THESE TWO TO RECONFIGURE
.IIF	NDF,PHVEC	PHVEC=170		;PSEUDO VECTOR
.IIF	NDF,MMG$T	MMG$T=0
.IIF	NDF,ERL$G	ERL$G=0
.IIF	NDF,TIM$IT	TIM$IT=0		;ASSUME NO TIMEOUT
.QELDF
;OTHER PSEUDO DEVICE ADDRESSES

.IIF NDF,ORVEC	ORVEC=270	;PSEUDO VECTOR OF MATING P HANDLER

;OTHER DEVICE CONSTANTS
	PHDSIZ=0

.IIF	NDF,PHSTS	PHSTS=4

;ANCILLIARY DEFINITIONS
OXVEC=ORVEC+4
TRVEC=PHVEC+4
RCVEC=PHVEC

;	OTHER VECTOR POSSIBILLITIES:

;	340,350,360,370,400-470

;CONSTANTS
	OFFSET=270		;OFFSET TO MONITOR COMPLETION ENTRY
	ERROFF=272		;OFFSET TO SPUSR ERROR CODE IN RMON
	RMON=54			;LOCATION OF LOCATION OF RMON

	EOF=20000		;EOF BIT IN CSW
	PR7=340			;PSW VALUE FOR PRIORITY 7
	PR4=200			;PSW VALUE FOR PRIORITY 4
	CLOSE=1
	DELETE=2
	LOOKUP=3
	ENTER=4

	ETB=27
	HT=11			;TAB
	LF=12			;LINE FEED
	FF=14			;FORM FEED
	CR=15			;CARRIAGE RETURN=15
	CTRLU=25		;CTRL/U
	CTRLZ=32		;CTRL/Z
	CNTRLZ=32
	SPACE=40		;SPACE
	DELET=177		;RUBOUT
	ENQ=5
	ACK=6
	NAK=25
	PSW..=177776

WCNT=Q.WCNT-Q.BLKN
BUFF=Q.BUFF-Q.BLKN
FUNC=Q.FUNC-Q.BLKN
CSW=Q.CSW-Q.BLKN
.PAGE
;	MACRO DEFINITIONS

.MACRO	POINT	REG,LOC
	MOV	PC,REG
	ADD	#LOC-.,REG
.ENDM

.MACRO	SNAP	MSG
.IF DF,DEBUG$
	.MTPS	#340
	JSR	R5,PRINT
	.WORD	NAME-2-.
	JSR	R5,PRINT
	.WORD	MSG-2-.
	.IF GE,DEBUG$-2
	JSR	PC,$SNAP
	.ENDC
	.MTPS	#0
.ENDC
.ENDM

.MACRO	PNTR5	REG
	MOV	(R5)+,REG
	ADD	R5,REG
.ENDM

.MACRO	LEVEL
	.MFPS
	BIC	#177437,(SP)+
.ENDM

.MACRO	.PRAST	NAME,PRI,ABORT
.GLOBL	$INPTR
.IF B,ABORT
	RTS	%7
.IFF
	BR	ABORT
.ENDC
'NAME'INT::	TSTB	'NAME'AST
	BNE	.+4
	RTI
	JSR	%5,@$INPTR
	.WORD	^C<PRI*^O40>&^O340
.ENDM

.MACRO	SIGNAL	VECTOR
.IF DF,$TRAP
.IF GE,$TRAP
	TRAP	VECTOR
.ENDC
.IFF
	CLR	-(SP)
	MOV	PC,-(SP)
	ADD	#16,(SP)
	MOV	#340,-(SP)
	MOV	@#VECTOR,-(SP)
	RTI
.ENDC
.ENDM

;	THE SIGNAL MACRO REQUIRES THAT THE TRAP LOCATION 034 BE
;	PROTECTED AND LOADED WITH A POINTER TO A SHORT TRAP ROUTINE,
;	AN EXAMPLE OF WHICH IS GIVEN.  IN FACT, WE INCLUDE A
;	CONDITIONAL PARAMETER WHICH WILL INCORPORATE ITS ASSEMBLY.
;	SEE THE END OF THIS HANDLER.

.IF NDF,PSW$
.MACRO	.MTPS	ARG
.IF DF,NO$LSI
.IF NB,ARG
	MOV	ARG,@#PSW..
.IFF
	MOV	(SP)+,@#PSW..
.ENDC
.IFF
.IF B,ARG
	JSR	PC,@TPS
.IFF
	.IF IDN,ARG,#0
	CLR	-(SP)
	.IFF
	MOV	ARG,-(SP)
	.ENDC
	JSR	PC,@TPS
.ENDC
.ENDC
.ENDM

.MACRO	.MFPS	ARG
.IF DF,NO$LSI
.IF NB,ARG
	MOV	@#PSW..,ARG
.IFF
	MOV	@#PSW..,-(SP)
.ENDC
.IFF
	JSR	PC,@FPS
.IF NB,ARG
	MOV	(SP)+,ARG
.ENDC
.ENDC
.ENDM
.ENDC

.MACRO	TAS	LOC,LOC1	;PSEUDO TEST-AND-SET
	.MFPS
	BIC	#37,(SP)
	.MTPS	#340
	TST	LOC
	BNE	.+10
	.IF B,LOC1
	INC	LOC
	.IFF
	INC	LOC1
	.ENDC
	BIS	#4,(SP)
	MOV	#2,-(SP)
	ADD	PC,(SP)
	RTI
.ENDM

;	TAS RETURNS WITH Z BIT SET IF LOC WAS ZERO, OTHERWISE
;	ALL CC ARE RESET. IN ANY CASE, LOC IS NON ZERO AFTER
;	EXECUTION OF TAS.
.PAGE
;	SET OPTIONS

.ASECT
.=400
	NOP
	.RAD50	/LINE  /
	.BYTE	<O.LINE-400>/2
	.BYTE	200

	NOP
	.RAD50	/ASCII /
	.BYTE	<O.AS-400>/2
	.BYTE	200

.IF DF,EOF$
	BR	NO..Z-EOF..+.
	.RAD50	/EOF   /
	.BYTE	<O.EOF-400>/2
	.BYTE	200
.ENDC

	.WORD		;END OF SET OPTIONS

O.LINE:	MOV	(PC)+,R3
	BEQ	RETLF-LINE+.
	MOV	R3,LINE
	RTS	PC

O.AS:	MOV	(PC)+,R3
	BEQ	RETLF-ASC+.
	MOV	R3,ASC
	RTS	PC

.IF DF,EOF$
O.EOF:	MOV	(PC)+,R3
	BNE	NO..Z-EOF..+.
	MOV	R3,EOF..
	RTS	PC
.ENDC
.PAGE
	.CSECT
;	BEGINNING OF P HANDLER.  THIS IS WHERE .READ AND .WRIT REQUESTS
;	ENTER AND WHERE WE SEPARATE THEM.

.DRBEG	PH,PHVEC,PHDSIZ,PHSTS,PH$TBL

	MOV	PHCQE,R4	;SEE IF READ,WRITE OR SEEK

.IF NDF,NO$LSI
.IF NDF,PSW$
	TST	PSFLAG
	BNE	9$
	ADD	@#54,TPS
	ADD	@#54,FPS
	INC	PSFLAG
9$:
.ENDC
.ENDC

.IF DF,$TRAP
.IF GE,$TRAP-1
.ENABL	LSB
	TST	TFLAG
	BNE	1$
	JMP	$PROT		;GO SET UP TRAP VECTORS
BACK:	BCC	1$		;WE DID IT
	.IF NDF,$HALT
	INC	TFLAG		;SOMEBODY ELSE DID IT
	.IFF
	BR	ERROR		;WE CALL THIS AN ERROR
	.ENDC
1$:
.DSABL	LSB
.ENDC
.ENDC

	SNAP	MSGIN
	ASL	WCNT(R4)
.IF NDF,DEBUG$
	BCC	RC
	BEQ	STOP
	BR	TR
.IFF
	BCC	RCJMP
	BEQ	STPJMP
	JMP	TR

RCJMP:	JMP	RC
STPJMP:	JMP	STOP
.ENDC

.IF NDF,NO$LSI
.IF NDF,PSW$
PSFLAG:	.WORD	0
TPS:	.WORD	360
FPS:	.WORD	362
.ENDC
.ENDC

PH$TBL:	.WORD	PHVEC
	.WORD	PHINT-.
	.WORD	340
	.WORD	TRVEC
	.WORD	TRINT-.
	.WORD	340
	.WORD	0		;END OF TABLE
.PAGE
;	TRANSMITTER ASYNCHRONOUS TRAP ENTRY

	.PRAST	TR,4
	SNAP	MSGTR2
	.FORK	FORK1
	SNAP	MSGTR3
	MOV	PHCQE,R4
	BR	TR2

;	.WRITE ENTRY AND "MONITOR" PORT

TR:
TR0:	SNAP	MSGTR1
	INCB	TRAST		;ONLY ONE .DRFIN PER .WRIT
	CLR	FLAG		;TELL US WE HAVE JUST ENTERED
TR2:	MOV	@#ORVEC,R5	;R5-> MATING RECEIVER
	TST	-(R5)		;SKIP ABORT CODE

TR1:	TAS	-(R5),(R5)	;SEE IF BUSY
				;AFTER TAS R5->BUSY
	BEQ	1$		;WE HAVE TAKEN BUSY
	SNAP	MSGTR6
	RTS	PC		;OTHERWISE WE WAIT FOR SIGNAL

1$:	SNAP	MSGTR4
	TST	FLAG		;WE ARE THE BUSY ONE, BUT SEE
	BNE	3$		;IF WE HAVE DONE THIS BEFORE.
	MOV	BUFF(R4),-(R5)	;WE GIVE MATE OUR PTR AND COUNT
	MOV	WCNT(R4),-(R5)
	INC	FLAG		;SO WE WON'T DO IT TWICE
9$:	CLR	4(R5)		;CLEARING BUSY, SINCE WE ARE DONE HERE
	SNAP	MSGTR5
	SIGNAL	ORVEC		;LET MATE KNOW
	RTS	PC		;LET HIM DO IT, AND THEN TELL US

3$:				;AT THIS POINT R5->BUSY
	TST	-4(R5)		;SEE IF BYTE COUNT IS ZERO, IE. RCV DONE!
	BEQ	TRDONE		;THEN WE ARE DONE.
	SNAP	MSGTR7
	CLR	(R5)		;CLEAR BUSY, WE HAVE NO BUSINESS HERE
	RTS	PC		;GO WAIT SOME MORE
.PAGE
TRDONE:	CLR	-(R5)		;CLEAR BUFPTR SO THAT WE WILL KNOW NEXT
				;TIME THAT WE ARE READY FOR A NEW POINTER.
				;FLAG TELLS US, IF WE ARE SIGNALLED IN THE
				;MEANTIME, THAT WE EITHER HAVE OR DO NOT
				;HAVE A NEW BUFFER.
	CLRB	TRAST		;WE COULDN'T GET HERE UNLESS TRAST NE 0
				;THIS WAY WE NEED ANOTHER .WRITE BEFORE
				;WE CAN PASS THIS WAY AGAIN.
	CLR	2(R5)		;AND FINALLY CLEAR BUSY

STOP:
DONE:	SNAP	MDONE
	.DRFIN	PH
.IF DF,$TRAP
	.IF DF,$HALT
ERROR:	BIS	#1,@CSW(R4)
	BR	DONE
	.ENDC
.ENDC
.PAGE
;	RECEIVER CODE:  THE RECEIVER DOES THE DATA TRANSFER. THEREFORE,
;	AS YOU HAVE JUST SEEN, THE TRANSMITTER'S ROLE IS LIMITED TO
;	DELIVERING A BUFFER POINTER AND BYTE COUNT TO IT'S MATING
;	RECEIVER, AND SIGNALING SAME.  THE RECEIVER MUST DETERMINE
;	WHETHER A NEW BUFFER IS AVAILABLE FROM THE XMITR AND THEN TAKE
;	AS MUCH OF IT AS IT CAN.  WHEN WE HAVE TAKEN ALL OF THE XMITR'S
;	DATA, WE SIGNAL IT SO THAT IT CAN GO AWAY AND GET SOME MORE.

RC:	SNAP	MSGPH1
	INCB	PHAST		;TELL US WE HAVE ENTERED
RC2:	MOV	@#RCVEC,R5	;R5-> US, WHERE WE STORE BUSY, ETC.
	TST	-(R5)		;SKIP PAST ABORT CODE

RC1:	TAS	-(R5),(R5)	;SEE IF WE CAN GET IN
				;NOW R5->BUSY
	BEQ	1$		;WE HAVE TAKEN BUSY
	SNAP	MSGPH8
	RTS	PC		;WE LOST

1$:	SNAP	MSGPH2
	TST	-(R5)		;TEST FOR DATA
				;THIS MAKES R5->BUFPTR
	BNE	XFER		;YES, THERE WAS SOME
3$:
	SNAP	MSGPH3
	CLR	BUSY
	SIGNAL	OXVEC		;SO TELL MATE TO GO AHEAD
2$:	RTS	PC		;WHILE WE WAIT

;	----- HERE IS OUR DATA TRANSFER LOOP ---

.ENABL	LSB
XFER:
				;TELLS US IF WE HAVE DONE IT ALREADY
	CLRB	PHAST		;REMEMBER WE ARE ABOUT TO DO IT NOW

	MOV	(R5),R5		;R5->XMIT BUFFER
1$:	TST	TRCNT		;SEE IF XMIT EMPTY
	BEQ	RET0		;YES, MT, NO MORE DATA

.IF DF,EOF$
	CMPB	#CTRLZ,(R5)	;TEST FOR EOF
EOF..:	BNE	NO..Z		;NOTICE WE DO NOT INCLUDE IN BUFFER
	BIS	#EOF,@CSW(R4)	;TO CONFORM TO V3 PRACTICE, ^Z SHOULD
	BR	RETLF		;BE THE ONLY THING SENT.
NO..Z:
.ENDC

	MOVB	(R5),@BUFF(R4)	;OTHERWISE SHIFT ANOTHER BYTE
	INC	TRCNT		;TELL OFF ONE XMIT COUNT
	INC	BUFF(R4)	;UPDATE RECV BUF POINTER

	TSTB	(R5)		;IF ASCII IS SET, WE STOP ON NULL
ASC:	BEQ	RETLF

	CMPB	#LF,(R5)+	;UPDATE XMIT PTR & CHECK FOR LINE
LINE:	BEQ	RETLF		;IF LINE ORIENTED, STOP HERE
				;WE HAVE A SET COMMAND THAT MAKES
				;THIS A NOP FOR A NON-LINE ORIENTED
				;PSEUDO HANDLER.  MAKE SURE YOU SET
				;BOTH MATES THE SAME.
	DEC	WCNT(R4)	;NOW CHECK RECV BUFFER COUNT
	BNE	1$		;AND LOOP IF NOT FULL
.DSABL	LSB

;	--- RECEIVER RETURNS ------

RET:	TST	TRCNT		;NORMAL RETURN
	BEQ	RDONE		;WE TELL XMITR TO GO HOME TOO

P:	MOV	R5,TRPTR	;OTHERWISE WE ARE ONLY PARTLY DONE
				;AND MUST COME BACK FOR MORE
	CLR	BUSY
.IF NDF,DEBUG$
	BR	DONE
.IFF
	JMP	DONE
.ENDC

RDONE:
	CLR	BUSY
	SNAP	MSGPH5
	SIGNAL	OXVEC		;WHEN WE ARE DONE
.IF NDF,DEBUG$
	BR	DONE
.IFF
	JMP	DONE
.ENDC

.ENABL	LSB
RETLF:	DEC	WCNT(R4)	;WE HAVE LF, IS IT LAST?
	BEQ	2$		;YES, SO WE NEEDN'T NULL BUFFER

RET0:	CLRB	@BUFF(R4)	;OTHERWISE, NULL BUFFER LOOP
	INC	BUFF(R4)
	DEC	WCNT(R4)
	BNE	RET0

2$:	CLR	TRCNT		;WE NEED TO TELL XMIT WE ARE DONE
	BR	RDONE
.DSABL	LSB
.PAGE
;	THE RECEIVER ASYNCHRONOUS ENTRY POINT
;	WE KEEP OUR FLAGS AND SUCH HERE FOR THE MATING HANDLER TO
;	USE BY ACCESSING US THROUGH OUR VECTOR LOCATION.

FLAG:	.WORD	1
TRCNT:	.WORD	0
TRPTR:	.WORD	0
BUSY:	.WORD	0

	.PRAST	PH,4
	SNAP	MSGPH6
	.FORK	FORK2

	SNAP	MSGPH7
	MOV	PHCQE,R4	;GET THE QUEUE ELEMENT
.IF NDF,DEBUG$
	BR	RC2		;SIMPLE, ISN'T IT.
.IFF
	JMP	RC2
.ENDC
.PAGE
;	THIS IS THE TRAP HANDLER FOR THE "TRAP" INSTRUCTION
;	USED IN THE SIGNAL MACRO.  CODE IS INCLUDED HERE TO 
;	INITIALIZE THE TRAP DISTRIBUTER AND SHOULD BE ASSEMBLED ONLY
;	IN THE FIRST PSEUDO HANDLER TO BE LOADED IF $HALT IS SPECIFIED,
;	OTHERWISE THE PSEUDO HANDLERS ASSUME THAT IF THE "TRAP" VECTOR
;	IS PROTECTED, IT HAS ALREADY BEEN TAKEN CARE OF BY ANOTHER
;	P HANDLER.
.IF DF,$TRAP
.IF GE,$TRAP-1
TRAP$:	MOV	@-2(SP),-(SP)	;PUSH TRAPPING INSTRUCTION
	BIC	#177400,(SP)	;CLEAN OFF INSTRUCTION PART
	JMP	@(SP)+		;JUMP VIA VECTOR PORTION

;	--- THIS SUBROUTINE SETS UP AND PROTECTS TRAP VECTOR ---

$PROT:
.IF DF,PROT$
	.IIF GE,DEBUG$-1	SNAP	MSGPR1
	POINT	R0,AREA		;POINT R0 TO AREA
	.PROTECT
	BCS	1$
.ENDC
	INC	TFLAG
	POINT	R0,TRAP$	;POINT R0 TO TRAP$
	MOV	R0,@#34
	MOV	#200,@#36	;SET TRAP PRIORITY AT 1
	CCC
1$:
.IIF GE,DEBUG-1	SNAP	MSGPR2
	JMP	BACK

TFLAG:	.WORD	0		;WE ONLY DO IT THE FIRST TIME
.IF DF,PROT$
AREA:	.BYTE	0,31
	.WORD	34,0
.ENDC
.ENDC
.ENDC
FORK1:	.BLKW	4
FORK2:	.BLKW	4
TRAST:	.BYTE	0	;SO WE DON'T DO MORE THAN ONE .DRFIN FOR
PHAST:	.BYTE	0	;EACH PROGRAMMED REQUEST
.PAGE
;	DEBUG OPTION
.IF DF,DEBUG$
NAME:	.BYTE	CR,LF,LF
.IF EQ,PHVEC-170
	.ASCIZ	/PH:** /
.IFF
	.ASCIZ	/HP:** /
.ENDC
.MACRO	.ASCIR	MSG
	.ASCII	/MSG/
	.BYTE	CR,LF,0
.ENDM
.IF DF,PROT$
.IF GE,DEBUG$-1
MSGPR1:	.ASCIR	<BF PROT>
MSGPR2:	.ASCIR	<AF PROT>
.ENDC
.ENDC
MSGIN:	.ASCIR	ENTERED
MSGTR1:	.ASCIR	TR
MSGTR2:	.ASCIR	<TR .DRAST>
MSGTR3:	.ASCIR	<TR .FORKED>
MSGTR4:	.ASCIR	<TR BUSY>
MSGTR5:	.ASCIR	<TR SIG>
MSGTR6:	.ASCIR	<TR WAIT>
MSGTR7:	.ASCIR	<TR NO SIG>
MDONE:	.ASCIR	<DONE>
MSGPH1:	.ASCIR	RC
MSGPH8:	.ASCIR	<RC WAIT>
MSGPH2:	.ASCIR	<RC BUSY>
MSGPH3:	.ASCIR	<RC SIG NO BUF>
MSGPH4:	.ASCIR	<RC NO SIG>
MSGPH6:	.ASCIR	<RC .DRAST>
MSGPH7:	.ASCIR	<RC .FORKED>
MSGPH5:	.ASCIR	<RC SIG RDONE>
	.EVEN

PRCSR=177564
PRBUF=PRCSR+2

PRINT:	MOV	R0,-(SP)
	PNTR5	R0
1$:	TSTB	@R0
	BEQ	9$
2$:	BITB	#200,@#PRCSR
	BEQ	2$
	MOVB	(R0)+,@#PRBUF
	BR	1$

9$:	MOV	(SP)+,R0
	RTS	R5

$SNAP:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	#60,R1
;		THIS MAKES THE STACK LOOK LIKE
;			OLD PC
;			R0
;		SP->	R1
;
;		SO THE SP PRIOR TO THE CALL IS SP + 6

	JSR	PC,REGOUT
	MOV	(SP),R0
	JSR	PC,REGOUT
	MOV	R2,R0
	JSR	PC,REGOUT
	MOV	R3,R0
	JSR	PC,REGOUT
	MOV	R4,R0
	JSR	PC,REGOUT
	MOV	R5,R0
	JSR	PC,REGOUT
	MOV	SP,R0
	ADD	#6,R0
	JSR	PC,REGOUT
	MOV	4(SP),R0
	JSR	PC,REGOUT

	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC

REGOUT:	MOVB	R1,REGNO
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)

	POINT	R1,WORK
	MOV	#6,R3
	BR	1$

2$:	MOV	#3,R2
3$:	CLC
	ROR	R0
	SOB	R2,3$

1$:	MOV	R0,R2
	BIC	#177770,R2
	ADD	#60,R2
	MOVB	R2,-(R1)

	SOB	R3,2$

	JSR	R5,PRINT
	.WORD	REGMSG-2-.

	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	INC	R1
	RTS	PC

REGMSG:	.ASCII	/REG /
REGNO:	.BYTE	60
	.ASCII	/ = /
	.BYTE	60,60,60,60,60,60
WORK:	.BYTE	CR,LF,0,0
	.EVEN
.ENDC
	.DREND	PH
	.END