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

; THIE ROUTINE WILL CONVERT AN 18 CHARACTER ARRAY OF DIGITS BETWEEN
; ZERO AND NINE TO A 64 BIT CLUNK VALUE.
;
; LAST EDIT: 1-JUL-1988 10:48:58 
;
; 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 ARRAY OF 18 DIGITS	( INPUT PRESERVED )
;	4(R5) = ADDRESS TO CLUNK VALUE		( OUTPUT )
;
; THIS ROUTINE STEPS THRU THE LIST OF DIGITS AND THEN MULTIPLIES BY
; THE APPROPRIATE PLACE MULTIPLIER. THE ROUTINE DOES NO ERROR CHECKING
; TO SEE IF THE ARRAY CONTAINS ONLY DIGITS. IF THE ARRAY CONTAINS ANYTHING
; OTHER THEN THE DIGITS 0 THRU 9 UNEXPECTED CLUNK VALUES WILL RESULT.
; REMEMBER THAT CLUNKS ARE UNSIGNED 64 BIT INTEGERS.
;
; AN EXAMPLE OF ANY INPUT VALUE '000000001234567890'.
;
; ALL REGISTERS ARE PRESERVED
;

.PSECT CLUNK,RO,LCL,REL
C18CLU::
	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		; START OF INPUT ARRAY
	MOV 4(R5),R1		; OUTPUT CLUNK

	MOV R0,-(SP)		; MULTIPLY AND ADD PARAMETER BLOCK
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV SP,R5

ADDBUF=18.
	MOV R0,-(SP)		; BUFFER FOR ACCUMULATING CLUNK VALUE
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)

PRODUT=10.
	MOV R0,-(SP)		; BUFFER FOR PLACE CLUNK VALUE
	MOV R0,-(SP)
	MOV R0,-(SP)
	MOV R0,-(SP)

DIGIT=2.
	MOV #0,-(SP)		; CREATE DIGIT MULTIPLY BUFFER ON STACK
	MOV #0,-(SP)
	MOV #0,-(SP)
	MOV #0,-(SP)

	MOV R0,-(SP)		; STATUS RETURN SPOT

	MOV #0, (R1)		; ZERO OUT CLUNK
	MOV #0,2(R1)
	MOV #0,4(R1)
	MOV #0,6(R1)		

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

10$:	MOVB (R0),R3		; GET FIRST DIGIT OF ARRAY
	SUB #060,R3		; CONVERT TO INTEGER
	BEQ 20$			; OPTIMIZE - BRANCH IF DIGIT ZERO
	MOV R3,DIGIT(SP)	; MOVE INTEGER TO MULTIPLY BUFFER

	MOV SP,2(R5)		; FIRST MULIPLY VALUE POINTS TO MULBUF
	ADD #DIGIT,2(R5)	
	MOV R4,4(R5)		; SECOND VALUE POINTS TO PLACE MULTIPLYER
	MOV SP,6(R5)		; THIRD VALUE POINTS TO PRODUCT RESULT	
	ADD #PRODUT,6(R5)
	MOV SP,10(R5)		; POINTS TO RETURN STATUS

	JSR PC, MUL64

	MOV SP,2(R5)		; PRODUCT OF PLACE MULIPLY
	ADD #PRODUT,2(R5)
	MOV SP,4(R5)		; SUM FROM PREVIOUS PLACES
	ADD #ADDBUF,4(R5)
	MOV  (R1),ADDBUF(SP)	; MOVE LAST RESULT TO INPUT BUFFER
	MOV 2(R1),ADDBUF+2(SP)
	MOV 4(R1),ADDBUF+4(SP)
	MOV 6(R1),ADDBUF+6(SP)
	MOV R1,6(R5)		; RESULT REGISTER

	JSR PC, ADD64

20$:	INC R0			; POINT TO NEXT DIGIT IN ARRAY
	ADD #8.,R4		; POINT TO NEXT PLACE MULTIPLIER
	SOB R2,10$		; LOOP UNTIL LAST DIGIT PROCESSED

	ADD #180.,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