.TITLE RABERR ERROR ROUTINE FOR RMS
	.SBTTL LOCAL COPY OF USER RAB
	.EVEN
RABBLK:
RABWDS:
	.WORD	ZR.BID
ZR.BKT:	.BLKW	2	; RELATIVE RECORD NUMBER OR VBN	
	.WORD	ZR.BLN
ZR.CTX:	.BLKW	1	; USER DATA
ZR.FAB:	.BLKW	1	; FAB ADDRESS
ZR.ISI:	.BLKW	1	; POINTER TO IRAB
ZR.KBF:	.BLKW	1	; KEY BUFFER ADDRESS
	.WORD	ZR.KRF	
	.WORD	ZR.KSZ
	.WORD	ZR.MBC
	.WORD	ZR.MBF
ZR.RBF:	.BLKW	1	; ADDRESS OF OUTPUT RECORD
ZR.RFA:	.BLKW	3	; RECORD'S FILE ADDRESS
ZR.RHB:	.BLKW	1	; FIXED CONTROL AREA BUFFER
ZR.RSZ:	.BLKW	1	; SIZE OF RECORD OUTPUT
ZR.STS:	.BLKW	1	; COMPLETION CODE
ZR.STV:	.BLKW	1	; MORE ERROR INFO
ZR.UBF:	.BLKW	1	; INPUT RECORD BUFFER
ZR.USZ:	.BLKW	1	; INPUT RECORD BUFFER SIZE
;
ZR.BID:	.BLKB	1	; RAB IDENTIFIER
ZR.BLN:	.BLKB	1	; RAB LENGTH
ZR.KRF:	.BLKB	1	; KEY OF REFERENCE
ZR.KSZ:	.BLKB	1	; KEY SIZE
ZR.MBC:	.BLKB	1	; MULTIBLOCK COUNT
ZR.MBF:	.BLKB	1	; MULTIBUFFER COUNT
ZR.RAC:	.BLKB	1	; RECORD ACCESS FIELD
;
; THE FOLLOWING IS A TABLE OF ADDRESSES FOR $EDMSG 
; TO CONVERT BIT ENCODED VALUES TO ASCII STRINGS
;
	.EVEN
RABYTS:

	.WORD	ZR.RAC
RACLEN:	.BLKW	1
RACADR:	.WORD	RACSTR
ZR.ROP:	.BLKW	1	; RECORD PROCESSING OPTION
ROPLEN:	.BLKW	1	; LENGTH OF FILE OP STRING
ROPADR:	.WORD	ROPSTR	; ADDRESS OF ASCII ROP
;
	.PAGE
	.SBTTL	FORMAT CONTROL FOR $EDMSG
	.NLIST	BEX
RWDSTR:
	.ASCII	/RAB NUMERIC VALUES%N/
	.ASCII	/BID: %B%5SBKT: %2O%5SBLN: %B%5SCTX: %O%5SFAB: %O%N/
	.ASCII	/ISI: %O%5SKBF: %O%5SKRF: %B%5SKSZ: %B%5SMBC: %B%N/
	.ASCII	/MBF: %B%5SRBF: %O%5SRFA: %3O%N/
	.ASCII	/RHB: %O%5SRSZ: %D.%5SSTS: %D.%5SSTV: %D.%N/
	.ASCIZ	/UBF: %O%5SUSZ: %D.%2N/
	.EVEN
RBYSTR:
	.ASCII	/RAB LOGICAL VALUES%N/
	.ASCII	/RAC: %B=%VA%N/
	.ASCIZ	/ROP: %O=%VA%N/
;
	.EVEN
RABOUT:	.BLKB	512.
LEN:	.BLKW	1
FORMAT:	.ASCIZ	/%6A!/
	.PAGE
	.SBTTL	(RAC) FILE ACCESS TABLES
	.EVEN
RACENT:	.WORD	3.		; NUMBER OF ENTRIES IN TABLE
RACSTR:	.BLKB	23.
	.EVEN
RACVAL:
	.WORD	RB$KEY		; PERFORMS RANDOM RECORD OPERATIONS VIA KEYS
	.WORD	RB$RFA		; RECORD'S FILE ADDRESS OERATIONS
	.WORD	RB$SEQ		; SEQUENTIAL RECORD OPERATIONS
RBKEY:	.ASCII	/RB$KEY/
RBRFA:	.ASCII	/RB$RFA/
RBSEQ:	.ASCII	/RB$SEQ/
RACTBL:
	.WORD	RBKEY
	.WORD	RBRFA
	.WORD	RBSEQ
	.PAGE
	.SBTTL	(ROP) RECORD PROCESSING OPTION TABLES
ROPENT:	.WORD	9.		; NUMBER OF ENTRIES IN TABLE
ROPSTR:	.BLKB	65.
	.EVEN
ROPVAL:
	.WORD	RB$ASY		; ASYNCHRONOUS RECORD OPERATIONS
	.WORD	RB$EOF		; SETS STREAM CONTEXT TO EOF WHEN $CONNECT
	.WORD	RB$FDL		; FAST DELETE
	.WORD	RB$KGE		; >= RECORD SEARCH
	.WORD	RB$KGT		; > RECORD SEARCH
	.WORD	RB$MAS		; MASS INSERT
	.WORD	RB$LOA		; OBEY BUCKET FILL #'S WHEN INSERTING
	.WORD	RB$LOC		; LOCATE RECORD TRANSFER
	.WORD	RB$UIF		; UPDATE IF RECORD IN TARGET CELL
RBASY:	.ASCII	/RB$ASY/
RBEOF:	.ASCII	/RB$EOF/
RBFDL:	.ASCII	/RB$FDL/
RBKGE:	.ASCII	/RB$KGE/
RBKGT:	.ASCII	/RB$KGT/
RBMAS:	.ASCII	/FC$MAS/
RBLOA:	.ASCII	/RB$LOA/
RBLOC:	.ASCII	/RB$LOC/
RBUIF:	.ASCII	/RB$UIF/
ROPTBL:
	.WORD	RBASY
	.WORD	RBEOF
	.WORD	RBFDL
	.WORD	RBKGE
	.WORD	RBKGT
	.WORD	RBMAS
	.WORD	RBLOA
	.WORD	RBLOC
	.WORD	RBUIF
	.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			; RAB 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	512.		; 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 RAB
	R$RAC	RB$SEQ		; SEQUENTIAL ACCESS
	R$UBF	RABOUT		; ADDRESS OF OUTPUT BUFFER FOR $PUT
	R$USZ	512.		; 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$RAB	1		; 1 RAB
	P$RAB	1 		; 1 RAB
	P$BUF	512.		; 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
;
RABERR::	
	$INITIF			; INITIALIZE RMS
	MOV	#FABTI,R3	; OPEN TI: ON CHAN 5
	MOV	#RABTI,R4
	$CREATE	R3,#ERRORR	; TRY TO CREATE THE FILE
	$CONNECT R4,#ERRORR	; CONNECT TO THE RAB
	MOV	2(R5),R3	; PICK UP RAB ADDRESS TO DUMP FROM PARM BLK
	$FETCH	ZR.BID,BID,R3
	$FETCH	ZR.BKT,BKT,R3
	$FETCH	ZR.BLN,BLN,R3
	$FETCH	ZR.CTX,CTX,R3
	$FETCH	ZR.FAB,FAB,R3
	$FETCH	ZR.ISI,ISI,R3
	$FETCH	ZR.KBF,KBF,R3
	$FETCH	ZR.KRF,KRF,R3
	$FETCH	ZR.KSZ,KSZ,R3
	$FETCH	ZR.MBC,MBC,R3
	$FETCH	ZR.MBF,MBF,R3
	$FETCH	ZR.RAC,RAC,R3
	$FETCH	ZR.RBF,RBF,R3
	$FETCH	ZR.RFA,RFA,R3
	$FETCH	ZR.RHB,RHB,R3
	$FETCH	ZR.ROP,ROP,R3
	$FETCH	ZR.RSZ,RSZ,R3
	$FETCH	ZR.STS,STS,R3
	$FETCH	ZR.STV,STV,R3
	$FETCH	ZR.UBF,UBF,R3
	$FETCH	ZR.USZ,USZ,R3
	MOV	R5,-(SP)	; SAVE R5 FOR LATER
	CLR	R3		
	.PAGE
	.SBTTL	CONVERT RAC
				;
	MOV	#RACSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#RACTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	CLR	R3
	MOVB	ZR.RAC,R3	; GET THE RAC FROM USER BLOCK
	MOV	#RACVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	RACENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,RACLEN	; NOW ENTER THE LENGTH IN ARG BLOCK
				;
	.SBTTL	CONVERT ROP
				;
	MOV	#ROPSTR,R0	; POINT TO OUTPUT BUFFER
	MOV	#FORMAT,R1	; FORMAT CONVERSION STRING
	MOV	#ROPTBL,R2	; ARGUMENT BLOCK (BEGINNING OF TABLE)
	MOV	ZR.ROP,R3	; GET THE ROP FROM USER BLOCK
	MOV	#ROPVAL,R4	; ADDRESS OF VALUES TO TEST
	MOV	ROPENT,R5	; NUMBER OF ENTRIES IN TABLE
	CALL	CVTVAL		; CONVERT FROM BITS TO ASCII
	MOV	R1,ROPLEN	; 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	#RABOUT,R0	; POINT TO OUTPUT BUFFER
	MOV	#RWDSTR,R1	; FORMAT STRING
	MOV	#RABWDS,R2	; ARGUMENT BLOCK
	CALL	$EDMSG
	MOV	R1,LEN		; TEMP FOR STORING LENGTH OF CURRENT STRING
	MOV	#RBYSTR,R1	; OUTPUT THE LOGICAL FLAGS
	MOV	#RABYTS,R2
	CALL	$EDMSG
	ADD	R1,LEN		; ADD THE LENGTH TO OVERALL RECORD LENGTH
				; NOW DO THE FILE SPECS
	MOV	#FABTI,R3	; MAKE SURE $EDMSG DIDNT DESTROY
	MOV	#RABTI,R4	; R3 & R4
	$STORE	#RABOUT,RBF,R4
	$STORE	LEN,RSZ,R4	; STORE # OF BYTES CONVERTED BU $EDMSG
	$PUT	R4,#ERRORR
	$DISCONNECT R4,#ERRORR		; DISCONNECT
	$CLOSE R3,#ERRORR	; CLOSE THE FILE
	$RETURN
ERRORR::	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
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