.MCALL	.MODULE
.MODULE	FORMAT,VERSION=32,COMMENT=<DEVICE FORMATTER>,AUDIT=YES

; Copyright (c) 1998 by Mentec, Inc., Nashua, NH.
; All rights reserved
;
; This software is furnished under a license for use only on a
; single computer system and  may  be  copied  only  with  the
; inclusion of the above copyright notice.  This software,  or
; any other copies thereof, may not be provided  or  otherwise
; made available to any other person except for  use  on  such
; system and to one who agrees to these license  terms.  Title
; to  and  ownership of the software shall at all times remain
; in Mentec, Inc.
;
; The information in this document is subject to change without
; notice and should not be construed as a commitment by Digital
; Equipment Corporation, or Mentec, Inc.
;
; Digital and Mentec  assume  no  responsibility for the use or
; reliability of its software on equipment which is not supplied
; by Digital  or Mentec,  and listed  in the  Software  Product
; Description.
;
;	Edit	Who	Date		Description of modification
;	----	---	----		---------------------------
;	001	WLD	24-MAY-1991	Allow FORMAT to run with
;					MSCP model 30. controller ;RQZX1
;	032	Tim Shoppa		FMTDU modified for
;			12-Jan-1997	Andromeda support
;--
;
;  AUTHOR: JONATHAN P. HARRIS	5-DEC-77	V01-00
;
;  MODIFIED: BARBARA DOERRE	7-NOV-78	V01-01
;  MACROS MODIFIED AND ADDED TO SUPPORT VERIFIFICATION FUNCTIONALITY AND
;  TO OVERLAY FORMAT ROUTINES
;		1)MODIFIED DEVIC$ AND ENTRY$ MACROS
;		2)ADDED LDPT$ MACRO
;
;
;     THIS MODULE IS A PREFIX FILE FOR ASSEMBLY OF THE FORMAT ROOT
;     AND OVERLAYS.  IT PROVIDES MACROS NEEDED TO SPECIFY OPTIONS
;     AND CREATE TABLES AND ENTRY POINTS.
;     TO ADDED A DEVICE:
;     1) INVOKE DEVIC$ MACRO IN MODULE FMTDEV.MAC FOR THE DEVICE
;     2) CREATE A FILE FMTXX.MAC (XX=DEVICE MNEMONIC) CONTAINING THE FOLLOWING
;	 IN THE SPECIFIED ORDER
;		A. MACRO PREFIX FILE
;		B. INVOKE LDPT$ MACRO FOR DEVICE
;		C. DEVICE CHECK ROUTINE
;		D. INVOKE OPTN$ MACRO (OPTIONAL)
;		E. INVOKE ENTRY$ MACRO
;		F. FORMAT ROUTINE (IF ONE EXISTS)
;-
.SBTTL	MACROS (PREFIX FILE)
.AUDIT	.FMTDE,.FMTDT,.FMTDP,.FMTDY,.FMTDD,.FMTDL,.FMTDX,.FMTRK,.FMTDM,.FMTDW,.FMTDZ,.FMTDU
;+
; DEVIC$ - USED TO SET UP EACH FORMATTING OVERLAY
;
; THIS MACRO CREATES THE DEVICE TABLE ENTRY FOR THE DEVICE.
; IT SHOULD BE PLACED IN THE FMTDEV.MAC MODULE.
; A ROUTINE FOR DEVICE XX WILL HAVE DEVICE TABLE ENTRIES CREATED
; FOR IT.
;
; THE MACRO HAS THREE PARAMETERS, THE TWO LETTER DEVICE MNEMONIC,
; THE DEVICE ID NUMBER AS RETURNED BY .DSTATUS, AND FMTRT, A 'Y' OR 'N'
; TO INDICATE WHETHER A FORMATTING ROUTINE EXISTS FOR THIS DEVICE.
;
;	**THIS MACRO IS NOT TO BE INVOKED IN THE ROOT OR FORMAT OVERLAYS**
;
; TO INVOKE IT, TYPE:
;
;			DEVIC$	XX,IDNUM,FMTRT
;
; WHERE XX IS THE DEVICE MNEMONIC, IDNUM IS THE .DSTATUS NUMBER
; AND FMTRT IS A 'Y' OR 'N' TO INDICATE WHETHER A FORMAT ROUTINE
; EXISTS FOR THIS DEVICE.
;
; EXAMPLES:
;		DEVIC$	RK,0,Y		;DOES SETUP FOR RK05
;		DEVIC$	DM,23,Y		;DOES SETUP FOR RK06/7
;		DEVIC$	DX,22,N		;DOES SETUP FOR RX01
;-
;
;	SYMBOLIC DEFINITIONS FOR DEVICE TABLE
;
;SYMBOL				MEANING
;------				-------
				;OFFSETS INTO DEVICE TABLE ENTRY:
RADNAM=0			;	RAD50 DEVICE NAME
DEVTYP=2			;	.DSTATUS DEVICE ID NUMBER
ASCNAM=4			;	ASCII DEVICE NAME
OPVAL=6				;	POINTER TO LIST OF VALID OPTIONS
LOADPT=8.			;	LOAD ENTRY POINT
ENTRY=10.			;	ENTRY POINT TO ROUTINE
END=12.				;	END POINT OF ROUTINE			;BD1+
DEVCHK=14.			;	DEVICE CHECK ROUTINE ENTRY POINT
CHAR=16.			;	DEVICE CHARACTERISTICS
RTDVSZ=1			;		SPFUN RETURNS DEVICE SIZE 
SPFIO=2				;		SPFUN READS/WRITES
BFSZP1=4			;		BUFFER SIZE PLUS 1 FOR R/W	;BD1-
DVENSZ=18.			;SIZE OF EACH ENTRY IN DEVICE TABLE
;
	.MACRO	DEVIC$	NAME,IDNUM,FMTRT,CHARDV
	.PSECT	$DV,RO,D,GBL
	.GLOBL	$'NAME'TAB,$'NAME'END,$'NAME'DCK,NAME'LD
	.IIF	IDN	Y,FMTRT	.GLOBL	$'NAME'FMT
	.RAD50	/NAME/
	.WORD	IDNUM
	.ASCII	/NAME/
	.WORD	$'NAME'TAB
	.WORD	NAME'LD
	.IF IDN	Y,FMTRT
		.WORD	$'NAME'FMT
	.IFF
		.WORD	0
	.ENDC
	.WORD	$'NAME'END
	.WORD	$'NAME'DCK
	.WORD	CHARDV
	.PSECT
	.ENDM
;+
; LDPT$ - THIS MACRO CREATES THE NECESSARY LOAD POINTS AND POINTERS
;	  TO THE LIST OF OPTIONS FOR THE DEVICE.
;	  A DEVICE WILL HAVE THE FOLLOWING CREATED FOR IT:
;		1) POINTER TO LIST OF VALID OPTIONS FOR THIS DEVICE
;		2) LOAD POINT FOR OVERLAY
;		3) DEVICE CHECK ROUTINE ENTRY POINT
;		4) PATCH SPACE
;
;	A SHORT DEVICE CHECK ROUTINE SHOULD FOLLOW
;	A CALL TO THIS MACRO OF THE FORM:
;		IF (DEVICE NOT READY OR WRITE LOCKED) THEN SEC
;						      ELSE CLC
;	THE UNIT NUMBER OF THE DEVICE TO BE TESTED IS PASSED IN R1.
;
;	   **THIS MACRO IS NOT TO BE USED IN THE ROOT**
;
;
;	TO INVOKE IT, TYPE:
;
;			LDPT$	NAME
;
;	WHERE 'NAME' IS THE TWO LETTER DEVICE MNEMONIC.
;
; EXAMPLES:		LDPT$	RK	;FOR RK05
;			LDPT$	DM	;FOR RK06/07
;
;-
	.MACRO	LDPT$	NAME
	.PSECT	PATCH,RW,I
	.BLKW	32.
	.PSECT	$OP,RW,D,GBL
$'NAME'TAB::
	.PSECT	DATA,RW,D
	.PSECT	PUREDATA,RO,D
	.PSECT	NAME,I,RW
NAME'LD::	RTS	PC
	.PSECT	NAME'END,RO,D
$'NAME'END::
	.PSECT	NAME,I,RW
$'NAME'DCK::
	.ENDM
;+
; OPTN$ -  USED TO GENERATE THE 8 BYTE OPTION TABLE ENTRY THAT DEFINES AN OPTION.
;
;	THIS MACRO ALLOWS EACH FORMATTING ROUTINE TO SPECIFY THE OPTIONS
;	IT WILL NEED.  THE OPTIONS SO SPECIFIED BECOME KNOWN TO THE ROOT
;	AT LINK TIME, THUS THERE IS NO NEED TO MODIFY THE ROOT TO ADD AN
;	OPTION TO THE PROGRAM.
;
;	THERE CAN BE ANY NUMBER OF OPTIONS IN THE TABLE. THE TABLE IS
;	TERMINATED WITH A .WORD  0	(AUTOMATICALLY HANDLED BY ENTRY$ MACRO).
;	TO USE THE MACRO WITHIN A FORMATTING ROUTINE, PLACE IT AT THE
;	BEGINNING OF THE ROUTINE IMMEDIATELY FOLLOWING THE DEVIC$ CALL.
;	WITHIN THE ROOT, PLACE THE MACRO FOLLOWING EXISTING INVOCATIONS OF OPTN$.
;	THE MACRO HAS TWO PARAMETERS: OPTION, THE ASCII OPTION, AND
;	ACCEPT, A 'Y' OR 'N' TO INDICATE WHETHER THE OPTION WILL ACCEPT
;	A VALUE.
;
;	TO ACCESS THE INFORMATION IN THE TABLE, THE FOLLOWING SYMBOLS ARE
;	PROVIDED WITH EACH OPTION '?':
;		GIV.?    = 1  IF USER SPECIFIED THAT OPTION WITH A VALUE,
;			 = 0  IF USER DIDN'T SPECIFY OPTION
;			 = -1 IF USER SPECIFIED OPTION WITHOUT A VALUE
;		VAL.?    VALUE GIVEN WITH OPTION ? (IF A VALUE WAS GIVEN)
;			    (ONLY PROVIDED IF OPTION ACCEPTS A VALUE)
;
;	TO INVOKE OPTN$, TYPE
;
;			OPTN$ OPTION,ACCEPT
;
;	EXAMPLES:
;		OPTN$ S,Y    -  SETS UP OPTION "S" THAT ACCEPTS A VALUE
;		OPTN$ Q,N    -  SETS UP OPTION "Q" WHICH DOES NOT ACCEPT
;				A VALUE
;
;
;	EACH ENTRY CONSISTS OF:
;
;		+--------+--------+
;		! VALLOW ! OPTION !
;		+--------+--------+
;		!  RES.  ! GIVEN  !
;		+--------+--------+
;		!      VALUE      !
;		+--------+--------+
;
;	WHERE:
;		OPTION (1 BYTE) IS THE ASCII OPTION
;		VALLOW (1 BYTE) IS:
;				   1 - IF OPTION WILL ACCEPT A VALUE
;				   0 - IF NOT
;		GIVEN  (1 BYTE) IS:
;				   1 - IF OPTION SPECIFIED WITH A VALUE
;				   0 - IF OPTION NOT SPECIFIED
;				  -1 - IF OPTION SPECIFIED WITHOUT A VALUE
;		RES.   (1 BYTE) IS RESERVED FOR FUTURE USE
;		VALUE  (1 WORD) IS THE VALUE GIVEN WITH OPTION ( IF ALLOWED)
;-
;
;	SYMBOLIC DEFINITONS FOR OPTION TABLE
;
;SYMBOL				MEANING
;-----				-------
OPT=0				;OFFSETS INTO AN OPTION ENTRY: ASCII OPTION
VALLOW=1			;	ALLOW A VALUE?
GIVEN=2				;	OPTION GIVEN?
VALUE=4				;	VALUE GIVEN
OPENSZ=6			;SIZE OF EACH OPTION TABLE ENTRY IN BYTES
;
	.MACRO	OPTN$	OP,ACCEPT
	.PSECT	$OP,RW,D,GBL
		.BYTE	''OP
	.IF IDN	Y,ACCEPT
		.BYTE	1
	.IFF
		.BYTE	0
	.IFTF
GIV.'OP:	.BYTE	0
		.BYTE	0
	.IFT
VAL.'OP:	.WORD	0
	.IFF
		.WORD	0
	.ENDC
	.PSECT
	.ENDM
;+
; ENTRY$ - THIS MACRO CREATES THE NECESSARY ENTRY POINT AND .PSECT
;	 FOR THE FORMATTING ROUTINE.IT ALSO CLOSES OFF THE OPTION TABLE
;	 WITH A 0.
;
;	   **THIS MACRO IS NOT TO BE USED IN THE ROOT**
;
;	TO INVOKE IT, TYPE:
;
;			ENTRY$	NAME
;
;	WHERE 'NAME' IS THE TWO LETTER DEVICE MNEMONIC.
;
; EXAMPLES:		ENTRY$	RK	;FOR RK05
;			ENTRY$	DM	;FOR RK06/07
;
;-
	.MACRO	ENTRY$	NAME
	.PSECT	$OP,RW,D,GBL
	.WORD	0
	.PSECT	NAME,I,RW
$'NAME'FMT::
	.ENDM
.SBTTL	ROOT CODE
;+
;
;                        COPYRIGHT (c) 1989 BY
;             DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;                         ALL RIGHTS RESERVED.
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
; ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
; INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
; COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
; OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
; TRANSFERRED.
;
; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
; AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
; CORPORATION.
;
; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
;
;  AUTHOR: JONATHAN P. HARRIS	5-DEC-77	Y01-00
;
;  MODIFIED:	(DON'T FORGET TO CHANGE VERSION # AT VERS:,TOO!)
;
; Y01-01 12-DEC-77	MODIFIED DEVICE CHECKS TO RECOGNIZE LOGICAL
;	   -JPH-	DEVICE NAMES					;JH1
;
; Y01-02  4-JAN-78	ADDED PATCH .PSECT, CORRECTED VERSION #'S
;	   -JPH-							;JH2
;
; Y01-03 11-JAN-78	CHANGED .FETCH IN LDECOD TO LOAD
;	   -JPH-	HANDLER AT @#50 INSTEAD OF AT #FREE.
;			THIS EDIT IS TO BE UNDONE WHEN FORMAT
;			BECOMES OVERLAID.				;JH3
;
; Y01-04 12-JAN-78	DISABLED ^C DURING FORMATTING
;	   -JPH-							;JH4
;
; Y01-05  7-NOV-78	ADD VERIFICATION CODE AND OPTIONS
;	   -BJD-	OVERLAID FORMAT ROUTINES			;BD1
;
; Y01.06  2-AUG-79	MODIFIED MESSG$ AND ADDED CODE TO SUPPORT
;	   -MBG-	THE SETTING OF THE USER PROGRAM ERROR STATUS
;			BYTE (53)					;MG1
;
; V04.00 16-NOV-79	Copyright statement update
;	   -MBG-
;
; X05.00 07-JUL-82	Copyright statement, identification, and
;	   -CA-         version update.
;
; X05.00 08-JUL-82	Querys response, adjusted to utilities standard.
;	   -CA-
;
; X05.00 08-JUL-82    	Query to proceed when detection of Foreground 
;	   -CA-         job loaded.
;
; X05.00 14-JUL-82 	Search for protected files in the device to 
;    	   -CA-         be formatted. Query user if any are found.
;
; X05.00 15-JUL-82	Change messages used with the /W wait option
; 	   -CA-	 	to follow the RT11 standard.
;
; X05.00 27-JUL-82      Insert message 'operation not completed' when
;          -CA-         a no response is issued to a query during /w.
;
; X05.00 27-JUL-82     When the /Y option is given do not query for 
;          -CA-        anything, or search for protected files.
;
; X05.00 13-SEP-82	Get the CSR address from the device handler
;	   -CA-
;
; Y05.01 24-NOV-82 	Select the right monitor handler for reading
;	   -CA-		the CSR address. (get monitor suffix)
;
; Y05.02 30-NOV-82      Take routine PDECOD out.
;	   -CA-
;
; Y05.03 21-DEC-82	Check for the correct system version of RT11
;	   -CA-		
;
; Y05.04 31-JAN-83	Trap to 10 when no disk was on the drive and try
;      	   -CA-         to format
;
; Y05.05 15-FEB-83	Prevent formatting software protected RX02
;	   -CA-
;     THIS MODULE IS THE ROOT CODE FOR THE FORMAT PROGRAM.
;     THE OVERLAYS ARE DEVICE SPECIFIC FORMATTING ROUTINES.
;     THIS MODULE DECODES COMMAND LINES, DISPATCHES TO DEVICE FORMATTING
;     ROUTINES, AND PROVIDES COMMON ROUTINES USED BY THE OVERLAYS.
;
;-
	.SBTTL	ASSEMBLY ORDER OF PSECTS

	.PSECT
	.PSECT	DATA,D
	.PSECT	$OP,RW,D,GBL
	.PSECT	PUREDATA,RO,D
	.PSECT	$DV,RO,D,GBL
	.PSECT	END$DV,RO,D
	.PSECT	MAIN,RO
	.PSECT	.LIBC.,RW,I
	.PSECT	SYS$D,RW,D
	.PSECT	SYS$I,RW,I
	.PSECT	SYS$S,RW,D

;*** The following PSECT must be last so that there is no root code
;*** after FREE:

	.PSECT	PATCH,RW,I						;JH2
	.SBTTL	SYMBOLS

; SYSTEM MACROS

	.MCALL	.CSISP,	.DSTAT,	.EXIT,	.GTLIN,  .TTYOUT, .GTIM
	.MCALL	.CSTAT,	.PRINT,	.RCTRL,	.TTYIN,	.TTINR, .GVAL
	.MCALL	.FETCH,	.LOOKU,	.SAVES,	.SCCA,	.RELEA			;JH1,4
	.MCALL	.REOPE,	.PURGE,	.READW,	.WRITW,	.SPFUN,	.SETTO		;BD1

	.LIBRARY "SRC:SYSTEM"
	.MCALL	.JSXDF	.SYCDF
	.JSXDF
	.SYCDF

; GLOBALS

	.GLOBL	$SERR1,	$SERR2,	$SERR3,	$WAIT,	$CNVRT,	$SVRG,	$RSTRG	;BD1
	.GLOBL	$FNASC, USERRB, ERR18, DWFLAG
	.GLOBL	PREMSG							;MG1+
	.IRPC	X,<IWEFU>
	.GLOBL	ERR$$'X
	.ENDR								;MG1-

;
;	LOCAL SYMBOLS
;
;	SYMBOL			MEANING
;	------			--------
	SPINIT	= 42		;INITIAL VALUE OF STACK POINTER IS AT LOC 42
	JSW	= 44		;LOCATION OF JOB STATUS WORD
	TTNOWT	= 100		;	INHIBIT TT WAIT BIT IN JSW
	REENTR	= 20000		;	REENTER BIT IN JSW
	USERRB	= 53		;USER PROGRAM ERROR STATUS BYTE
	ERR$$I	= 0		;	INFORMATIONAL MESSAGE		;MG1+
	ERR$$W	= 1		;	WARNING MESSAGE
	ERR$$E	= 2		;	ERROR MESSAGE
	ERR$$F	= 3		;	FATAL/SEVERE ERROR MESSAGE
	ERR$$U	= 4		;	UNCONDITIONAL ABORT MESSAGE	;MG1-
	OFFCSR	= 176		;OFFSET ON DEVICE HANDLER TO CSR ADDR
	RMON	= 54		;POINTER TO START OF RESIDENT MONITOR
	FGND	= 200		;	FGND JOB LOADED BIT IN CONFIG WORD
	USRLOC	= 266		;	OFFSET FROM RMON OF USR LOCATION
	SYSUNT	= 275		;	OFFSET FROM RMON OF SYS DEVICE UNIT#
	SYSVER	= 276		;	OFFSET FROM RMON TO SYSTEM VERSION
	CONFIG	= 300		;	OFFSET FROM RMON OF SYS CONFIG WORD
	PNPTR	= 404		;	OFFSET FROM RMON TO $PNAME OFFSET
	SUFFIX	= 412		;	OFFSET FROM RMON TO MONITOR SUFFIX
	GETVEC	= 436		;	OFFSET FROM RMON TO $GTVEC ROUTINE
	DWTYPE	= 440		;	OFFSET FROM RMON TO DW TYPE WORD
	DFLPAT	= 200		;DEFAULT VERIFY PATTERN

; DIRECTORY HEADER OFFSETS

	DH.AVL	= 0		;AVAILABLE SEGMENTS
	DH.NXT	= 2		;POINTER TO NEXT DIRECTORY SEGMENT
	DH.HI	= 4		;HIGHEST DIRECTORY SEGMENT OPEN
	DH.EXB	= 6		;NUMBER OF EXTRA BYTES
	DH.STB	= 10		;STARTING BLOCK NUMBER FOR FILES IN SEG
	DH.SIZ	= 12		;SIZE OF HEADER IN BYTES

; DIRECTORY ENTRY OFFSETS

	DE.ST	= 0		;STATUS OF ENTRY
		DS.TNT	= 400	;TENTATIVE
		DS.EMP	= 1000	;EMPTY
		DS.PRM	= 2000  ;PERMANENT
		DS.EOS	= 4000	;END OF SEGMENT
		DS.PRO  = 100000;PROTECTED
	DE.SIZ  = 16		;SIZE OF DIRECTORY ENTRY

; DIRECTORY DEFINITIONS

	MAXSEG	= 31.		;MAXIUM NUMBER OF SEGMENTS
	BLKSIZ	= 512.		;512 BYTES/BLOCK
	SEGSIZ  = BLKSIZ*2 	;2 BLOCKS/SEGMENT
	MAXBYT	= 356		;MAXIMUM NUMBER OF EXTRA BYTES

; DEVICE HANDLER OFFSETS

	H.DATA	= 72		;.DRTAB addr

; ASCII DEFINITIONS

	LF	= 15		;LINE FEED
	CR	= 12		;CARRIAGE RETURN
	NULL	= 200		;NULL BYTE

; RD50/51 AND RX50 DEVICE DATA

	DWSTAT	= 20		; OFFSET OF STATUS/INIT REGISTER FROM DW START ADDRESS
		STDCAP	= 400	; Drive capacity (1=5MB, 0=10 MB)

	DW$ID	= 401		; DW HARDWARE ID
	DZ$ID	= 2004		; DZ HARDWARE ID

	DEV.DU	= 50		; DU .DSTATUS ID
	DWNUM	= 53		; DW .DSTATUS ID
	DZNUM	= 52		; DZ .DSTATUS ID
	.SBTTL	MACROS


;
;MESSG$ - USED TO PRINT MESSAGES TO THE TERMINAL
;
; TO INVOKE MESSG$, TYPE
;
;	MESSG$	ADDR,CODE	;CODE IS OPTIONAL
;
; WHERE		ADDR	IS THE ADDRESS OF THE START OF THE MESSAGE.
;			THE MESSAGE IS TERMINATED WITH A ZERO BYTE IF
;			A CR-LF IS DESIRED, A 200 BYTE OTHERWISE.
;
;		CODE	(OPTIONAL) IS A SINGLE LETTER (I,W,E,F OR U)
;			TO INDICATE THE TYPE OF MESSAGE.  IF CODE IS
;			SPECIFIED, THE PREFIX '?FORMAT-C-' (C=I,W,E,F OR U)
;			IS ADDED TO THE BEGINNING OF THE MESSAGE.
;
; THE MACRO GENERATES A CALL TO EITHER THE PREMSG OR MSG SUBROUTINE, DEPENDING
; ON WHETHER OR NOT THE PREFIX IS TO BE PRINTED.
;
;-

	.MACRO	MESSG$	ADDR,CODE
	.IF NB <CODE>
	MOV	#ERR$$'CODE',R0
	MOV	ADDR,-(SP)
	CALL	PREMSG
	.IFF
	MOV	ADDR,R0
	CALL	MSG
	.ENDC
	.ENDM
;+
;
;    * N O T E S   C O N C E R N I N G   T H I S   M O D U L E *
;
;****
;	D A T A   S T R U C T U R E S
;
; - DEVICE TABLE
;
;	THE DEVICE TABLE CONSISTS OF CONSECUTIVE ENTRIES OF LENGTH
;	DVENSZ (CURRENTLY 18.) STARTING AT DEVNAM IN .PSECT $DV, AND
;	IS TERMINATED BY A .WORD  0 IN .PSECT  END$DV.
;	AN ENTRY FOR DEVICE XX WITH .DSTATUS ID NUMBER N CONSISTS OF:
;
;		.RAD50	/XX/		;RAD50 DEVICE NAME
;		.WORD	N		;.DSTATUS DEVICE ID NUMBER
;		.ASCII	/XX/		;ASCII DEVICE NAME
;		.WORD	$XXTAB		;POINTER TO OPTIONS LIST
;		.WORD	XXLD		;POINTER TO LOAD POINT ENTRY
;		.WORD	$XXFMT		;POINTER TO ENTRY POINT OF FORMAT ROUTINE
;					; = 0 IF NO FORMAT ROUTINE EXISTS FOR
;					;THE DEVICE
;		.WORD	$XXEND		;POINTER TO END OF ROUTINE
;		.WORD	$XXDCK		;POINTER TO DEVICE CHECK FOR ROUTINE
;		.WORD	DEVCHR		;DEVICE CHARACTERISTICS FOR VERIFY
;
;	THIS DATA STRUCTURE IS BUILT AT LINK TIME FROM THE ENTRIES
;	IN EACH FORMATTING ROUTINE.
;
; - OPTION TABLE
;
;	THE OPTION TABLE CONSISTS OF CONSECUTIVE ENTRIES OF LENGTH
;	OPENSZ (CURRENTLY 6.) STARTING AT OPTBL IN .PSECT  $OP.
;	EACH FORMATTING ROUTINE GENERATES ENTRIES FOR THE OPTIONS
;	IT NEEDS.  THE ENTRIES FOR ROOT OPTIONS BEGIN AT OPTBL AND ARE
;	TERMINATED WITH A .WORD  -1.  THE ENTRIES FOR FORMATTING ROUTINE
;	XX BEGIN AT $XXTAB IN THE OPTION TABLE AND ARE TERMINATED WTH A
;	.WORD  0.
;	     FOR EXAMPLE, IF ROUTINE XX HAS OPTIONS /D AND /M, ROUTINE
;	YY HAS NO OPTIONS, ROUTINE ZZ HAS OPTION /M, AND THE ROOT HAS
;	OPTIONS /Y AND /W, THE TABLE WOULD LOOK LIKE:
;
;		+----------+
;	OPTBL:	! /Y ENTRY !	;OPENSZ BYTES
;		+----------+
;		! /W ENTRY !	;OPENSZ BYTES
;		+----------+
;		!    -1    !	;END OF ROOT OPTIONS
;		+----------+
;	$XXTAB: ! /D ENTRY !	;OPENSZ BYTES
;		+----------+
;		! /M ENTRY !	;OPENSZ BYTES
;		+----------+
;		!     0    !	;END OF XX OPTIONS
;		+----------+
;	$YYTAB: !     0    !	;END OF YY OPTIONS
;		+----------+
;	$ZZTAB: ! /M ENTRY !	;OPENSZ BYTES
;		+----------+
;		!     0    !	;END OF ZZ OPTIONS
;		+----------+
;
;	THIS DATA STRUCTURE IS BUILT AT LINK TIME FROM THE ENTRIES IN
;	EACH FORMATTING ROUTINE.
;
;	THE FORMAT OF AN ENTRY IS GIVEN IN THE MACRO PREFIX FILE IN THE
;	SECTION ON THE OPTN$ MACRO.
;****
;	O P T I O N    P R O C E S S O R
;
;   THE OPTION PROCESSOR WILL DECODE THE OPTION INFORMATION THAT
;THE COMMAND STRING INTERPRETER PUTS ON THE STACK.  EACH OPTION MUST
;HAVE AN ENTRY IN THE OPTION TABLE, AS DESCRIBED ABOVE.  THE PROCESSOR
;WILL FILL IN THE 'VALUE' AND 'GIVEN' FIELDS FROM THAT OPTION INFORMATION.
;WHEN FILLING IN THE OPTION TABLE, THE LIST OF ROOT OPTIONS IS SEARCHED
;FIRST, THEN THE OPTIONS SPECIFIED BY THE FORMATTING ROUTINE.
;
;   TO ADD AN OPTION TO THE PROGRAM, USE THE "OPTN$" MACRO.
;
;   LIMITATIONS:
; 1) ONLY ONE OCCURRENCE OF AN OPTION IS VALID.  MORE THAN ONE WILL PRODUCE
;    AN ERROR.
; 2) ONLY ONE VALUE PER OPTION IS ALLOWED.  MORE THAN ONE WILL PRODUCE
;    AN ERROR.
;****
;
;	G E N E R A L   N O T E S :
;
; 1) FORMATTING ROUTINES AND VERIFY ROUTINES ARE NOT ALLOWED TO USE THE USR,
;    BECAUSE IF THE /W OPTION WAS GIVEN THE SYSTEM VOLUME MIGHT NOT BE
;    PRESENT, AND THE USR MIGHT NOT BE RESIDENT.
;
; 2) THE UNIT NUMBER OF THE DEVICE TO BE FORMATTED IS PASSED TO THE
;    FORMATTING ROUTINE IN R1 AND FREE AREA POINTER IS PASSED IN R2.
;
; 3) THE FORMATTING ROUTINES SHOULD RETURN VIA AN RTS PC.  THE CARRY BIT
;    SHOULD BE SET IF FORMATTING FAILED.
;
; 4) THREE MESSAGES ARE PROVIDED FOR USE BY THE FORMATTING ROUTINES-
;	(USE THE MESSG$ MACRO TO ACCESS THEM!)
;    $SERR1-DEVICE NOT READY
;    $SERR2-DEVICE ERROR
;    $SERR3-INSUFFICIENT MEMORY
;
; 5) A SUBROUTINE TO PRINT A MESSAGE AND THEN WAIT FOR A Y OR N
;    RESPONSE IS INCLUDED IN THE DRIVER.  SEE THE PAGE TITLED "DRIVER
;    SUBROUTINES" FOR INFORMATION ON HOW TO USE IT.
;
; 6) /W,/Y,/V AND /P ARE TO BE USED ONLY BY THE ROOT.
;
; 7) THE UNIT TO BE CHECKED IS PASSED IN R1 TO THE DEVICE CHECK ROUTINES FOR
;    EACH DEVICE. THE CARRY BIT SHOULD BE SET IF DEVICE IS NOT READY OR WRITE
;    PROTECTED.
;-
.ASECT
.=$JSX
	.WORD	NOVBG$

	.SBTTL	**** MAIN PROGRAM: ****
	.PSECT	MAIN,RO

; M A I N    P R O G R A M
	VER5  = 5			;CURRENT VERSION OF RT11

	NOP				;REENTRY POINT
START::	BIS	#REENTR,@#JSW		;SAY WE ARE REENTERABLE
	.GTIM	#AREA,#AREA+2		; TIME ROLLOVER SUPPORT.
	.GVAL	#AREA,#SYSVER		;GET SYSTEM VERSION
	CMPB	#VER5,R0		;CORRECT VERSION?
	BEQ	BEGIN			;YES, BRANCH
	MESSG$	#ERR16,F		;"WRONG VERSION OF RT11"
	.EXIT

BEGIN:	
	CLR	DWFLAG
	.SETTO	LMBLK+2			;SET UP THE HIGH LIMIT OF PROGRAM;BD1
	CALL	GETINP			;GET SYNTACTICALLY CORRECT INPUT
	BCS	BEGIN			; INCORRECT INPUT SYNTAX
	CALL	UNITYP			;GET UNIT# AND DEVICE TYPE
	BCS	BEGIN			; ILLEGAL DEVICE OR UNIT NUMBER
	MOV	R5,DEVINX		;SAVE INDEX INTO THE DEVICE TABLE;BD1
	CALL	OPTION			;INITIALIZE, FILL IN OPTION TABLE
	BCS	BEGIN			; ILLEGAL OPTIONS GIVEN
	TSTB	GIV.Y			;NO QUERY SWITCH?		;CA5+
	BNE	2$			;YES, SKIP NEXT			
	MOV	@#RMON,R0		;R0-->RMON			
	BIT	#FGND,CONFIG(R0)	;FOREGROUND JOB LOADED?		
	BEQ	2$			;NO-OK.				
	MESSG$	#MSG10,W		;;;PRINT FOREGROUND LOADED	;CA5-
2$:	CALL	SYSVOL			;TRYING TO FORMAT/VERIFY SYSTEM VOL?
	BCS	BEGIN			; YES- NOT ALLOWED
	CALL	GTCSR			; GET CSR FROM HANDLER		;CA5
	BCS	BEGIN			;BRANCH IF ERROR 
	CALL	TSTOPT			;TEST OPTIONS AND DISPATCH	;BD1
	BR	BEGIN			;ONCE MORE, WITH FEELING
	.SBTTL	1) GET USER INPUT

;+
;
; GETINP - GETS A VALID COMMAND LINE
;
;	   ONLY 1 INPUT DEVICE ALLOWED;
;	   NO OUTPUT DEVICES VALID;
;	   NO FILENAMES VALID ANYWHERE;
;	   IF NO DEVICES ARE GIVEN, THE VERSION NUMBER IS PRINTED.
;
; ON RETURN:
;	ANY PREVIOUS INFORMATION ON THE STACK IS DESTROYED,
;	THE STANDARD CSI OPTION INFORMATION IS ON THE STACK.
;	R0,R1,R2 ARE DESTROYED
;
; ERRORS:	THE C BIT WILL BE SET ON RETURN IF
;		1) OUTPUT DEVICES WERE SPECIFIED
;		2) MORE THAN ONE INPUT DEVICE WAS SPECIFIED
;		3) A FILE NAME WAS GIVEN
;
;-

GETINP:	MOV	(SP),R1			;SAVE RETURN ADDRESS FOR LATER
10$:	MOV	@#SPINIT,SP		;INITIALIZE STACK POINTER
	.CSISP	#OUTSPC,#DEFEXT,#0	;REQUEST INPUT

	CLR	-(SP)			;STORAGE FOR OR OF OUTPUT FILESPECS
	MOV	#OUTSPC,R2		;R2 -> START OF OUTPUT FILESPECS
	MOV	#15.,R0			;R0 = NUMBER OF WORDS TO OR
20$:	BIS	(R2)+,(SP)		;OR WORD WITH TOP OF STACK
	SOB	R0,20$			;  LOOP TILL DONE
	TST	(SP)+			;ANY OUTPUT DEVICES GIVEN?
	BNE	40$			;YES- ERROR.

	CLR	-(SP)			;STORAGE FOR OR OF OUTPUT FILESPECS
	MOV	#OUTSPC+40,R2		;ANY FILE NAME OR
	MOV	#23.,R0			;R0 = NUMBER OF WORDS TO OR
30$:	BIS	(R2)+,(SP)		;OR WORD WITH TOP OF STACK
	SOB	R0,30$			; LOOP TILL DONE
	TST	(SP)+			;ANY INPUT FILESPECS GIVEN OR OTHER
					; THEN 1ST DEVICE SPECIFIED?
	BNE	40$			;YES- ERROR.
	TST	DEVNAM			;ANYTHING GIVEN AT ALL?
	BNE	50$			;YES-GO PROCESS
	MESSG$	#VERS			;NO-PRINT VERSION NUMBER
	BR	10$			; AND REQUEST INPUT AGAIN

40$:	MESSG$	#ERR1,F			; '?ILLEGAL COMMAND LINE'
	SEC				;INDICATE ERROR
50$:	MOV	R1,-(SP)		;RESTORE RETURN ADDRESS
	RETURN
	.SBTTL	2) DETERMINE DEVICE TYPE AND UNIT NUMBER

;+									;JH1+
;
; UNITYP - DETERMINE DEVICE AND UNIT NUMBER AND IF LEGAL
;
; ON ENTRY:  DEVNAM CONTAINS THE RAD50 DEVICE NAME AND UNIT #
;
; ON RETURN ( IF NO ERRORS PRESENT ),
;	UNIT CONTAINS UNIT NUMBER
;	R0 IS DESTROYED
; 	R4 IS DESTROYED
;       R5 = INDEX INTO FORMAT'S DEVICE TABLE
;
; ERRORS:
;	THE C BIT WILL BE SET ON RETURN IF:
;	1) THE DEVICE WAS ILLEGAL
;	2) THE UNIT NUMBER WAS ILLEGAL
;
;-

UNITYP:	.DSTAT	#DSTBLK,#DEVNAM	;GET DEVICE INFO
	BCC	20$			;BRANCH IF NO ERROR
	MOV	#DWTBL,R5		;Lets check for DW
	MOV	(R5),PHYNAM		;Assume DW
	CMP	DEVNAM,(R5)+		;This is (DW )?
	BNE	10$			;Yes, but need to set up unit.
	ADD	#<^R  0>,DEVNAM		;Add in a zero
10$:	CMP	DEVNAM,(R5)+		;Is this it (DW0)?
	BNE	30$			;NO, error	
	INC	DWFLAG			;Set the flag for later
	CLRB	UNIT			;Get DW unit (only unit 0 for now)
20$:	CALLR	LDECOD			;GET DEVICE TABLE OFFSET, UNIT NUMBER

30$:	MESSG$	#ERR3,F			;PRINT "INVALID DEVICE..."
	SEC				;SET CARRY
	RETURN
	.SBTTL	   IT MIGHT BE A LOGICAL NAME

;+									;JH1+
;
; LDECOD - DETERMINE DEVICE TABLE OFFSET AND UNIT NUMBER OF (LOGICAL?)
;	   DEVICE NAME
;
; ON ENTRY:  DEVNAM CONTAINS THE RAD50 DEVICE NAME AND UNIT #
;
; ON RETURN ( IF NO ERRORS PRESENT ),
;	UNIT CONTAINS UNIT NUMBER
;	R0 IS DESTROYED
; 	R4 IS DESTROYED
;       R5 = INDEX INTO FORMAT'S DEVICE TABLE
;
; ERRORS:
;	THE C BIT WILL BE SET ON RETURN IF:
;	1) THE DEVICE WAS ILLEGAL
;
; NOTES:
;	1) THE UNIT NUMBER MUST BE LEGAL BECAUSE IT IS OBTAINED FROM
;	   THE CHANNEL INFORMATION
;
;	2) NO ERRORS CAN OCCUR DURING THE .FETCH-.LOOKUP-.SAVESTATUS
;	   SEQUENCE BECAUSE HANDLER MUST BE PRESENT ON SYSTEM VOLUME BECAUSE
;	   THE .DSTATUS IN ROUTINE UNITYP SUCCEEDED.
;
;-

LDECOD:	MOV	#DEVTAB,R5		;GET ADDRESS OF DEVICE TABLE
	MOVB	DSTBLK,R4		;R4=DEVICE ID NUMBER
	TST	DWFLAG			;Is this unformatted DW?
	BEQ	10$
	MOVB	#DWNUM,R4		;Yes, get device id in R4
10$:	CMP	R4,DEVTYP(R5)		;IS THIS THE DEVICE?
	BEQ	20$			; YES
	ADD	#DVENSZ,R5		; NO. POINT R5 TO NEXT DEVICE IN TABLE
	TST	RADNAM(R5)		;AT END OF TABLE?
	BNE	10$			; NO-KEEP LOOKING
	MESSG$	#ERR3,F			;'?DEVICE UNKNOWN'
	BR	60$			;ERROR RETURN

20$:	TST	DWFLAG			;Is this unformatted DW?
	BNE	50$			;Already have unit, return
	
	.FETCH	#FREE,#DEVNAM		;DETERMINE UNIT#: FETCH HANDLER	;BD1
	BCC	30$			;BRANCH IF NO ERROR
	MESSG$	#ERR9,U			;'DEVICE HANDLER FETCH ERROR'
	BR	60$			;ERROR RETURN

30$:	.LOOKU	#AREA,#0,#DEVNAM	; ASSOCIATE CHANNEL 0 WITH DEVICE
	BCC	40$			; BRANCH IF NO ERROR
	MESSG$	#ERR11,F		; 'LOOKUP ERROR'
	BR	60$			; ERROR RETURN

40$:	.CSTAT	#AREA,#0,#CSTBLK	; GET PHYSICAL DEVICE NAME
	.SAVES	#AREA,#0,#CBLK		; GET CHANNEL INFORMATION
	.RELEA	#DEVNAM			;RELEASE THE HANDLER CAUSE IT GETS
					; OVERWRITTEN ANYWAY BY THE OVERLAYS
	MOVB	CBLK+11,UNIT		;EXTRACT UNIT# FROM CHANNEL INFO
50$:	TST	(PC)+			;INDICATE SUCCESS
60$:	SEC				;INDICATE ERROR
	RETURN				;RETURN				;JH1-
	.SBTTL	3) PROCESS OPTION INFO

;+
;
;	VALID ROOT OPTIONS:	/Y TO INDICATE NOQUERY
;				/W TO WAIT BEFORE FORMATTING
;
;	OFFSETS IN THIS SECTION OF CODE ARE DEFINED IN THE "OPTN$"
;	MACRO USED TO HELP CREATE THE OPTION TABLE
;
; ON ENTRY: THE STACK CONTAINS THE OPTION INFORMATION THAT
;	     THE CSI RETURNS.
;	    UNIT CONTAINS THE UNIT NUMBER OF THE DEVICE
;	    R5 IS THE INDEX INTO THE DEVICE TABLE
;
; ON RETURN,
;	R0,R1,R2,R3,R4 ARE DESTROYED,
;	THE OPTION INFORMATION HAS BEEN REMOVED FROM THE STACK
;
; ERRORS:	ON RETURN, THE C BIT WILL BE SET IF ANY ILLEGAL
;		OPTIONS WERE GIVEN.
;
;-

OPTION:	MOV	(SP)+,RETADR		;SAVE RETURN ADDRESS FOR LATER
	MOV	#OPTBL,R0		;R0-->ROOT OPTION TABLE ENTRIES
1$:	TST	(R0)			;AT END OF TABLE?
	BEQ	3$			; YES-PROCESS OPTION INFO
	BMI	2$			; NO-STILL HAVE FORMATTING ROUTINE 
					;    ENTRIES TO INIT
	CLRB	GIVEN(R0)		;SAY OPTION NOT GIVEN (YET)
	ADD	#OPENSZ,R0		;POINT TO NEXT ENTRY
	BR	1$			;AND LOOP

2$:	MOV	OPVAL(R5),R0		;R0-->FORMATTING ROUTINE ENTRIES
	BR	1$			;GO INITIALIZE THEM

; SCAN, FILL IN OPTION TABLE

3$:	CLRB	FLAG			;INIT ERROR INDICATOR
	MOV	(SP)+,R3		;R3 = NUMBER OF OPTIONS GIVEN
4$:	TST	R3			;FINISHED WITH SCAN?
	BEQ	15$			; YES
	MOV	#OPTBL,R1		;R1-->START OF ROOT OPTION ENTRIES
	MOV	(SP)+,R2		;GET FILE# AND OPTION
5$:	TST	(R1)			;AT END OF TABLE?
	BGT	7$			; NO - GO PROCESS THEM
	BLT	6$			; NO-STILL HAVE FORMAT ROUTINE ENTRIES
					;    TO CHECK
	MESSG$	#ERR4,F			;'?ILLEGAL OPTION...'		;MG1
	BR	12$			;REMOVE VALUE FROM STACK, IF ANY, THEN
					; PRINT MESSAGE
6$:	MOV	OPVAL(R5),R1		;R1-->START OF FORMAT ROUTINE ENTRIES
	BR	5$			;GO CHECK THEM

7$:	CMPB	R2,OPT(R1)		;IS THIS THE OPTION?
	BNE	11$			; NO-TRY NEXT ENTRY
	TSTB	GIVEN(R1)		;WAS OPTION ALREADY SPECIFIED?
	BEQ	8$			; NO- OK.
	MESSG$	#ERR8,W			;'?DUPLICATE OPTION...'		;MG1
	BR	12$			;REMOVE VALUE IF ANY, THEN PRINT MSG

8$:	TST	R2			;DID OPTION HAVE A VALUE?
	BPL	10$			; NO- OK.
	TSTB	VALLOW(R1)		; YES- IS IT ALLOWED?
	BNE	9$			;      YES
	MESSG$	#ERR5,F			;'?NO VALUE CAN BE SPECIFIED...';MG1
	BR	12$			;REMOVE VALUE IF ANY, THEN PRINT MSG

9$:	MOVB	#1,GIVEN(R1)		;SAY OPTION WAS GIVEN WITH A VALUE
	CMPB	R2,#'V			;/V OPTION ?			;BD1+
	BNE	17$			;NO, CONTINUE WITH SCAN
	CMP	(SP),#^RONL		;VALUE = ONL ?
	BEQ	17$			;YES, VALUE VALID
	MESSG$	#ERR10,F		;?'ILLEGAL VALUE SPECIFIED...'	;MG1
	BR	12$			;OUTPUT ERROR MESSAGE

17$:	MOV	(SP)+,VALUE(R1)		;INSERT OPTION VALUE IN TABLE	;BD1-
	BR	14$			;ON TO NEXT OPTION

10$:	MOVB	#-1,GIVEN(R1)		;SAY OPTION WAS GIVEN WITHOUT A VALUE
	BR	14$			;ON TO NEXT OPTION

11$:	ADD	#OPENSZ,R1		;R1-->NEXT ENTRY IN TABLE
	BR	5$			;ON TO NEXT ENTRY

12$:	TST	R2			;DID OPTION HAVE VALUE?
	BPL	13$			; NO- JUST PRINT MESSAGE
	ADD	#2,SP			; YES- REMOVE IT FROM STACK
13$:	MOVB	R2,BUFFER		;LOAD BUFFER WITH OPTION
	CLRB	BUFFER+1		;  FOR PRINTING
	MESSG$	#BUFFER			;PRINT IT
	INCB	FLAG			;INDICATE ERROR
14$:	DEC	R3			;DECREMENT COUNT OF OPTIONS TO PROCESS
	BR	4$			;ON TO NEXT OPTION

15$:	CLC				;ASSUME NO ERRORS
	TSTB	FLAG			;ANY ERRORS?
	BEQ	16$			; NO- OK.
	SEC				;INDICATE ERRORS
16$:	MOV	RETADR,-(SP)		;RESTORE RETURN ADDRESS
	RETURN
	.SBTTL	4) CHECK IF IT IS SYSTEM VOLUME

;+
;
; SYSVOL - CHECK IF USER WANTS TO FORMAT SYSTEM VOLUME
;
; ON ENTRY:
;	UNIT = UNIT#
;	R5 = INDEX INTO DEVICE TABLE
;
; ON RETURN:
;	R0 IS DESTROYED
;	R3 IS DESTROYED
;
; ERRORS:
;	THE C BIT WILL BE SET IF THE USER IS TRYING TO FORMAT
;	THE SYSTEM VOLUME
;
;-

SYSVOL:	TSTB	GIV.W			;WAS /W GIVEN?
	BNE	10$			;  YES- OK IF IT IS SYSTEM VOLUME
	.DSTAT	#SYSTYP,#SYSNAM		;GET SYSTEM DEVICE INFO		;BD1
	CMPB	SYSTYP,DEVTYP(R5)	;SAME SYS AND INPUT DEVICE TYPES?
	BNE	10$			;NO, OK-BRANCH.
	MOV	@#RMON,R3		;R3-->RMON
	CMPB	UNIT,SYSUNT(R3)		;SAME SYS AND INPUT DEVICE UNIT#?
	BNE	10$			;NO, OK-BRANCH.
	MESSG$	#ERR6,U			;'?FORMATTING THE SYSTEM DEVICE...'
	SEC				;INDICATE ERROR
	BR	20$

10$:	CLC				;INDICATE SUCCESS
20$:	RETURN
	.SBTTL	GTCSR - Get the CSR address
;+
; For non-PRO 300 series disks, the CSR address for the device to be 
; formatted is obtained from the device handler. The device handler suffix 
; is obtained from a monitor fixed offset. The device handler file is on the 
; system disk therefore no need to load the handler.
;
; For the PRO 300 series DW and DZ devices, the CSR address is found in the
; CONFIG table.  The hardware device ID is given to the monitor routine $GTCSR
; (the address is 2 + the contents of fixed offset 436), and $GTCSR returns
; the CSR on the stack.
;
;	R5 -> DEVICE TABLE
;
;	CALL	GTCSR
;
; ON RETURN - The CSR address has been stored at location NONCSR.
;
	.ENABL	LSB
GTCSR::
	JSR	R5,$SVRG		; Save registers to be used
	MOV	DEVINX,R0		; Get the index for this device

; Check for PRO devices and if so, get PRO CSR address

	MOV	#DW$ID,R1		; Get DW HW ID
	CMP	#DWNUM,DEVTYP(R0)	; Are we formatting a DW?
	BEQ	10$			; If yes, branch
	CMP	#DZNUM,DEVTYP(R0)	; Are we formatting a DZ?
	BNE	20$			; If not, branch
	MOV	#DZ$ID,R1		; Get DZ HW ID
10$:	MOV	R1,-(SP)		; Put the HW ID onto the stack
	MOV	@#RMON,R0		; Get the start of RMON
	MOV	GETVEC(R0),R0		; R0 -> $GTVEC
	TST	(R0)+			; R0 -> $GTCSR
	CALL	@R0			; @SP gets the CSR
	MOV	(SP)+,NONCSR		; *C* Save the CSR
	BCS	90$			; If no CSR, go out
	BR	80$			; Merge below

; GET CSR ADDRES FOR NON-PRO DEVICES

20$:	MOV	PHYNAM,STODEV		; Assume 2 letter device name already
	MOV	@#RMON,R5		; R5 -> RMON
	CMPB	UNIT,#7			; Is the unit number greater than 7?
	BLOS	50$			; Branch if not

;+
; Get pointer to $PNAM2 and offset to $PNAME
;-

	MOV	PNPTR(R5),R2		; R4 = offset from RMON to $PNAME.
	ADD	R5,R2			; R4 -> $PNAME
	MOV	R2,R1			; R3 -> $PNAME

; Calculate $SLOT*4 by searching for -1 at end of $ENTRY table

30$:	CMP	(R1)+,#-1		; Search for end of $ENTRY table.
	BNE	30$			; Keep going
	TST	-(R1)			; R3 -> end of $ENTRY table
	SUB	R2,R1			; R3 = bytes in combined tables

; R3 now contains the value $SLOT*4; the size of 2 tables

	MOV	R1,R0			; Save $SLOT*4 value
	ASL	R1			; Calculate offset from $PNAME
	ADD	R0,R1			;   to $PNAM2		$SLOT*4  * 3
	TST	(R1)+			;   + 2 for -1 at end of $ENTRY table
	ADD	R1,R2			; R4 -> $PNAM2

;+
; Find device name in $PNAM2 - must be there since unit # greater than 7
;-

40$:	CMP	PHYNAM,(R2)+		; Is this the entry?
	BNE	40$			; Branch if not, loop till found

;+
; Get 2 letter device name from corresponding entry in $PNAME
;-

	SUB	R1,R2			; R4 -> entry in $PNAME + 2
	MOV	-(R2),STODEV		; Get 2 letter device name
50$:	ADD	SUFFIX(R5),STODEV	; Add suffix to device
	.LOOKUP #AREA,#1,#HANDEV	; Open handler file
	BCC	60$			; Branch if no error
	MESSG$	#ERR14,F		; Error message
;;;<-F-FILE NOT FOUND>
	MOV	#HANDEV,R0		; R0 -> FILESPEC
	MOV	#OUTSPC,R1		; R1 -> BUFFER
	CALL	$FNASC			; Call routine
	MOVB	#LF,(R1)+		; Put line feed followed
	MOVB	#CR,(R1)+		; - by a carriage return
	MOVB	#NULL,(R1)		; - terminal ASCII string
	.PRINT	#OUTSPC			; Print it
	BR	90$			; Take error return

60$:	.READW	#AREA,#1,#FREE,#256.,#0	; Read logical block zero
	BCC	70$			; Branch if no error
	MESSG$	#ERR15,F		; Error message
;;;<-F-INPUT ERROR>				
	BR	90$			; Take error return

70$:	MOV	#FREE,R1		; R1 -> read buffer
	MOV	OFFCSR(R1),NONCSR	; Store the CSR

; If DU specified, get offset to STATU$ in DU 

	CMPB	#DEV.DU,DSTBLK	; Is this the DU device
	BNE	80$		; Branch if not
	CLR	CURBLK		; Block 0 currently in memory
	MOV	FREE+H.DATA,R2	; Get address of .DRTAB tables
710$:	CALL	GHNDBL		; Get handler block containing tables
	CMP	#^RUMS,FREE(R4)	; Is this the table were looking for?
	BEQ	720$		; Branch if so
	ADD	#6,R2		; Point to handler address of next entry
	BR	710$		; Loop and get new buffer if needed

720$:	TST	(R2)+		; Point to handler address of STATU$
	CALL	GHNDBL		; Get handler block containing addr of STATU$
	MOV	FREE(R4),STATU$ ; Save address of STATU$
	SUB	#1006,STATU$	; Offset for loaded handler

80$:	TST	(PC)+			; Clear carry skip next
90$:	SEC				; Set error indicator
	ROR	R1			; Preserve carry bit
	.PURGE	#1			; Close the channel
	ROL	R1			; Restore carry bit
	JSR	R5,$RSTRG		; *C* Restore the registers
	RETURN
	.DSABL	LSB
.SBTTL	GHNDBL - SUBROUTINE TO GET HANDLER BLOCK

;+
;	SUBROUTINE TO GET A BLOCK FROM THE DEVICE HANDLER
;
;	INPUT VARIABLES
;		R2 = ADDRESS IN THE DEVICE HANDLER TO BE READ
;
;	OUTPUT VARIABLES
;		R2 = ADDRESS IN THE DEVICE HANDLER READ
;		R3 = BLOCK NUMBER READ
;		R4 = OFFSET IN HANBUF FOR ADDRESS IN R2
;
;	CALLING SEQUENCE
;
;		MOV	DEVICE_ADDRESS,R2
;		CALL	GHDNBL
;-

GHNDBL:	MOV	R2,R4		; CALCULATE OFFSET IN HANBUF FOR ADDRESS
	BIC	#^C777,R4	;  CLEAR BLOCK NUMBER BITS
	MOV	R2,R3		; CALCULATE BLOCK NUMBER TO READ
	BIC	R4,R3		;  CLEAR BYTE WITHIN BLOCK BITS
	SWAB	R3		;  DIVIDE BY 256
	ASR	R3		;  DIVIDE BY 2
	CMP	R3,CURBLK	; IS THIS BLOCK ALREADY IN MEMORY?
	BEQ	10$		; BRANCH IF SO
	MOV	R3,CURBLK	; NO, BUT IT WILL BE
	.READW	#AREA,#1,#FREE,#256.,R3 ; READ THE BLOCK
10$:	RETURN
	.SBTTL	5) TEST ROOT OPTIONS AND CALL FORMAT/VERIFY ROUTINES

;+									;BD1+
;
; TSTOPT - TESTS THE SPECIFIED ROOT OPTIONS, AND RECONFIRMS USER'S
;          DESIRE TO FORMAT/VERIFY,IF NECESSARY, THEN CALLS APPROPRIATE
;	   DEVICE FORMATTING ROUTINE AND/OR THE DEVICE VERIFIER.
;
; ON ENTRY,
;	UNIT = UNIT NUMBER OF DEVICE
;       DEVINX = INDEX INTO FORMAT'S DEVICE TABLES
;	R5 = INDEX INTO FORMAT'S DEVICE TABLES
;
; ON RETURN, ALL REGISTERS DESTROYED
;
; ERRORS:
;	THE C BIT WILL BE SET ON RETURN IF THE USER DID NOT
;	RECONFIRM FORMATTING/VERIFY, OR IF A FORMATTING/VERIFY ERROR OCCURRED.
;
;-

TSTOPT::MOV	END(R5),WRTBUF		;SAVE THE FREE AREA POINTER
	CALL	@LOADPT(R5)		;LOAD FORMATTING ROUTINE OVERLAY
	TSTB	GIV.V			;/V OPTION SPECIFIED ?
	BEQ	1$			;IF EQ - NO
	TST	DWFLAG			;Is this unformatted DW?
	BNE	22$			;Yes, /VERIFY is invalid
	.FETCH	WRTBUF,#DEVNAM		;FETCH THE HANDLER FOR THE VERIFY
	BCC	20$			;CLEAN SAILING
	MESSG$	#ERR9,U			;'?DEVICE HANDLER MUST BE...'	;MG1
	BR	8$			;SEVERE ERROR

20$:	MOV	R0,WRTBUF		;STORE THE NEW FREE AREA POINTER
	TSTB	GIV.V			;/V:ONL GIVEN ?
	BGT	21$			;IF GT - YES
1$:	TST	ENTRY(R5)		;THIS DEVICE SUPPORTED BY FORMAT?
	BNE	2$			;YES...THEN SUPPORT IT
	MESSG$	#ERR3,F			;'?DEVICE ILLEGAL OR NOT...'	;MG1
	BR	8$			;SEVERE ERROR

21$:	TST	DWFLAG			;Is this unformatted DW?
	BEQ	2$			;No, skip next
	
22$:	MESSG$	#ERR17,F		;Cannot verify only RD must format
	BR	9$

2$:	TSTB	GIV.Y			;SHOULD WE QUERY?
	BNE	3$			;NO
	CALL	QUERY			;YES- GO QUERY USER
	BCS	10$			;USER DOESN'T WANT TO FORMAT AFTER ALL
3$:	CALL	WAITB			;HANDLE /W OPTION QUERYING (BEGIN)
	BCS	9$			;USER DOESN'T WANT TO FORMAT AFTER ALL
	TST	DWFLAG			;Is this unformatted DW?
	BNE	4$			;Yes, don't check for protected files
	CALL	CHKPRO			;GO FIND IF ANY PROTECTED FILES	;CA5
	BCS	9$			;USER DOESN'T WANT TO FORMAT 	;CA5
4$:	MOV	DEVINX,R5		;R5 = INDEX INTO FORMAT'S DEVICE TABLE
	CLRB	FLAG			;CLEAR THE ERROR FLAG
	CLR	TRMSTS			;TERMINAL STATUS WORD INIT
	.SCCA	#AREA,#TRMSTS		;INHIBIT ^C DURING FORMATTING	;JH4
	TSTB	GIV.V			;FORMAT THE DEVICE ?
	BGT	5$			;IF GT - NO
	CALL	FORMAT			;GO PERFORM FORMAT
	BCS	6$			;IF CS - FORMAT ERROR OCCURRED
	TSTB	GIV.V			;VERIFY THE DEVICE ?
	BEQ	7$			;IF EQ - NO
5$:	TST	DWFLAG			;Is this unformatted DW?
	BNE	9$			;Yes, /VERIFY is invalid
	CALL	VERIFY			;GO PERFORM THE VERIFY
	BCC	7$			;IF CC NO VERIFY ERRORS
6$:	INCB	FLAG			;SET ERROR FLAG
7$:	CALL	WAITE			;HANDLE /W OPTION QUERYING (END)
	.SCCA	#AREA,#0		;ALLOW ^C NOW
	TSTB	FLAG			;ERROR ?
	BNE	9$			;IF NE - YES
	CLC				;CLEAR ERROR INDICATOR
	BR	10$			;BYE

8$:
9$:	SEC				;SET ERROR INDICATOR
	TSTB	GIV.W			;WAS /W GIVEN?			;CA5+
	BEQ	10$			;NO, SKIP NEXT
	MESSG$	#ERR13,E		;INDICATE ABORT			;CA5-
10$:	RETURN								;BD1-
	.SBTTL	.  A)CALL DEVICE FORMATTING ROUTINE.

;+									;BD1+
;
; FORMAT - CALLS APPROPRIATE DEVICE FORMATTING ROUTINE OVERLAY.
;
; ON ENTRY,
;	UNIT = UNIT NUMBER OF THE DEVICE
;	R5 = INDEX INTO FORMAT'S DEVICE TABLE
;
; ON RETURN, ALL REGISTERS DESTROYED
;
; ERRORS : THE C BIT IS SET IF A FORMATTING ERROR OCCURRED.
;
;-

FORMAT::TST	DWFLAG			;IS THIS UNFORMATTED DW?
	BNE	3$			;YES, SKIP NEXT
	CALL	CHKDY			;CHECK IF DY OR DW IS SET NOWRITE
	BCS	1$			;BRANCH IF ERROR
3$:	MOVB	UNIT,R1			;UNIT NUMBER TO R1
	MOV	WRTBUF,R2		;FREE AREA POINTER TO R2
	CALL	@ENTRY(R5)		;CALL FORMATTING ROUTINE
	BCS	1$			;ERRORS OCCURRED
	.RCTRL				;ENABLE CONSOLE PRINTING
	MESSG$	#MSG3,I			; '?FORMATTING COMPLETE'
	CLC				;CLEAR ERROR INDICATOR
	BR	2$

1$:	.RCTRL				;ENABLE CONSOLE PRINTING
	MESSG$	#MSG2,I			; '?FORMATTING ABORTED'
	SEC				;INDICATE ERROR
2$:	RETURN								;BD1-
	.SBTTL	.  B)CALL DEVICE VERIFYING ROUTINES.

;+									;BD1+
;
; VERIFY - CALLS DEVICE VERIFYING ROUTINE
;
; ON ENTRY,
;	UNIT CONTAINS UNIT NUMBER OF THE DEVICE
;	DEVINX CONTAINS THE INDEX INTO FORMAT'S DEVICE TABLE FOR THE DEVICE
;
; ON RETURN, ALL REGISTERS DESTROYED
;
; ERRORS : THE C BIT IS SET IF A VERIFY ERROR OCCURRED.
;	   THE C BIT IS CLEAR IF VERIFY SUCCEEDED
;
;-

VERIFY::CLR	-(SP)			;ASSUME NO ERRORS
	CALL	CHKDY			;CHECK FOR SPECIAL RX02 OR RD50/51 CASE
	BCS	1$			;INDICATE ERROR IF CARRYSET
	CALL	SETVER			;SET UP FOR THE VERIFY
	BCS	1$			;ABORT IF ERRORS
	CALL	VERPAT			;CALL VERIFY ROUTINE
	BCC	2$			;NO ERRORS OCCURRED
1$:	INC	(SP)			;INDICATE ERROR
2$:	.PURGE	#0			;CANCEL THE CHANNEL
	.RELEA	#DEVNAM			;RELEASE THE HANDLER
	TST	(SP)+			;ANY ERRORS ?
	BNE	3$			;YES VERIFICATION ABORTED
	.RCTRL				;ENABLE CONSOLE PRINTING
	MESSG$	#MSG8,I			; '?VERIFICATION COMPLETE'
	CLC				;CLEAR ERROR INDICATOR
	BR	4$

3$:	.RCTRL				;ENABLE CONSOLE PRINTING
	MESSG$	#MSG7,I			; '?VERIFICATION ABORTED'
	SEC				;INDICATE ERROR
4$:	RETURN								;BD1-
	.EVEN
	.SBTTL	.    SETVER - SET UP PARAMETERS FOR THE VERIFY

;+									;BD1+
;
; SETVER -	ALLOCATES MEMORY TO THE WRITE AND READ BUFFERS FOR THE VERIFY.
;		DETERMINES THE NUMBER OF BLOCKS TO BE USED IN THE WRITE,
;	   	READ AND COMPARE CYCLE OF THE VERIFY AND DETERMINES THE DEVICE
;	   	CHARACTERISTICS AND BLOCK SIZE.
;		REOPENS THE CHANNEL FOR I/O
;
;	WRTBUF -> START OF FREE MEMORY,ALSO START OF WRITE BUFFER
;	DEVINX CONTAINS THE INDEX INTO FORMAT'S DEVICE TABLE FOR THE DEVICE
;
;	CALL	SETVER
;
;	RDBUF -> START OF THE READ BUFFER
;	XFRNO CONTAINS THE NUMBER OF BLOCKS TO TRANSFER IN VERIFY CYCLE
;	DEVCHR CONTAINS THE DEVICE'S CHARACTERISTICS WORD
;	DEVSIZ CONTAINS THE DEVICE'S BLOCK SIZE
;
;	C = 0 MEANS SET-UP SUCCESSFUL
;	C = 1 MEANS SET-UP FAILED
;
;-

SETVER::MOV	@#RMON,R5		;JUST ASK FOR MEMORY
	MOV	USRLOC(R5),R0		; UP TO THE LOCATION BEFORE THE
	TST	-(R0)			; START OF THE USR
1$:	.SETTO				;REQUEST
	SUB	WRTBUF,R0		;DID WE GET WHAT WE NEED ?
	BCS	2$			;NO - ERROR INSUFFICEINT MEMORY
					; NOTE THE CARRY IS CLEAR
	ROR	R0			;CONVERT #BYTES AVAILABLE TO WORDS
	ASR	R0			;SPLIT EQUALLY FOR R/W BUFFERS
	MOV	R0,-(SP)		;R0 = #WORDS IN WRITE BUFFER
	ASL	(SP)			;CONVERT THAT TO BYTES
	ADD	WRTBUF,(SP)		;ADD IN THE START OF THE WRITE BUFFER
	MOV	(SP)+,RDBUF		;TO GET THE START OF THE READ BUFFER
	DEC	R0			;ALLOW EXTRA BUFFER WORD
	CLRB	R0			;CONVERT THE #WORDS AVAILABLE TO
	SWAB	R0			; BLOCKS
	MOV	R0,XFRNO		;STORE THE TRANSFER BLOCK NUMBER
	BNE	3$			;THERE IS AT LEAST ONE BLOCK
2$:	MESSG$	#$SERR3,F		;'?INSUFFICIENT MEMORY...'	;MG1
	BR	6$			;RETURN WITH AN ERROR

3$:	.REOPE	#AREA,#0,#CBLK		;OPEN THE CHANNEL AGAIN
	BCS	5$			;NO ERRORS ALLOWED
	MOV	DEVINX,R5		;GET THE INDEX FOR THIS DEVICE
	MOV	CHAR(R5),DEVCHR 	;STORE THIS DEVICE'S CHARACTERISTICS
	MOV	DSTBLK+6,DEVSIZ		;GET THE DSTATUS SIZE
	BIT	#RTDVSZ,DEVCHR		;DOES IT RETURN DEVICE SIZE ON SPFUN ?
	BEQ	4$			;NOPE USE DSTATUS RESULT
	.SPFUN	#AREA,#0,#373,#DEVSIZ,#1,#0,#0 ;GET TRUE SIZE 
	BCS	5$			;NO ERRORS TOLERATED
4$:	CLC				;INDICATE SUCCESSFUL SET UP
	BR	7$			; AND RETURN

5$:	MESSG$	#$SERR2,F		;'?DEVICE ERROR'		;MG1
6$:	SEC				;INDICATE SET-UP FAILED
7$:	RETURN								;BD1-
	.SBTTL	.    VERPAT - DETERMINE PATTERNS AND INITIATE VERIFY

;+									;BD1+
;
; VERPAT -	DETERMINES PATTERNS AND FOR EACH PATTERN SPECIFIED:
;		FILLS WRITE BUFFER WITH PATTERN,SETS UP THE STARTING BLOCK AND
;		NUMBER OF BLOCKS AND CALLS WRTCHK TO VERIFY THE SPECIFIED
;		BLOCKS. IF WRTCHK RETURNS AN ERROR THE USER IS QUERIED ABOUT
;		THE WRITE LOCK CONDITION.
;
;	DEVSIZ CONTAINS NUMBER BLOCKS ON THE DEVICE
;	DEVCHR CONTAINS THE DEVICE'S CHARACTERISTICS WORD
;	XFRNO CONTAINS THE NUMBER OF BLOCKS FOR WRITE,READ,COMPARE CYCLE
;	VAL.P CONTAINS THE PATTERN SELECTOR WORD IF SPECIFIED
;
;	CALL	VERPAT
;
;	CARRY BIT SET IF ERRORS ENCOUNTERED
;	CARRY BIT CLEAR IF VERIFY SUCCESSFUL
;
;-

VERPAT::TST	VAL.P			;WAS A PATTERN SELECTOR GIVEN? 	;CA5
	BNE	1$			;IF NE YES
	MOV	#DFLPAT,VAL.P		;ELSE GIVE 'EM ONE
1$:	MOV	#30.,R0			;SET UP THE INDEX TO PATRN TABLE;CA5	
2$:	TST	VAL.P			;THIS PATTERN SELECTED		;CA5
	BPL	8$			;NO - TRY ANOTHER
	MOV	R0,-(SP)		;SAVE THE CURRENT INDEX
	MOV	TBLPAT(R0),R1		;PICK UP THE PATTERN
	ASR	R0			;CONVERT INDEX TO NUMBER
	INC	R0			;ADD ONE TO COUNT BEG AT ONE 	;CA5+
	CMP	#12.,R0			;IMPLEMENTED PATTERN?
	BGE	6$			;YES, SKIP NEXT
	MOV	#8.,R0			;DEFAULT TO PATTERN EIGHT
6$:	MOV	R0,BUFFER		; AND STORE FOR OUTPUT
	MESSG$	#MSG9,I			;'PATTERN #'
	MOV	BUFFER,R0		;GET BINARY PATTERN NUMBER
	CALL	DECIMA			;PRINT ASCII PATTERN NUMBER	
	.PRINT	#CRLF			;PUT LINE TERMINATOR		;CA5-
	MOV	DEVSIZ,CNTDWN		;INIT THE BLOCK COUNT DOWN
	MOV	XFRNO,R3		;#BLOCKS TO TRANSFER
	SWAB	R3			;CONVERT TO WORDS
	MOV	WRTBUF,R2		;INIT ALL BUFFER WORDS WITH PATTERN
3$:	MOV	R1,(R2)+		;STORE THE PATTERN
	DEC	R3			;MORE TO DO
	BGE	3$			;YES CONTINUE
	MOV	DEVINX,R1		;Get the index for this device
	CMP	#DWNUM,DEVTYP(R1)	;Are we verifying a DW?
	BNE	445$			;Branch if not
	MOV	#-1,R2			;Do real physical block 0
	MOV	#1,R1			;Do only physical block 0
	CALL	WRTCHK			;Write and write check block 0
	BCS	444$			;Branch on error
445$:	CLR	R2			;STARTING BLOCK NUMBER INIT TO 0
5$:	MOV	XFRNO,R1		;NUMBER OF BLOCKS TO TRANSFER
	CMP	R1,CNTDWN		;CONTINUE AT THIS RATE ?
	BLOS	4$			;IF LOS - YES
	MOV	CNTDWN,R1		;SET RATE FOR REMAINDER OF THE BLOCKS
	BEQ	7$			;IF NOTHING LEFT, GET OUT
4$:	SUB	R1,CNTDWN		;DECREMENT THE # BLOCKS BEING DONE
	CALL	WRTCHK			;WRITE AND WRITE CHECK THE BLOCKS
	BCC	5$			;NO ERRORS
444$:	TST	(SP)+			;CLEAN STACK
	SEC				;INDICATE ERRORS
	BR	9$			;AND EXIT

7$:	MOV	(SP)+,R0		;RECALL THE INDEX
8$:	SUB	#2,R0			;BUMP TO NEXT PATTERN
	ASL	VAL.P			;;;SHIFT TO THE NEXT SELECTOR BIT ;CA5
	BNE	2$			;LOOK FOR IT IF SOMETHING'S THERE
	CLC				;NO ERRORS
9$:	RETURN								;BD1-

	.SBTTL	CHKDY - Check device RX02 and RD50/51
;+
; The following routine will check if the device to be formatted is an 
; RX02 or an RD50/51. If so, then it must be checked to see if the device 
; has been software write-protected to prevent from formatting it. Up to 
; this point this check was done on the hardware registers but this new 
; software protection created the exemption.
;
;	R5 = INDEX'S INTO FORMAT DEVICE TABLE
;
;	CALL	CHKDY
;
;-

CHKDY::	CMP	#6,DEVTYP(R5)			;RX02 ?
	BEQ	100$				;IF YES, BRANCH
	CMP	#DWNUM,DEVTYP(R5)		;RD50/51?
	BNE	44$				;NO, BRANCH
100$:	TSTB	GIV.V				;/V GIVEN?
	BNE	11$				;YES, BRANCH
	.FETCH	WRTBUF,#DEVNAM			;FETCH HANDLER
	BCC	1$				;BRANCH IF NO ERROR
	MESSG$	#ERR9,U				;ERROR MESSAGE
	BR	5$				;COMMON ERROR EXIT

1$:	MOV	R0,WRTBUF			;SAVE NEW TOP
11$:	.LOOKUP	#AREA,#0,#DEVNAM		;OPEN CHANNEL
	BCC	2$				;BRANCH IF NO ERROR
	MESSG$	#ERR11,F			;ERROR MESSAGE
	BR	5$				;COMMON ERROR EXIT

2$:	MOV	WRTBUF,R4			;R4 -> BUFFER
	.WRITW	#AREA,#0,R4,#256.,#0		;INTENT TO WRITE
	BCC	3$				;BRANCH IF NO ERROR
	MESSG$	#$SERR2,F			;ERROR MESSAGE ---
;;; POSSIBLE WRITE PROTECTED DY DRIVE
	BR	5$				;COMMON EXIT

3$:	TSTB	GIV.V				;/V GIVEN?
	BNE	4$				;NO, SKIP NEXT
	.RELEAS #DEVNAM				;RELEASE HANDLER
4$:	.PURGE 	#0				;PURGE CHANNEL
44$:	CLC					;CLEAR CARRY
	RETURN

5$:	.RELEAS	#DEVNAM				;RELEASE HANDLER
	.PURGE	#0
55$:	SEC
	RETURN
	.SBTTL	.    DECIMA - CONVERT BINARY TO ASCII NUMBERS

;+
; THE FOLLOWING ROUTINE TAKES A BINARY NUMBER FROM R0 AND CONVERTS IT
; TO ASCII. THEN IT PRINTS IT.
;
;	R0 = BINARY NUMBER
;
;	CALL	DECIMA
;
	.ENABL	LSB
DECIMA:	MOV	R0,-(SP)		;STORE THE VALUE		;CA5+
	CLR	R0			;SERVE AS COUNTER
1$:	INC	R0			;COUNT ONE
	SUB	#10.,(SP)		;DIVIDE BY REPETIVE SUBTRACT
	BHIS	1$			;BRANCH IF MINUS
	ADD	#10.+60,(SP)		;RESTORE REMAINING NUMBER
	DEC	R0			;DECREMENT COUNTER
	BEQ	2$			;IF=0 FINISH
	JSR	PC,DECIMA		;REPEAT IF NOT

2$:	.TTYOUT	(SP)+			;PRINT IT
	RTS	PC			;KEEP PRINTING TILL RETURN ADDRESS
	.DSABL	LSB							;CA5-
	.SBTTL	.    WRTCHK - WRITE,READ, AND COMPARE DRIVER

;+									;BD1+
;
; WRTCHK -	INITIATES THE WRITE,READ AND COMPARE CYCLE
;		IF AN ERROR IS ENCOUNTERED, THE BAD BLOCK IS ISOLATED BY
;		INITIATING 1 BLOCK VERIFY CYCLES. THE BAD BLOCK IS RETRIED
;		2 TIMES.IF ERROR PERSISTS, THE BAD BLOCK IS OUTPUT TO THE
;		TERMINAL.
;
;	R1 = NUMBER OF BLOCKS TO WRITE READ AND COMPARE AT A TIME
;	R2 = STARTING BLOCK NUMBER
;
;	CALL	WRTCHK
;
;	R1 = DESTROYED
;	R2 = UPDATED STARTING BLOCK NUMBER
;
;	C = 0 IF OPERATION COMPLETE
;
;-

WRTCHK::CALL	WRTRDC			;WRITE,READ COMPARE BLOCKS
	BCC	4$			;NO ERRORS
	MOV	R1,NOREM		;NUMBER OF BLOCKS REMAINING =
	SUB	R3,NOREM		; NUMBER REQUESTED - NUMBER COMPLETED
	MOV	#1,R1			;1 BLOCK TRANSFERS TILL BAD ONE FOUND
	MOV	#2,RTRIES		;2 RETRIES ON EVERY BLOCK
1$:	CALL	WRTRDC			;WRITE,READ + COMPARE
	BCC	2$			;NO ERRORS
	DEC	RTRIES			;ANY RETRIES REMAINING
	BNE	1$			;IF NE YES
	JSR	R5,$SVRG		;SAVE REGISTERS TO REPORT BAD BLOCK
	MOV	#CHRBUF,R0		;POINT TO THE CHARACTER BUFFER
	MOV	R2,R1			;SET UP THE BLOCK NUMBER FOR OUTPUT
	CLR	R5			;ALL CHARACTERS TO BE PRINTED
	CALL	$CNVRT			;CONVERT TO ASCII
	CLR	(R0)			;CLOSE OFF THE STRING WITH 0
	.PRINT	#CHRBUF			;PRINT THE BLOCK NUMBER
	JSR	R5,$RSTRG		;RESTORE REGISTERS
	INC	R2			;BUMP THE STARTING BLOCK NUMBER
	MOV	NOREM,R1		;GET NUMBER BLOCKS LEFT TO DO
	DEC	R1			;ACCOUNT FOR THE ONE JUST DONE
	BNE	WRTCHK			;CONTINUE AT FASTER RATE IF SOME TO DO
	BR	5$			;ALL DONE WITH THIS TRANSFER

2$:	INC	R2			;BUMP THE STARTING BLOCK NUMBER
	DEC	NOREM			;LOG ANOTHER DONE
	BNE	1$			;CONTINUE 1 BLOCK TRANSFERS
	BR	5$			;RETURN NO ERROR

4$:	ADD	R3,R2			;UPDATE THE STARTING BLOCK NUMBER
5$:	CLC				;INDICATE OPERATION COMPLETE
6$:	RETURN								;BD1-
	.SBTTL	.    WRTRDC - WRITE,READ AND COMPARE BLOCKS

;+									;BD1+
;
; WRTRDC -	WRITE PATTERN TO BLOCKS INDICATED,READ THE BLOCKS AND COMPARE
;		IF ERROR DURING A READ OR WRITE, CHECK IF IT'S A DEVICE ERROR
;		OR DISK ERROR. DEVICE ERRORS ARE FATAL.
;
;	R1 = NUMBER OF BLOCKS IN TRANSFERS
;	R2 = STARTING BLOCK NUMBER
;
;	CALL	WRTRDC
;
;	R4,R5 DESTROYED
;	R3 = NUMBER BLOCKS SUCCESSFULLY COMPLETED
;	C = 0 MEANS NO ERRORS
;	C = 1 MEANS ERRORS
;
;-

WRTRDC::TST	TRMSTS			;CONTROL C TYPED?
	BMI	20$			;YES,TIME TO GO
	MOV	R1,R3			;COPY NUMBER OF BLOCKS
	MOV	R1,R5			;AGAIN
	SWAB	R5			;MAKE BLOCK COUNT A WORD COUNT
	BIT	#SPFIO,DEVCHR		;USE .SPFUN I/O ?
	BEQ	1$			;NO, DO .WRITW AND .READW
	.SPFUN	#AREA,#0,#376,WRTBUF,R5,R2,#0 ;SPFUN WRITE OF THE BLOCKS
	BCS	5$			;AN ERROR OCCURRED GO INVESTIGATE
	.SPFUN	#AREA,#0,#377,RDBUF,R5,R2,#0 ;SPFUN READ OF THE BLOCKS
	BCS	5$			;ERROR DURING READ
	BR	2$			;NO ERROR CONTINUE WITH THE COMPARE

1$:	.WRITW	#AREA,#0,WRTBUF,R5,R2	;REGULAR WRITE OF THE BLOCKS
	BCS	5$			;AN ERROR OCCURRED GO INVESTIGATE
	.READW	#AREA,#0,RDBUF,R5,R2	;REGULAR READ OF THE BLOCKS
	BCS	5$			;ERROR DURING READ
2$:	MOV	WRTBUF,R4		;R4 -> WRITE BUFFER
	MOV	2(R4),R0		;GET THE 2ND WORD FOR THE COMPARISON
	MOV	RDBUF,R4		;->READ BUFFER
	BIT	#BFSZP1,DEVCHR		;EXTRA WORD IN DEVICE'S I/O BUFFERS?
	BEQ	3$			;NO
	TST	(R4)+			;YES, ACCOUNT FOR IT
3$:	CMP	R0,(R4)+		;PATTERN MATCH?
	BNE	4$			;NO
	DEC	R5			;MORE WORDS TO CHECK?
	BNE	3$			;YES, CONTINUE
	BR	8$			;WE'RE SUCCESSFUL

4$:	ADD	#377,R5			;ROUND UP TO BLOCK BOUNDARY
	CLRB	R5			;CLEAR OUT LOW BYTE
	SWAB	R5			;CONVERT TO BLOCKS NOT COMPLETED
	SUB	R5,R3			;R3 = NUMBER OF BLOCKS COMPLETED
	BR	7$			;INDICATE UNABLE TO FINISH ALL BLOCKS

5$:	CLR	R3			;NO BLOCKS COMPLETED
	JSR	R5,$SVRG		;SAVE REGISTERS
	MOV	DEVINX,R5		;R5 = INDEX INTO FORMAT'S DEVICE TABLE
	MOVB	UNIT,R1			;STORE THE UNIT NUMBER
	MOV	WRTBUF,R2		;R2 = POINTER TO PATTERN WRITE BUFFER
					;     *** DO NOT MODIFY ***
	CALL	@DEVCHK(R5)		;DEVICE ABLE ?
	BCC	6$			;YES, IT'S A DISK ERROR
	JSR	R5,$RSTRG		;RESTORE REGISTERS
	MESSG$	#$SERR2,F		;'?DEVICE ERROR'		;MG1
20$:	TST	(SP)+			;IT'S DEVICE ERROR SKIP RETURN
					; IT'S FATAL
	BR	7$			;INDICATE ERROR AND EXIT

6$:	JSR	R5,$RSTRG		;RESTORE REGISTERS
7$:	SEC				;BUT THERE WAS AN ERROR
8$:	RETURN								;BD1-
	.SBTTL	.  C) QUERY USER TO CONFIRM FORMATTING/VERIFYING OK

;+
;
; QUERY - QUERY'S USER TO CONFIRM ORIGINAL DESIRE TO FORMAT VOLUME
;
; ON ENTRY,
;	UNIT = UNIT NUMBER
;	R5 = INDEX INTO FORMAT'S DEVICE TABLE
;
; ON RETURN,
;	R0 IS DESTROYED
;	R1 IS DESTROYED
;	R3 IS DESTROYED
;
; "ERRORS":
;	THE C BIT WILL BE SET ON RETURN IF THE USER DID NOT RECONFIRM
;	FORMATTING.
;
;-

QUERY::	CALL	OUTDEV			;OUTPUT THE DEVICE, UNIT NUMBER	;BD1+
	MOV	#MSG1,-(SP)		; '/FORMAT
	TSTB	GIV.V			;VERIFY ?
	BLE	1$			;IF LE N0
	MOV	#MSG4,(SP)		; '/VERIFY
1$:	CALL	$WAIT
	TST	R0			;PROCEED?			;CA5+
	BEQ	2$			;NO, BRANCH
	BLT	QUERY			;INVALID ANSWER REPEAT QUERY
	TST	(PC)+			;CLEAR CARRY, SKIP NEXT
2$:	SEC				;SET CARRY ON 'NO' ANSWER	;CA5-
	RETURN								

;+									;BD1+
;
; OUTDEV - OUTPUT THE DEVICE NAME AND UNIT NUMBER
;
; ON ENTRY,
;	UNIT = UNIT NUMBER
;	DEVINX = INDEX INTO FORMAT'S DEVICE TABLE
;
; ON RETURN,
;	R0,R3 DESTROYED
;	R5 = INDEX INTO FORMAT'S DEVICE TABLE
;
;-

OUTDEV:	MOV	#BUFFER,R0		; Address to store ASCII device name
	CALL	PUTDEV			; Go Get device name
	MESSG$	#BUFFER			; Output the device identifier
	RETURN				; All done
	.SBTTL	/W OPTION QUERYING SUBROUTINES

;+
;
; WAITB AND WAITE - USED TO HANDLE THE /W OPTION.
;
;WAITB IS CALLED PRIOR TO ENTERING THE FORMATTING OVERLAY,
;WAITE IS CALLED FOLLOWING THE RETURN FROM THE OVERLAY.
;ALL REGISTERS REMAIN INTACT THROUGH THE CALL.
;  THE CALLS HAVE THE FOLLOWING FORMAT:
;
;	CALL	WAITB			CALL	WAITE
;	C CLEAR IF "Y"			NO ERRORS
;	C SET OTHERWISE			RETURNED
;
;-

WAITB:	TSTB	GIV.W			;DO WE HAVE TO WAIT?
	BEQ	4$			;NO
	MOV	#FORDEV,R0		;ADDRESS TO STORE DEVICE	;CA5
	CALL	PUTDEV			;GO PUT IT			;CA5
1$:	MOV	#INSERT,-(SP)		;PUSH POINTER TO MSG ON STACK	;BD1+
	TSTB	GIV.V			;VERIFYING ?
	BLE	2$			;IF LE - NO
	MOV	#VERDEV,R0		;ADDRESS TO STORE DEVICE	;CA5
	CALL	PUTDEV			;GO PUT IT			;CA5
	MOV	#INSRTV,(SP)		;PUT ON VERIFY MESSAGE		;BD1-
2$:	CALL	$WAIT			;WAIT FOR RESPONSE
	TST	R0			;PROCEED?
	BEQ	3$			;NO, BRANCH
	BLT	1$			;INVALID ANSWER, REPEAT PROMPT
	TST	(PC)+			;SKIP NEXT, CLEAR CARRY
3$:	SEC				;SET CARRY
4$:	RETURN				;CARRY SET OR CLEAR FROM $WAIT

WAITE:	TSTB	GIV.W			;DO WE HAVE TO WAIT?
	BEQ	2$			;NO
1$:
	MOV	#SYSDEV,R0		;GET DEVICE ADDRESS
	CALL	PUTDEV			;STORE IT
	MOV	#REPLAC,-(SP)		;PUSH POINTER TO MSG ON STACK
	CALL	$WAIT			;WAIT FOR RESPONSE
	TST	R0			;PROCEED?
	BLE	1$			;NO, REPEAT PROMPT
2$:	RETURN
	.SBTTL	PUT DEVICE ON MESSAGE LOCATION

;+
; Get ASCII device name and unit into message.
;-
	.ENABL 	LSB

PUTDEV::MOV	R0,-(SP)		; Save output buffer pointer
	CLR	R1			; R1 = Unit number
	BISB	UNIT,R1			;      - Without sign extension
	MOV	PHYNAM,R0		; R0 = 1/2 letter device name	
	CALL	$DEVTR			; Combine device name and unit (RAD50)
					; R0 = Word to convert
	MOV	(SP)+,R1		; R1 -> Buffer to receive string
	CALL	$R50ASC			; Convert to ASCII
	RETURN				; All done

	.SBTTL	6) PREPARE FOR CHECKING IF PROTECTED ENTRIES

;+
; THE ROUTINE PREPARES FOR SEARCHING A DEVICE FOR PROTECTED FILES.
; IF THE /V OPTION HAS BEEN GIVEN THERE IS NO NEED TO FETCH THE 
; HANDLER. A CHANNEL IS OPEN TO THE DEVICE AND THE ROUTINE WHICH
; CHECKS IF THERE ARE PERMANENT FILES IS CALLED (FNDPRO). ON 
; RETURN FROM FNDPRO R0 INDICATES THAT THERE ARE PROTECTED FILES
; BY BEING NON-ZERO. THE USER IS QUERY IF HE WANTS TO CONTINUE
; IF PROTECTED FILES WERE FOUND. AT THE END THE CHANNEL IS PURGED
; AND THE HANDLER IS RELEASED IF THE /V OPTION WAS NOT GIVEN.
;
;	CALL 	CHKPRO
;
;	C-BIT = 0  - PROCEED WITH OPERATION
;	      = 1  - ABORT THE OPERATION
;-
	.ENABL	LSB

CHKPRO:	TSTB	GIV.V			;/V OPTION SPECIFIED?		;CA5+
	BNE	8$			;YES, SKIP NEXT
	.FETCH	WRTBUF,#DEVNAM		;FETCH HANDLER
	BCC	7$			;BRANCH IF NO ERROR
	MESSG$	#ERR9,U			;PRINT ERROR MESSAGE
	BR	5$			;ABORT

7$:	MOV	R0,WRTBUF		;SAVE FOR BUFFER SPACE
8$:	MOV	WRTBUF,$DIRBF		;SAVE DIRECTORY BUFFER POINTER
	MOV	$DIRBF,R0		;COPY TO R0
	ADD	#<SEGSIZ+4>,R0		;ALLOCATE SPACE FOR SEGMENT
	.SETTO	R0			;ASK FOR THIS AMOUNT OF MEMORY
	CLR	$DIRCH			;USE CHANNEL ZERO
	.LOOKUP	#AREA,$DIRCH,#DEVNAM	;OPEN CHANNEL NFS
	BCC	1$			;BRANCH IF NO ERROR
	MESSG$	#ERR11,F		;ERROR LOOKUP
	BR	5$			;LEAVE

1$:	MOV	#1,$NXTSG		;FORCE SEGMENT ONE
	TSTB	GIV.Y			;DO WE HAVE TO CHECK PROTEC FILES?
	BNE	4$			;NO, SKIP NEXT
	CALL	FNDPRO			;ARE THERE ANY PROTECTED FILES?
	BCC	2$			;BRANCH IF NO ERROR
	BR	5$			;LEAVE

2$:	TST	R0			;WHERE ANY FOUND?
	BEQ	4$			;NO, BRANCH
3$:	MOV	#MSG11,-(SP)		;LOAD MESSAGE
	CALL	$WAIT			;QUERY USER
	TST	R0			;CONTINUE?
	BEQ	5$			;NO, BRANCH
	BLT	3$			;GARBAGE, REPEAT MESSAGE
4$:	TSTB	GIV.V			;/V OPTION GIVEN
	BNE	6$			;YES, BRANCH
	.RELEA	#DEVNAM			;RELEASE HANDLER
6$:	.PURGE	$DIRCH			;PURGE CHANNEL
	CLC				;CLEAR CARRY
	RETURN				;RETURN

5$:	.RELEA	#DEVNAM			;RELEASE HANDLER
	.PURGE 	$DIRCH			;PURGE CHANNEL BEFORE...
	SEC				;SET CARRY
	RETURN				;...LEAVING			;CA5-
	.DSABL	LSB
	.SBTTL		A) FNDPRO - FIND A PROTECTED ENTRY

;+
; THE DIRECTORY SEGMENT ENTRY STATUS WORDS ARE OBTAINED BY CALLING
; ROUTINE (NEXTFL). THE STATUS WORD IS TESTED BY THE END OF SEGMENT
; AND THE PROTECTED FILE MASKS AND THE RESULT IS SEND TO THE CALLER.
;
;	$DIRBF	--> DIRECTORY BUFFER
;	$DIRCH	=   CHANNEL NUMBER FOR DIRECTORY I/O
;
;	CALL	FNDPRO
;
;	C-BIT = 0 --> NO ERROR
;		R0 = 0 --> NO PROTECTED FILE FOUND
;		R0 <> 0 --> PROTECTED FILES FOUND
;	      = 1 --> ERROR 
;	
;-
	.ENABL	LSB
FNDPRO:	
	CLR	$NXTFL			;FORCE A NEW SEGMENT TO BE READ	;CA+
	MOV	#MAXSEG+1,SEGCHK	;ASSUME A NEW DIRECTORY
3$:	CALL	NEXTFL			;GET NEXT ENTRY
4$:	BCS	10$			;BRANCH ON ERROR
	TST	R0			;DID WE GET AN ENTRY?
	BEQ	11$			;BRANCH IF NOT. END OF DIRECTORY
	BIT	#DS.EOS,@R0		;END OF SEGMENT ENTRY?
	BEQ	5$			;BRANCH IF NOT
	DEC	SEGCHK			;COUNT DOWN SEGMENTS
	BNE	5$			;BRANCH IF DIRECTORY STILL VALID
	CLR	R0			;INDICATE TO PROCEED
	BR	11$			;RETURN WITH CARRY SET

5$:	BIT 	#DS.PRO,@R0			;IS THE ENTRY TYPE CORRECT
	BEQ	3$			;BRANCH IF NOTGET NEXT ENTRY
	TST	(PC)+			;NO ERROR, CLEAR CARRY
10$:	CLR	R0			;CLEAR REGISTER			
11$:	
	RETURN								;CA5-	
	.DSABL	LSB
	.SBTTL		B) NEXTFL - GET NEXT FILE ENTRY

;+
; THIS ROUTINE RETURNS THE NEXT ENTRY IN A DIRECTORY. IF THERE ARE NO MORE
; IT RETURNS C-BIT SET.
;
;  	$NXTFL -> NEXT ENTRY IN DIRECTORY. CALLER SHOULD SET THIS TO 0
; 		  TO FORCE THE NEXT SEGMENT TO BE READ
;	$NXTSG	= SEGMENT NUMBER OF THE NEXT DIRECTORY SEGMENT. CALLER
;		  SHOULD SET THIS TO 1 TO FORCE THE DIRECTORY TO BE READ
;		  FROM THE BEGINNING.
;
;	CALL	NEXTFL
;
;	C-BIT = 0 => NO ERROR
;	R0 <> 0 STATUS OF ENTRY
;	R0 = 0  NO MORE ENTRIES
;	C-BIT = 1 => ERROR
;	

;-
	.ENABL LSB

NEXTFL:
	MOV	R3,-(SP)		;SAVE R3			;CA5+
	MOV	R4,-(SP)		;SAVE R4
	MOV	R5,-(SP)		;SAVE R5
1$:	MOV	$NXTFL,R0		;R0 -> NEXT DIRECTORY ENTRY
	BNE	5$			;BRANCH IF WE HAVE ONE
	MOV	$NXTSG,R5		;R5 = NEXT SEGMENT NUMBER.
	BEQ	7$			;BRANCH IF NO MORE

2$:
	MOV	$DIRBF,R4		;R4->DIRECTORY INPUT BUFFER
	MOV	R4,$NXTFL		;COPY IT
	ADD	#DH.SIZ,$NXTFL		;$NXTFL -> FIRST ENTRY
	ASL	R5			;DIRECTORY SEG ARE TWO BLOCKS LONG
	ADD	#4,R5			;START AT BLOCK SIX
	MOV	R5,$DIRSG		;SAVE THE BLOCK FOR WRTDIR
	.READW	#AREA,$DIRCH,R4,#BLKSIZ,R5
	BCS	8$			;RESTORE REG. BEFORE LEAVING
NXTFL1:	MOV	DH.NXT(R4),$NXTSG	;SAVE THE BLOCK NUMBER OF THE NEXT SEGMENT
	CMP	#6,R5			;THIS THE FIRST SEG?
	BNE	1$			;BRANCH IF NOT
	MOV	DH.SIZ(R4),$HISEG	;SAVE THE HIGHEST SEGMENT OPEN
	MOV	DH.AVL(R4),$AVAIL	;AND THE HIGHEST AVAILABLE
	BLE	4$			;BRANCH IF INVALID
	CMP	#MAXSEG,$AVAIL		;IS IT GOOD?
	BLO	4$			;BRANCH IF NOT
3$:	MOV	DH.EXB(R4),$EXTBY	;SAVE NUMBER OF EXTRA BYTES
	CMP	#MAXBYT,$EXTBY		;VALID?
	BLO	4$			;BRANCH IF NOT
	BIT	#1,$EXTBY		;IS IT ODD?
	BEQ	1$			;BRANCH IF NOT
4$:
	CLR	R0			;CLEAR REGISTER
	BR	7$			;GO RETURN

5$:	BIT	#DS.EOS,@R0		;END-OF-SEGMENT
	BEQ	6$			;BRANCH IF NOT
	CLR	$NXTFL			;FORCE NEXT CALL TO READ NEXT SEG
	BR	7$			;DONE

6$:	ADD	#DE.SIZ,$NXTFL		;POINT TO NEXT ENTRY
	ADD	$EXTBY,$NXTFL		;DON'T FORGET EXTRA BYTES
7$:	CLC				;INDICATE NO ERROR
8$:	MOV	(SP)+,R5		;RESTORE R5
	MOV	(SP)+,R4		;" " " " R4
	MOV	(SP)+,R3		;" " " " R3			;CA5-
	RETURN
	.DSABL	LSB
	.SBTTL	MESSAGE PRINT ROUTINES


;
;PREMSG - PRINTS A MESSAGE TO THE TERMINAL WITH THE ?FORMAT-C-
;	  PREFIX. (WHERE C=I,W,E,F OR U)
;
;MSG -   ALTERNATE ENTRY POINT - OMITS PRINTING OF PREFIX
;
; THIS ROUTINE IS USED IN CONJUNCTION WITH THE MESSG$ MACRO TO PRINT MESSAGES
; TO THE TERMINAL.
;
; ON ENTRY TO PREMSG:
;	R0 CONTAINS THE OFFSET INTO 'MSKLST' FOR THE MASK TO BE OR'D
;		INTO BYTE 53 (ALSO THE OFFSET INTO 'CHRLST' FOR THE
;		CHARACTER TO BE USED TO COMPLETE THE PREFIX)
;	THE ADDRESS OF THE MESSAGE IS ON THE STACK
;
; ON ENTRY TO MSG:
;	THE ADDRESS OF THE MESSAGE IS IN R0
;
; ON RETURN:
;	R0 IS DESTROYED
;	THE STACK ARGUMENT ( IF ONE ) HAS BEEN REMOVED.
;
;-

PREMSG:	BISB	MSKLST(R0),@#USERRB	;SET ERROR SEVERITY		;MG1+
	MOVB	CHRLST(R0),LEVEL	;COMPLETE THE PREFIX
	.PRINT	#PREFIX			;AND PRINT IT
	MOV	2(SP),R0		;R0->MESSAGE CONTINUATION
	MOV	(SP),2(SP)		;MUDDLE WITH STACK TO
	TST	(SP)+			; REMOVE ARGUMENT		;MG1-
MSG:	.PRINT				;PRINT MESSAGE
	RETURN
	.SBTTL	DRIVER SUBROUTINES

;+
;
; $WAIT - THIS SUBROUTINE PRINTS A MESSAGE POINTED TO BY THE TOP ELEMENT OF
;THE STACK, THEN WAITS FOR A RESPONSE.THE MESSAGE MUST BE TERMINATED WITH
;A 0 OR 200 BYTE.  
;
;RESPONSE:
;
;	R0 =  1  --> ANYTHING THAT STARTS WITH 'Y' "YES"
;
;	R0 =  0  --> ANYTHING THAT STARTS WITH 'N' "NO"
;
;	R0 = -1  --> ANYTHING ELSE 
;	
;ALL REGISTERS REMAIN INTACT THROUGH THE CALL EXCEPT R0.  THE CALL HAS THE 
;FOLLOWING FORMAT:
;
;		MOV	#MSG,-(SP)	;PUSH --> TO MSG ON STACK
;		CALL	$WAIT	
;
;-

$WAIT:
	BIS	#TTNOWT,@#JSW		;INHIBIT TT WAIT
1$:	.TTINR				;CLEAR TERMINAL RING BUFFER
	BCC	1$
	BIC	#TTNOWT,@#JSW		;ALLOW TT WAIT
	MESSG$	2(SP)			;PRINT USERS MESSAGE		;CA5
	MOV	(SP),2(SP)		;REMOVE ARGUMENT FROM STACK	;CA5
	ADD	#2,SP			;NOTE THAT THIS CLEARS CARRY
	.TTYIN	-(SP)			;GET HIS RESPONSE
	BIS	#TTNOWT,@#JSW		;INHIBIT TT WAIT
2$:	.TTINR				;CLEAR TERMINAL RING BUFFER
	BCC	2$
	BIC	#TTNOWT,@#JSW		;ALLOW TT WAIT
	CLR	R0			;USED AS A FLAG		;CA5+
	CMPB	#'Y,(SP)		;IS IT A 'YES'
	BNE	3$			;NO, BRANCH
	INC	R0			;FLAG THE 'YES'
	BR	5$			;RETURN

3$:	CMPB	#'N,(SP)		;IS IT A 'NO'
	BNE	4$			;NO, BRANCH
	BR	5$			;RETURN

4$:	DEC	R0			;FLAG ANSWER
	

5$:	
	TST	(SP)+			;POP ENTERED CHARACTER 	;CA5-
	RETURN
	.SBTTL	$CNVRT CONVERT WORD TO 6 ASCII OCTAL DIGITS

;+								;BD1+
;
;$CNVRT - CONVERT WORD TO 6 ASCII OCTAL DIGITS
;
; INPUTS : R0 = ADDRESS OF THE OUTPUT BUFFER
;          R1 = WORD TO BE CONVERTED
;          R5 = -1 SUPPRESS LEADING ZEROS
;                0 ALL CHARACTERS PRINTED
;
;OUTPUTS : R0 -> THE LAST CHARACTER OUTPUT
;
;-

$CNVRT::MOV	#6,R4			;SIX CHARACTERS TO OUTPUT
	CLR	R2
	CLR	R3			;CLEAR NUMBER OF CHARACTERS OUTPUT
	ROL	R1			;GET MSB OF WORD
	ROL	R2			;   INTO BITS 2-0 OF R2
	BR	2$			;GO CONVERT THE FIRST CHARACTER

1$:	ROL	R1			;GET THE NEXT OCTAL DIGIT INTO
	ROL	R2
	ROL	R1			;   BITS 2-0 OF R2
	ROL	R2
	ROL	R1
	ROL	R2
2$:	BIC	#177770,R2		;MASK THE NEXT CHARACTER
	BNE	3$			;IF NE IT'S NON ZERO CHARACTER
	TST	R5			;CHECK IF SUPPRESS LEADING ZEROS
	BNE	4$			;IF NE YES
3$:	ADD	#'0,R2			;CONVERT THE CHARACTER TO ASCII
	MOVB	R2,(R0)+		;OUTPUT IT
	INC 	R3			;BUMP THE NUMBER OF CHARACTERS OUTPUT
4$:	DEC	R4			;CHECK IF ALL CHARACTERS DONE ?
	BNE	1$			;IF NE NO - CONTINUE
	TST	R3			;CHECK IF ANY CHARACTERS OUTPUT
	BNE	5$			;IF NE YES
	MOVB	#'0,(R0)+		;OUTPUT ZERO INDICATOR
5$:	RETURN				;RETURN				;BD1-
	.SBTTL	$SVRG,$RSTRG - SAVE AND RESTORE REGISTERS

;+
;									;BD1+
;$SVRG,$RSTRG - THESE ROUTINES SAVE AND RESTORE REGISTERS R0 - R5
;                CALLING SEQUENCE : JSR R5,SAVREG AND JSR R5,RSTREG
;
;-

$SVRG::	MOV	R4,-(SP)		;SAVE R4
	MOV	R3,-(SP)		;SAVE R3
	MOV	R2,-(SP)		;SAVE R2
	MOV	R1,-(SP)		;SAVE R1
	MOV	R0,-(SP)		;SAVE R0
	MOV	10.(SP),-(SP)		;SAVE R5
	RTS	R5
$RSTRG:: TST	(SP)+			;POP OFF R5
	MOV	(SP)+,R0		;RESTORE R0
	MOV	(SP)+,R1		;RESTORE R1
	MOV	(SP)+,R2		;RESTORE R2
	MOV	(SP)+,R3		;RESTORE R3
	MOV	(SP)+,R4		;RESTORE R4
	RTS	R5							;BD1-
	.SBTTL	MAIN ROUTINE DATA AREA

	.PSECT	DATA,D
BUFFER:	.BLKB	3			;ASCII DEVICE NAME WORK BUFFER
	.BYTE	200			;NO CR-LF
FLAG:					;ERROR INDICATOR FLAG
					; (OVERLAYS INLINE)
INLINE:	.BLKB	82.			;INPUT BUFFER FOR GTLIN
	.EVEN
RETADR:	.BLKW	1			;TEMP STORAGE FOR RETURN ADDRESSES
OUTSPC::.BLKW	39.			;CSISPC DATA AREA
					;-DSTATUS DATA AREA OVERLAYS FIRST
					; 4 WORDS OF CSISPC DATA AREA	;JH1+
					;-AREA BLOCK OVERLAYS NEXT 6 WORDS
					;-CBLK OVERLAYS NEXT 5 WORDS	;JH1-

	;OUTSPC REUSE

	DSTBLK	= OUTSPC	;EMT MEMORY BLOCK FOR .DSTATUS 4 WD	;JH1
	AREA	= OUTSPC+8.	;EMT ARGUMENT BLOCK 6 WORDS REQUIRED	;JH1
	CBLK	= OUTSPC+20.	;USER MEMORY BLOCK FOR .SAVESTATUS 5 WD	;JH1

	DEVNAM == OUTSPC+30.	;LOCATION OF INPUT DEVICE NAME
	SYSTYP	= OUTSPC+38.	;LOCATION OF SYSTEM DEVICE TYPE	4 WD	;BD1+
				;VERIFY DATA AREA OVERLAYS UNUSED
				; WORDS OF OUTSPC
	DEVCHR	= OUTSPC+46.	;DEVICE CHARACTERISTICS WORD
	WRTBUF	= OUTSPC+48.	;WRITE BUFFER ADDRESS
	RDBUF	= OUTSPC+50.	;READ BUFFER ADDRESS
	DEVINX	= OUTSPC+52.	;INDEX INTO FORMAT'S DEVICE TABLES
	DEVSIZ	= OUTSPC+54.	;DEVICE SIZE
	XFRNO	= OUTSPC+56.	;NUMBER OF BLOCKS IN A VERIFY TRANSFER
	CHRBUF	= OUTSPC+58.	;OUTPUT CHARACTER BUFFER (8 BYTES)
	CNTDWN	= OUTSPC+66.	;NUMBER OF BLOCKS LEFT TO DO IN VERIFY
	RTRIES	= OUTSPC+68.	;RETRY COUNT FOR BAD BLOCKS
	NOREM	= OUTSPC+70.	;NUMBER OF BLOCKS REMAINING		
	TRMSTS	= OUTSPC+72.	;TERMINAL STATUS FOR .SCCA		;BD1-

CSTBLK:	.BLKW	6
	PHYNAM == CSTBLK+10.	;PHYSICAL DEVICE NAME

;LOCATIONS FOR SUPPORT OF PROTECTED FILES SEARCH CODE

$AVAIL:	.WORD 	0			;NUMBER OF DIRECTORY SEG AVAILABLE
$DIRBF: .WORD 	0			;-> DIRECTORY BUFFER
$DIRCH: .WORD 	0			; DIRECTORY CHANNEL NUMBER
$DIRSG:	.WORD	0			; BLCOK NUMBER OF CURRENT SEG
$EXTBY:	.WORD	0			; NUMBER OF EXTRA BYTES
$HISEG:	.WORD	0			; HIGHEST SEGMENT IN USE
$NXTFL:	.WORD	0			; NEXT FILE IN DIRECTORY SEG
$NXTSG:	.WORD	0			; SEGMENT NUMBER OF NEXT DIR SEG
SEGCHK:	.WORD	0			; COUNT OF SEGMENT ALREADY READ

HANDEV:	.RAD50	/SY/			;DEVICE BLOCK FOR LOOKUP
STODEV:	.WORD	0			;DEVICE RAD50 FIRST 3 CHARS
	.WORD	0			;LAST 3 CHARACTERS
	.RAD50	/SYS/			;.SYS FILE
NONCSR::.WORD	0			;STORE HANDLER CSR ADDRESS
LMBLK:	.LIMIT				;LOW/HIGH IMAGE LIMITS		;BD1
UNIT:	.BYTE	0			;UNIT NUMBER
PREFIX::.NLCSI	PART=PREFIX	TYPE=I
LEVEL:	.ASCII	/x-/<200>		;MESSAGE TYPE (x=I,W,E,F OR U)	;MG1+
MSKLST:	.BYTE	0,2,4,10,20		;ERROR SEVERITY MASK LIST
CHRLST:	.ASCII	/IWEFU/			;PREFIX SEVERITY INDICATOR LIST	;MG1
	.EVEN				;MAKE BOUNDARY EVEN FOR ROUTINES

; OPTION TABLE

	.PSECT	$OP,RW,D,GBL
	.EVEN
OPTBL:					;START OF OPTION TABLE
	OPTN$	Y,N			;/Y (NOQUERY) OPTION (NO VALUES)
	OPTN$	W,N			;/W (WAIT) OPTION (NO VALUES)
	OPTN$	V,Y			;/V (VERIFICATION) OPTION (VALUE);BD1+
	OPTN$	P,Y			;/P (PATERN) OPTION (VALUE)	;BD1-

; INSTALL ADDITIONAL ROOT OPTIONS HERE

	.PSECT	$OP,RW,D,GBL
	.WORD	-1			;END OF ROOT OPTION LIST

; OPTIONS ADDED BY FORMAT ROUTINES GO HERE

	.PSECT	PUREDATA,RO,D
	.EVEN
DEFEXT:	.WORD	0,0,0,0			;NO DEFAULT EXTENSIONS
SYSNAM:	.RAD50	/SY /
TBLPAT:	.WORD	0			;TABLE OF PATTERNS		;BD1+
	.WORD	177777
	.WORD	163126
	.WORD	125252
	.WORD	052525
	.WORD	7417
	.WORD	21042
	.WORD	104210			;DEFAULT PATTERN		;BD1-
	.WORD	155555			;RLO1-RLO2 PATTERNS
	.WORD	145454			;AZTEC (TBD)
	.WORD	146314			;AZTEC (TBD)
	.WORD	162745			;eeeeeeeeeeeeeeeeee
	.WORD	104210			;RESERVED
	.WORD	104210			;RESERVED
	.WORD	104210			;RESERVED
	.WORD	104210			;RESERVED
DWFLAG:	.WORD	0			;Unformatted DW flag, 0=formatted,1=unformatted
DWTBL:	.RAD50	/DW /
	.RAD50	/DW0/
CURBLK:	.WORD	0			;Current block number of handler file
					; read into memory.
STATU$::.WORD	0			;Offset to DU STATU$ word.
.SBTTL	 	M E S S A G E S
	.NLIST	BEX
	.ENABL	LC			;ALLOW LC MESSAGES

VERS::	.NLCSI	TYPE=I				;VERSION NUMBER
PATLVL::.ASCIZ	/ /							;JH2
CRLF:	.ASCII	<12><15><200>
ERR1:	.ASCIZ	/Invalid command line/
ERR2:	.ASCIZ	/Unit number must be in range 0-7/
ERR3:	.ASCIZ	/Device invalid or not supported by FORMAT/		;JH4
ERR4:	.ASCII	'Invalid option: /'<200>
ERR5:	.ASCII	'Invalid option: /'<200>
ERR6:	.ASCIZ	'Formatting/verifying the system volume is not allowed'	;BD1
ERR7:	.ASCIZ	'Invalid directory'
ERR8:	.ASCII	'Duplicate option specified: /'<200>
ERR9:	.ASCIZ	/Device handler fetch error/				;BD1
ERR10:	.ASCIZ	'Invalid value specified with option: /'<200>		;BD1
ERR11:	.ASCIZ  /LOOKUP ERROR/
ERR12:	.ASCIZ	/Directory input error/
ERR13:	.ASCIZ	/Operation not completed/
ERR14:	.ASCII	/File not found /<200>
ERR15:	.ASCIZ	/Input error/
ERR16:	.ASCIZ	/Wrong version of RT11/
ERR17:	.ASCIZ	\Device invalid for /VERIFY, or not formatted\
ERR18:	.ASCIZ	/Install DW/
MSG1:	.ASCII	':/FORMAT-Are you sure? '<200>
MSG2:	.ASCIZ	/Formatting aborted/
MSG3:	.ASCIZ	/Formatting complete/
MSG4:	.ASCII	':/VERIFY-Are you sure? '<200>				;BD1+
MSG5:	.ASCII	': is write locked.  CONTINUE(Y/N)? '<200>
MSG7:	.ASCIZ	/Verification aborted/

MSG8:	.ASCIZ	/Verification complete/
MSG9:	.ASCII	/PATTERN #/<200>					;BD1-
MSG10:	.ASCIZ	/Foreground loaded/
MSG11:	.ASCII	/Volume contains protected files; Are you sure? /<200>
$SERR1:	.ASCIZ	/Device not ready/					;MG1+
$SERR2:	.ASCIZ	/Device error/
$SERR3:	.ASCIZ	/Insufficient memory/					;MG1-
INSERT:	.ASCII	/Mount input volume in /
FORDEV:	.BLKB	3.
	.ASCII	/:; Continue? /<200>
INSRTV:	.ASCII	/Mount input volume in /
VERDEV:	.BLKB	3.
	.ASCII	/:; Continue? /<200>
REPLAC:	.ASCII	/Mount system volume in /
SYSDEV:	.BLKB	3.
	.ASCII	/:; Continue? /<200>
	.EVEN		;SO THAT .PSECT PUREDATA STARTS ON EVEN BOUNDARY FOR
			;FORMATTING ROUTINES

	.LIST	BEX
	.SBTTL	DEVICE TABLE

;+
;
;	DEVICE TABLE:
;	THE DEVICE TABLE IS BUILT FROM THE INFORMATION
;	IN GLOBAL .PSECTS IN EACH FORMAT ROUTINE.  THIS
;	ALLOWS NEW FORMAT ROUTINES TO BE ADDED AT LINK
;	TIME, THUS NOT REQUIRING CHANGES AND REASSEMBLY 
;	OF THE ROOT CODE FOR EACH NEW ROUTINE.
;	->  SEE THE NOTES ON DATA STRUCTURES FOR MORE INFO.
;
;-

	.PSECT	$DV,RO,D,GBL
DEVTAB:
	.PSECT	END$DV,RO,D
	.WORD	0

	.PSECT	PATCH,RW,I

FREE:					;END OF ROOT-LOCATION TO LOAD HANDLER
	.END	START							;JH2-