.TITLE CLUC18
.IDENT /V1.0/
.SBTTL COVERT A CLUNK VALUE TO AN 18 CHARACTER STRING

; THIS ROUTINE WILL CONVERT A CLUNK VALUE TO AND 18 CHARACTER ARRAY
; OF DIGITS BETWEEN ZERO AND NINE 
;
; LAST EDIT: 1-JUL-1988 11:43:57 
;
; AUTHOR:	PETER STADICK
;		CARGILL INC.
;		P.O. DRAWER AR
;		RESERVE,LA 70084
;
; EDIT HISTORY:	CREATED JUN-88 PJS
;
;
; CALL PARAMETER LIST
;	2(R5) = ADDRESS TO CLUNK VALUE		( INPUT PRESERVED )
;	4(R5) = ADDRESS TO ARRAY OF 18 DIGITS	( OUTPUT )
;
; THIS ROUTINE PERFORMS 18 DIVIDES TO COMPUTE THE DIGIT VALUE FOR
; EACH PLACE IN THE OUTPUT STRING.
;
; ALL REGISTERS ARE PRESERVED
;

.PSECT CLUNK,RO,LCL,REL
CLUC18::
	MOV R0, -(SP)		; PRESERVE REGISTERS
	MOV R1, -(SP)		
	MOV R2, -(SP)		
	MOV R3, -(SP)
	MOV R4, -(SP)
	MOV R5, -(SP)
;
; LOAD PLACE MULTIPLIES ONTO STACK
;
; 1
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00000,-(SP)	
	MOV #^D00001,-(SP)	;LSW 
;
; 10
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00000,-(SP)	
	MOV #^D00010,-(SP)	;LSW 
;
; 10^2 - 100
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00000,-(SP)	
	MOV #^D00100,-(SP)	;LSW 
;
; 10^3 - 1,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00000,-(SP)	
	MOV #^D01000,-(SP)	;LSW 
;
; 10^4 - 10,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00000,-(SP)	
	MOV #^D10000,-(SP)	;LSW 
;
; 10^5 - 100,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00001,-(SP)	
	MOV #^D34464,-(SP)	;LSW 
;
; 10^6 - 1,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00015,-(SP)	
	MOV #^D16960,-(SP)	;LSW 
;
; 10^7 - 10,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D00152,-(SP)	
	MOV #^D-27008,-(SP)	;LSW 
;
; 10^8 - 100,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D01525,-(SP)	
	MOV #^D-7936,-(SP)	;LSW 
;
; 10^9 - 1,000,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00000,-(SP)	
	MOV #^D15258,-(SP)	
	MOV #^D-13824,-(SP)	;LSW 
;
; 10^10 - 10,000,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00002,-(SP)	
	MOV #^D21515,-(SP)	
	MOV #^D-7168,-(SP)	;LSW 
;
; 10^11 - 100,000,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00023,-(SP)	
	MOV #^D18550,-(SP)	
	MOV #^D-6144,-(SP)	;LSW 
;
; 10^12 - 1,000,000,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D00232,-(SP)	
	MOV #^D-11099,-(SP)	
	MOV #^D04096,-(SP)	;LSW 
;
; 10^13 - 10,000,000,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D02328,-(SP)	
	MOV #^D20082,-(SP)	
	MOV #^D-24576,-(SP)	;LSW 
;
; 10^14 - 100,000,000,000,000
	MOV #^D00000,-(SP)	;MSW 
	MOV #^D23283,-(SP)	
	MOV #^D04218,-(SP)	
	MOV #^D16384,-(SP)	;LSW 
;
; 10^15 - 1,000,000,000,000,000
	MOV #^D00003,-(SP)	;MSW 
	MOV #^D-29314,-(SP)	
	MOV #^D-23354,-(SP)	
	MOV #^D-32768,-(SP)	;LSW 
;
; 10^16 - 10,000,000,000,000,000
	MOV #^D00035,-(SP)	;MSW 
	MOV #^D-30990,-(SP)	
	MOV #^D28609,-(SP)	
	MOV #^D00000,-(SP)	;LSW 
;
; 10^17 - 100,000,000,000,000,000
	MOV #^D00355,-(SP)	;MSW 
	MOV #^D17784,-(SP)	
	MOV #^D23946,-(SP)	
	MOV #^D00000,-(SP)	;LSW 

	MOV SP,R4		; SET R4 TO START OF PLACE MULIPLIERS

	MOV 2(R5),R0		; INPUT CLUNK
	MOV 4(R5),R1		; START OF OUTPUT ARRAY

	MOV R0,-(SP)		; DIVIDE PARAMETER BLOCK
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV SP,R5

DIVDND=18.
	MOV R0,-(SP)		; BUFFER FOR DIVIDENED OF DIVIDE
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)

QIOENT=10.
	MOV R0,-(SP)		; BUFFER FOR QUOTIENT
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)

REMAIN=2.
	MOV #0,-(SP)		; REMAINDER
	MOV #0,-(SP)
	MOV #0,-(SP)
	MOV #0,-(SP)

	MOV R0,-(SP)		; STATUS RETURN SPOT

	MOV #18.,R2		; NUMBER OF DIGITS TO PROCESS

	MOV  (R0),DIVDND(SP)	; MOVE CLUNK VALUE TO DIVIDEND
	MOV 2(R0),DIVDND+2(SP)
	MOV 4(R0),DIVDND+4(SP)
	MOV 6(R0),DIVDND+6(SP)

10$:	MOV SP,2(R5)		; DIVIDEND BUFFER ( CLUNK VALUE )
	ADD #DIVDND,2(R5)
	MOV R4,4(R5)		; DIVISOR BUFFER ( PLACE VALUE )
	MOV SP,6(R5)		; REMAINDER BUFFER
	ADD #REMAIN,6(R5)	
	MOV SP,10(R5)		; QUOTIENT BUFFER OR DIGIT VALUE
	ADD #QIOENT,10(R5)
	MOV SP,12(R5)		; STATUS OF DIVIDE

	JSR PC, DIV64

	ADD #060,@10(R5)	; CONVERT RESULT TO ASCII DIGIT
	MOVB @10(R5),(R1)	; MOVE DIGIT TO OUTPUT ARRAY

	INC R1			; POINT TO NEXT PLACE IN ARRAY
	
	MOV REMAIN(SP),  DIVDND(SP)	; MOVE REMAINDER TO DIVIDEND
	MOV REMAIN+2(SP),DIVDND+2(SP)
	MOV REMAIN+4(SP),DIVDND+4(SP)
	MOV REMAIN+6(SP),DIVDND+6(SP)

	ADD #8.,R4		; POINT TO NEXT PLACE MULTIPLIER
	SOB R2,10$		; LOOP UNTIL LAST DIGIT PROCESSED

	ADD #182.,SP		; ADJUST STACK BACK

	MOV (SP)+,R5		; RESTORE REGISTERS
	MOV (SP)+,R4
	MOV (SP)+,R3
	MOV (SP)+,R2		
	MOV (SP)+,R1		
	MOV (SP)+,R0		

	RTS PC

	.END