.TITLE	P
;PROCESSDPY
;IN PLACE OF OLD J PROGRAM
;

	.SBTTL		DEFINITIONS

	.LIBRARY	@SYS$LIBRARY:LIB@
	.LIBRARY	@DPYDEF@
	$TTDEF
	$FH2DEF
	$FI2DEF
	$ATRDEF
	$LOGDEF				;LOGICAL NAME TABLE DEFINITIONS
	$SETIMRDEF			;SET TIMER DEFINITIONS
	$IRPDEF				;I/O REQUEST PACKET
	$DCDEF				;DEVICE TYPES
	$PRVDEF				;PRIVILEGE BIT DEFINITIONS
	$FAODEF				;FAO CALL
	$CEBDEF				;COMMON EVENT FLAG BLOCKS
	$FIBDEF				;FILE INFO BLOCK
	$DQFDEF				;DISK QUOTA ENTRY
	$DEVDEF				;DEVICES
	$VCBDEF				;VOLUME CONTROL BLOCKS
	$FCBDEF				;FILE CONTROL BLOCK
	$PSLDEF				;PSL DEFINITIONS
	$PRIDEF				;PRIORITY INCREMENTS
	$PHDDEF				;PHD SYMBOLS
	$JIBDEF				;JIB SYMBOLS
	$PCBDEF				;PCB SYMBOLS
	$CCBDEF				;CHANNEL CONTROL BLOCKS
	$WCBDEF				;WINDOW CONTROL BLOCK
	$UCBDEF				;UCB
	$DDBDEF				;DDB
	$IFDDEF				;IMAGE FILE DESCRIPTOR
	$ACBDEF				;AST CONTROL BLOCK DEFINITIONS
	$JPIDEF
	$STATEDEF			;SCHEDULAR STATES


COMMA=^X2C

;# OF SCANS BEFORE FIXING THE CPU TIME:

	SCANMAX=50

	.SBTTL		TERMINAL UCB STUFF

;FROM TTYUCBDEF.MAR:

	UCB$W_TT_INAHD=^X92
	UCB$L_TT_WRTBUF=^XB4
	UCB$L_TT_WFLINK=^XAC
	UCB$L_TT_WBLINK=^XB0
	UCB$L_TT_TYPAHD=^X88
	UCB$L_TT_STATE=UCB$K_LENGTH

	$DEFINI		TTY

	$VIELD		TTY,0,<-
		<ST_XON,,M>-
		<ST_XOFF,,M>-
		<ST_CTRLS,,M>-
		<ST_FILL,,M>-
		<ST_CURSOR,,M>-
		<ST_SENDLF,,M>-
		<ST_MULTI,,M>-
		<ST_WRITE,,M>-
		<ST_BRDCST,,M>-
		<ST_EOL,,M>-
		<ST_CTRLR,,M>-
		<ST_READ,,M>-
		<ST_CTRLO,,M>-
		<ST_DEL,,M>-
		<ST_PASALL,,M>-
		<ST_NOECHO,,M>-
		<ST_WRTALL,,M>-
		<ST_PROMPT,,M>-
		<ST_NOFLTR,,M>-
		<ST_ESC,,M>-
		<ST_BADESC,,M>-
		<ST_NL,,M>-
		<ST_REFRSH,,M>-
		<ST_TYPFUL,,M>-
		<ST_SKIPLF,,M>-
		<ST_GETAHD,,M>-
		<ST_UNSOL,,M>-
		<ST_ESC_O,,M>-
		<ST_CTRLSP,,M>-
		<ST_WRAP,,M>-
	>
	$DEFEND		TTY

	$DEFINI		TTY

$DEF	TTY$L_RB_NXT	.BLKL	1
$DEF	TTY$L_RB_UVA	.BLKL	1
$DEF	TTY$L_RB_SIZE	.BLKL	1
			.BLKB	1
			.BLKB	1
$DEF	TTY$W_RB_ORGHOR	.BLKW	1
$DEF	TTY$W_RB_TIMOS	.BLKW	1
$DEF	TTY$L_RB_DATA	.BLKL	1

	$DEFEND		TTY

	$DEFINI		TTY

$DEF	TTY$L_WB_FLINK	.BLKL	1
$DEF	TTY$L_WB_BLINK	.BLKL	1
$DEF	TTY$W_WB_SIZE	.BLKW	1
$DEF	TTY$B_WB_TYPE	.BLKB	1
$DEF	TTY$B_WB_FIPL	.BLKB	1
$DEF	TTY$L_WB_NEXT	.BLKL	1
$DEF	TTY$L_WB_END	.BLKL	1
$DEF	TTY$L_WB_IRP	.BLKL	1
$DEF	TTY$W_WB_STATUS	.BLKW	1
$DEF	TTY$W_WB_BCNT	.BLKW	1
$DEF	TTY$L_WB_DATA	.BLKL	1

	$DEFEND		TTY

	$DEFINI		TTY

$DEF	TTY$L_TA_PUT	.BLKL	1
$DEF	TTY$L_TA_GET	.BLKL	1
$DEF	TTY$W_TA_SIZE	.BLKW	1
$DEF	TTY$B_TA_TYPE	.BLKB	1
			.BLKB	1
$DEF	TTY$L_TA_END	.BLKL	1
$DEF	TTY$L_TA_DATA	.BLKL	1

	$DEFEND		TTY

	.SBTTL	SPECIAL MACROS

	.MACRO	MAKFAO	PRMLST
		XX=0
	.IRP	FOO,<'PRMLST'>
		DOFAO	%EXTRACT(0,1,FOO),%LOCATE(<=>,FOO),FOO

	.ENDR
	.ENDM

	.MACRO	DOFAO		TYPE,POSIT,PARM
	.IF	NE,<^A/'TYPE'/-^A/P/>
		MOVL		PARM,FAOPRM+<4*XX>
		.MEXIT
	.ENDC
	XXX=POSIT-1
	XXXX=XXX
	CHKFAO	%EXTRACT(XXX,1,PARM)
	XX=%EXTRACT(1,XXX,PARM)
	ZZZ=%LENGTH(PARM)
	ZZ=XXXX+2
	.IF	EQ,<XXX-XXXX>
		MOVAL		%EXTRACT(ZZ,ZZZ,PARM),-
				FAOPRM+<4*<XX-1>>
	.IF_FALSE
		MOVL		%EXTRACT(ZZ,ZZZ,PARM),-
				FAOPRM+<4*<XX-1>>
	.ENDC
	.ENDM


	.MACRO	CHKFAO		ARG

	.IF	EQ,<^A/'ARG'/-^A/V/>
		XXX=XXX-1
	.ENDC
	.ENDM

	.SBTTL	INITIALIZATION

;SETUP

	.PSECT		CODE,RD,NOWRT,EXE

	.ENTRY	P,^M<R2,R3,R4,R5,R6,R7>

	$GETJPI_S	ITMLST=MYSTF		;FIND WHO I AM
	DPY$SETUP				;SET UP CHMU HANDLER
	INI$		#-1			;SET UP DPY
	$ASSIGN_S	CHAN=TTCHN,DEVNAM=TTDEV	;SET UP
	PUSHAL		CMDEFN
	CALLS		#1,LIB$GET_EF
	PUSHAL		IOEFN
	CALLS		#1,LIB$GET_EF
	PUSHAL		SLPEFN
	CALLS		#1,LIB$GET_EF
	$QIOW_S		EFN=CMDEFN,-
			CHAN=TTCHN,FUNC=#IO$_SETMODE!IO$M_CTRLCAST,-
			IOSB=IOSB,-
			P1=CCAST
	$QIO_S		EFN=CMDEFN,-
			CHAN=TTCHN,-
			FUNC=#IO$_READVBLK!IO$M_NOECHO!IO$M_CVTLOW,-
			IOSB=IOSB,ASTADR=DOCMD,-
			P1=TTIBUF,P2=#1

	.SBTTL		MAIN LOOP

LOOP:	BBC		#FLG$V_SUM,PFLG,10$
	BRW		DOSUM
10$:	CALLS		#0,GETINF		;GET INFO ON PROCESS
	CMPL		#SS$_NONEXPR,R0		;NON-EXISTANT?
	BNEQ		FDSP			;NO
	SIZ$		MINLIN=#0,MAXLIN=#-1,MINCOL=#0,MAXCOL=#-1
	STR$		CRLF			;CLEAR SCREEN
	BRW		DONE

		.SBTTL DISPLAY ROUTINE

;THIS ROUTINE FORMATS THE DATA FOR "EASY" VIEWING
;WE DO THE FILE STUFF FIRST SO WE ARE CLOSER IN TIME TO THAT POINT
;IN WHICH THE CHANNEL DATA WAS GATHERED

FDSP:
	SIZ$		MINLIN=#13,MAXCOL=#-1,MINCOL=#0,MAXCOL=#-1
	TAB$		DEVTBS				;SET TAB MASK
	MOVAB		CCB+^X800-CCB$K_LENGTH,R2	;POINT TO BASE-1
	CLRL		R3
	CLRW		CCBCNT
CCBLP:	ACBW		CCBLIM,#1,CCBCNT,5$		;SKIP CHANNELS
	TSTB		CCB$B_AMOD(R2)			;ASSIGNED?
	BNEQ		10$
5$:	BRW		NXTCCB
10$:	PUSHR		#^M<R2,R3>			;SAVE
	MOVC5		#0,FCBSTRT,#0,#FCBLEN,FCBSTRT	;ZAP ALL BLOCKS
	POPR		#^M<R2,R3>
	SUBL3		#CCB+^X800,R2,CURCHN		;GET CURRENT CHANNEL
	PUSHAB		UCB				;UCB IS DESTINATION
	PUSHL		CCB$L_UCB(R2)			;POINT THERE
	MNEGL		#UCB$K_TT_LENGTH,-(SP)
	PUSHL		#3
	MOVL		SP,R4				;POINT TO LIST
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)	;GET THE UCB
	MOVL		CCB$L_UCB(R2),UCBADR		;SAVE UCB ADDRESS
	$CMEXEC_S	ROUTIN=FNDIRP,ARGLST=(R4)	;FIND THE IRPS
NOIO:	MOVL		#-1000,4(SP)			;GET WCB IF
	MOVL		IRP+IRP$L_WIND,8(SP)
	BNEQ		20$
	MOVL		CCB$L_WIND(R2),8(SP)
	BGTR		NOWCB
20$:	MOVAB		WCB,12(SP)			;..
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)	;POINT THERE
NOWCB:	MOVL		#FCB$K_LENGTH,4(SP)
	MOVL		WCB+WCB$L_FCB,8(SP)
	MOVAB		FCB,12(SP)
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)
	MOVL		#DDB$K_LENGTH,4(SP)
	MOVL		UCB+UCB$L_DDB,8(SP)
	MOVAB		DDB,12(SP)
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)
	MOVL		#VCB$K_LENGTH,4(SP)
	MOVL		UCB+UCB$L_VCB,8(SP)
	MOVAB		VCB,12(SP)
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)
;NOTE THAT STACK IS NOT YET FIXED, BECUASE WE MAY WANT THIS ARG LIST LATER
;NOTE THAT R4 CANNOT BE DESTOYED EITHER YET

;DISPLAY DEVICE NAME, UNIT NUMBER

	MOVAQ		DV1CTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1=DDB+DDB$T_NAME,P2V=UCB+UCB$W_UNIT>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;DO VCB IF PRESENT, AND A "REAL" VCB

	CMPB		#DYN$C_VCB,VCB+VCB$B_TYPE
	BNEQ		NOVCB1
	BBS		#DEV$V_SPL,UCB+UCB$L_DEVCHAR,NOVCB1	;WRONG TYPE
	MOVAQ		VOLCTR,FAOLST+FAO$_CTRSTR
	MOVAB		VCB+VCB$T_VOLNAME,R1			;POINT TO NAME
	MOVL		#9,R0
VOLLP:	LOCC		#^A/ /,R0,(R1)				;LOCATE / /
	BEQL		10$
	PUSHL		R0					;SAVE CHARS
	SKPC		#^A/ /,R0,(R1)
	BNEQ		VOLLP
	POPL		R0
10$:	SUBL3		R0,#9,R0
	MAKFAO		<P1V=R0,P2=VCB+VCB$T_VOLNAME>
	$FAOL_G		FAOLST
	STR$		OUTDSC

	.SBTTL		ACCESS MODE OF ALLOCATION

NOVCB1:	MOVZBL		CCB$B_AMOD(R2),R0
	MOVAB		MODES-1(R0),R0
	MAKFAO		<P1V=#1,P2=(R0)>
	MOVAQ		MODCTR,FAOLST+FAO$_CTRSTR
	$FAOL_G		FAOLST
	STR$		OUTDSC

;SAY IF DEVICE IS MOUNTED FOREIGN
	BBC		#DEV$V_FOR,UCB+UCB$L_DEVCHAR,310$
	STR$		FOREIGN
310$:

;SEE IF DEVICE IS TERMINAL

TRYTTY:	CMPB		#DC$_TERM,UCB+UCB$B_DEVCLASS		;TERMINAL?
	BEQL		10$
5$:	BRW		NOTERM
10$:	MOVAB		BUFIO,12(R4)
	MOVL		#-200,4(R4)				;MAX LENGTH
	BBC		#UCB$V_BSY,UCB+UCB$W_STS,20$
	MOVAB		@IRP+IRP$L_SVAPTE,8(R4)			;BUFIO BUFFER
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)		;CALL
	BLBC		R0,20$
	BRW		30$
20$:	BBC		#TTY$V_ST_WRITE,UCB+UCB$L_TT_STATE,25$	;OUTPUT STATE?
	TSTW		CCB$W_IOC(R2)				;ACTIVE ON THIS CHAN?
	BEQL		25$					;NO, IGNORE
	MOVAB		@UCB+UCB$L_TT_WRTBUF,8(R4)
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)		;GET BUFFER
	BLBC		R0,25$
	MOVAB		BUFIO+TTY$L_WB_DATA,R0
	ADDL3		#TTY$L_WB_DATA,8(R4),OUTDSC
	SUBL3		OUTDSC,BUFIO+TTY$L_WB_END,OUTDSC
	BLEQ		25$
	CMPB		#DYN$C_IRP,IRP+IRP$B_TYPE
	BEQL		23$
	MOVB		#DYN$C_IRP,IRP+IRP$B_TYPE		;IF NOT THERE,
	MOVW		#IO$_WRITEVBLK,IRP+IRP$W_FUNC		;FAKE A WRITE
23$:	BRW		32$
25$:	MOVZWL		UCB+UCB$W_TT_INAHD,-(SP)		;ANY TYPAHD?
	BGTR		27$
26$:	CLRL		(SP)+
	BRW		50$
27$:	MOVAB		@UCB+UCB$L_TT_TYPAHD,8(R4)
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)		;GET BUFFER
	BLBC		R0,26$					;NONE
	SUBL3		8(R4),BUFIO+TTY$L_TA_GET,R0		;SET OFFSET
	MOVAB		BUFIO(R0),R0				;SET ADDRESS
	POPL		R1
	BRB		32$
30$:	BBC		#TTY$V_ST_READ,UCB+UCB$L_TT_STATE,31$
	MOVW		#IO$_READVBLK,IRP+IRP$W_FUNC		;FAKE READ
31$:	MOVAB		BUFIO+TTY$L_RB_DATA,R0
	SUBL3		IRP+IRP$L_SVAPTE,BUFIO,R1		;CHARACTERS
	SUBL2		#TTY$L_RB_DATA,R1			;NO HEADER
	BLEQ		50$
32$:	SUBL3		R0,#BUFIO+200,-(SP)
	BLEQ		47$
	CMPL		(SP),R1
	BGEQ		40$
	MOVL		(SP),R1
40$:	MOVL		#35,OUTDSC
	PUSHR		#^M<R2,R3,R4,R5>
	MOVTC		R1,(R0),#^A/ /,NOCTL,OUTDSC,@OUTDSC+4
	POPR		#^M<R2,R3,R4,R5>
45$:	STR$		OUTDSC
47$:	CLRL		(SP)+					;FIX STACK
50$:
NOTERM:

;IF AN FCB EXISTS, DISPLAY FILE INFORMATION

DOFCB:	CMPB		#DYN$C_FCB,FCB+FCB$B_TYPE	;GET THE FCB?
	BEQL		315$
	BRW		NOFCB1
315$:	TSTL		FCB+FCB$W_FID
	BNEQ		317$
	BRW		320$
317$:	MOVAQ		DEVNAMCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1=DDB+DDB$T_NAME,P2V=UCB+UCB$W_UNIT>
	$FAOL_G		FAOLST
	$ASSIGN_S	CHAN=DSKCHN,DEVNAM=OUTDSC
	BLBC		R0,320$
	PUSHR		#^M<R2,R3,R4,R5>
	MOVC5		#0,FIB+FIB$W_DID,#0,#6,FIB+FIB$W_DID
	MOVC3		#6,FCB+FCB$W_FID,FIB+FIB$W_FID
	POPR		#^M<R2,R3,R4,R5>
	$QIOW_S		EFN=IOEFN,-
			CHAN=DSKCHN,FUNC=#IO$_ACCESS,-
			IOSB=DQIOSB,-
			P1=FIBDSC,P5=#ATRLST
	$DASSGN_S	CHAN=DSKCHN
320$:	MOVAQ		DV3CTR,FAOLST+FAO$_CTRSTR
	MOVZBL		FILHDR+FH2$B_IDOFFSET,R0	;POINT TO NAME
	ASHL		#1,R0,R0			;TO BYTES
	MAKFAO		<P1V=FCB+FCB$W_FID,P2V=FCB+FCB$W_FID+2,-
			P3V=FCB+FCB$W_FID+4,P4V=#20,-
			P5=FILHDR+FI2$T_FILENAME(R0)>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;DISPLAY # OF REQUESTS OUTSTANDING ON THIS DEVICE

NOFCB1:	BICL2		#FLG$M_RW,PFLG			;BE SURE CLEAR
	MOVAB		SPACE,R0			;ASSUME NOIO
	TSTW		CCB$W_IOC(R2)
	BEQL		DOIOC
	CMPB		#DYN$C_IRP,IRP+IRP$B_TYPE	;FIND THE IRP?
	BNEQ		DOIOC				;NO
	EXTZV		#IRP$V_FCODE,#IRP$S_FCODE,IRP+IRP$W_FUNC,R1
	CMPL		R1,#IO$_WRITEVBLK
	BEQL		ISWRT
	CMPL		R1,#IO$_WRITELBLK
	BEQL		ISWRT
	CMPL		R1,#IO$_WRITEPBLK
	BNEQ		TRYRD
ISWRT:	BISL2		#FLG$M_RW,PFLG			;KNOWN AS WRITE
	MOVAB		RTAB,R0
	BRB		DOIOC
TRYRD:	CMPL		R1,#IO$_READVBLK
	BEQL		ISRD
	CMPL		R1,#IO$_READLBLK
	BEQL		ISRD
	CMPL		R1,#IO$_READPBLK
	BNEQ		DOIOC
ISRD:	MOVAB		LTAB,R0
	BISL2		#FLG$M_RW,PFLG			;KNOWN AS READ
DOIOC:	MOVAQ		DVSTSCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1V=CCB$W_IOC(R2),P2V=#1,P3=(R0)>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;SEE ABOUT PARAMETERS FOR CURRENT BLOCK

	CMPB		#DYN$C_FCB,FCB+FCB$B_TYPE
	BNEQ		NOFCB2
	MOVL		WCB+WCB$L_STVBN,R0		;DEFAULT MAPPED
	MOVAQ		DVVBNMCTR,FAOLST+FAO$_CTRSTR	;AND THAT CTR
	BBCC		#FLG$V_RW,PFLG,NOIRP1		;NO IRP IF NOT R/W
	CMPB		#DYN$C_IRP,IRP+IRP$B_TYPE	;IS THERE AN IRP?
	BNEQ		NOIRP1				;NO
	MOVL		IRP+IRP$L_MEDIA,R0		;GET PHYS ADDR
	BSBW		PHYTOVIR			;CONVERT TOVIRT
	MOVAQ		DVVBNCTR,FAOLST+FAO$_CTRSTR
	TSTL		R0
	BGEQ		NOIRP1
	MOVAQ		DVVBNQCTR,FAOLST+FAO$_CTRSTR	;DON'T KNOW NUMBER
	MAKFAO		P1V=FCB+FCB$L_FILESIZE
	BRB		DOBN
NOIRP1:	MAKFAO		<P1V=R0,P2V=FCB+FCB$L_FILESIZE>	;OUTPUT
	BRB		DOBN
NOFCB2:	CMPB		#DC$_DISK,UCB+UCB$B_DEVCLASS	;DISK?
	BNEQ		CHKTRM2				;IGNORE "LBN" THEN
	BBCC		#FLG$V_RW,PFLG,GOACMOD		;IRP IS NOT A R/W IRP
	CMPB		#DYN$C_IRP,IRP+IRP$B_TYPE	;IS THERE AN IRP?
	BNEQ		GOACMOD				;NO, NOTHING TO DO
	MOVL		IRP+IRP$L_MEDIA,R0		;GET PHYS ADR
	BSBW		PHYTOLOG			;USE LBN
	MOVAQ		DVLBNCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		P1V=R0
DOBN:	$FAOL_G		FAOLST
	STR$		OUTDSC				;OUTPUT IT
GOACMOD:
	BRW		ACMODE

CHKTRM2:
	CMPB		#DC$_TERM,UCB+UCB$B_DEVCLASS
							;IS IT A TTY?
	BNEQ		GOACMOD
	PUSHL		#32				;# OF BITS
	PUSHL		#0				;OFFSET
TTSTATE:
	FFS		(SP),4(SP),UCB+UCB$L_TT_STATE,R0;FIND STATE BIT
	BEQL		TTSTATEND
	SUBL2		R0,4(SP)
	MOVL		R0,(SP)				;SAVE
	MOVL		TTSTTAB[R0],R0
	STR$		(R0)
	INCL		(SP)
	DECL		4(SP)
	BGTR		TTSTATE
TTSTATEND:
	CLRQ		(SP)+				;FIX STACK
	MOVZBL		UCB+UCB$B_TT_SPEED,R0
	MOVZBL		UCB+UCB$B_TT_DESPEE,R1
	MOVAQ		SPDCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1V=TRMSPD[R0],P2V=TRMSPD[R1]>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;ACCESS MODE OF ALLOCATION
ACMODE:
	BBC		#DEV$V_ALL,UCB+UCB$L_DEVCHAR,320$
	CMPL		UCB+UCB$L_PID,PCB+PCB$L_PID	;BUT NOT UNLESS
	BNEQ		320$				;TO THIS PROCESS
	MOVZBL		UCB+UCB$B_AMOD,R0
	MOVAB		MODES(R0),R0
	MOVAQ		ALLOCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1V=#1,P2V=R0>
	$FAOL_G		FAOLST
	STR$		OUTDSC
320$:	STR$		CRLF				;DONE

;GO TO NEXT DEVICE NOW

NXTCCB:	SUBL2		#CCB$K_LENGTH,R2
	AOBLEQ		#127,R3,400$
	BRB		450$
400$:	BRW		CCBLP

;BEGIN SEARCH FOR DEVICES WHICH ARE ALLOCATED BUT HAVE NOT CHANNELS ASSIGNED

450$:	CLRL		DEVCHN				;NO DEVS FOUND
	MOVL		@#IOC$GL_DEVLIST,LSTDDB		;POINT TO DDB
DEVLP:	PUSHL		R4				;SAVE
	MOVC5		#0,FCBSTRT,#0,#FCBLEN,FCBSTRT	;ZAP ALL BLOCKS
	POPL		R4				;..
	$CMEXEC_S	ROUTIN=FNDUCB			;SEE IF ANY UCB'S
	BLBS		R0,330$
	BRW		DONDEV
330$:	MOVZBL		UCB+UCB$B_AMOD,R0
	MOVAB		MODES(R0),R0
	MOVAQ		ALLO2CTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1=DDB+DDB$T_NAME,P2V=UCB+UCB$W_UNIT,P3V=#1,P4=(R0)>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	BBC		#DEV$V_FOR,UCB+UCB$L_DEVCHAR,335$
	STR$		FOREIGN
335$:	BBS		#DEV$V_SPL,UCB+UCB$L_DEVCHAR,340$ ;FAKE "VCB" HERE
	CMPB		#DYN$C_VCB,VCB+VCB$B_TYPE
	BNEQ		340$
	MOVAQ		VOLCTR,FAOLST+FAO$_CTRSTR
	MOVAB		VCB+VCB$T_VOLNAME,R1			;POINT TO NAME
	MOVL		#9,R0
336$:	LOCC		#^A/ /,R0,(R1)				;LOCATE / /
	BEQL		337$
	PUSHL		R0					;SAVE CHARS
	SKPC		#^A/ /,R0,(R1)
	BNEQ		336$
	POPL		R0
337$:	SUBL3		R0,#9,R0
	MAKFAO		<P1V=R0,P2=VCB+VCB$T_VOLNAME>
	$FAOL_G		FAOLST
	STR$		OUTDSC
340$:	CMPB		#DC$_TERM,UCB+UCB$B_DEVCLASS		;TERMINAL?
	BEQL		350$
345$:	BRW		360$
350$:	MOVW		UCB+UCB$W_TT_INAHD,OUTDSC		;ANY TYPAHD?
	BLEQ		345$
	MOVAB		BUFIO,12(R4)
	MOVAB		@UCB+UCB$L_TT_TYPAHD,8(R4)
	MNEGL		#100,4(R4)
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)		;GET BUFFER
	BLBC		R0,360$					;NONE
	SUBL3		8(R4),BUFIO+4,R0			;SET OFFSET
	MOVAB		BUFIO(R0),R0				;SET ADDRESS
	CMPL		OUTDSC,#35				;TOO MANY?
	BLEQ		355$
	MOVL		#35,OUTDSC
355$:	CLRL		R1					;INDEX
356$:	MOVB		(R0)[R1],@OUTDSC+4[R1]		;MOVE CHAR
	CMPB		#^A/ /,@OUTDSC+4[R1]
	BLEQ		358$
	MOVB		#^A/ /,@OUTDSC+4[R1]
358$:	AOBLSS		OUTDSC,R1,356$
	STR$		OUTDSC
360$:	STR$		CRLF
	BRW		DEVLP
DONDEV:	ADDL2		#4*4,SP				;FIX STACK
	TAB$						;RESET TABS

;NOW DISPLAY BASIC JOB INFORMATION
;FIRST LINE:  PID, USER, LOGIN TERMINAL AND TIME

FIRST:	SIZ$		MINLIN=#0,MAXLIN=#12,MINCOL=#0,MAXCOL=#-1
	TSTL		PHD+PHD$L_PCB		;DID WE GET PHD?
	BNEQ		HAVPHD			;YES
	PUSHL		PCB+PCB$L_PID		;NO, GIVE ONE MORE TRY
	PUSHL		#1
	MOVAL		(SP),R0
	$CMKRNL_S	ROUTIN=GETPHD,ARGLST=(R0)
	CLRQ		(SP)+
HAVPHD:	MOVZBL		#12,R2
	SKPC		#0,#12,USERNAM
	BNEQ		5$
	CLRL		R2
5$:	MOVAQ		LINE1,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1V=PCB+PCB$L_PID,P2=PCB+PCB$T_LNAME,P3V=R2,-
			P4=USERNAM>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	CMPC3		#12,USERNAM,JIB+JIB$T_USERNAME
	BEQL		SAMNAM
	MOVAQ		OTHRUSR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1V=#12,P2=JIB+JIB$T_USERNAME>
	$FAOL_G		FAOLST
	STR$		OUTDSC
SAMNAM:	STR$		LINE1C
	MOVZWL		PCB+PCB$L_UIC+2,R0
	CALLS		#0,OCTDPY
	CHR$		#COMMA
	MOVZWL		PCB+PCB$L_UIC,R0
	CALLS		#0,OCTDPY
	MOVAB		LMSG,R1
	BBC		#PCB$V_LOGIN,PCB+PCB$L_STS,10$
	MOVAB		SMSG,R1
10$:	MOVAQ		LINE1B,FAOLST+FAO$_CTRSTR
	TSTL		LOGINT+4
	BNEQ		20$
	TSTL		LOGINT				;JUST IN CASE
	BNEQ		20$
	MOVAQ		LINE1D,FAOLST+FAO$_CTRSTR
20$:	MAKFAO		<P1=PCB+PCB$T_TERMINAL,P2=(R1),P3=LOGINT>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;SECOND LINE:  IMAGE NAME, STATE, AST STUFF
	SUBB3		PCB+PCB$B_PRI,#^X1F,PRI
	SUBB3		PCB+PCB$B_PRIB,#^X1F,PRIB
	MOVZWL		PCB+PCB$W_STATE,R0
	MOVAB		UNKSTT,R1
	CMPL		#STATEMAX,R0
	BLSS		200$
	MOVL		STTTAB[R0],R1
200$:	MOVAQ		LINE2,FAOLST+FAO$_CTRSTR
	TSTL		PHD+PHD$L_PCB
	BNEQ		250$
	MOVAQ		LINE2B,FAOLST+FAO$_CTRSTR
250$:	MAKFAO		<P1=IMGNAM,P2V=PHD+PHD$L_IMGCNT,P3V=PRI,P4V=PRIB,-
			P5=(R1)>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	MOVZBL		PCB+PCB$B_ASTACT,R0
	BSBW		ASTDSP

;THIRD LINE:  CORE SIZES, CPU TIMES, MORE AST STUFF

THIRD:	EMUL		#-100*1000,PHD+PHD$L_CPUTIM,#0,CPUTIM
	CLRQ		R2
	SUBW3		PHD+PHD$W_WSLIST,PHD+PHD$W_WSAUTH,R2
	SUBW3		PHD+PHD$W_WSLIST,PHD+PHD$W_WSQUOTA,R3
	INCW		R2
	INCW		R3
	CLRL		R4
	SUBW3		PHD+PHD$W_WSLIST,PHD+PHD$W_WSLAST,R4
	INCW		R4
	MOVAQ		LINE3,FAOLST+FAO$_CTRSTR
	TSTL		PHD+PHD$L_PCB
	BNEQ		10$
	MOVAQ		LINE3NPH,FAOLST+FAO$_CTRSTR
10$:	MAKFAO		<P1V=PCB+PCB$W_GPGCNT,P2V=PCB+PCB$W_PPGCNT,-
			P3V=R4,P4V=R3,P5V=R2,P6=CPUTIM>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	MOVAQ		TAB,R1
	TSTL		PHD+PHD$L_CPULIM
	BEQL		NOLIM
	EMUL		#-100*1000,PHD+PHD$L_CPULIM,#0,CPULIM
	MOVAQ		CPLCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		P1=CPULIM
	$FAOL_G		FAOLST
	MOVAQ		OUTDSC,R1
NOLIM:	STR$		(R1)
	STR$		ASTEN
	MOVZBL		PCB+PCB$B_ASTEN,R0
	BSBW		ASTDSP

;FOURTH LINE: NON DISK QUOTAS

FOURTH:	MOVAQ		LINE4,FAOLST+FAO$_CTRSTR
	TSTL		PHD+PHD$L_PCB
	BNEQ		10$
	MOVAQ		LINE4NPH,FAOLST+FAO$_CTRSTR
10$:	MAKFAO		<P1V=JIB+JIB$L_BYTCNT,P2V=JIB+JIB$L_BYTLM,-
			P3V=PCB+PCB$W_BIOCNT,P4V=PCB+PCB$W_BIOLM,-
			P5V=PHD+PHD$L_BIOCNT,-
			P6V=PCB+PCB$W_DIOCNT,P7V=PCB+PCB$W_DIOLM,-
			P8V=PHD+PHD$L_DIOCNT,-
			P9V=PCB+PCB$W_ASTCNT,P10V=PHD+PHD$W_ASTLM,-
			P11V=JIB+JIB$W_FILCNT,P12V=JIB+JIB$W_FILLM>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;LINE 5:  PAGE STATISTICS

PAGE:	SUBL3		PHD+PHD$L_P1LR,#1@21+1,R0
	ADDL2		PHD+PHD$L_P0LRASTL,R0
	MOVAQ		LINE5,FAOLST+FAO$_CTRSTR
	TSTL		PHD+PHD$L_PCB
	BNEQ		10$
	MOVAQ		LINE5NPH,FAOLST+FAO$_CTRSTR
10$:	MAKFAO		<P1V=PHD+PHD$L_PAGEFLTS,P2V=R0,-
			P3V=JIB+JIB$L_PGFLCNT,P4V=JIB+JIB$L_PGFLQUOTA,-
			P5V=JIB+JIB$W_PRCCNT,P6V=JIB+JIB$W_PRCLIM>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;PRIVILEGE VECTORS, TIMER QUEUE QUOTAS, STATUS

DOPRV:	MOVAQ		PRVCTR,FAOLST+FAO$_CTRSTR
	TSTL		PHD+PHD$L_PCB
	BNEQ		10$
	MOVAQ		PRVCTR2,FAOLST+FAO$_CTRSTR
10$:	MAKFAO		<P1V=JIB+JIB$W_TQCNT,P2V=JIB+JIB$W_TQLM,-
			P3V=PCB+PCB$L_STS,P4V=PCB+PCB$L_OWNER,-
			P5V=PCB+PCB$W_MTXCNT,-
			P6V=PRIVS,P7V=PRIVS+4,-
			P8V=PHD+PHD$Q_PRIVMSK,P9V=PHD+PHD$Q_PRIVMSK+4,-
			P10V=PHD+PHD$Q_IMAGPRIV,P11V=PHD+PHD$Q_IMAGPRIV+4,-
			P12V=PHD+PHD$Q_AUTHPRIV,P13V=PHD+PHD$Q_AUTHPRIV+4>
	$FAOL_G		FAOLST
	STR$		OUTDSC

;EVENT FLAGS:

DOEFN:	MOVAQ		EFNMCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		P1V=PCB+PCB$L_EFWM
	$FAOL_G		FAOLST
	STR$		OUTDSC
	MOVAQ		EFNCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		P2V=#1					;SET P2
	MOVAB		COLON,R0
	TSTB		PCB+PCB$B_WEFC
	BNEQ		10$
	MOVAB		RTAB,R0
10$:	MAKFAO		<P1=ZERO,P3=(R0),P4V=PCB+PCB$L_EFCS>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	MOVAB		COLON,R0
	CMPB		#1,PCB+PCB$B_WEFC
	BNEQ		20$
	MOVAB		RTAB,R0
20$:	MAKFAO		<P1=ONE,P3=(R0),P4V=PCB+PCB$L_EFCU>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	MAKFAO		P1=CEB+CEB$T_EFCNAM
	PUSHAL		CEB
	CLRL		-(SP)
	PUSHL		#CEB$K_LENGTH
	PUSHL		#3
	MOVL		SP,R4
	MOVL		PCB+PCB$L_EFC2P,8(SP)
	BEQL		NOEFN2
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)
	BLBC		R0,NOEFN2
	MOVAB		COLON,R0
	CMPB		#2,PCB+PCB$B_WEFC
	BNEQ		30$
	MOVAB		RTAB,R0
30$:	MAKFAO		<P3=(R0),P4V=CEB+CEB$L_EFC>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	BBC		#CEB$V_PERM,CEB+CEB$B_STS,NOEFN2
	CHR$		#^A/*/
NOEFN2:	MOVL		PCB+PCB$L_EFC3P,8(SP)
	BEQL		NOEFN3
	$CMEXEC_S	ROUTIN=GETMEM,ARGLST=(R4)
	BLBC		R0,NOEFN3
	CMPB		#3,PCB+PCB$B_WEFC
	BNEQ		40$
	MOVAB		RTAB,R0
40$:	MAKFAO		<P3=(R0),P4V=CEB+CEB$L_EFC>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	BBC		#CEB$V_PERM,CEB+CEB$B_STS,NOEFN3
	CHR$		#^A/*/
NOEFN3:	CLRQ		(SP)+
	CLRQ		(SP)+
	STR$		CRLF

;STACK POINTERS, PC, AND CURRENT ACCESS MODE:

STKS:	TSTL		PHD+PHD$L_PCB
	BNEQ		DOSTK
	STR$		CRLF
	BRW		NOSTK
DOSTK:	EXTZV		#PSL$V_CURMOD,#PSL$S_CURMOD,PHD+PHD$L_PSL,R5
	BBS		#PSL$V_CM,PHD+PHD$L_PSL,99$
	CMPL		#PSL$C_USER,R5
	BGEQ		100$
99$:	MOVZBL		#PSL$C_USER+1,R5		;SET UNDEFINED
;THE BELOW CODE DEPENDS ON THE FACT THAT THE STACK POINTERS ARE CONTIGUOUS
;IN THE PHD
100$:	CLRL		R4
110$:	MOVAB		SMOD(R4),R1
	MOVAB		SMODSP,R2
	CMPL		R4,R5				;CURRENT MODE?
	BNEQ		120$				;NO
	MOVAB		MODES(R5),R1			;YES
	MOVAB		MODSP,R2
120$:	MOVAQ		STKCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1V=#1,P2=(R1),P3=(R2),P4V=PHD+PHD$L_KSP[R4]>
	$FAOL_G		FAOLST
	STR$		OUTDSC
	AOBLEQ		#PSL$C_USER,R4,110$
	MOVAQ		PCCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		P1V=PHD+PHD$L_PC
	$FAOL_G		FAOLST
	STR$		OUTDSC
NOSTK:

;DIRECTORY STRING, ACCOUNT, AND DEFAULT PROTECTION

	TSTL		DEFDEV
	BEQL		NOL7
10$:	MOVAQ		LINE7,FAOLST+FAO$_CTRSTR
	MAKFAO		<P1V=DEFDEV,P2=DEFDEV+8,-
			P3=DDSTR,P4V=DEFPRO,P5V=#8,P6=ACCT>
	$FAOL_G		FAOLST
	STR$		OUTDSC
NOL7:

;DISK QUOTAS:

DISKQ:	MOVL		@#IOC$GL_DEVLIST,LSTDDB
	CLRL		DEVCHN				;CLEAR UCB NAME
	MAKFAO		P1=DEVDSC
DQLP:	$CMEXEC_S	ROUTIN=FNDDSK			;FIND A DISK
	BLBS		R0,10$
	BRW		DQDON
10$:	BSBW		MAKDSK
	$ASSIGN_S	CHAN=DSKCHN,DEVNAM=DEVDSC
	BLBS		R0,12$
	MOVAQ		UNKQTA,FAOLST+FAO$_CTRSTR
	$FAOL_G		FAOLST
	STR$		OUTDSC
	BRW		60$
12$:	MOVL		PCB+PCB$L_UIC,QUSBLK+DQF$L_UIC
	CLRL		QURBLK+DQF$L_USAGE
	CLRL		QURBLK+DQF$L_PERMQUOTA
	CLRL		QURBLK+DQF$L_OVERDRAFT
	$QIOW_S		EFN=IOEFN,-
			CHAN=DSKCHN,FUNC=#IO$_ACPCONTROL,-
			IOSB=DQIOSB,-
			P1=FIBDSC,P2=#QUSDSC,P4=#QURDSC
	CMPW		#SS$_NOQFILE,DQIOSB		;QUOTA FILE?
	BEQL		15$
	CMPW		#SS$_QFNOTACT,DQIOSB
	BNEQ		20$				;OR IF NOT ACTIVE
15$:	MOVAQ		INFQTA,FAOLST+FAO$_CTRSTR
	$FAOL_G		FAOLST
	STR$		OUTDSC
	BRB		60$
20$:	TSTL		QURBLK+DQF$L_PERMQUOTA		;IF ZERO
	BNEQ		40$
	TSTL		QURBLK+DQF$L_OVERDRAFT
	BNEQ		40$
	TSTL		QURBLK+DQF$L_USAGE
	BEQL		60$
40$:	MOVAQ		DQQCTR,FAOLST+FAO$_CTRSTR
	MAKFAO		<P2V=QURBLK+DQF$L_USAGE,P3V=QURBLK+DQF$L_PERMQUOTA,-
			P4V=QURBLK+DQF$L_OVERDRAFT>
	$FAOL_G		FAOLST
	STR$		OUTDSC
60$:	$DASSGN_S	CHAN=DSKCHN
	BRW		DQLP
DQDON:
	STR$		CRLF

	.SBTTL		DISPLAY

DONE:	BBCC		#FLG$V_REF,PFLG,10$
	REF$
	BRB		20$
10$:	DPY$
20$:	$CANWAK_S
	$SCHDWK_S	DAYTIM=SLPTIM
	$HIBER_S
	BRW		LOOP

	.SBTTL		SUMMARY ROUTINE


DOSUM:
	CLRQ		R5			;CLEAR INDEX & FRAME
	MOVL		FRAME,R7		;GET CURRENT FRAME
	BISL2		#FLG$M_NLL,PFLG		;ASSUME HAVE SEEN NULL
	MOVZWL		SOFFSET,PIX		;STARTING PID
	BNEQ		DOSUM1			;IF NOT STARTING AT BEGINNING
	BBCC		#FLG$V_NLL,PFLG,DOSUM1	;HAVE NOT SEEN "NULL" YET
DOSUM1:	INCL		R6			;INCREMENT FRAME COUNT
	TSTL		R7
	BEQL		0$
	CMPL		R6,R7
	BNEQ		1$
0$:	SIZ$		MINCOL=#0,MAXCOL=#40,-
			MINLIN=#0,MAXLIN=#-1
1$:	CLRL		R4
PRCLP:	$CMEXEC_S	ROUTIN=SUBPCB
	BLBS		R0,10$
	TSTL		R7
	BEQL		54$
	CMPL		R6,R7
	BNEQ		55$
54$:	MOVW		R0,-(SP)
	STR$		CRLF
	CMPW		#SS$_NOMOREPROC,(SP)+
	BNEQ		55$
	TSTL		R4			;PART OF FRAME?
	BNEQ		545$
	STR$		CRLF
	SIZ$		MINLIN=#0,MAXLIN=#-1,MINCOL=#41,MAXCOL=#-1
	STR$		CRLF
545$:	BRW		DONE
55$:	BRW		NXTPRC
10$:	TSTL		R7			;THIS FRAME ONLY?
	BEQL		15$			;NO
	CMPL		R6,R7
	BNEQ		NXTPRC
15$:	MOVAB		UNKSTT,R1
	MOVZWL		PCB+PCB$W_STATE,R0	;GET STATE
	CMPL		#STATEMAX,R0
	BLSS		20$
	MOVL		STTTAB[R0],R1
20$:	MOVAQ		SUMLIN,FAOLST+FAO$_CTRSTR
	SUBB3		PCB+PCB$B_PRI,#^X1F,PRI
	MAKFAO		<P1V=PCB+PCB$L_PID,P2=PCB+PCB$T_LNAME,P3V=PRI,-
			P4=(R1)>
	$FAOL_G		FAOLST
	STR$		OUTDSC
NXTPRC:	AOBLSS		#24,R5,27$
	BRB		28$
27$:	BRW		PRCLP
28$:	BBCS		#0,R4,30$
	TSTL		R7
	BEQL		25$
	CMPL		R7,R6
	BNEQ		29$
285$:	BRW		DONE
25$:	CMPL		PIX,@#SCH$GL_MAXPIX		;VERY LAST DONE?
	BGTR		285$
	DPY$
	$CANWAK_S
	$SCHDWK_S	DAYTIM=SLPTIM
	$HIBER_S
	BBS		#FLG$V_SUM,PFLG,29$
	BRW		LOOP
29$:	CLRL		R5
	BRW		DOSUM1
30$:	TSTL		R7
	BEQL		40$
	CMPL		R6,R7
	BNEQ		50$
40$:	SIZ$		MINCOL=#41,MAXCOL=#-1,-
			MINLIN=#0,MAXLIN=#-1
50$:	CLRL		R5
	BRW		PRCLP

	.ENTRY		SUBPCB,^M<R2,R3,R4,R5>

	MOVL		PIX,R0			;GET INDEX
5$:	CMPL		R0,@#SCH$GL_MAXPIX
	BLEQ		10$			;OK
	MOVZWL		#SS$_NOMOREPROC,R0
	RET
10$:	MOVL		@SCH$GL_PCBVEC[R0],R0	;GET PCB ADDRESS
	CMPL		R0,#SCH$GL_NULLPCB	;IS IT NULL?
	BNEQ		20$			;NO
	BBCS		#FLG$V_NLL,PFLG,20$
	MOVZWL		#SS$_NONEXPR,R0
	BRB		30$
20$:	MOVC3		#PCB$K_LENGTH,(R0),PCB	;GET PCB
	MOVZWL		#SS$_NORMAL,R0
30$:	INCL		PIX
	RET

	.SBTTL		COMMAND ROUTINES

	.ENTRY		DOCMD,0

	BLBS		IOSB,10$
	BRW		EXTCMD
10$:	LOCC		TTIBUF,#MAXCMD,CMDTAB		;FIND COMMAND
	BEQL		ILLCMD				;IF NOT FOUND
	SUBL2		#CMDTAB,R1			;DISPACEMENT
	MOVL		ADRTAB[R1],R1			;ROUTINE
	CALLS		#0,(R1)				;CALL ROUTINE
ILLCMD:
	$QIO_S		EFN=CMDEFN,-
			CHAN=TTCHN,-
			FUNC=#IO$_READVBLK!IO$M_NOECHO!IO$M_CVTLOW,-
			IOSB=IOSB,ASTADR=DOCMD,-
			P1=TTIBUF,P2=#1
	RET

;PROCESS COMMAND

	.ENTRY	PCMD,0
	BICL2		#FLG$M_SUM,PFLG
	CLRL		SCANCNT
	$QIOW_S		EFN=CMDEFN,-
			CHAN=TTCHN,-
			FUNC=#IO$_READVBLK!IO$M_NOECHO!IO$M_CVTLOW,-
			IOSB=IOSB,-
			P1=TTIBUF,P2=#10
	BSBW		HEXCVT
	MOVL		R1,PID
	RET

;SUMMARY COMMAND

	.ENTRY	SCMD,0

	BISL2		#FLG$M_SUM,PFLG
	$QIOW_S		CHAN=TTCHN,EFN=CMDEFN,-
			IOSB=IOSB,-
			FUNC=#IO$_READVBLK!IO$M_CVTLOW!IO$M_NOECHO!IO$M_TIMED,-
			P1=TTIBUF,P2=#80,P3=#2
	BLBC		IOSB,15$
	BSBW		HEXCVT
	MOVL		R1,SOFFSET
15$:	RET

;F COMMAND: SET SUMMARY FRAME

	.ENTRY		FCMD,0

	BSBW		DECIN
	MOVL		R1,FRAME
	MOVZWL		#SS$_NORMAL,R0
	RET

;Z COMMAND: CHANGE SLEEP TIME

	.ENTRY		ZCMD,0

	BSBW		DECIN
	BBS		#PRV$V_CMKRNL,@#CTL$GQ_PROCPRIV,20$
	CMPL		#5,R1
	BLEQ		20$
	MOVZBL		#5,R1				;SO CAN'T INFLUENCE
							;OTHERS TOO MUCH
20$:	EMUL		#-10*1000*1000,R1,#0,SLPTIM
	BRB		UPDAT1

;FORCE AN UPDATE (" " COMMAND)
;NOTE: THIS SHOULD BE WITHIN BRB RANGE OF THE Z COMMAND ROUTINE

	.ENTRY		UPDAT,0

UPDAT1:	$QIOW_S		EFN=CMDEFN,-
			CHAN=TTCHN,-
			FUNC=#IO$_READVBLK!IO$M_TIMED!IO$M_NOECHO!IO$M_PURGE,-
			IOSB=IOSB,-
			P1=TTIBUF,P2=#80,P3=#0
	$CANTIM_S
	$CANWAK_S
	$WAKE_S
	RET

;r command: do refresh

	.ENTRY		RCMD,0

	BISL2		#FLG$M_REF,PFLG
	RET

	.ENTRY		CCAST,0

EXTCMD:	TTY$		#TRM$C_TTY_BOTOM
	$EXIT_S

;a command: enable/disable usage of ast's

	.ENTRY		ACMD,0

	XORL2		#FLG$M_AST,PFLG
	RET
;^ COMMAND: disregard first n channels

	.entry		UPARW,0

	BSBW		DECIN
	MOVW		R1,CCBLIM
	RET

DECIN:	$QIOW_S		EFN=CMDEFN,-
			CHAN=TTCHN,-
			FUNC=#IO$_READVBLK!IO$M_CVTLOW!IO$M_NOECHO,-
			IOSB=IOSB,-
			P1=TTIBUF,P2=#80
	MOVZWL		#1,R0
	CLRL		R1
	TSTW		IOSB+2
	BNEQ		10$
	RSB
10$:	MOVZBL		TTIBUF-1(R0),-(SP)
	SUBL2		#^A/0/,(SP)
	MULL2		#10,R1
	ADDL2		(SP)+,R1
	ACBW		IOSB+2,#1,R0,10$
	RSB

HEXCVT:	CLRL		R1
	MOVZBL		#1,R0
	TSTW		IOSB+2
	BNEQ		PIDLP
	RSB
PIDLP:	ASHL		#4,R1,R1
	SUBB3		#^A/0/,TTIBUF-1(R0),-(SP)
	CMPB		#9,(SP)			;**HEX**
	BGEQ		10$
	SUBB2		#<^A/A/-^A/0/-^XA>,(SP)
10$:	BISB2		(SP)+,R1
	ACBW		IOSB+2,#1,R0,PIDLP
	RSB

	.SBTTL		UTILITY ROUTINES

;ROUTINE TO DISPLAY AST MODES
;CALL: BSB/BSW
;R0 HAS BYTE SPECIFYING MODES

ASTDSP:	TSTB		R0
	BNEQ		5$
	STR$		NONE
	RSB
5$:	MOVB		R0,-(SP)			;SAVE IT
	BBC		#PSL$C_KERNEL,(SP),10$
	CHR$		#^A/K/
10$:	BBC		#PSL$C_EXEC,(SP),20$
	CHR$		#^A/E/
20$:	BBC		#PSL$C_SUPER,(SP),30$
	CHR$		#^A/S/
30$:	BBC		#PSL$C_USER,(SP),40$
	CHR$		#^A/U/
40$:	INCL		SP				;FIX STACK
	RSB

	.ENTRY		GETMEM,^M<R2,R3,R4,R5>		;GET  SYSTEM MEM

	MOVZWL		#SS$_ACCVIO,R0
	MOVL		4(AP),R1
	BGTR		50$
	MNEGL		R1,R1
50$:	PROBEW		#0,R1,@12(AP)		;BE SURE OK TO WRITE
	BEQL		200$
	MOVPSL		-(SP)				;GET PSL
	EXTZV		#PSL$V_CURMOD,#PSL$S_CURMOD,(SP),R0
	INSV		R0,#PSL$V_PRVMOD,#PSL$S_PRVMOD,(SP)
	PUSHAB		100$
	REI

100$:	MOVL		4(AP),R1			;GET SIZE
	BGTR		150$				;ALL IS WELL
	MNEGL		R1,R1				;MAKE POSITIVE
	PROBER		#0,#10,@8(AP)
	BEQL		200$
	PUSHAW		@8(AP)
	ADDL2		#8,(SP)
	CMPW		@(SP),R1
	BGEQ		150$
	MOVZWL		@(SP),R1
150$:	CLRL		(SP)+
	PROBER		#0,R1,@8(AP)			;SEE IF READ OK
	BEQL		200$
	PUSHL		R1
	MOVC3		R1,@8(AP),@12(AP)
	MOVZWL		#SS$_NORMAL,R0
	POPL		R1				;RETURN SIZE OF BLOCK
200$:	RET

	.ENTRY	FNDIRP,^M<R2,R3,R4,R5>			;FIND THE CURRENT IRP

	MOVL		UCBADR,R5
	BBC		#UCB$V_BSY,UCB$W_STS(R5),IOQ	;MUST LOOK AT QUEUE
	MOVL		#IRP$K_LENGTH,4(AP)		;IRP SIZE
	MOVAB		IRP,12(AP)			;SET UP CURRENT IRP
	MOVAB		@UCB$L_IRP(R5),8(AP)
	CALLG		(AP),GETMEM			;FIND PACKET
	BLBC		R0,IOQ				;?
	CMPL		IRP+IRP$L_PID,PCB+PCB$L_PID	;US?
	BNEQ		IOQ
	CMPW		IRP+IRP$W_CHAN,CURCHN		;RIGHT CHANNEL?
	BNEQ		IOQ
	BRW		FNDIRPRET
IOQ:	MOVAB		@UCB$L_IOQFL(R5),R2		;POINT TO QUEUE
	MOVAB		UCB$L_IOQFL(R5),R3		;REMEMBER BEGINNING
IOQL:	CMPL		R2,R3
	BNEQ		10$
	CLRL		R0
5$:	PUSHL		R0
	MOVC5		#0,IRP,#0,#IRP$K_LENGTH,IRP	;CLEAR IRP
	POPL		R0
	RET
10$:	MOVL		R2,8(AP)
	MOVL		IRP$L_IOQFL(R2),R2		;POINT TO NEXT PACKET
	CALLG		(AP),GETMEM
	BLBC		R0,5$
	CMPL		IRP+IRP$L_PID,PCB+PCB$L_PID
	BNEQ		IOQL
	CMPW		IRP+IRP$W_CHAN,CURCHN
	BNEQ		IOQL
FNDIRPRET:
	MOVZWL		#SS$_NORMAL,R0
	RET

	.ENTRY	GETPHD,^M<R2,R3,R4,R5>

;THIS ROUTINE COPIES THE PHD OF A RESIDENT PROCESS TO AREA PHD.
;IT IS TO BE USED AS A LAST RESORT IF AN AST CANNOT BE QUEUED (OR DID NOT
;RETURN FROM) A PROCESS

	MOVZWL		4(AP),R0			;GET PIX
	CMPL		R0,@#SCH$GL_MAXPIX		;BE SURE IT'S LEGAL
	BLEQ		10$				;OK
5$:	MOVZWL		#SS$_NONEXPR,R0			;NOPE
	RET
10$:	MOVL		@SCH$GL_PCBVEC[R0],R0		;POINT TO PCB
	CMPL		4(AP),PCB$L_PID(R0)		;BE SURE SAME PROCESS
	BNEQ		5$				;NO
	TSTB		100$				;BE SURE RESIDENT
	SETIPL		#IPL$_SYNCH
	BBC		#PCB$V_RES,PCB$L_STS(R0),100$	;IS PHD HERE?
	MOVC3		#PHD$K_LENGTH,@PCB$L_PHD(R0),PHD	;MOVE IN
100$:	SETIPL		#0
	MOVZWL		#SS$_NORMAL,R0
	RET

	.ENTRY		OCTDPY,^M<R2,R3>
;CALL WITH R0=NUMBER TO CONVERT

	MOVZBL		#8,R3
	BRB		NUMDPY

	.ENTRY		HEXDPY,^M<R2,R3>
;AS ABOVE

	MOVZBL		#16,R3
NUMDPY:	CLRL		R2
	PUSHAB		NUMRET
DPYLP:	CLRL		R1
	EDIV		R3,R0,R0,-(SP)
	BEQL		DPYNUM
	PUSHAB		DPYNUM
	BRB		DPYLP

DPYNUM:	ADDL3		#^A/0/,(SP)+,R1			;GET CHARACTER
	CMPL		#^A/9/,R1
	BGEQ		10$
	ADDL2		#<^A/A/-^A/9/-^XA>,R1		;MAKE HEX DIGIT
10$:	CHR$		R1				;OUTPUT
	RSB
NUMRET:	MOVZWL		#SS$_NORMAL,R0
	RET

;BLOCK CONVERSION ROUTINES:

;PHYSICAL ADDRESS IN R0
;TRANSLATED ADDRESS RETURNED IN R0
;-1 IF TRANSLATION IS UNSUCCESSFUL

PHYTOLOG:
	PUSHL		R1				;SAVE R1
	MOVZBL		R0,-(SP)			;SECTOR #
	EXTZV		#8,#8,R0,-(SP)			;TRACK #
	EXTZV		#16,#16,R0,-(SP)		;CYL #
	MOVZBL		UCB+UCB$L_DEVDEPEND+1,R0	;TRACKS/CYL
	MOVL		R0,R1
	MULL2		(SP)+,R0			;CONVERT TO TRACKS
	ADDL2		(SP)+,R0			;ADD TRACK #
	MOVZBL		UCB+UCB$L_DEVDEPEND,-(SP)
	MULL2		(SP),R1				;MAX PHYS BLOCK
	MULL2		(SP)+,R0			;TO SECTORS
	ADDL2		(SP)+,R0			;TO LBN
	MOVZWL		UCB+UCB$L_DEVDEPEND+2,-(SP)
	MULL2		R1,(SP)
	DIVL2		UCB+UCB$L_MAXBLOCK,(SP)
	DIVL2		(SP)+,R0
	POPL		R1
	RSB

PHYTOVIR:
	BSBW		PHYTOLOG			;CONVERT TO LBN
	PUSHR		#^M<R1,R2,R3,R4,R5>		;SAVE
	MOVZWL		WCB+WCB$W_NMAP,R1		;# OF MAP POINTERS
	BEQL		NOMAP				;EMPTY
	CMPL		R1,#<1000-WCB$K_LENGTH>/6	;MORE THAN WE COPIED?
	BLEQ		10$
	MOVL		#<1000-WCB$K_LENGTH>/6,R1	;FORCE W/I LIMITS
10$:	MOVAL		WCB+WCB$L_STVBN,R3		;POINT TO MAP AREA
	MOVL		(R3)+,R2			;STARTING VBN
MAPLP:	MOVZWL		(R3)+,R4			;COUNT
	SUBL3		(R3)+,R0,R5			;DESIRED-GIVEN
	BLSS		NXTMP				;NO
	CMPL		R4,R5				;W/IN RANGE?
	BLSS		NXTMP				;NO
	ADDL3		R5,R2,R0			;VBN
MAPRT:	POPR		#^M<R1,R2,R3,R4,R5>
	RSB
NXTMP:	ADDL2		R4,R2				;UPDATE
	SOBGTR		R1,MAPLP
NOMAP:	MNEGL		#1,R0
	BRB		MAPRT				;NOT FOUND

MAKDSK:
	PUSHR		#^M<R2,R3,R4,R5>		;SAVE REGISTERS
	MOVZBL		DDB+DDB$T_NAME,DEVDSC		;SET THIS
	MOVC3		DEVDSC,DDB+DDB$T_NAME+1,@DEVDSC+4	;SET THE CONTROLLER
	PUSHAB		DONMAK				;RETURN
	MOVZWL		UCB+UCB$W_UNIT,R0		;GET UNIT
MAKLP:	CLRL		R1				;CLEAR UPPER
	EDIV		#8,R0,R0,R1			;GET
	BEQL		DONUM
	PUSHL		R1
	BSBB		MAKLP
	POPL		R1
DONUM:	ADDB3		#^A/0/,R1,(R3)+
	INCL		DEVDSC
	RSB
DONMAK:	MOVB		#^A/:/,(R3)+
	INCL		DEVDSC
	POPR		#^M<R2,R3,R4,R5>
	RSB


;ROUTINE FNDUCB FINDS UCB'S WHICH HAVE BEEN ALLOCATED TO THE PROCESS
;IT RETURNS SUCCESS IF A DEVICE IS FOUND WHICH HAS THE ALLOCATED BIT
;SET (DEV$V_ALL) IN UCB$V_DEVCHAR AND THE REFERENCE COUNT IS 1
;(IF IT IS MORE THAN ONE, THAN THE DEVICE HAS A CHANNEL ASSIGNED AND
;SHOULD HAVE ALREADY BEEN OUTPUT)
;IMPLIED INPUTS:
;
;	LSTDDB POINTS TO THE LAST DDB LOOKED AT
;	DEVCHN POINTS TO THE LAST UCB LOOKED AT OR ZERO IF NONE
;	PCB+PCB$L_PID CONTAINS THE PID TO LOOK FOR
;IMPLIED OUTPUTS:
;
;	BLOCKS UCB AND DDB ARE FILLED IF SUCCESS IS RETURNED
;RETURN CODES:
;		SS$_NOSUCHDEV
;		SS$_NORMAL
;		SS$_ACCVIO

	.ENTRY	FNDUCB,^M<R2,R3,R4,R5,R6>

	MOVL		LSTDDB,R2
	MOVL		DEVCHN,R3
	BNEQ		NXTUCB			;IF THERE IS ONE
DDBLP:	MOVL		DDB$L_UCB(R2),R3	;POINT TO UCB
UCBLP:	CMPW		#1,UCB$W_REFC(R3)	;REF COUNT ONE?
	BNEQ		NXTUCB			;NO
	CMPL		PCB+PCB$L_PID,UCB$L_PID(R3)
	BNEQ		NXTUCB
	BBS		#DEV$V_ALL,UCB$L_DEVCHAR(R3),HAVUCB
NXTUCB:	MOVL		UCB$L_LINK(R3),R3
	BNEQ		UCBLP
	MOVL		DDB$L_LINK(R2),R2
	BNEQ		DDBLP
	CLRL		LSTDDB
	CLRL		DEVCHN
	MOVZWL		#SS$_NOSUCHDEV,R0
	RET
HAVUCB:	MOVL		R2,LSTDDB
	MOVL		R3,DEVCHN
	MOVL		DEVCHN,R0
	MOVZWL		UCB$W_SIZE(R0),R1
15$:	MOVC5		R1,(R0),#0,#UCB$K_TT_LENGTH,UCB
	MOVC3		#DDB$K_LENGTH,@LSTDDB,DDB
	TSTL		UCB+UCB$L_VCB
	BEQL		20$
	MOVC3		#VCB$K_LENGTH,@UCB+UCB$L_VCB,VCB
20$:	MOVZWL		#SS$_NORMAL,R0
	RET

;FNDDSK SIMILAR TO FNDUCB, EXCEPT FINDS ALL DISK DEVICES (NOT A PID CHECK)

	.ENTRY	FNDDSK,^M<R2,R3,R4,R5,R6>

	MOVL		LSTDDB,R2
	MOVL		DEVCHN,R3
	BNEQ		DNXTUCB			;IF THERE IS ONE
DDDBLP:	MOVL		DDB$L_UCB(R2),R3	;POINT TO UCB
DUCBLP:	CMPB		#DC$_DISK,UCB$B_DEVCLASS(R3)
	BEQL		DHAVUCB
DNXTUCB:
	MOVL		UCB$L_LINK(R3),R3
	BNEQ		DUCBLP
	MOVL		DDB$L_LINK(R2),R2
	BNEQ		DDDBLP
	CLRL		LSTDDB
	CLRL		DEVCHN
	MOVZWL		#SS$_NOSUCHDEV,R0
	RET
DHAVUCB:
	MOVL		R2,LSTDDB
	MOVL		R3,DEVCHN
	MOVC3		#UCB$K_LENGTH,@DEVCHN,UCB
	MOVC3		#DDB$K_LENGTH,@LSTDDB,DDB
	TSTL		UCB+UCB$L_VCB
	BEQL		20$
	MOVC3		#VCB$K_LENGTH,@UCB+UCB$L_VCB,VCB
20$:	MOVZWL		#SS$_NORMAL,R0
	RET

	.SBTTL		DATA GATHERING

	.ENTRY		GETPCB,^M<R2,R3,R4,R5,R6>

	CMPW		PID,@#SCH$GL_MAXPIX	;BE SURE LEGAL
	BLEQ		10$
5$:	MOVZWL		#SS$_NONEXPR,R0
	RET
10$:	MOVZWL		PID,R0
	MOVL		@SCH$GL_PCBVEC[R0],R6
	CMPW		PID,PCB$L_PID(R6)	;BE SURE INDEX MATCHES
	BNEQ		5$
HAVPID:	MOVC3		#PCB$K_LENGTH,(R6),PCB	;MOVE IN PCB
	TSTL		PCB$L_JIB(R6)
	BEQL		NOJIB
	MOVC3		#JIB$K_LENGTH,@PCB$L_JIB(R6),JIB	;MOVE IN JIB
NOJIB:	TSTW		PID
	BEQL		NOAST			;FOR NULL
	CMPL		PCB+PCB$L_PID,MYPID		;IS IT ME?
	BEQL		NOAST			;MUST USE AST IF NOT
	MOVZBL		#3,R0			;SIGNAL TO DO AST
	RET
NOAST:	MOVC3		#PHD$K_LENGTH,@PCB$L_PHD(R6),PHD	;SET PHD
	TSTW		PCB+PCB$L_PID		;IF NULL,
	BNEQ		10$
	RET
10$:	MOVC3		#12,@#CTL$T_USERNAME,USERNAM
	MOVC3		#^X800,@#CTL$GL_CCB-^X800,CCB
	MOVQ		@#CTL$T_ACCOUNT,ACCT
	MOVQ		@#CTL$GQ_PROCPRIV,PRIVS
	MOVC3		#84,@#PIO$GT_DDSTRING,DDSTR
	MOVW		@#PIO$GW_DFPROT,DEFPRO
	MOVL		@#CTL$GL_IMGHDRBF,R1	;POINT TO BUFFER
	BEQL		RET1
	MOVL		4(R1),R1		;POINT TO AREA
	MOVQ		IFD$Q_CURPROG(R1),R0	;GET DESCRIPTOR
	MOVZBL		R0,IMGNAM
	MOVC3		IMGNAM,(R1),IMGNAM+1	;MOVE IN ASCIC NAME
	MOVQ		@#CTL$GQ_LOGIN,LOGINT
	MOVQ		#^A/SYS$DISK/,DEFDEV+8
	MOVL		#8,DEFDEV
	MOVAB		DEFDEV+8,DEFDEV+4
TRNLP:	$TRNLOG_G	LOGLST
	MOVL		DEFDEV,R1
	CMPB		#^A/:/,DEFDEV+8-1[R1]
	BNEQ		10$
	DECL		DEFDEV
10$:	CMPW		#SS$_NOTRAN,R0
	BEQL		DONTRN
	BLBS		R0,TRNLP
DONTRN:	MOVZWL		#SS$_NORMAL,R0
RET1:	RET

;THIS IS THE MAIN DATA GATHERING ROUTINE

	.ENTRY		GETINF,0

	MOVC5		#0,DATA1,#0,#DATALEN,DATA1	;CLEAR DATA
	$CMEXEC_S	ROUTIN=GETPCB		;GET PCB
	BLBC		R0,INVPID
	BBS		#FLG$V_AST,PFLG,INVPID	;IF NO AST'S
	CMPL		#3,R0			;INCOMPLETE?
	BNEQ		INVPID			;NO
	BBS		#PRV$V_WORLD,@#CTL$GQ_PROCPRIV,DOAST
	CMPW		MYUIC+2,PCB+PCB$L_UIC+2			;SAME GROUP?
	BNEQ		INVPID					;NO
3$:	BBS		#PRV$V_GROUP,@#CTL$GQ_PROCPRIV,DOAST	;IF HAS GROUP
	CMPL		MYUIC,PCB+PCB$L_UIC
	BEQL		DOAST
INVPID:	RET

	.MACRO		CHKAST		?L1
	MOVZWL		PCB+PCB$L_PID,-(SP)
	BBCS		(SP)+,BITMAP,L1
	BRW		NOAST1
L1:
	.ENDM		CHKAST

DOAST:
	CHKAST
	MOVL		#PHD$K_LENGTH,QASTPRM+8
	MOVAB		@PCB+PCB$L_PHD,QASTPRM+12
	MOVAB		PHD,QASTPRM+16			;SET TO COPY PHD
	CLRL		QASTPRM+20
	$CMKRNL_G	KRNLPRM
	BLBC		R0,10$
	BSBW		ASTWAIT
	CHKAST
10$:	MOVL		#IMGLEN,QASTPRM+8		;NOW COPY IMAGE NAME
	CLRL		QASTPRM+12			;CODE 0
	MOVAB		IMGNAM,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,20$
	BSBW		ASTWAIT
	CHKAST
20$:	MOVL		#12,QASTPRM+8
	MOVAB		@#CTL$T_USERNAME,QASTPRM+12
	MOVAB		USERNAM,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,30$
	BSBW		ASTWAIT
	CHKAST
30$:	MOVL		#8,QASTPRM+8
	MOVAQ		@#CTL$GQ_PROCPRIV,QASTPRM+12
	MOVAQ		PRIVS,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,40$
	BSBW		ASTWAIT
	CHKAST
40$:
;	MOVL		#8,QASTPRM+8			;FROM BEFORE
	MOVAQ		@#CTL$GQ_LOGIN,QASTPRM+12
	MOVAQ		LOGINT,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,50$
	BSBW		ASTWAIT
	CHKAST
50$:
;	MOVL		#8,QASTPRM+8			;FROM PREVIOUS
	MOVAQ		@#CTL$T_ACCOUNT,QASTPRM+12
	MOVAQ		ACCT,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,60$
	BSBW		ASTWAIT
	CHKAST
60$:	MOVL		#84,QASTPRM+8
	MOVAB		@#PIO$GT_DDSTRING,QASTPRM+12
	MOVAB		DDSTR,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,70$
	BSBW		ASTWAIT
	CHKAST
70$:	MOVL		#64+8,QASTPRM+8
	MOVL		#1,QASTPRM+12
	MOVAB		DEFDEV,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,80$
	BSBW		ASTWAIT
	CHKAST
80$:	MOVL		#2,QASTPRM+8
	MOVAB		@#PIO$GW_DFPROT,QASTPRM+12
	MOVAW		DEFPRO,QASTPRM+16
	$CMKRNL_G	KRNLPRM
	BLBC		R0,90$
	BSBW		ASTWAIT
	CHKAST
90$:	MOVL		#^X800,QASTPRM+8
	MOVAB		@#CTL$GL_CCB-^X800,QASTPRM+12
	MOVAB		CCB,QASTPRM+16
	AOBLSS		#SCANMAX,SCANCNT,100$
	CLRL		SCANCNT
	MOVL		#1,QASTPRM+20		;SET TO FUDGE ACCOUNTING
100$:	$CMKRNL_G	KRNLPRM
	BLBC		R0,NOAST2
	BSBW		ASTWAIT
NOAST1:	MOVL		ASTSTT,R0
	RET

NOAST2:	MOVZWL		PCB+PCB$L_PID,R0
	BBSC		R0,BITMAP,NOAST1
	BRB		NOAST1

	.SBTTL	HERE IF THE AST TIMES OUT

	.ENTRY	QAST_TIMEOUT,0

	CMPL		4(AP),QAST_COUNT	;THIS REQUEST?
	BNEQ		90$
	INCL		QAST_COUNT		;SO WILL FALL ON THE FLOOR
	$WAKE_S
90$:	RET

	.SBTTL	ROUTINE TO WAIT FOR AST TO COMPLETE

ASTWAIT:
	MOVL		QAST_COUNT,TMRPRM+SETIMR$_REQIDT
	$SETIMR_G	TMRPRM
	$HIBER_S
	$CANTIM_S
	RSB

	.SBTTL	ROUTINE TO ACTUALLY GET PHD ET AL INFO

	.ENTRY		QAST,^M<R2,R3,R4,R5>

;INPUTS:
;		(AP): 	.LONG	5
;		4(AP):	.LONG	ADDR TO STORE STATUS
;		8(AP):	.LONG	# BYTES TO TRANSFER
;		12(AP):	.LONG	ADDRESS TO TRANSFER FROM
;		16(AP):	.LONG	ADDRESS TO TRANSFER TO
;		20(AP):	.LONG	TIME TO SUBTRACT FROM OTHER PROCESS
;
;IMPLIED INPUTS:
;		LOCATION "PCB+PCB$L_PID" IS PID OF PROCESS TO GET INFO FROM

	MOVL		#SS$_TIMEOUT,@4(AP)	;ASSUME A TIMEOUT
20$:	ADDL3		8(AP),#PKT_FIXED,R1	;# BYTES TO GET
	JSB		@#EXE$ALLOCBUF		;GET NPAGED MEMORY
	BLBS		R0,30$
	RET
30$:	MOVL		R2,R5			;SAVE WHERE PACKET IS
	MOVL		8(AP),PKT_LEN(R5)	;SIZE OF TRANSFER
	MOVL		12(AP),PKT_LOC(R5)	;WHERE TO READ FROM
	MOVL		16(AP),PKT_RETADR(R5)	;WHERE TO WRITE TO
	MOVL		20(AP),PKT_FIXTIM(R5)
	MOVAB		BITMAP,PKT_BITMAP(R5)
	MOVL		QAST_COUNT,PKT_ASTCNT(R5)
	MOVAL		QAST_COUNT,PKT_ASTCNTADR(R5)
	MOVL		PCB+PCB$L_PID,ACB$L_PID(R5)	;PID TO QUEUE TO
	MOVB		#1@ACB$V_KAST,ACB$B_RMOD(R5);SET SPECIAL AST
	MOVAB		PKT_CODE(R5),ACB$L_KAST(R5) ;WHERE AST IS
	MOVL		#SS$_ACCVIO,PKT_STATUS(R5)  ;DEFAULT STATUS
	MOVL		4(AP),PKT_STATLOC(R5)	;STORE
	MOVL		@#SCH$GL_CURPCB,R4	;POINT TO US
	MOVL		PCB$L_PHD(R4),R0	;POINT TO OUR PHD
	MOVL		PCB$L_PID(R4),PKT_ORIGPID(R5)  ;SET OUR PID
	MOVL		PHD$L_IMGCNT(R0),PKT_IMGCNT(R5);STORE THIS ALSO
	PUSHL		R5			;SAVE FOR MOVC
	MOVC3		#CODELEN,CODE,@ACB$L_KAST(R5) ;MOVE IN CODE
	POPL		R5
	MOVZBL		#PRI$_TICOM,R2		;INCREMENT
	MOVZWL		PCB+PCB$L_PID,R1	;HIS PIX
	MOVL		@#SCH$GL_PCBVEC,R0
	MOVL		(R0)[R1],R1		;HIS PCB
	SETIPL		5000$
70$:	CMPW		#SCH$C_SUSP,PCB$W_STATE(R1)
	BEQL		100$
	CMPW		#SCH$C_SUSPO,PCB$W_STATE(R1)
	BEQL		100$
	BBS		#PCB$V_SUSPEN,PCB$L_STS(R1),100$
	BBS		#PCB$V_DELPEN,PCB$L_STS(R1),100$
	JSB		@#SCH$QAST		;QUEUE THE AST
	BLBC		R0,90$
	CMPW		#SCH$C_COM,PCB$W_STATE(R4) ;COMPUTE?
	BEQL		80$
	CMPW		#SCH$C_COMO,PCB$W_STATE(R4)
	BNEQ		90$
80$:	MOVL		SCH$GL_CURPCB,R3
	MOVB		PCB$B_PRI(R3),R0
	CMPB		R0,PCB$B_PRI(R4)
	BGEQU		90$
	CMPB		#16,R0
	BLEQU		85$
	MOVZBL		#16,R0
85$:	JSB		@#SCH$CHSEP	
90$:	MOVZWL		#SS$_NORMAL,R0
	SETIPL		#0
	RET
100$:	MOVL		R5,R0
	JSB		@#EXE$DEANONPAGED
	MOVZWL		#SS$_SUSPENDED,R0
	SETIPL		#0
	RET
5000$:	.LONG		IPL$_SYNCH
	
	.IF		GT,<5000$-70$-512>
	.ERROR		;CANNOT LOCK MORE THAN ONE PAGE OF CODE
	.ENDC

	.SBTTL	CODE WHICH IS ACTUALLY QUEUED BETWEEN PROCESSES:

;ASSUMPTIONS:  R4=ADDRESS OF PCB
;	       R5=ADDRESS OF ACB CONTROL BLOCK
;		R0-R5 ARE USABLE

CODE:	MOVL		PCB$L_PHD(R4),R0		;POINT TO PHD
	PUSHL		PHD$L_CPUTIM(R0)		;SAVE OLD CPU TIME
	PUSHR		#^M<R4,R7>			;SAVE PCB, THIS
	MOVL		R5,R7				;MAKE NON-PERISHABLE
	CASEL		PKT_LOC(R7),#0,#1
1$:	.WORD		CHKIMG-1$
	.WORD		GETDSK-1$
NOTIMG:							;HERE IF NOT SPEC CODE
	PROBER		#0,PKT_LEN(R7),@PKT_LOC(R7)
	BEQL		NOIMG
	MOVC3		PKT_LEN(R7),@PKT_LOC(R7),PKT_DATA(R7)
NOIMG1:	MOVZWL		#SS$_NORMAL,PKT_STATUS(R7)
NOIMG:
	PUSHL		ACB$L_PID(R7)
	MOVL		PKT_ORIGPID(R7),ACB$L_PID(R7)
	POPL		PKT_ORIGPID(R7)
	MOVB		#1@ACB$V_KAST,ACB$B_RMOD(R7)
	MOVAB		RETAST,ACB$L_KAST(R7)
	MOVZBL		#PRI$_TICOM,R2
	MOVL		R7,R5				;FOR QAST
	POPR		#^M<R4,R7>
	MOVL		PCB$L_PHD(R4),R0
	SUBL2		PKT_FIXTIM(R5),(SP)		;FOR OVERHEAD
	SUBL3		(SP),PHD$L_CPUTIM(R0),PKT_FIXTIM(R5)
	POPL		PHD$L_CPUTIM(R0)
	JMP		@#SCH$QAST

CHKIMG:	CLRB		PKT_DATA(R7)
	PROBER		#0,#4,@#CTL$GL_IMGHDRBF	;FIND THIS
	BEQL		NOIMG
	MOVL		@#CTL$GL_IMGHDRBF,R4
	BEQL		NOIMG
	PROBER		#0,#8,(R4)			;POINT TO THIS?
	BEQL		NOIMG
	MOVL		4(R4),R4			;POINT THERE
	PROBER		#0,#8,IFD$Q_CURPROG(R4)		;CAN WE GET NAME?
	BEQL		NOIMG				;NO
	MOVQ		IFD$Q_CURPROG(R4),R0		;POINT TO THIS
	PROBER		#0,R0,(R1)			;CAN WE GET IT?
	BEQL		NOIMG				;NO
	CMPL		#IMGLEN-1,R0			;BIG ENOUGH BUFFER?
	BGEQ		100$
	MOVL		#IMGLEN-1,R0
100$:	MOVB		R0,PKT_DATA(R7)
	MOVC3		R0,(R1),PKT_DATA+1(R7)		;MOVE IN
	BRW		NOIMG1

GETDSK:	CLRL		PKT_DATA(R7)			;IN CASE NO PROC TBL
	MOVL		#8,PKT_DATA(R7)			;SET UP DESCRIPTOR
	MOVAB		PKT_DATA+8(R7),PKT_DATA+4(R7)
	MOVQ		#^A/SYS$DISK/,PKT_DATA+8(R7)
	PROBER		#0,#4*LOG$C_PROCESS,@#LOG$AL_LOGTBL
	BNEQ		130$
120$:	BRW		NOIMG
130$:	CLRL		R5
	MOVL		#LOG$C_PROCESS,R1
135$:	MOVL		@#LOG$AL_LOGTBL[R1],R2
	PROBER		#0,#4,(R2)
	BNEQ		140$
	BBSS		R1,R5,140$
140$:	SOBGEQ		R1,135$
150$:	MOVAQ		PKT_DATA(R7),R1
	MOVZBL		#63,R2
	MOVAB		PKT_DATA+8(R7),R3
	JSB		@#LOG$TRNSLOGNAME
	CMPB		#^A/:/,PKT_DATA+8-1(R7)[R1]	;IS LAST CHR ":"
	BNEQ		155$
	DECL		R1
155$:	MOVL		R1,PKT_DATA(R7)
	BLBC		R0,160$
	CMPW		#SS$_NOTRAN,R0
	BNEQ		150$
160$:	MOVL		R0,PKT_STATUS(R7)
	BRW		NOIMG

RETAST:	PUSHL		R7
	MOVL		R5,R7				;GET NON-DESTRUCTABLE
	MOVL		PCB$L_PHD(R4),R0		;SEE IF SAME IMAGE
	ADDL2		PKT_FIXTIM(R5),PHD$L_CPUTIM(R0)
	CMPL		PKT_IMGCNT-AST(R7),PHD$L_IMGCNT(R0)
	BNEQ		40$				;DROP IT ON THE FLOOR
	CMPL		@PKT_ASTCNTADR(R5),PKT_ASTCNT(R5)
	BNEQ		30$				;IF WE DON'T WANT
	BLBC		PKT_STATUS(R7),30$
	PROBEW		#0,PKT_LEN(R7),@PKT_RETADR(R7)
	BEQL		30$				;ACCVIO
	MOVC3		PKT_LEN(R7),PKT_DATA(R7),@PKT_RETADR(R7)
30$:	MOVZWL		PKT_ORIGPID(R7),-(SP)
	BBCC		(SP)+,@PKT_BITMAP(R7),35$
35$:	MOVL		PKT_STATUS(R7),@PKT_STATLOC(R7)
	MOVL		ACB$L_PID(R7),R1
	SETIPL		#IPL$_SYNCH
	JSB		@#SCH$WAKE
	SETIPL		#IPL$_ASTDEL
40$:	MOVL		R7,R0
	POPL		R7
	JMP		@#EXE$DEANONPAGED

	CODELEN=.-CODE

	.SBTTL		WRITABLE DATA

	.PSECT		DATAW,RD,WRT,NOEXE

SLPTIM:	.LONG		-5*10*1000*1000,-1		;DEFAULT SLEEP TIME

TTCHN:	.BLKW		1				;CHANNEL FOR TERMINAL

TTIBUF:	.BLKB		80

IOSB:	.BLKQ		1

PIX:	.BLKL		1

PID:	.BLKL		1				;PID TO LOOK AT

DATA1:
PCB:	.BLKB		PCB$K_LENGTH			;FOR PCB COPY

PHD:	.BLKB		PHD$K_LENGTH			;FOR PHD

JIB:	.BLKB		JIB$K_LENGTH			;FOR JIB

ACCT:	.BLKQ		1

CCB:	.BLKB		^X800

DDSTR:	.BLKB		84
PRIVS:	.BLKQ		1
LOGINT:	.BLKQ		1

IMGNAM:	.BLKB		84+9+1+3+1+5		;FOR IMAGE NAME
		IMGLEN=.-IMGNAM

USERNAM:
	.BLKB		12
DEFPRO:	.BLKW		1

DEFDEV:	.BLKB		8+64


	DATALEN=.-DATA1

MYPID:	.BLKL		1
MYUIC:	.BLKL		1

OUTDSC:	.BLKL		1
	.LONG		TTOBUF

TTOBUF:	.BLKB		400

QAST_COUNT:
	.BLKL		1

CPUTIM:
	.BLKQ		1
CPULIM:
	.BLKQ		1

PRI:	.BLKB		1
PRIB:	.BLKB		1

PFLG:	.LONG		FLG$M_SUM

	FLG$V_SUM=0			;DO SUMMARY
	FLG$M_SUM=1
	FLG$V_NLL=1			;HAVE SEEN NULL (FOR SUMMARY ROUTINE)
	FLG$M_NLL=2
	FLG$V_REF=2			;DO REFRESH
	FLG$M_REF=4
	FLG$V_AST=3			;DO NOT USE AST'S TO GET INFO
	FLG$M_AST=8
	FLG$V_RW=4			;IRP SHOWS A READ OR WRITE
	FLG$M_RW=16			;..

FCBSTRT:
UCB:	.BLKB		UCB$K_TT_LENGTH

WCB:	.BLKB		1000

FCB:	.BLKB		FCB$K_LENGTH

DDB:	.BLKB		DDB$K_LENGTH

VCB:	.BLKB		VCB$K_LENGTH

IRP:	.BLKB		IRP$K_LENGTH

FILHDR:
	.BLKB		ATR$S_HEADER

	FCBLEN=.-FCBSTRT
UCBADR:	.BLKL		1

CEB:	.BLKB		CEB$K_LENGTH

LSTDDB:	.BLKL		1
DEVCHN:	.BLKL		1

FIBDSC:	.LONG		FIB$K_LENGTH
	.LONG		FIB

FIB:	.BLKB		FIB$K_LENGTH
	..=.
	.=FIB+FIB$W_CNTRLFUNC
	.WORD		FIB$C_EXA_QUOTA
	.=..

QUSDSC:	.LONG		QBLKLEN
	.LONG		QUSBLK

QURDSC:	.LONG		QBLKLEN
	.LONG		QURBLK

	QBLKLEN=32

QURBLK:	.BLKB		QBLKLEN
QUSBLK:	.BLKB		QBLKLEN

DEVDSC:	.BLKL		1
	.LONG		DEVNAM

DEVNAM:	.BLKB		63

DQIOSB:	.BLKQ		1

DSKCHN:	.BLKW		1

FAOLST:	$FAOL		OUTLEN=OUTDSC,OUTBUF=BUFDSC,PRMLST=FAOPRM

FAOPRM:	.BLKL		30

BUFIO:	.BLKB		200

CURCHN:	.BLKL		1

ASTSTT:	.BLKL		1

QASTPRM:
	.LONG		5
	.LONG		ASTSTT
	.BLKL		1		;FROM
	.BLKL		1		;TO
	.BLKL		1		;FLAGS

TMRPRM:	$SETIMR		ASTADR=QAST_TIMEOUT,DAYTIM=TIMOUT,EFN=SLPEFN

SCANCNT:
	.BLKL		1		;TIMES WE HAVE SCANNED THIS PROC

BITMAP:
	.BLKB		256/8

CCBCNT:	.BLKW		1
CCBLIM:	.BLKW		1

SLPEFN:	.BLKL		1
IOEFN:	.BLKL		1
CMDEFN:	.BLKL		1

FRAME:	.LONG		0

SOFFSET:
	.LONG		0

	.SBTTL	AST PACKET DEFINITIONS

	.SAVE_PSECT
	.PSECT	ASTBLK,ABS

AST:	.BLKB	ACB$K_LENGTH

	PKT_ORIGPID=AST+ACB$L_ASTPRM
	.BLKL	1
PKT_STATUS:
	.BLKL	1

PKT_STATLOC:
	.BLKL	1

PKT_FIXTIM:
	.BLKL	1

PKT_IMGCNT:
	.BLKL	1

PKT_BITMAP:
	.BLKL	1

PKT_ASTCNT:
	.BLKL	1

PKT_ASTCNTADR:
	.BLKL	1

PKT_LEN:
	.BLKL	1

PKT_LOC:
	.BLKL	1

PKT_RETADR:
	.BLKL	1

PKT_CODE:
	.BLKB	CODELEN
		PKT_FIXED=.-AST

PKT_DATA:

	.RESTORE_PSECT

	.SBTTL		PURE DATA

	.PSECT		DATAR,RD,NOWRT,NOEXE

KRNLPRM:
	$CMKRNL	ROUTIN=QAST,ARGLST=QASTPRM

TIMOUT:
	.LONG	-10*1000*1000*10,-1	;TEN SECONDS

TTDEV:	.ASCID/TT/

MYSTF:	.WORD	4,JPI$_PID
	.LONG	MYPID,0
	.WORD	4,JPI$_UIC
	.LONG	MYUIC,0
	.LONG	0

SUMLIN:	.ASCID\!XL	!15AC	!2UB !5AC!/\
LINE1:	.ASCID\PID !XL !AC !AD\
LINE1B:	.ASCID\] !AC !AC !%D!/\
OTHRUSR:
	.ASCID\(!AD)\
LINE1C:	.ASCID\ [\
LINE1D:	.ASCID\] !AC!/\
LINE2:	.ASCID\!38<!AC[!UL]!>	Pri !5<!SB/!SB!> !AC	AST's Active: \
LINE2B:	.ASCID\!38<!AC!+!>	Pri !5<!SB/!SB!>  !AC	AST's Active: \
LINE3:	.ASCID\!/!25<!SW+!SW [!SW/!SW/!SW]!> !16<!%D!>\
LINE3NPH:
	.ASCID\!/!25<!SW+!SW!>                     \
LINE4:	.ASCID\!/!19<BYTCNT: !SL/!SL!> !16<BIO: !SW/!SW/!SL!> \-
	\!16<DIO: !SW/!SW/!SL!> !10<AST: !SW/!SW!> Files: !SW/!SW!/\
LINE4NPH:
	.ASCID\!/!19<BYTCNT: !SL/!SL!> !16<BIO: !SW/!SW/?!+!> \-
	\!16<DIO: !SW/!SW/?!+!> !10<AST: !SW/?!+!> Files: !SW/!SW!/\
LINE5:	.ASCID\!20<Page faults: !SL!> !20<Virtual limit: !SL!> Pgfl: !UW/!UW\-
	\ Prc: !UW/!UW!/\
LINE5NPH:
	.ASCID\!20<Page faults: ?!+!> !20<Virtual limit: ?!+!> Pgfl: !UW/!UW\-
	\ Prc: !UW/!UW!/\
PRVCTR:	.ASCID\Privilege vectors:  !11<TQ: !UW/!UW!> Status: !XL  Master: !XL\-
	\ Mtx: !UW!/\-
	\D: !XL!XL C: !XL!XL I: !XL!XL A: !XL!XL!/\

PRVCTR2:
	.ASCID\                    !11<TQ: !UW/!UW!> Status: !XL  Master: !XL\-
	\ Mtx: !UW!/!/\

EFNMCTR:
	.ASCID\Msk: !XL\
EFNCTR:	.ASCID\ !AC!AD !XL\
COLON:	.ASCII/:/
SPACE:	.ASCII/ /
LTAB:	.ASCII/</
RTAB:	.ASCII/>/
ZERO:	.ASciC/0/
ONE:	.ASCic/1/

STKCTR:
	.ASCID\!1AD!2AC: !XL \
PCCTR:	.ASCID\PC: !XL!/\
LINE7:	.ASCID\!AD:!AC (Prot: !XW)  Account: !AD!/\
DQQCTR:	.ASCID\!AS(!UL/!UL+!UL) \
UNKQTA:	.ASCID\!AS(?) \
INFQTA:	.ASCID\!AS(*) \
DV1CTR:
	.ASCID\!AC!UW:\
MODCTR:	.ASCID\	(!AD) \
DV3CTR:	.ASCID\FID: !UW,!UW,!UW !AD\
DEVNAMCTR:
	.ASCID\!AC!UW\
VOLCTR:	.ASCID\[!AD]\
DVSTSCTR:
	.ASCID\	!2UW !AD\
DVLBNCTR:
	.ASCID\ LBN: !UL\
DVVBNMCTR:
	.ASCID\ VBM: !UL/!UL\
DVVBNQCTR:
	.ASCID\ VBN: ?/!UL\
DVVBNCTR:
	.ASCID\ VBN: !UL/!UL\
ALLOCTR:
	.ASCID\ A:!1AD\
ALLO2CTR:
	.ASCID\!AC!UW:	(Allocated:!AD)\
SPDCTR:	.ASCID\ !UL(!UL)\
FOREIGN:
	.ASCID\/Foreign \
MODES:	.ASCII/KESU?/
SMOD:	.ASCII/kesu/
SMODSP:	.ASCIC/sp/
MODSP:	.ASCIC/SP/
CMODE:	.ASCII/C/
CPLCTR:	.ASCID\[!16%D]\
LMSG:	.ASCIC/Logged in/
SMSG:	.ASCIC/Started/
ASTEN:	.ASCID\	Enabled: \
NONE:	.ASCID\(None)\
CRLF:	.ASCID	<^O15><^O12>
TAB:	.ASCID/	/
CMDTAB:	.ASCII/PSZRA ^F/
	MAXCMD=.-CMDTAB

ADRTAB:	.LONG	PCMD
	.LONG	SCMD
	.LONG	ZCMD
	.LONG	RCMD
	.LONG	ACMD
	.LONG	UPDAT
	.LONG	UPARW
	.LONG	FCMD

	.MACRO	STATES	LIST
	STATEMAX=0
	.IRP	FOO,<'LIST'>
		.=STTTAB+<4*SCH$C_'FOO'>
	.IF	LT	STATEMAX-SCH$C_'FOO'
		STATEMAX=SCH$C_'FOO'
	.ENDC
	.LONG		FOO
		.SAVE_PSECT
		.PSECT	STATES,RD,NOWRT,NOEXE

	FOO':	.ASCIC/'FOO'/
		.RESTORE_PSECT
	.ENDR
	.ENDM	STATES

STTTAB:	STATES	<LEF,LEFO,CUR,COM,COMO,MWAIT,SUSP,SUSPO,CEF,PFW,HIB,HIBO,FPG,COLPG>
	.=STTTAB+<4*STATEMAX+4>

UNKSTT:	.ASCIC/???/

BUFDSC:	.LONG		400,TTOBUF

DEVTBS:	.BYTE		0,0,2,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0

LOGLST:
	$TRNLOG		RSLLEN=DEFDEV,LOGNAM=DEFDEV,RSLBUF=LOGBUF2

LOGBUF2:
	.LONG		63,DEFDEV+8

ATRLST:
	.WORD		ATR$S_HEADER,ATR$C_HEADER
	.LONG		FILHDR
	.LONG		0

	.MACRO		NOCTLTAB
	XX=0
	.REPEAT		256
	.IF		LT,<XX-^A/ />
		.BYTE	^A/ /
	.IFF
		.BYTE	XX
	.ENDC
	XX=XX+1
	.ENDR
	.ENDM

NOCTL:	NOCTLTAB

	.MACRO		TERMSPEED	SPEED

	..=.
	.=TRMSPD+<4*TT$C_BAUD_'SPEED'>
	.LONG	SPEED
	.IF		GT,<..-.>
	.=..
	.ENDC
	.ENDM

TRMSPD:	TERMSPEED	9600
	TERMSPEED	7200
	TERMSPEED	4800
	TERMSPEED	3600
	TERMSPEED	2400
	TERMSPEED	2000
	TERMSPEED	1800
	TERMSPEED	1200
	TERMSPEED	600
	TERMSPEED	300
	TERMSPEED	150
	TERMSPEED	134
	TERMSPEED	110
	TERMSPEED	75
	TERMSPEED	50

	.MACRO		TERMSTATE	BIT,TEXT,?L1
	..=.
	.SAVE_PSECT
	.PSECT		TERMSTATE,RD,NOWRT,NOEXE
L1:
	.IF		B,<'TEXT'>
	.ASCID/ /\'BIT'\
	.IFF
	.ASCID/ /\'TEXT'\
	.ENDC
	.RESTORE_PSECT

	.=TTSTTAB+<4*TTY$V_ST_'BIT'>
	.LONG	L1
	.IF		GT,<..-.>
	.=..
	.ENDC
	.ENDM

TTSTTAB:
	TERMSTATE	XON
	TERMSTATE	XOFF
	TERMSTATE	CTRLS,<^S>
	TERMSTATE	FILL,F
	TERMSTATE	CURSOR,CRS
	TERMSTATE	SENDLF,LF
	TERMSTATE	MULTI,M
	TERMSTATE	WRITE,O
	TERMSTATE	BRDCST,B
	TERMSTATE	EOL
	TERMSTATE	CTRLR,<^R>
	TERMSTATE	READ,I
	TERMSTATE	CTRLO,<^O>
	TERMSTATE	DEL
	TERMSTATE	PASALL,<*I>
	TERMSTATE	NOECHO,NE
	TERMSTATE	WRTALL,<*O>
	TERMSTATE	PROMPT,P
	TERMSTATE	NOFLTR,<~>
	TERMSTATE	ESC,<$>
	TERMSTATE	BADESC,<~$>
	TERMSTATE	NL
	TERMSTATE	REFRSH,RF
	TERMSTATE	TYPFUL,<^G>
	TERMSTATE	SKIPLF,<~LF>
	TERMSTATE	GETAHD,%
	TERMSTATE	UNSOL,U
	TERMSTATE	<ESC_O>,<$O>
	TERMSTATE	CTRLSP,<^SP>
	TERMSTATE	WRAP,W

	.END		P