.TITLE	DUMP	   
;	  
; MCR TASK THAT	PROVIDES OCTAL DUMPS OF SPECIFIED AREAS OF CORE.  
; WHEN DUMPING A SPECIFIED TASK, DUMP 'FREEZES' THE TASK IN CORE
; (SUSPENDS IT AND DISABLES CHECKPOINTING), MAPS TO THE AREA TO
; BE DUMPED, GENERATES THE OCTAL DUMP AND SPOOLS IT TO THE LINE
; PRINTER.  IT THEN RESTORES THE ORIGINAL STATUS OF THE TASK.
; WHEN DUMPING BY MEMORY ADDRESS, THE SAME PROCEDURE IS FOLLOWED
; EXCEPT THAT ACTIVITY IN THE AREA BEING DUMPED IS NOT INHIBITED.
;	  
; WRITTEN   APR	1976   R B FRENCH   THE	BOEING COMPANY  
;
; MODIFIED  JUN 1977   R B FRENCH   +01 BUG FIX - FW GREATER THAN 100000
;				        OCTAL WAS TREATED AS A NEGATIVE VALUE
;				        AND SET TO ZERO.
;
; MODIFIED  OCT 1977   R B FRENCH   +02 CAPABILITY ADDED TO DUMP BY
;				        ABSOLUTE MEMORY ADDRESS.
;
; MODIFIED  NOV 1977   R B FRENCH   +03 KERNEL SWITCH (/KN) ADDED.  VALID
;					FOR SCOMM ADDRESSES (100000 - 1577776)
;					ONLY.
; MODIFIED  SEP 1978   R B FRENCH   +04 ADDED EXTERNAL PAGE ADDRESS TO /KN
;					SWITCH.  NON-EXISTANT UNIBUS ADDRESSES
;					WILL APPEAR AS ASTERICKS.
;	  
; CALLING SEQUENCE:	    
;	  
; MCR>DUM[P] [TASKNAME][/SWITCHES]   
;	  
;   TASKNAME = NAME OF TASK TO BE DUMPED (OMIT FOR MEMORY DUMP)    
;	  
;   SWITCHES:	 
;    ALL NUMERIC ARGUMENTS ARE IN OCTAL.  THE DELIMITER    
;    CAN EITHER BE A COLON, AS SHOWN, OR AN EQUAL SIGN.   
;    NOTE: FOR MEMORY DUMPS EITHER FW OR LW (OR BOTH)
;    MUST BE INPUT.
;	  
;    /HD       DUMP TASK HEADER (IGNORED FOR MEMORY DUMP)	    
;    /FW:ADR   ADR IS THE FIRST	WORD TO BE DUMPED.  IT  
;	       WILL BE ROUNDED DOWN TO THE NEAREST 100    
;              BYTE BOUNDARY.  DEFAULT IS ZERO.
;    /LW:ADR   ADR IS THE LAST WORD TO BE DUMPED.  IT   
;	       WILL BE ROUNDED UP TO THE NEAREST 100  
;	       BYTE BOUNDARY.  DEFAULT FOR A TASK DUMP   
;	       IS THE MAXIMUM TASK SIZE.  DEFAULT FOR
;	       MEMORY DUMP IS THE PHYSICAL UPPER LIMIT
;	       OF MEMORY.
;    /NW:NUM   NUM IS THE NUMBER OF BYTES TO DUMP.  
;    /KN       DUMP ADR'S WILL BE INTREPRETED AS KERNEL
;	       VIRTUAL SPACE.  VALID ONLY FOR MEMORY DUMPS 
;	       (NO TASKNAME INPUT) - IGNORED 0THERWISE.
;	       OUTPUT FOR THIS SWITCH IS VALID ONLY FOR
;	       SCOMM AND THE EXTERNAL PAGE (KERNAL VIRTUAL
;	       100000 TO 177776).
;	  
;    IF	NO SWITCHES ARE	SPECIFIED WHEN DUMPING A TASK,  
;    THE ENTIRE TASK, EXCLUDING HEADER, WILL BE DUMPED.  
;    IF THE INPUT OR COMPUTED (VIA NW) VALUES OF FW AND 
;    LW EXCEED THE TASK LIMITS, THEY WILL BE TRUNCATED 
;    TO THE TASK LIMITS.  A SYNTAX ERROR MESSAGE WILL 
;    BE PRINTED IF LW IS GREATER THAN OR EQUAL TO FW, 
;    IF FW, LW AND NW ARE SIMULTANEOUSLY INPUT, OR IF  
;    SWITCH(ES) ARE INPUT OTHER THAN DEFINED ABOVE.
;	  
; IF ALL ARGUMENTS ARE OMITTED,	DUMP WILL REQUEST INPUT 
; WITH THE PROMPT 'DUMP>'.  ONCE A DUMP	REQUEST FOR A TASK  
; IS MADE IN THIS MANNER, IT WILL REMAIN 'FROZEN' UNTIL  
; A CONTROL Z OR ANOTHER TASKNAME (OR MEMORY DUMP REQUEST) 
; IS ENTERED.  MULTIPLE DUMPS OF A TASK CAN BE MADE IN THIS   
; MANNER.
;	  
; TASK BUILD FILE	  
;	  
;   DUMP/PR/-FP/-CP/MU=DUMP,[1,1]EXEC.STB/SS  
;   /	  
;   TASK=...DUM	    
;   ASG=TI:1	   
;   PRI=100	 
;   LIBR=SYSRES:RO	 
;   STACK=32	   
;   /	  
;	  
	.MCALL	DIR$,GMCR$,QIOW$,OPEN$,PRINT$,DELET$,PUT$,EXIT$S   
	.MCALL	FSRSZ$,FDBDF$,FDAT$A,FDRC$A,FDOP$A,NMBLK$,SVDB$S   
;	  
; MAP APR1 TO THE 1ST 100 BYTES	OF OUR HEADER.  ALL APR 
; CHANGES MUST BE MADE IN THE HEADER ALSO OR EXEC ACTIVITY  
; WILL RESTORE THE APR'S TO THEIR ORIGINAL VALUES.  
;+04 ALSO SPECIFY THE SST VECTOR TABLE HERE, WHICH TRAPS 
;+04 REFERENCES TO NON-EXISTANT UNIBUS ADDRESSES WHEN DUMPING
;+04 THE EXTERNAL PAGE.
; THIS CODE IS EXECUTED	ONLY ONCE AND THEN WILL BE USED 
; AS STACK SPACE.	  
START:	MOV	.CRTSK,R0	;GET OUR ATL NODE  
	MOV	A.HA(R0),R0	;GET OUR LOAD ADDRESS  
	MOV	#406,R1		;PDR FOR 100 BYTES    
	MOV	@#177776,-(SP)	;PSW TO	STACK   
	BIS	#140,@#177776	;;INHIBIT TASK SWITCHING 
	MOV	R0,@#177642	;;MAP APR1 TO FIRST 100    
	MOV	R1,@#177602	;;BYTES	OF OUR HEADER  
	MOV	R0,@#20024	;;PUT APR1 IN OUR HEADER    
	MOV	R1,@#20004	;;	 
	JSR	PC,..ENB0	;ENABLE	TASK SWITCHING   
	SVDB$S	#EXPG,#1	;+04 - SPECIFY THE VECTOR TABLE
	JSR	SP,GETMCR	;MAKE PREVIOUS CODE STACK SPACE  
;	  
; GET THE MCR COMMAND LINE AND LOCATE THE START AND 
; LENGTH OF THE	REQUEST.  THIS CODE IS EXECUTED ONLY    
; ONCE AND WILL	BE USED	LATER AS THE USER RECORD BUFFER 
; FOR PUT$ OPERATIONS.	 
GMCR:	GMCR$	    
GETMCR:	DIR$	#GMCR		;GET COMMAND LINE   
	CMP	0,#4		;ANY ARGUMENTS?  
	BLE	GETCMD		;IF NOT, GO GET COMMAND    
	INC	MCRFLG	    
	MOV	#GMCR+G.MCRB,R0	;GET MCR LINE ADDRESS  
	MOV	0,R1		;GET NUMBER OF CHARACTERS    
10$:	CMPB	#' ,(R0)+	;SCAN FOR BLANK 
	BEQ	20$	   
	SOB	R1,10$	    
	BR	GETCMD		;IF NONE, GO READ COMMAND   
20$:	DEC	R1	    
	BEQ	GETCMD	    
30$:	CMPB	#' ,(R0)+	;SCAN FOR NON-BLANK 
	BNE	40$	   
	SOB	R1,30$	    
	BR	GETCMD	 
40$:	DEC	R0	    
	MOV	R0,R3	 
	MOV	R1,IOST+2	;SAVE CHARACTER COUNT    
	BR	RDNAME	 
;	  
SYNERR:	DIR$	#QIOW		;WRITE SYNTAX ERROR MESSAGE 
;	  
DONE:	TST	MCRFLG		;COMMAND FROM MCR LINE?   
	BEQ	GETCMD		;NO - GET ANOTHER COMMAND  
EXIT:	TST	SAVNAM		;IS A TASK SUSPENDED? 
	BEQ	10$	   
	JSR	PC,RESUME	;RESUME	IT BEFORE EXITING    
10$:	TST	TSKNAM		;+02 MEMORY DUMP?
	BNE	20$		;+02
	JSR	PC,SPOOL	;+02 SPOOL THE OUTPUT
20$:	EXIT$S	    
;	  
; COME HERE TO WRITE 'DUMP>' PROMPT AND	TO READ REQUEST 
; IF NONE WAS GIVEN IN MCR LINE.    
GETCMD:	DIR$	#PROMPT		;WRITE PROMPT 
	MOV	#GMCR,R3   
	DIR$	#READ		;READ COMMAND  
	CMP	#-10.,IOST	;CONTROL Z? 
	BNE	RDNAME	    
	BR	EXIT	   
;	  
; READ TASKNAME	AND CONVERT IT TO RAD50.    
RDNAME:	CLRB	SWMASK		;CLEAR SWITCH MASK 
	MOV	#"  ,R0		;BLANK OUT TASKNAME   
	MOV	#TSKNAM,R1	    
	MOV	#3,R2	 
10$:	MOV	R0,(R1)+   
	SOB	R2,10$	    
	MOV	IOST+2,R4	;GET NUMBER OF CHARACTERS    
	MOV	R3,R5		;ADD ZERO BYTE  
	ADD	R4,R5	 
	CLRB	(R5)	 
	MOV	#TSKNAM,R0	;TASKNAME STRING IN R0  
	MOV	R0,R5		;AND SAVE IT    
20$:	CMPB	#'/,(R3)	;GET TASKNAME    
	BEQ	30$	   
	MOVB	(R3)+,(R0)+	  
	SOB	R4,20$	    
30$:	MOV	R5,R0		;RESET R0 TO TASKNAME SRTING
	MOV	#NAME,R1	;ADDRESS OF TITLE BLOCK NAME IN R1
	MOV	#3,R2		;3 WORDS TO MOVE
40$:	MOV	(R0)+,(R1)+	;PUT TASKNAME IN TITLE BLOCK
	SOB	R2,40$
	MOV	R5,R0		;RESET R0 TO TASKNAME STRING    
	MOV	#1,R1		;SET PERIOD ACCEPT  
	JSR	PC,$CAT5	;CONVERT 1ST WORD OF TASKNAME 
	MOV	R1,(R5)+	;SAVE IT  
	BCC	50$		;ANY ERRORS?
	CLR	(R5)		;IF SO - CLEAR 2ND WORD
	BR	60$		;AND ASSUME WE'RE DONE
50$:	JSR	PC,$CAT5	;CONVERT 2ND WORD OF TASKNAME 
	MOV	R1,(R5)		;SAVE IT  
60$:	TST	TSKNAM		;+02 TASKNAME INPUT?
	BNE	70$		;+02 BRANCH IF SO
	MOV	#NAME,R1	;+02 PUT 'MEMORY' IN TITLE BLOCK
	MOV	#"ME,(R1)+	;+02
	MOV	#"MO,(R1)+	;+02
	MOV	#"RY,(R1)	;+02
70$:				;+02
	TST	R4		;ANY SWITCHES  
	BEQ	GO		;IF NOT	- GO   
	INC	R3		;STEP R3 PAST /    
;	  
; READ SWITCHES	AND SET	PARAMETERS ACCORDINGLY  
RDSW:	MOVB	(R3)+,SW	;GET SWITCH NAME    
	MOVB	(R3)+,SW+1	   
	MOV	SW,R0		;AND PUT IN R0  
	SUB	#3,R4		;STEP R4 PAST SWITCH    
	MOVB	NSWTCH,R5	;NUMBER	OF POSSIBLE SWITCHES    
	MOV	#SWTYP,R1	;SWITCH	TABLE ADR IN R1  
10$:	CMP	R0,(R1)+	;CHECK FOR SWITCH TYPE    
	BEQ	20$	   
	SOB	R5,10$	    
	BR	SYNERR		;ERROR IF NO MATCH  
20$:	DEC	R5		;USE SWITCH POINTER    
	MOV	#1,R0		;TO SET	MASK    
	ASH	R5,R0	 
	BISB	R0,SWMASK	    
	CMP	#1,R5		;+03 HEADER OR KERNEL?
	BGE	30$		;+03 BRANCH IF SO
	CMPB	#':,(R3)+	;CHECK FOR SEMI-COLON   
	BEQ	25$		;BRANCH	IF THERE  
	CMPB	#'=,-1(R3)	;HOW ABOUT EQUAL SIGN? 
	BNE	SYNERR		;SYNTAX	ERROR IF NEITHER   
25$:	MOV	R3,-(SP)	;+02 SAVE R3
26$:	CMPB	#60,(R3)+	;+02 SCAN FOR END OF SWITCH VALUE
	BLE	26$		;+02
	SUB	#3,R3		;+02 BACK UP AND CLEAR DIGIT
	CLRB	(R3)		;+02 TO STOP $COTB
	MOV	(SP)+,R3	;+02 RESTORE R3
	MOV	R3,R0	  
	JSR	PC,$COTB	;CONVERT SWITCH PARAMETER 
	ADD	#2,R3		;+02 SKIP OVER IGNORED CHARACTERS
	ASL	R5	    
	MOV	R1,FW-4(R5)	;+03 AND SAVE IT
30$:	TST	R4		;ANY MORE CHARACTERS   
	BEQ	GO		;IF NOT	- GO   
	CMPB	#'/,(R3)+	;SCAN FOR NEXT SWITCH   
	BEQ	RDSW		;AND GO	READ IT  
	SOB	R4,30$	    
;	  
; CHECK	FOR NEW	TASKNAME.  IF NEW, RESUME PREVIOUS TASK 
; (IF ANY) BEFORE SUSPENDING NEW ONE. 
GO:	CMP	TSKNAM,SAVNAM	;COMPARE 1ST WORD OF OLD AND NEW TASKNAMES    
	BNE	10$		;BRANCH	IF DIFFERENT  
	CMP	TSKNAM+2,SAVNAM+2 ;COMPARE 2ND WORD    
	BEQ	SETUP		;IF THE	SAME - GO DUMP SOME MORE    
10$:	TST	SAVNAM		;IS A TASK SUSPENDED   
	BEQ	SUSPND		;BRANCH	IF NOT 
	JSR	PC,RESUME	;RESUME	THE OLD TASK 
SUSPND:	TST	TSKNAM		;+02 IS THIS A MEMORY DUMP?
	BEQ	TSKDMP		;+02 IF SO, BRANCH
	MOV	#.ATLLH,R0	;GET ATL LISTHEAD    
	MOV	R0,R3		;AND SAVE IT    
	MOV	#TSKSIZ,R2	;START OF PARAMETERS IN R2  
	MOV	@#177776,-(SP)	;PUSH PSW TO STACK  
	BIS	#140,@#177776	;;INHIBIT TASK SWITCHING 
ATLSCN:	MOV	(R0),R0		;;GET NEXT ATL NODE    
	CMP	R0,R3		;;END OF ATL?   
	BEQ	ERRTS		;;GO WRITE NOT ACTIVE MESSAGE   
	MOV	A.TD(R0),R1	;;STD ADDRESS IN R1    
	CMP	(R1),TSKNAM	;;CHECK	1ST WORD OF TASKNAME   
	BNE	ATLSCN	    
	CMP	2(R1),TSKNAM+2	;;CHECK	2ND WORD OF TASKNAME    
	BNE	ATLSCN	    
	MOV	S.TZ(R1),(R2)+	;;MATCH	FOUND - SAVE MAX TASK SIZE  
	MOV	A.TS(R0),(R2)+	;;SAVE TASK STATUS  
	MOV	A.TF(R0),(R2)+	;;SAVE TASK FLAGS   
	MOVB	#TS.SUS,A.TS(R0) ;;SUSPEND TASK   
	BIS	#AF.CD,A.TF(R0)	;;DISABLE CHECKPOINTING    
	MOV	A.HA(R0),R1	;;GET TASK LOAD ADDRESS    
	MOV	R1,(R2)+	;;AND SAVE IT 
	MOV	R1,@#177644	;;MAP APR2 TO FIRST 200    
	MOV	#1002,@#177604	;;BYTES	OF HEADER   
	MOV	R1,@#20026	    
	MOV	#1002,@#20006	 
	MOV	@#40000+H.HSZ,(R2)+ ;;SAVE HEADER SIZE 
	DECB	@#177605	;;CHANGE MAPPING TO 100 BYTES    
	DECB	@#20007	  
	JSR	PC,..ENB0	;ENABLE	TASK SWITCHING   
	MOV	R0,(R2)+	;SAVE THE ATL NODE ADDRESS    
	MOV	TSKNAM,(R2)+	;SAVE THE NEW TASKNAME    
	MOV	TSKNAM+2,(R2)+	    
	BR	SETUP	  
ERRTS:	JSR	PC,..ENB0	;ENABLE	TASK SWITCHING 
	DIR$	#NOTACT		;WRITE NOT ACTIVE MESSAGE    
	JMP	DONE	  
;	  
; IF HEADER DUMP IS REQUESTED, DO IT FIRST. 
SETUP:	OPEN$	#FDB		;OPEN THE PRINT FILE   
	TST	TSKNAM		;+02 MEMORY DUMP?
	BEQ	TSKDMP		;+02 THEN BRANCH
	MOV	HDADR,PADR	;GET LOAD ADDRESS 
	BITB	#HDSW,SWMASK	;HEADER	DUMP REQUESTED?  
	BEQ	TSKDMP		;BRANCH	IF NOT 
	MOV	PADR,LPADR	;SET UP	TO DUMP HEADER  
	ADD	HEADSZ,LPADR	  
	CLR	VADR	  
	MOV	#HDTITL,R0	;PUT HEADER TITLE IN TITLE
	MOV	#FROM,R1
	MOV	#8.,R2
10$:	MOV	(R0)+,(R1)+
	SOB	R2,10$
	PUT$	#FDB,#TITLE,#36. ;PRINT HEADER TITLE
	BICB	#HDSW,SWMASK	;CLEAR HEADER REQUEST BIT    
	JMP	DUMP		;AND GO	DUMP HEADER   
;	  
; CHECK	FOR SWITCH PARAMETERS AND SET POINTERS ACCORDINGLY  
TSKDMP:	BITB	#FWSW,SWMASK	;FW INPUT?    
	BNE	10$		;BRANCH IF SO	   
	CLR	FW		;DEFAULT IS ZERO   
10$:	BITB	#LWSW,SWMASK	;LW INPUT?   
	BNE	20$		;BRANCH IF SO	   
	TST	TSKNAM		;+02 MEMORY DUMP?
	BNE	15$		;+02 BRANCH IF NOT
	MOV	.MSIZE,LW	;+02 SET LW TO UPPER MEMORY LIMIT
	BR	20$		;+02
15$:	MOV	TSKSIZ,LW	;DEFAULT IS MAX TASK SIZE 
	SUB	HEADSZ,LW	;SUBTRACT HEADER SIZE 
20$:	BITB	#NWSW,SWMASK	;NW INPUT?   
	BEQ	30$		;BRANCH IF NOT	   
	CMPB	#FWSW!LWSW,SWMASK ;ARE FW AND LW BOTH INPUT?
	BNE	21$		;BRANCH IF NOT
	JMP	SYNERR		;HE'S GOT TO MAKE UP HIS MIND!!
21$:	BITB	#LWSW,SWMASK	;FW OR LW INPUT?  
	BNE	25$		;BRANCH	IF LW 
	MOV	FW,LW		;RECOMPUTE LW AS LW=FW+NW   
	ADD	NW,LW	 
	SUB	#2,LW	 
	BR	30$	    
25$:	MOV	LW,FW		;RECOMPUTE FW AS FW=LW-NW   
	SUB	NW,FW	 
	BCC	30$		;+01 BRANCH ON NO CARRY
	CLR	FW		;+01 OTHERWISE SET FW=0
;+01 FOLLOWING CODE DELETED
;30$:	TST	FW		;CHECK IF FW IS NEGATIVE
;	BGE	35$		;BRANCH IF NOT
;	CLR	FW		;CLEAR IT IF IT IS
;35$:
;+01 END OF CODE DELETION	  
30$:	MOV	#40.,R4		;+04 ASSUME 40. BYTES IN HEADER
	TST	TSKNAM		;+02 MEMORY DUMP?
	BNE	35$		;+02 BRANCH IF NOT
	CMP	LW,.MSIZE	;+02 CHECK IF LW EXCEEDS MEMORY SIZE
	BLE	5$		;+02 BRANCH IF NOT
	MOV	.MSIZE,LW	;+02 OTHERWISE SET LW TO MEMORY SIZE
5$:	MOV	FW,PADR		;+02 SET UP DUMP LIMITS
	MOV	LW,LPADR	;+02
	MOV	FW,VADR		;+02
;
	BITB	#KNSW,SWMASK	;+03 KERNEL SWITCH INPUT?
	BEQ	45$		;+03 BRANCH IF NOT
	CMP	#1600,FW	;+04 ADDRESS IN EXTERNAL PAGE?
	BGT	32$		;+04 BRANCH IF NOT
	CMP	#2000,LW	;+04 ADDRESS IN RANGE?
	BGE	31$		;+04
	JMP	SYNERR		;+04 SYNTAX ERROR IF NOT
31$:	ADD	#176000,PADR	;+04 SET PADR FOR EXTERNAL PAGE
	ADD	#176000,LPADR	;+04 LPADR ALSO
	MOV	#84.,R4		;+04 84. BYTES IN UNIBUS HEADER
	BR	34$		;+04
;
32$:	CMP	#1000,FW	;+03 CHECK ADDRESS LIMITS
	BLE	33$		;+03
	JMP	SYNERR		;+03 SYNTAX ERROR IF TOO LOW
33$:	MOV	#1400,R0	;+03 CALCULATE VIRTUAL-PHYSICAL 
	SUB	@#KP.AR6,R0	;+03 OFFSET FOR KERNAL PAR 6
	SUB	R0,PADR		;+03 ADJUST PADR ACCORDINGLY
	SUB	R0,LPADR	;+03 LPADR ALSO
;
34$:	MOV	#NAME,R0	;+03 PUT KERNEL IN TITLE BLOCK
	MOV	#"KE,(R0)+	;+03
	MOV	#"RN,(R0)+	;+03
	MOV	#"EL,(R0)	;+03
	BR	45$		;+02
35$:	ADD	HEADSZ,PADR	;OFFSET	TO START OF TASK   
	MOV	PADR,LPADR	;SET UP DUMP LIMITS
	ADD	FW,PADR		;LOWER LIMIT
	ADD	LW,LPADR	;UPPER LIMIT
	MOV	HDADR,R0	;CALCULATE UPPER TASK LIMIT
	ADD	TSKSIZ,R0	
	CMP	R0,LPADR	;CHECK IF DUMP EXCEEDS IT
	BGE	40$		;BRANCH IF IT DOESN'T
	MOV	R0,LPADR	;SET DUMP LIMIT TO TASK LIMIT
40$:	MOV	FW,VADR		;SET UP VIRTUAL ADDRESS
45$:	CMP	PADR,LPADR	;IS PADR LT LPADR?
	BLT	50$		;SYNTAX ERROR IF NOT
	JMP	SYNERR
50$:	CLRB	SWMASK	   
;	  
; PRINT TITLE
	MOV	#1,R2		;SET ZERO FILL FLAG
	MOV	#FROM,R0	;PUT START OF DUMP IN TITLE
	MOV	FW,R1
	JSR	PC,$CBOMG
	MOV	#"00,(R0)+	;+02 ADD FILLER ZEROS
	MOV	#" T,(R0)+
	MOV	#"O ,(R0)+
	MOV	LW,R1		;PUT END OF DUMP IN TITLE
	JSR	PC,$CBOMG
	MOV	#"00,(R0)+	;+02 ADD FILLER ZEROS
	PUT$	#FDB,#TITLE,R4	;PRINT THE TITLE
;
; DUMP THE TASK PER REQUEST
DUMP:	INC	FLAG		;INCREMENT THE PRINT FLAG
	MOV	@#177776,-(SP)	;PSW TO	STACK   
	BIS	#140,@#177776	;;INHIBIT TASK SWITCHING 
	MOV	PADR,@#177644	;;MAP TO START OF DUMP   
	MOV	PADR,@#20026	;;	  
	TST	TSKNAM		;;+02 MEMORY DUMP?
	BNE	10$		;;+02 BRANCH IF NOT
	MOV	#402,@#177604	;;+02 SET UP PDR2
	MOV	#402,@#20006	;;+02
10$:	JSR	PC,..ENB0	;ENABLE	TASK SWITCHING   
	DEC	LPADR
	MOV	#1,R2		;ZERO FILL FLAG FOR $CBOMG
CNVRT:	MOV	#40000,R5	;APR2 OFFFSET IN R5  
	MOV	#GMCR,R0	;OUTPUT	STRING ADDRESS    
	MOV	VADR,R1		;CONVERT VIRTUAL ADDRESS  
	JSR	PC,$CBOMG	 
	MOV	#"00,(R0)+	;+02 ADD FILLER ZEROS
	MOV	#"  ,(R0)+	;ADD TWO BLANKS 
LOOP1:	CLR	R4		;CLEAR COUNTER 
	MOV	#20,R3		;20 WORDS PER LINE 
LOOP2:	MOVB	#' ,(R0)+	;ADD A BLANK    
	CMP	#4,R4		;FOUR WORDS CONVERTED?  
	BNE	10$	   
	MOVB	#' ,(R0)+	;THEN ADD A BLANK   
	CLR	R4		;AND CLEAR THE COUNTER 
10$:	MOV	(R5)+,R1   
	JSR	PC,$CBOMG	;CONVERT A WORD  
CONT:	INC	R4		;INCREMENT COUNTER
	SOB	R3,LOOP2	    
	PUT$	#FDB,#GMCR,#125. ;PRINT THE LINE
	CMP	#"40,GMCR+6	;WAS THIS 2ND HALF OF BLOCK? 
	BEQ	30$		;BRANCH IF SO
	MOV	#"40,GMCR+6	;PUT "40 IN BUFFER
	MOV	#GMCR+12,R0	;AND RESET POINTER
	BR	LOOP1	
30$:	INC	VADR		;INCREMENT ADR POINTER
	DEC	LPADR	 
	CMP	PADR,LPADR	;ARE WE	DONE?   
	BGT	40$		;BRANCH	IF SO 
	MOV	@#177776,-(SP)	;OTHERWISE - PSW TO STACK   
	BIS	#140,@#177776	;;INHIBIT TASK SWITCHING 
	INC	@#177644	;;INCREMENT PAR2  
	INC	@#20026	   
	JSR	PC,..ENB0	;ENABLE	TASK SWITCHING   
	BR	CNVRT		;AND GO	DUMP SOME MORE 
40$:	TSTB	SWMASK		;ANY MORE SWITCH MASKS SET?   
	BEQ	50$		;IF NOT, WE'RE DONE   
	JMP	TSKDMP	    
50$:	JMP	DONE	  
;
EXPG:	.WORD	SST		;+04 SST VECTOR TABLE
SST:	MOV	#6,R1		;+04 6 BYTES PER ENTRY
10$:	MOVB	#'*,(R0)+	;+04 PUT IN ASTERICKS
	SOB	R1,10$		;+04
	CMP	(SP)+,(SP)+	;+04 CLEAN UP STACK
	BR	CONT		;+04 RESUME NORMAL CODE
;	  
; SUBROUTINE THE RESTORE THE STATUS OF AND RESUME THE   
; SUSPENDED TASK.	  
RESUME:	MOV	ATLNOD,R0	;GET ATL NODE 
	MOV	@#177776,-(SP)	;PUSH PSW TO STACK  
	BIS	#140,@#177776	;;INHIBIT TASK SWITCHING 
	MOVB	STATUS,A.TS(R0)	;;RESTORE ORIGINAL TASK STATUS    
	BIS	FLAGS,A.TF(R0)	;;RESTORE ORIGINAL TASK FLAGS   
	JSR	PC,..ENB0	;ENABLE	TASK SWITCHING   
SPOOL:	TST	FLAG		;ANYTHING TO PRINT?
	BNE	10$		;IF SO, GO PRINT IT
	DELET$	#FDB		;OTHERWISE DELETE THE FILE
	BR	20$		;AND RETURN
10$:	PRINT$	#FDB		;SPOOL THE PRINT FILE 
	CLR	FLAG		;CLEAR THE PRINT FLAG
20$:	RTS	PC	    
;	  
TITLE:	.ASCII	<12>/ DUMP OF /
NAME:	.ASCII	/          /
FROM:	.ASCII	/          /
TO:	.ASCII	/          /
	.ASCII	/      (****** = NON-EXISTANT UNIBUS ADDRESS)/
HDTITL:	.ASCII	/TASK HEADER DUMP/
	.EVEN
FLAG:	.WORD	0		;PRINT FLAG
;
KNSW=1
HDSW=2	 
FWSW=4	 
LWSW=10	 
NWSW=20	    
MCRFLG:	.WORD	0	    
PADR:	.WORD	0	  
LPADR:	.WORD	0	 
VADR:	.WORD	0	  
TSKNAM:	.WORD	0,0,0	    
;	  
SWMASK:	.BYTE	0	    
NSWTCH:	.BYTE	5	    
SWTYP:	.ASCII	/NWLWFWHDKN/	   
; THE REMAINING	PARAMETERS ARE ORDER DEPENDENT - DO NOT ALTER   
FW:	.WORD	0	    
LW:	.WORD	0	    
NW:	.WORD	0	    
SW:	.WORD	0	    
;	  
TSKSIZ:	.WORD	0	    
STATUS:	.WORD	0	    
FLAGS:	.WORD	0	 
HDADR:	.WORD	0	 
HEADSZ:	.WORD	0	    
ATLNOD:	.WORD	0	    
SAVNAM:	.WORD	0,0	  
;	  
	FSRSZ$	1	  
FDB:	FDBDF$	    
	FDAT$A	R.VAR,FD.CR,123.    
	FDOP$A	2,,NMBLK,FO.WRT	    
NMBLK:	NMBLK$	DUMP,LST  
;	  
QIOW:	QIOW$	IO.WLB,1,1,,,,<SYNMSG,22.>  
SYNMSG:	.ASCII	<12>/DUMP -- SYNTAX ERROR/<15>   
NOTACT:	QIOW$	IO.WLB,1,1,,,,<ACTMSG,25.>    
ACTMSG:	.ASCII	<12>/DUMP -- TASK NOT ACTIVE/<15>    
	.EVEN	 
PROMPT:	QIOW$	IO.WLB,1,1,,,,<PRMT,6,0>  
PRMT:	.ASCII	<12>/DUMP>/	   
READ:	QIOW$	IO.RLB,1,1,,IOST,,<GMCR,80.,0>  
IOST:	.BLKW	2	  
;	  
	.END	START