.TITLE	DSUSUB - DATA SET UTILITY PROGRAM SUBROUTINES
	.IDENT	/DSU.03/
;
;
; DSU.04	17-FEB-82 - SPLIT OUT SUBROUTINES
;
;
;
	.NLIST 	BEX,SEQ,SYM
	.DSABL	GBL
;
;	ENTRY POINTS IN THIS MODULE
;
	.GLOBL	O2A,OB2A,OO2AA,RADIX,QUERY,LKUP,MAPIT
	.GLOBL	OCTAL,ASCII,HEX,TOGGLE,OBYTE,EBCDIC
;
;	EXTERNAL ENTRY POINTS
;
	.GLOBL	VDTIN,CURSOR,ECHO,RDBLK,WIGGLE,WIG,GLE,EXIT
;
;	EXTERNAL DATA
;
	.GLOBL	DATA,INBUF,BLKHI,BLKLO,OLDBHI,OLDBLO
	.GLOBL	IDXHED,MFDHED,NMAPS,NEWDATA,DATPTR,SCREND
	.GLOBL	IO.WLB,BLKNO,AUBAS,VDTSTAT,BELL,TSWTCH,DSPMODE
	.GLOBL	BLKFLD,MODEFLD,LINE6,HOME,SCREEN,VBLKHI,VBLKLO,CSTAT
	.GLOBL	DIRECTION
;
;	MACROS
;
	.MCALL	DIR$,QIOW$C,QIOW$S,CSI$
;
;	DEFINITIONS
;
ESC=33
CSI$
;
;	****************************************************************
	.SBTTL	SUPPORT SUBROUTINES
;	****************************************************************
;
;
;
;	GET THE LOGICAL/VIRTUAL BLOCK NUMBER AND DISPLAY MODE OPTIONS.
;	ROUTINE INTERPRETS INPUT AND CONTROLS CURSOR MOVEMENT
;	WITHIN BLOCKNO AND DISPLAY MODE FIELDS. CNTRL/C EXITS
;
QUERY:	QIOW$S	#IO.WLB,#5,#4,,,,<#BLKFLD,#8.,0> ;PUT CURSOR INTO BLKNO FLD
	MOV	#9.,R4			;INIT CURSOR RECKONER
LOOP:  	CALL	VDTIN			;GET SOMETHING IN
	BCC	CONT
CONT:	CMPB	#3,INBUF		;THE GREAT ESCAPE?
	BNE	NOTXIT			;NO
	QIOW$C	IO.WLB,5,1,,,,<AUBAS,8.,0>	;ELSE BOTTOM OUT
	JMP	EXIT			;BYE-BYE!
NOTXIT:
1$:	CMPB	#ESC,INBUF		;HOUDINI SEQUENCE?
	BNE	2$			;NO
	CALL	CMOVE			;YES
	BCC	LOOP			;EVERYTHING'S COOL
	JMP	BADTYP			;ELSE, BARK
2$:	CMPB	#15,INBUF		;CR?
	BNE	5$			;NO
	CMP	BLKHI,OLDBHI		;RE-DISPLAY OF SAME BLOCK?
	BNE	3$			;NO, DISPLAY 1ST HALF OF NEW BLOCK
	CMP	BLKLO,OLDBLO		;DITTO
	BEQ	4$			;DOUBLE DITTO
3$:	TST	TSWTCH			;ARE WE IN SECOND HALF?
	BEQ	4$			;NO
	CALL	TOGGLE			;ELSE FLIP HALVES
4$:	RETURN
5$:	CMPB	#40,INBUF		;SPACE?
	BNE	6$			;NO, MUST BE A DIGIT
	CALL	TOGGLE			;FLIP DISPLAY
	RETURN
6$:	CMP	#10.,R4			;IN MODE FIELD?
	BNE	7$			;NO
	CALL	NEWMODE			;ELSE INTERPRET MODE CHANGE
	BCC	LOOP			;SUCCESS
	JMP	BADTYP			;OR FAILURE
7$:	CALL	DIGIT			;ONLY THING LEFT IS NUMERIC STUFF
	BCC	LOOP			;EITHER VALID
					;OR INVALID
BADTYP:	QIOW$S	#IO.WLB,#5,#1,,#VDTSTAT,,<#BELL,#1>	;SNEEZE
	BR	LOOP			;AND TRY AGAIN
;
;
;
;
;	DATA QUERY AND CURSOR MOVE SUPPORT SUBROUTINES
;
;
;
NEWMODE:				;GO THROUGH THE DISPLAY MODE ALPHABET
	CMPB	#'O,INBUF		;OCTAL WORD IS OKAY
	BEQ	1$
	CMPB	#'B,INBUF		;SO IS OCTAL BYTE
	BEQ	1$
	CMPB	#'A,INBUF		;SO IS ASCII
	BEQ	1$
	CMPB	#'H,INBUF		;SO IS HEX
	BEQ	1$
	CMPB	#'R,INBUF		;SO IS RAD50
	BEQ	1$
	CMPB	#'E,INBUF		;SO IS EBCDIC
	BNE	2$			;TOO BAD
1$:	CALL	GLE
	CALL	ECHO			;DISPLAY IT
	MOVB	INBUF,DSPMODE		;UPDATE MODE
	RETURN				;BACK FOR ANOTHER HELPING
2$:	SEC				;BAD NEWS
	RETURN
;
;
;	INTERPRET OCTAL DIGITS FOR BLOCK NO. SPECIFICATIONS
;
DIGIT:	CMPB	#'7,INBUF		;LEGAL OCTAL DIGIT?
	BLO	9$			;NO WAY
	CMPB	#'0,INBUF		;LOOKS GOOD SO FAR
	BHI	9$			;IT JUST STOPPED LOKING GOOD
					;NOW IN POSITIONAL CONTEXT
	TST	R4			;NO HIGHER THAN 3 IN FIRST POSITION
	BNE	1$			;NOT IN FIRST POSITION
	CMPB	#'3,INBUF
	BLO	9$
1$:	CMP	#4,R4			;ONLY 0 OR 1 IN FOURTH DIGIT
	BNE	2$			;ELSE, ANYTHING GOES!
	CMPB	#'1,INBUF
	BLO	9$			;OUT OF RANGE AND REASON!
2$:	CALL	WIGGLE
	CALL	ECHO			;SEND IT BACK
					;NOW WE HAVE TO UPDATE THE
					;HIGH AND LOW BLOCK COUNTS
					;FOR NEXT BLOCK READ
	MOVB	INBUF,R1		;GET THE SUCKER
	BIC	#60,R1			;MAKE DIGIT IT BINARY
	MOV	#BLKHI,R0		;POINT TO DESTINATION
	BITB	#CS.NMF!CS.DIF,CSTAT	;ARE WE LOGICAL OR VIRTUAL?
	BEQ	3$			;LOGICAL
	MOV	#VBLKHI,R0		;ELSE, UPDATE VBN, NOT LBN
3$:
	CMP	#2,R4			;ARE WE ON HI-ORDER BYTE?
	BHIS	4$			;YES
	ADD	#2,R0			;ELSE POINT TO HI-ORDER
4$:	MOV	R4,R3			;USE POSITION COUNTER
	ADD	#SHFTBL,R3		;AS BYTE POINTER INTO SHIFT TABLE
	MOVB	@R3,R3			;GET SHIFT COUNT
	MOV	#7,R2			;SET UP A MASK
	TST	R3			;THROUGH SHIFTING?
	BEQ	6$			;YES
5$:	ASL	R1			;ELSE SHIFT THE BINARY DIGIT
	CLC				;DON'T GENERATE CARRY BUGS
	ASL	R2			;AND THE MASK
	DEC	R3			;DECREMENT THE COUNT
	BNE	5$			;AND CONTINUE LOOP
6$:	BIC	R2,@R0			;STRIP ANY DIGIT THAT'S THERE
	BIS	R1,@R0			;AND SET THE NEW ONE
	CMP	#9.,R4			;ANY ROOM TO STEP RIGHT?
	BNE	7$			;YES
	INC	R4			;ELSE IT'S ALREADY OFF
	JMP	SLEFT			;SO BRING IT BACK
7$:	INC	R4			;FINALLY, COUNT THE POSITION
	CMP	R4,#3			;DON'T LEAVE CURSOR SITTING ON COMMA!
	BNE	8$			;IT'S NOT
	JMP	SRIGHT
8$:	CLC
	RETURN
9$:	SEC				;YOU LOSE
	RETURN
;
;
;
;	INTERPRET CURSOR MOVEMENTS
;
CMOVE:	CALL	VDTIN			;GET THE NEXT CHARACTER
	CMPB	INBUF,#'[		;NEXT THING A [?
	BNE	RETC			;DON'T KNOW WHAT ANYTHING ELSE MEANS
	CALL	VDTIN			;OK, MOVE CURSOR WHICH WAY?
	CMPB	#'A,INBUF		;UP?
	BNE	2$			;NOPE
	MOV	#BLKLO,R3		;MOVE AHEAD
	BITB	#CS.NMF!CS.DIF,CSTAT	;LOGICAL OR VIRTUAL?
	BEQ	1$			;LOGICAL
	MOV	#VBLKLO,R3		;VIRTUAL
1$:	INC	@R3			;MOVE AHEAD
	BNE	6$			;DIDN'T WRAP TO ZERO
	INCB	-2(R3)			;ELSE, UP THE ANTE ON HI-ORDER
	BR	6$	
2$:	CMPB	#'B,INBUF		;DOWN?
	BEQ	3$			;UH-HUH
	JMP	TRYRT			;UH-UH
3$:	MOV	#BLKLO,R3		;POINT TO LO-ORDER
	BITB	#CS.NMF!CS.DIF,CSTAT	;LOGICAL OR VIRTUAL?
	BEQ	4$			;LOGICAL
	MOV	#VBLKLO,R3		;VIRTUAL
4$:	TST	@R3			;STEP BACK, BUT NOT PAST ZERO
	BNE	5$
	TSTB	-2(R3)			;IF ZERO HERE IT'S THE END OF THE LINE
	BEQ	RETC
	DECB	-2(R3)			;ELSE, COME DOWN A PEG
5$:	DEC	@R3			;TAKE ONE BABY STEP BACK
6$:	INC	TSWTCH			;ALWAYS SHOW FIRST HALF OF BLOCK
	CALL	TOGGLE
	MOV	#BLKNO+4,R1		;PUT VBN/LBN INTO BLKNO ON SCREEN
	MOV	@R3,R0
	CALL	O2A			;LO LBN
	MOV	#BLKNO,R1
	MOV	-2(R3),R0
	CALL	OB2A			;AND HI LBN
	QIOW$C	IO.WLB,5,1,,VDTSTAT,,<HOME,3,0>	;HOME CURSOR
	QIOW$C	IO.WLB,5,1,,VDTSTAT,,<SCREEN,80.,0>	;RE-DISPLAY 1ST LINE
	MOVB	#15,INBUF		;NOW ACT LIKE YOU GOT A CARRIAGE RETURN
	MOV	#NOTXIT,(SP)		;FAKE RETURN ADDRESS
RETC:	SEC				;NOTXIT WON'T CARE ABOUT THE CARRY BIT
	RETURN
;
;	
TRYRT:	CMPB	#'C,INBUF		;RIGHT?
	BEQ 	SRIGHT			;YES
					;NO, ONLY ONE OTHER CHOICE
	CMPB	#'D,INBUF		;LEFT?
	BEQ	SLEFT			;YEP!
BOMB:	SEC				;AS THE NAME IMPLIES
	RETURN
SRIGHT:	CMP	#9.,R4			;ARE WE ALL THE WAY OVER?
	BLO	BOMB			;YES, COMPLAIN!
	BEQ	SETMODE			;YES, SET MODE
	MOVB	#'C,DIRECTION		;SET UP STEPPING DIRECTION
	CALL	CURSOR			;STEP TO NEXT DIGIT POSITION
	INC	R4			;AND COUNT IT
	CMP	#3,R4			;SITTING ON THE COMMA?
	BNE	1$			;NO
	CALL	CURSOR			;STEP CURSOR OVER COMMA
	INC	R4			;COUNT THAT STEP
1$:	CLC
	RETURN
SLEFT:	TST	R4			;ARE WE ALL THE WAY LEFT?
	BEQ	BOMB			;YES, COMPLAIN!
	CMP	#10.,R4			;STEPPING BACK FROM MODE FIELD?
	BNE	1$			;NO
	MOV	#QUERY,(SP)		;PUT CURSOR BACK TO LAST DIGIT
	CLC				;DON'T RETURN FALSE ERROR
	RETURN
1$:	MOVB	#'D,DIRECTION		;SET UP STEPPING DIRECTION
	CALL	CURSOR			;STEP TO PREVIOUS DIGIT POSITION
	DEC	R4			;AND COUNT IT
	CMP	#3,R4			;SITTING ON THE COMMA?
	BNE	2$			;NO
	CALL	CURSOR			;STEP CURSOR OVER COMMA
	DEC	R4			;COUNT THAT STEP, TOO
2$:	CLC
	RETURN
SETMODE:
	QIOW$S	#IO.WLB,#5,#4,,,,<#MODEFLD,#8.,0> ;PUT CURSOR INTO MODE FLD
	MOV	#10.,R4
	RETURN
SHFTBL:	.BYTE	6,3,0,16.,15.,12.,9.,6,3,0
;
;
;
;	TOGGLE SCREEN HALVES BY ADJUSTING POINTER INTO DATA BUFFER
;	AND FLIPPING ROW ADDRESSES BETWEEN 000-300 AND 400-700
;
TOGGLE:	MOV	#LINE6,R1		;POINT TO 1ST ROW ADDRESS
	MOV	#16.,R0			;GOTTA CHANGE 16. OF THE MOTHERS
	TST	TSWTCH			;CHECK SWITCH STATE
	BEQ	2$			;IT'S OFF
	CLR	TSWTCH			;ELSE TURN IT OFF
1$:	BICB	#4,@R1			;TURN OFF THE OFFSET BIT, TOO
	ADD	#80.,R1
	SOB	R0,1$			;FOR ALL ROWS
	MOV	#DATA,DATPTR		;AND START FROM THE TOP
	BR	3$
2$:	BISB	#4,@R1			;TURN ON THE OFFSET BIT
	ADD	#80.,R1
	SOB	R0,2$			;FOR ALL ROWS
	INC	TSWTCH			;TURN SWITCH ON
	ADD	#256.,DATPTR		;SHOW SECOND HALF
3$:	RETURN
;
;
;
	.PAGE
;	****************************************************************
;	.SBTTL	DISPLAY FORMAT ROUTINES
;	****************************************************************
;
OCTAL:	MOV	DATPTR,R4		;GET STUFF FROM HERE
	MOV	#NEWDATA+7,R1		;START PLUGGING IT IN HERE
1$:	MOV	#8.,R3			;MIGHT AS WELL DO IT IN A LOOP
2$:	MOV	(R4)+,R0		;PICK UP NEXT DATUM (HOW PRETENTIOUS!)
	CALL	O2A			;CHEW IT UP AND SPIT IT OUT
	MOVB	#40,(R1)+		;MOVE TO NEXT POSITION
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	DEC	R3			;THROUGH WITH THIS ITERATION?
	BNE	2$			;NO, KEEP SLOGGING THROUGH THE MIRE
	MOVB	#33,-1(R1)		;END LINE WITH A NEL
	MOVB	#'E,(R1)+
	CMP	R1,#SCREND		;OFF THE PIER?
	BHIS	3$			;YES, FALL OFF
	ADD	#7,R1			;ELSE MOVE TO NEXT PLANK
	BR	1$			;AND KEEP WALKING
3$:	RETURN
;
;
;	OCTAL BYTE DISPLAY
;
OBYTE:	MOV	DATPTR,R4		;GET STUFF FROM HERE
	MOV	#NEWDATA+7,R1		;START PLUGGING IT IN HERE
1$:	MOV	#8.,R3			;MIGHT AS WELL DO IT IN A LOOP
2$:	MOVB	(R4)+,R0		;PICK UP NEXT BYTE
	CALL	OB2A			;DECODE IT
	MOVB	#40,(R1)+		;LEAVE A SPACE
	MOVB	(R4)+,R0		;PICK UP NEXT BYTE
	CALL	OB2A			;DECODE IT
	MOVB	#40,(R1)+		;LEAVE A SPACE
	MOVB	#40,(R1)+		;LEAVE A SPACE
	DEC	R3			;THROUGH WITH THIS ITERATION?
	BNE	2$			;NO, KEEP SLOGGING THROUGH THE MIRE
	MOVB	#33,-1(R1)		;END LINE WITH A NEL
	MOVB	#'E,(R1)+
	CMP	R1,#SCREND		;OFF THE PIER?
	BHIS	3$			;YES, FALL OFF
	ADD	#7,R1			;ELSE MOVE TO NEXT PLANK
	BR	1$			;AND KEEP WALKING
3$:	RETURN
;
;
;	ASCII
;
ASCII:	MOV	DATPTR,R4		;GET STUFF FROM HERE
	MOV	#NEWDATA+7,R1		;START PLUGGING IT IN HERE
1$:	MOVB	#40,(R1)+		;INSERT SPACE
	MOV	#8.,R3			;MIGHT AS WELL DO IT IN A LOOP
2$:	MOVB	#40,(R1)+		;A SPACE
	MOVB	(R4)+,R0		;PICK UP NEXT BYTE
	BIC	#177400,R0		;CLEAR UPPER BYTE
	MOVB	ASCTBL(R0),(R1)+	;PICK UP ASCII TRANSLATION
	MOVB	(R4)+,R0		;PICK UP NEXT BYTE
	BIC	#177400,R0		;CLEAR UPPER BYTE
	MOVB	ASCTBL(R0),(R1)+	;PICK UP ASCII TRANSLATION
	MOVB	#40,(R1)+		;INSERT SPACE
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	DEC	R3			;THROUGH WITH THIS ITERATION?
	BNE	2$			;NO, KEEP SLOGGING THROUGH THE MIRE
	MOV	#105*400!33,-2(R1)	;END LINE WITH A NEL
	CMP	R1,#SCREND		;HAD ENOUGH?
	BHIS	3$			;YES, THANKS
	ADD	#7,R1			;ELSE STEP OVER ROW ADDRESS
	BR	1$			;AND GO BACK FOR MORE
3$:	RETURN
;
ASCTBL:	.ASCII	/                                /	;000 - 037
	.BYTE	40,41,42,43,44,45,46,47
	.BYTE	50,51,52,53,54,55,56,57
	.BYTE	60,61,62,63,64,65,66,67
	.BYTE	70,71,72,73,74,75,76,77
	.BYTE	100,101,102,103,104,105,106,107
	.BYTE	110,111,112,113,114,115,116,117
	.BYTE	120,121,122,123,124,125,126,127
	.BYTE	130,131,132,133,134,135,136,137
	.BYTE	140,141,142,143,144,145,146,147
	.BYTE	150,151,152,153,154,155,156,157
	.BYTE	160,161,162,163,164,165,166,167
	.BYTE	170,171,172,173,174,175,176,177
	.ASCII	/                                /	;200 - 237
	.ASCII	/                                /	;240 - 277
	.ASCII	/                                /	;300 - 337
	.ASCII	/                                /	;340 - 377

;
;
HEX:	MOV	DATPTR,R4		;GET STUFF FROM HERE
	MOV	#NEWDATA+7,R1		;START PLUGGING IT IN HERE
1$:	MOV	#8.,R3			;MIGHT AS WELL DO IT IN A LOOP
	MOVB	#40,(R1)+		;OVERWRITE ANY LEFT-OVER TRASH
2$:	MOVB	1(R4),R0		;PICK UP NEXT HIGH BYTE
	BIC	#177400,R0		;CLEAR UPPER BYTE
	ASL	R0			;MAKE INTO WORD OFFSET
	MOVB	HEXTBL(R0),(R1)+	;PICK UP HEX TRANSLATIONS
	MOVB	HEXTBL+1(R0),(R1)+
	MOV	(R4)+,R0		;GET FULL WORD
	BIC	#177400,R0		;ISOLATE LOW BYTE
	ASL	R0			;MAKE INTO WORD OFFSET
	MOVB	HEXTBL(R0),(R1)+	;PICK UP HEX TRANSLATIONS
	MOVB	HEXTBL+1(R0),(R1)+
	MOVB 	#40,(R1)+		;INSERT  SPACE
	MOVB 	#40,(R1)+
	MOVB 	#40,(R1)+
	MOVB 	#40,(R1)+
	MOVB 	#40,(R1)+
	DEC	R3			;THROUGH WITH THIS ITERATION?
	BNE	2$			;NO, KEEP SLOGGING THROUGH THE MIRE
	MOV	#105*400!33,-2(R1)	;END LINE WITH A NEL
	CMP	R1,#SCREND		;FINISHED?
	BHIS	3$			;YES, GO IN PEACE
	ADD	#7,R1			;ELSE, FORWARD MARCH
	BR	1$
3$:	RETURN
;
HEXTBL:	.ASCII	/000102030405060708090A0B0C0D0E0F/	;00 - 0F
	.ASCII	/101112131415161718191A1B1C1D1E1F/	;10 - 1F
	.ASCII	/202122232425262728292A2B2C2D2E2F/	;20 - 2F
	.ASCII	/303132333435363738393A3B3C3D3E3F/	;30 - 3F
	.ASCII	/404142434445464748494A4B4C4D4E4F/	;40 - 4F
	.ASCII	/505152535455565758595A5B5C5D5E5F/	;50 - 5F
	.ASCII	/606162636465666768696A6B6C6D6E6F/	;60 - 6F
	.ASCII	/707172737475767778797A7B7C7D7E7F/	;70 - 7F
	.ASCII	/808182838485868788898A8B8C8D8E8F/	;80 - 8F
	.ASCII	/909192939495969798999A9B9C9D9E9F/	;90 - 9F
	.ASCII	/A0A1A2A3A4A5A6A7A8A9AAABACADAEAF/	;A0 - AF
	.ASCII	/B0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF/	;B0 - BF
	.ASCII	/C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF/	;C0 - CF
	.ASCII	/D0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF/	;D0 - DF
	.ASCII	/E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF/	;E0 - EF
	.ASCII	/F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF/	;F0 - FF

;
;
;	RAD50 CONVERSION ROUTINE
;
RADIX:	MOV	DATPTR,R0		;PICK UP DATA POINTER
	MOV	#NEWDATA+7,R1		;START PLUGGING IT IN HERE
1$:	MOV	#8.,R5			;MIGHT AS WELL DO IT IN A LOOP
	MOVB	#40,(R1)+		;OVERWRITE ANY LEFT-OVER TRASH
2$:	MOV 	(R0)+,R4		;PICK UP NEXT WORD
	MOV	#3100,R3		;STRIP IT FROM THE TOP END
	CALL	R5STRP
	MOVB	RADTBL(R2),(R1)+	;GET THE CHARACTER
	MOV	#50,R3			;STRIP IT FROM THE TOP END
	CALL	R5STRP
	MOVB	RADTBL(R2),(R1)+	;GET THE NEXT CHARACTER
	MOVB	RADTBL(R4),(R1)+	;GET THE FINAL CHARACTER
	MOVB 	#40,(R1)+		;INSERT  SPACE
	MOVB 	#40,(R1)+
	MOVB 	#40,(R1)+
	MOVB 	#40,(R1)+
	MOVB 	#40,(R1)+
	MOVB 	#40,(R1)+
	DEC	R5			;THROUGH WITH THIS ITERATION?
	BNE	2$			;NO, KEEP SLOGGING THROUGH THE MIRE
	MOV	#105*400!33,-2(R1)	;END LINE WITH A NEL
	CMP	R1,#SCREND		;FINISHED?
	BHIS	3$			;YES, GO IN PEACE
	ADD	#7,R1			;ELSE, FORWARD MARCH
	BR	1$
3$:	RETURN

	RETURN
;
R5STRP:					;STRIP OFF RAD50 CHARACTER
					;RELATIVE VALUE BASED ON
					;ON PLACE VALUE IN R3. RAD50
					;VALUE IS IN R4. RETURN IN R2
	MOV	#1,R2			;KEEP A TALLY
1$:	SUB	R3,R4			;TAKE IT AWAY
	BCS	2$			;BUT DON'T GO OVERBOARD
	INC	R2			;COUNT IT
	BR	1$			;AND DO IT AGAIN
2$:	DEC	R2			;ADJUST DOWN
	ADD	R3,R4			;RESTORE REMAINDER TO HEALTH
	RETURN				;BEFORE RETURNING
;
RADTBL:	.ASCII	/ ABCDEFGHIJKLMNOPQRSTUVWXYZ$.?/
	.ASCII	/0123456789/
	.EVEN
;
	.PAGE
;	****************************************************************
	.SBTTL	DATA CONVERSION ROUTINES
;	****************************************************************
;
;	OCTAL-TO-ASCII CONVERSIONS
;	INPUT IN R0, DESTINATION @R1, R2 IS WORK REGISTER
;
;
;	DECODE OCTAL FULLWORD
;
O2A:	MOV	#100111,R2		;SET UP MASK
	MOV	R0,-(SP)		;SAVE ORIGINAL ARGUMENT
	BIC	#377,R0			;ISOLATE HIGH BYTE
1$:	CLRB	@R1			;PRECLEAR DESTINATION BYTE
2$:	BIT	R2,R0			;IS NEXT LOWER PLACE BIT SET?
	BEQ	3$			;N0
	BISB	R2,@R1			;ELSE SET CORESPONDING BIT
	BICB	#370,@R1		;ONLY LOW-ORDER THREE
3$:	ASR	R2			;MOVE TO NEXT LOWEST BIT
	BCC	2$			;NO CARRY, SO CARRY ON!
					;A CARRY OUT MEANS END OF OCTAL PLACE
	BIC	#100000,R2		;DON'T PROPAGATE SIGN GARBAGE!
	BISB	#60,(R1)+		;SO MAKE IT ASCII AND MOVE OVER ONE
	TSTB	R2			;END OF UPPER-7 BITS?
	BNE	1$			;NOT YET
	MOV	@SP,R0			;GET BACK ORIGINAL ARGUMENT
	BIC	#177400,R0		;ISOLATE LOW BYTE
	CALL	OB2A			;AND DO LOW BYTE
					;DO BIT 8 BEFORE GOING HOME
	BIT	#400,(SP)+		;IS IT SET IN ORIGINAL ARGUMENT?
	BEQ	4$			;NO, SO DON'T WORRY ABOUT IT
	BISB	#4,-3(R1)		;ELSE SET IT IN OCTAL DIGIT
4$:	RETURN				;DONE!
;
;
;	DECODE OCTAL BYTE
;
OB2A:	MOV	#100222,R2		;SET UP MASK
	SWAB	R0			;FLIP BYTES
	BIC	#377,R0			;ISOLATE HIGH BYTE
1$:	CLRB	@R1			;PRECLEAR DESTINATION BYTE
2$: 	BIT	R2,R0			;IS NEXT LOWER PLACE BIT SET?
	BEQ	3$			;N0
	BISB	R2,@R1			;ELSE SET CORESPONDING BIT
	BICB	#370,@R1		;ONLY LOW-ORDER THREE
3$:	ASR	R2			;MOVE TO NEXT LOWEST BIT
	BIC	#100000,R2		;DON'T SHIFT SIGN GARBAGE DOWN
	BCC	2$			;NO CARRY, SO CARRY ON!
					;A CARRY OUT MEANS END OF OCTAL PLACE
	BISB	#60,(R1)+		;SO MAKE IT ASCII AND MOVE OVER ONE
	BITB	#177,R2			;END OF THE BYTE
	BNE	1$			;NOT YET
	RETURN				;ELSE, RETURN
;
;	DECODE A 2-DIGIT OCTAL UNIT NO.
;	OUTPUT AS  'NN:' WITH LEADING ZERO TRUNCATED
;
OO2AA:	CLR	R2			;COUNT EIGHTS HERE
1$:	CMP	#7,R0			;UNIT > 7?
	BHIS	2$			;NO
	SUB	#10,R0			;ADJUST DOWN
	INC	R2			;COUNT EIGHTS
	BR	1$			;ETC...
2$:	TST	R2			;ANYTHING OUT FRONT?
	BEQ	3$			;NO, SUPPRESS THE ZERO
	BIS	#60,R2			;ELSE, MAKE LEADING DIGIT ASCII
	MOVB	R2,(R1)+		;PLUG IN LEADING DIGIT
3$:	BIS	#60,R0			;MAKE BINARY ASCII
	MOVB	R0,(R1)+		;PLUG IN DIGIT
	MOVB	#':,(R1)+		;AND THE COLON
	RETURN
;
;
;
;	SET LOGICAL BLOCK NO FOR GIVEN VIRTUAL BLOCK NO
;	ENTER WITH FILE HEADER IN IDXHED AND VIRTUAL BLOCK NO 
;	IN VBLKLO. RETURNS LBN IN BLKHI/BLKLO OR CARRY SET
;	IF VBN IS OUT OF RANGE. USE VBN AS FILE NUMBER AND DO
;	A LKUP SINCE FILE HEADER IS ALREADY IN IDXHED
;
MAPIT:	CLR	NMAPS			;FIRST CLEAR NMAPS SO LKUP DOESN'T
					;USE IT AS AN OFFSET
	MOV	VBLKLO,R0		;USE VBN AS FILE NUMBER
	DEC	R0			;THE FIRST ONE IS ZERO
	DEC	R0			;AND KICK DOWN SINCE LKUP'S
					;GONNA KICK IT UP
;
;	LOOKUP FILE IN INDEX FILE.
;	ENTER WITH FILE SEQUENCE NUMBER IN R0. RETURN LBN OF FILE HEADER
;	IN BLKHI/BLKLO
;	USING SEQ. NO., FIND FIRST CONTIG. AREA THAT CONTAINS HEADER THEN
;	OFFSET INTO THAT GROUP TO THE ACTUAL HEADER
;
LKUP:	MOV	IDXHED,R5		;GET OFFSET TO MAP AREA
	CLRB	R5			;IT'S IN UPPER BYTE
	SWAB	R5
	ASL	R5			;AND IT'S WORD OFFSET
	ADD	#IDXHED+10,R5		;ADD BASE ADDRESS + OFFSET
	MOV	(R5)+,R3		;GET COUNT OF MAP ENTRIES
	BIC	#177400,R3		;BYTE ONLY
	ASR	R3			;ADJUST INTO COUNT OF 2-BYTE BLOCK
	ADD	NMAPS,R0		;ADD INDEX BIT MAP COUNT TO SEQ. NO.
	INC	R0			;ADD 1 SINCE THE BIT MAPS OCCUPY THE
					;FIRST NMAPS-1 HEADER BLOCKS AND THE
					;BOOT BLOCK AND HOME BLOCK HAVE TO BE
					;TAKEN INTO ACCOUNT
1$:	MOVB	1(R5),R4		;GET CONTIG BLOCK COUNT OF NEXT MAP
	BIC	#177400,R4		;CLEAR UPPER BYTE
	INC	R4			;ADJUST TO REAL COUNT
	SUB	R4,R0			;SUBTRACT THAT MANY BLOCKS FROM SEQ. #
	BMI	3$			;UNDEFLOW MEANS YOU'RE IN THE BALL PARK
	ADD	#4,R5			;ELSE, BUMP TO NEXT RETRIEVAL POINTER
	DEC	R3			;ARE THERE ANY MORE?
	BNE	1$			;DEFINITELY!
					;'FRAID NOT
2$:	SEC				;FILE SEQUENCE OUT OF BOUNDS
	RETURN
3$:	ADD	R4,R0			;RESTORE REMAINDER OF SEQ. NO.
	MOV	(R5)+,BLKHI		;PICK UP LBN OF BASE OF CONTIG BLOCKS
	CLRB	BLKHI+1			;HI PART IS ONLY 1 BYTE
	MOV	(R5)+,BLKLO
	ADD	R0,BLKLO		;AND DOUBLE-PRECISION ADD REMAINDER
	ADC	BLKHI			;OF SEQUENCE NUMBER
	RETURN				;WELL DONE, LADS!
;
;
;	EBCDIC
;
EBCDIC:	MOV	DATPTR,R4		;GET STUFF FROM HERE
	MOV	#NEWDATA+7,R1		;START PLUGGING IT IN HERE
1$:	MOVB	#40,(R1)+		;INSERT SPACE
	MOV	#8.,R3			;MIGHT AS WELL DO IT IN A LOOP
2$:	MOVB	#40,(R1)+		;A SPACE
	MOVB	(R4)+,R0		;PICK UP NEXT BYTE
	BIC	#177400,R0		;CLEAR UPPER BYTE
	MOVB	EBCTBL(R0),(R1)+	;PICK UP ASCII TRANSLATION
	MOVB	(R4)+,R0		;PICK UP NEXT BYTE
	BIC	#177400,R0		;CLEAR UPPER BYTE
	MOVB	EBCTBL(R0),(R1)+	;PICK UP ASCII TRANSLATION
	MOVB	#40,(R1)+		;INSERT SPACE
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	MOVB	#40,(R1)+
	DEC	R3			;THROUGH WITH THIS ITERATION?
	BNE	2$			;NO, KEEP SLOGGING THROUGH THE MIRE
	MOV	#105*400!33,-2(R1)	;END LINE WITH A NEL
	CMP	R1,#SCREND		;HAD ENOUGH?
	BHIS	3$			;YES, THANKS
	ADD	#7,R1			;ELSE STEP OVER ROW ADDRESS
	BR	1$			;AND GO BACK FOR MORE
3$:	RETURN
;
EBCTBL:	.ASCII	/                                /	;00-1F (00-37)
	.ASCII	/                                / 	;20-3F (40-77)
	.ASCII	/           .<(+ &         !$*); /	;40-5F (100-137)
	.ASCII	*-/         ,% >?          :#@'="*	;60-7F (140-177)
	.BYTE	40,141,142,143,144,145,146,147,150,151	;80-89 (200-211)
	.ASCII	/      /				;8A-8F (212-217)
	.BYTE	40,152,153,154,155,156,157,160,161,162	;90-99 (220-231)
	.ASCII	/      /				;9A-9F (232-237)
	.BYTE	40,40,163,164,165,166,167,170,171,172	;A0-A9 (240-251)
	.ASCII	/      /				;AA-AF (252-257)
	.ASCII	/                {ABCDEFGHI      /	;B0-CF (260-317)
	.ASCII	/}JKLMNOPQR        STUVWXYZ      /	;D0-EF (320-357)
	.ASCII	/0123456789      /			;FO-FF (360-377)
;
;
;
	.END