.TITLE FABERR ERROR ROUTINE FOR RMS
	.SBTTL LOCAL COPY OF USER FAB
	.EVEN
FABBLK:
FABWDS:
ZF.ALQ:	.BLKW	2	; SIZE OF FILE
	.WORD	ZF.BID
	.WORD	ZF.BKS
	.WORD	ZF.BLN
ZF.BLS:	.BLKW	1	; BLOCK SIZE
ZF.BPA:	.BLKW	1	; PRIVATE BUFFER ADDRESS
ZF.BPS:	.BLKW	1	; PRIVATE BUFFER SIZE
ZF.CTX:	.BLKW	1	; USER DATA
ZF.DEQ:	.BLKW	1	; AUTO EXTENSION QUANTITY
	.WORD	ZF.FSZ
ZF.IFI:	.BLKW	1	; POINTER TO IFAB
	.WORD	ZF.LCH
ZF.MRN:	.BLKW	2	; MAXIMUM RECORD NUMBER
ZF.MRS:	.BLKW	1	; MAXIMUM RECORD SIZE
ZF.NAM:	.BLKW	1	; POINTER TO NAM BLOCK
	.WORD	ZF.RTV
	.WORD	ZF.SHR
ZF.STS:	.BLKW	1	; COMPLETION CODE
ZF.STV:	.BLKW	1	; MORE ERROR INFO
ZF.XAB:	.BLKW	1	; POINTER TO FIRST XAB
;
ZF.BID:	.BLKB	1	; FAB IDENTIFIER
ZF.BKS:	.BLKB	1	; BUCKET SIZE
ZF.BLN:	.BLKB	1	; RAB LENGTH
ZF.DEV:	.BLKB	1	; DEVICE CHARACTERISTICS
ZF.DNS:	.BLKB	1	; DEFAULT SPEC SIZE
ZF.FAC:	.BLKB	1	; TYPES OF RECORD OPERATION (FILE ACCESS)
ZF.FNS:	.BLKB	1	; SIZE OF FILESPEC
ZF.FSZ:	.BLKB	1	; SIZE OF FIXED AREA FOR VFC
ZF.LCH:	.BLKB	1	; LOGICAL CHANNEL
ZF.ORG:	.BLKB	1	; FILE ORGANIZATION
ZF.RAT:	.BLKB	1	; RECORD ATTRIBUTES
ZF.RFM:	.BLKB	1	; RECORD FORMAT
ZF.RTV:	.BLKB	1	; WINDOW/CLUSTER SIZE
ZF.SHR:	.BLKB	1	; FILE SHARING
;
; THE FOLLOWING IS A TABLE OF ADDRESSES FOR $EDMSG 
; TO CONVERT BIT ENCODED VALUES TO ASCII STRINGS
;
FABYTS:
	.WORD	ZF.DEV
DEVLEN:	.BLKW	1
DEVADR:	.WORD	DEVSTR
	.WORD	ZF.FAC
FACLEN:	.BLKW	1
FACADR:	.WORD	FACSTR
ZF.FOP:	.BLKW	1	; FILE PROCESSING OPTIONS
FOPLEN:	.BLKW	1	; LENGTH OF FILE OP STRING
FOPADR:	.WORD	FOPSTR	; ADDRESS OF ASCII FOP
	.WORD	ZF.ORG
ORGLEN:	.BLKW	1
ORGADR:	.WORD	ORGSTR
	.WORD	ZF.RAT
RATLEN:	.BLKW	1
RATADR:	.WORD	RATSTR
	.WORD	ZF.RFM
RFMLEN:	.BLKW	1
RFMADR:	.WORD	RFMSTR
;
FABSPC:
DSPECL:	.BLKW	1	; DEFAULT SPEC LENGTH FOR $EDMSG
ZF.DNA:	.BLKW	1	; DEFAULT FILESPEC ADDRESS
	.WORD	ZF.DNS	; DEFAULT SPEC LENGTH
FSPECL:	.BLKW	1	; FILE SPEC LENGTH FOR $EDMSG
ZF.FNA:	.BLKW	1	; ADDRESS  OF CONVERTED FILESPEC
	.WORD	ZF.FNS	; FILE SPEC LENGTH
	.PAGE
	.SBTTL	FORMAT CONTROL FOR $EDMSG
	.NLIST	BEX
FWDSTR:
	.ASCII	/FAB NUMERIC VALUES%N/
	.ASCII	/ALQ: %2O%5SBLS: %O%5S/
	.ASCII	/BID: %B%5SBKS: %B%5SBLN: %B%5SBPA: %O%N/
	.ASCII	/BPS: %O%5SCTX: %O%5SDEQ: %O%5SFSZ: %B%N/
	.ASCII	/IFI: %O%5SLCH: %B%5SMRN: %2D.%5SMRS: %D.%5SNAM: %O%N/
	.ASCIZ	/RTV: %B%5SSHR: %B%5SSTS: %D.%5SSTV: %D.%5SXAB: %O%2N/
	.EVEN
FBYSTR:
	.ASCII	/FAB LOGICAL VALUES%N/
	.ASCII	/DEV: %B=%VA%N/
	.ASCII	/FAC: %B=%VA%N/
	.ASCII	/FOP: %O=%VA%N/
	.ASCII	/ORG: %B=%VA%N/
	.ASCII	/RAT: %B=%VA%N/
	.ASCIZ	/RFM: %B=%VA%N/
FSPECS:
	.ASCII	/%NFAB. FILE SPECS%N/
	.ASCIZ	/DNA: %VA%10SDNS: %B%NFNA: %VA%10SFNS: %B%N/
;
	.EVEN
FABOUT:	.BLKB	1024.
LEN:	.BLKW	1
FORMAT:	.ASCIZ	/%6A!/
	.PAGE
	.SBTTL	(DEV) DEVICE CHARACTERISTICS TABLES
	.EVEN
DEVENT:	.WORD	6.		; NUMBER OF ENTRIES IN TABLE
DEVSTR:	.BLKB	44.
	.EVEN
DEVVAL:
	.WORD	FB$CCL		; CARRIAGE CONTROL DEVICE
	.WORD	FB$MDI		; MULTIPLE DIRECTORY DEVICE
	.WORD	FB$REC		; UNIT RECORD DEVICE
	.WORD	FB$SDI		; SINGLE DIRECTORY DEVICE
	.WORD	FB$SQD		; SEQUENTIAL, BLOCK-ORIENTED DEVICE
	.WORD	FB$TRM		; TERMINAL DEVICE DEVICE
FBCCL:	.ASCII	/FB$CCL/
FBMDI:	.ASCII	/FB$MDI/
FBREC:	.ASCII	/FB$REC/
FBSDI:	.ASCII	/FB$SDI/
FBSQD:	.ASCII	/FC$SQD/
FBTRM:	.ASCII	/FB$TRM/
DEVTBL:
	.WORD	FBCCL
	.WORD	FBMDI
	.WORD	FBREC
	.WORD	FBSDI
	.WORD	FBSQD
	.WORD	FBTRM
	.PAGE
	.SBTTL	(FAC) FILE ACCESS TABLES
FACENT:	.WORD	7.		; NUMBER OF ENTRIES IN TABLE
FACSTR:	.BLKB	51.
	.EVEN
FACVAL:
	.WORD	FB$REA		; $READ BLOCK I/O OPERATIONS
	.WORD	FB$WRT		; $WRITE BLOCK I/O OPERATIONS
	.WORD	FB$DEL		; $DELETE OPERATIONS
	.WORD	FB$GET		; $GET AND/OR $FIND OPERATIONS
	.WORD	FB$PUT		; $PUT OPERATIONS
	.WORD	FB$TRN		; $TRUNCATE OPERATIONS
	.WORD	FB$UPD		; $UPDATE OPERATIONS
FBREA:	.ASCII	/FB$REA/
FBWRT:	.ASCII	/FB$WRT/
FBDEL:	.ASCII	/FB$DEL/
FBGET:	.ASCII	/FB$GET/
FBPUT:	.ASCII	/FB$PUT/
FBTRN:	.ASCII	/FC$TRN/
FBUPD:	.ASCII	/FB$UPD/
FACTBL:
	.WORD	FBREA
	.WORD	FBWRT
	.WORD	FBDEL
	.WORD	FBGET
	.WORD	FBPUT
	.WORD	FBTRN
	.WORD	FBUPD
	.PAGE
	.SBTTL	(FOP) FILE PROCESSING OPTION TABLES
FOPENT:	.WORD	11.		; NUMBER OF ENTRIES IN TABLE
FOPSTR:	.BLKB	79.
	.EVEN
FOPVAL:
	.WORD	FB$TMD		; CREATE TEMP AND DELETE WHEN CLOSED
	.WORD	FB$CTG		; ALLOCATE CONTIGUOUSLY
	.WORD	FB$DFW		; DEFER WRITING
	.WORD	FB$FID		; USE NAME FID
	.WORD	FB$MKD		; MAKE THEN DELETE 
	.WORD	FB$NEF		; NO EOF POSITIONING
	.WORD	FB$POS		; POSITION MAGTAPE TO END OF VOLUME
	.WORD	FB$RWC		; REWIND WHEN CLOSED
	.WORD	FB$RWO		; REWIND WHEN OPENED
	.WORD	FB$SUP		; SUPERSEDE EXISTING FILE
	.WORD	FB$TMP		; CREATE TEMP FILE AND SAVE WHEN CLOSED
FBTMD:	.ASCII	/FB$TMD/
FBCTG:	.ASCII	/FB$CTG/
FBDFW:	.ASCII	/FB$DFW/
FBFID:	.ASCII	/FB$FID/
FBMKD:	.ASCII	/FB$MKD/
FBNEF:	.ASCII	/FC$NEF/
FBPOS:	.ASCII	/FB$POS/
FBRWC:	.ASCII	/FB$RWC/
FBRWO:	.ASCII	/FB$RWO/
FBSUP:	.ASCII	/FB$SUP/
FBTMP:	.ASCII	/FB$TMP/
FOPTBL:
	.WORD	FBTMD
	.WORD	FBCTG
	.WORD	FBDFW
	.WORD	FBFID
	.WORD	FBMKD
	.WORD	FBNEF
	.WORD	FBPOS
	.WORD	FBRWC
	.WORD	FBRWO
	.WORD	FBSUP
	.WORD	FBTMP
	.PAGE
	.SBTTL	(ORG) FILE ORGANIZATION TABLES
ORGENT:	.WORD	3.		; NUMBER OF ENTRIES IN TABLE
ORGSTR:	.BLKB	23.
	.EVEN
ORGVAL:
	.WORD	FB$SEQ		; SEQUENTIAL FILE ORGANIZATION
	.WORD	FB$REL		; RELATIVE FILE ORGANIZATION
	.WORD	FB$IDX		; INDEXED FILE ORGANIZATION
FBSEQ:	.ASCII	/FB$SEQ/
FBREL:	.ASCII	/FB$REL/
FBIDX:	.ASCII	/FB$IDX/
ORGTBL:
	.WORD	FBSEQ
	.WORD	FBREL
	.WORD	FBIDX
	.PAGE
	.SBTTL	(RAT) RECORD ATTRIBUTES TABLES
RATENT:	.WORD	3.		; NUMBER OF ENTRIES IN TABLE
RATSTR:	.BLKB	23.
	.EVEN
RATVAL:
	.WORD	FB$BLK		; RECORDS DO NOT CROSS BLOCK BOUNDARIES
	.WORD	FB$CR	; RECORDS PRECEDED WITH <CR> AND FOLLOWED WITH <LF>
	.WORD	FB$FTN		; FIRST BYTE IS FORTRAN FORMS CONTROL CHAR
FBBLK:	.ASCII	/FB$BLK/
FBCR:	.ASCII	/FB$CR /
FBFTN:	.ASCII	/FB$FTN/
	.EVEN
RATTBL:
	.WORD	FBBLK
	.WORD	FBCR
	.WORD	FBFTN
	.PAGE
	.SBTTL	(RFM) RECORD FORMAT TABLES
RFMENT:	.WORD	5		; NUMBER OF ENTRIES IN TABLE
RFMSTR:	.BLKB	37.
	.EVEN
RFMVAL:
	.WORD	FB$UDF		; UNDEFINED RECORD FORMAT (BLOCK I/O)
	.WORD	FB$VFC		; VARIABLE-WITH-FIXED-CONTROL RECORDS
	.WORD	FB$FIX		; FIXED LENGTH RECORDS
	.WORD	FB$STM		; ASCII STREAM RECORD FORMAT
	.WORD	FB$VAR		; VARIABLE-LENGTH RECORDS
FBUDF:	.ASCII	/FB$UDF/
FBVFC:	.ASCII	/FC$VFC/
FBFIX:	.ASCII	/FB$FIX/
FBSTM:	.ASCII	/FB$STM/
FBVAR:	.ASCII	/FB$VAR/
RFMTBL:
	.WORD	FBUDF
	.WORD	FBVFC
	.WORD	FBFIX
	.WORD	FBSTM
	.WORD	FBVAR
	.PAGE
	.SBTTL	RMS MACRO DEFINITIONS
	.MCALL  $INITIF,ORG$,POOL$B,EXIT$S
	.MCALL	$GNCAL,FAB$B,RAB$B,XAB$B,NAM$B
	.MCALL	$FBCAL,$RBCAL
	$GNCAL
	$FBCAL
	$RBCAL
	.SBTTL	CONTROL BLOCKS AND FILE NAME STRINGS
FILNAM:	.ASCII	/TI:TTYRMS.TMP/	; FILE NAME
FNLEN = .-FILNAM
DEFNAM:	.ASCII	/TI:[1,53]FOR005.DAT;0/
DEFLEN = .-DEFNAM
	.EVEN
FABTI:	FAB$B			; FAB FOR NEWLY CREATED FILE
	F$ALQ	10.
	F$FAC	FB$PUT		; WRITE ACCESS
	F$DNA	DEFNAM		; DEFAULT NAME STRING
	F$DNS	DEFLEN		; LENGTH OF DEFAULT STRING
	F$FNA	FILNAM		; ADDRESS OF USER FILE NAME
	F$FNS	FNLEN		; LENGTH OF USER FILE NAME
	F$LCH	5		; LOGICAL CHAN 5
	F$MRS	1024.		; MAXIMUM RECORD SIZE 80.
	F$FOP	FB$CTG!FB$TMD		; DELETE TEMP
	F$ORG	FB$SEQ		; WRITE A SEQUENTIAL FILE
	F$RAT	FB$CR		; <CR><LF> CONTROL
	F$RFM	FB$VAR		; FIXED LENGTH RECS
	FAB$E			; END FDB DEFINITION	
;
	.EVEN
RABTI:	RAB$B			; RAB FOR NEW FILE
	R$FAB	FABTI		; ADDRESS OF OWNING FAB
	R$RAC	RB$SEQ		; SEQUENTIAL ACCESS
	R$UBF	FABOUT		; ADDRESS OF OUTPUT BUFFER FOR $PUT
	R$USZ	1024.		; SIZE OF OUTPUT MSG
	RAB$E
;
;  STEP 4 - GENERATE RMS INTERNAL POOL SPACE
;
	.EVEN
	POOL$B			; BEGIN POOL SPEC
	P$BDB	2		; BUFFER DESCRIPTOR BLOCKS
	P$FAB	1		; 1 FAB
	P$RAB	1 		; 1 RAB
	P$BUF	1024.		; MAXIMUM BUFF SIZE 512.		
	POOL$E	
	.PAGE
;
;  STEP 5 - DEFINE THE RMS FUNCTIONALITY REQUIRED
;
	ORG$	SEQ,<CRE,PUT>	; SET ORGANIZ AS SEQUENTIAL
;  STEP 7 - PROGRAM FLOW
;
FABERR::	
	$INITIF			; INITIALIZE RMS
	MOV	#FABTI,R3	; OPEN TI: ON CHAN 5
	MOV	#RABTI,R4
	$CREATE	R3,#ERROR	; TRY TO CREATE THE FILE
	$CONNECT R4,#ERROR	; CONNECT TO THE RAB
	MOV	2(R5),R3	; PICK UP FAB ADDRESS TO DUMP FROM PARM BLK
	$FETCH	ZF.ALQ,ALQ,R3
	$FETCH	ZF.BID,BID,R3
	$FETCH	ZF.BKS,BKS,R3
	$FETCH	ZF.BLN,BLN,R3
	$FETCH	ZF.BLS,BLS,R3
	$FETCH	ZF.BPA,BPA,R3
	$FETCH	ZF.BPS,BPS,R3
	$FETCH	ZF.CTX,CTX,R3
	$FETCH	ZF.DEQ,DEQ,R3
	$FETCH	ZF.DEV,DEV,R3
	$FETCH	ZF.DNA,DNA,R3
	$FETCH	ZF.DNS,DNS,R3
	$FETCH	ZF.FAC,FAC,R3
	$FETCH	ZF.FNA,FNA,R3
	$FETCH	ZF.FNS,FNS,R3
	$FETCH	ZF.FOP,FOP,R3
	$FETCH	ZF.FSZ,FSZ,R3
	$FETCH	ZF.IFI,IFI,R3
	$FETCH	ZF.LCH,LCH,R3
	$FETCH	ZF.MRN,MRN,R3
	$FETCH	ZF.MRS,MRS,R3
	$FETCH	ZF.NAM,NAM,R3
	$FETCH	ZF.ORG,ORG,R3
	$FETCH	ZF.RAT,RAT,R3
	$FETCH	ZF.RFM,RFM,R3
	$FETCH	ZF.RTV,RTV,R3
	$FETCH	ZF.SHR,SHR,R3
	$FETCH	ZF.STS,STS,R3
	$FETCH	ZF.STV,STV,R3
	$FETCH	ZF.XAB,XAB,R3
	MOV	R5,-(SP)	; SAVE R5 FOR LATER
	CLR	R3		
	MOVB	ZF.DNS,R3	; GET DEFAULT SPEC SIZE
	MOV	R3,DSPECL	; SAVE IT FOR $EDMSG IN ARG BLOCK
	MOVB	ZF.FNS,R3	; GET FILE SPEC SIZE
	MOV	R3,FSPECL	; SAVE IT FOR $EDMSG IN ARG BLOCK
	.PAGE
	.SBTTL	CONVERT DEV
				;
	MOV	#DEVSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#DEVTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	CLR	R3
	MOVB	ZF.DEV,R3	; GET THE DEV FROM USER BLOCK
	MOV	#DEVVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	DEVENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,DEVLEN	; NOW ENTER THE LENGTH IN ARG BLOCK
				;
	.SBTTL	CONVERT FAC
				;
	MOV	#FACSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#FACTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	CLR	R3
	MOVB	ZF.FAC,R3	; GET THE FAC FROM USER BLOCK
	MOV	#FACVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	FACENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,FACLEN	; NOW ENTER THE LENGTH IN ARG BLOCK
				;
	.SBTTL	CONVERT FOP
				;
	MOV	#FOPSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#FOPTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	MOV	ZF.FOP,R3	; GET THE FOP FROM USER BLOCK
	MOV	#FOPVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	FOPENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,FOPLEN	; NOW ENTER THE LENGTH IN ARG BLOCK
				;
	.SBTTL	CONVERT ORG
				;
	MOV	#ORGSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#ORGTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	CLR	R3
	MOVB	ZF.ORG,R3	; GET THE ORG FROM USER BLOCK
	MOV	#ORGVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	ORGENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,ORGLEN	; NOW ENTER THE LENGTH IN ARG BLOCK
				;
	.SBTTL	CONVERT RAT
				;
	MOV	#RATSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#RATTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	MOVB	ZF.RAT,R3	; GET THE RAT FROM USER BLOCK
	MOV	#RATVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	RATENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,RATLEN	; NOW ENTER THE LENGTH IN ARG BLOCK
				;
	.SBTTL	CONVERT RFM
				;
	MOV	#RFMSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#RFMTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	MOVB	ZF.RFM,R3	; GET THE RFM FROM USER BLOCK
	MOV	#RFMVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	RFMENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,RFMLEN	; NOW ENTER THE LENGTH IN ARG BLOCK
				;
	.PAGE
	.SBTTL	FORMAT OUTPUT VIA $EDMSG FOR EASY OUTPUT
				;
	MOV	(SP)+,R5	; RESTORE R5
	.SBTTL	 FORMAT THE NUMERIC VALUES
	MOV	#FABOUT,R0	; POINT TO OUTPUT BUFFER
	MOV	#FWDSTR,R1	; FORMAT STRING
	MOV	#FABWDS,R2	; ARGUMENT BLOCK
	CALL	$EDMSG
	MOV	R1,LEN		; TEMP FOR STORING LENGTH OF CURRENT STRING
	MOV	#FBYSTR,R1	; OUTPUT THE LOGICAL FLAGS
	MOV	#FABYTS,R2
	CALL	$EDMSG
	ADD	R1,LEN		; ADD THE LENGTH TO OVERALL RECORD LENGTH
				; NOW DO THE FILE SPECS
	MOV	#FSPECS,R1
	MOV	#FABSPC,R2
	CALL	$EDMSG
	ADD	R1,LEN		; ADD THE LENGTH TO OVERALL RECORD LENGTH
	MOV	#FABTI,R3	; MAKE SURE $EDMSG DIDNT DESTROY
	MOV	#RABTI,R4	; R3 & R4
	$STORE	#FABOUT,RBF,R4
	$STORE	LEN,RSZ,R4	; STORE # OF BYTES CONVERTED BU $EDMSG
	$PUT	R4,#ERROR
	$DISCONNECT R4,#ERROR		; DISCONNECT
	$CLOSE R3,#ERROR	; CLOSE THE FILE
	$RETURN
ERROR::	BPT
	.PAGE
	.SBTTL	CVTVAL - CONVERT BIT ENCODED VALUES TO ASCII STRINGS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;  ENTRY WITH THE FOLLOWING:
;	R0 = OUTPUT BUFFER ADDRESS
;	R1 = FORMAT CONVERSION STRING ADDRESS (.ASCIZ	/%6A!/)
;	R2 = ADDRESS OF TABLE OF ASCII STRINGS TO OUTPUT
;	R3 = BIT ENCODED VALUE TO TRANSLATE
;	R4 = ADDRESS OF TABLE OF BIT VALUES TO TEST
;	R5 = NUMBER OF ENTRIES IN TABLES
;
; UPON RETURN:
;	R1 = NUMBER OF CHARACTERS CONVERTED IN OUTPUT BUFFER
;
CVTVAL:
	CLR 	LEN		; CLEAR THE TEMP CHR COUNT
	MOV	R3,-(SP)	; SAVE ORIGINAL R3 ON STACK
	CMP	#RFMTBL,R2	; SEE IF ITS RFM (HAS A ZERO VALUE)	
	BEQ	2$		; IT IS CHECK IF ZERO
	CMP	#ORGTBL,R2	; SEE IF ITS ORGTBL (ANOTHER ZERO VALUE TABLE)
	BNE	3$		; IT'S NOT, PROCEED AS NORMAL
2$:	CMP	#0,R3		; SEE IF R3 IS ZERO
	BEQ	3$		; IT'S ZERO SO NORMAL FLOW WORKS
	TST	(R2)+		; BUMP UP R2 TO NEXT ENTRY IN TABLE
	TST	(R4)+		; ALSO ADJUST R4 TO NEXT ENTRY IN TABLE
	DEC	R5		; DECREMENT THE # OF ENTRIES LEFT IN TABLE
3$:	MOVB	#'<,(R0)+	; COPY LEFT BRACKET
	ADD	#1,LEN		; STORE CHARACTER COUNT
5$:	
	BIS	#177777,R3	; PREPARE FOR MASK COMPARE
	BIC	(R4),R3		; SEE IF THIS VALUE IS SET
	BIS	(SP),R3		; SET THE FLAGS FROM THE ORGINAL VALUE
	CMP	#177777,R3	; SEE IF THERE ALL SET
	BNE	10$		; NOT SET
	CALL	$EDMSG		; THIS FLAG IS SET
	ADD	R1,LEN		; COUNT CHARACTERS CONVERTED
	MOV	#FORMAT,R1	; RELOAD FORMAT CONVERSION STRING
	TST	-(R2)		; UPON RETURN $EDMSG R2=NEXT ADDR OF ARGUMENT
				; SET R2 BACK 1 WORD IN TABLE
	BIC	(R4),(SP)	; TURN OFF THE BITS JUST TESTED	
10$:	TST	(R2)+		; BUMP UP R2 TO NEXT ENTRY IN TABLE
	TST	(R4)+		; ALSO ADJUST R4 IN CASE IT BRANCHED TO 10$
	SOB	R5,5$	
	TSTB	-(R0)		; POINT TO LAST "!"
	MOVB	#'>,(R0)+	; CHANGE TO ">" CHARACTER
	MOV	(SP)+,R3	; RESTORE STACK AND R3
17$:	MOV	LEN,R1		; STORE IN R1 FOR RETURN
	CMP	#1,R1		; SEE IF ANYTHING WAS CONVERTED
	BNE	20$		; IF THERE WAS RETURN
	CLR	R1		; IF NOT SET CHAR COUNT TO ZERO
	TSTB	-(R0)		; POINT TO "<"
	CLRB	(R0)		; CLEAR OUT THE "<" CHARACTER
20$:	RETURN
	.END