{125} Binary to Decimal Conversion using the Double Dabble Method in 68 bytes of 8085 Assembly

Описание: Binary to Decimal in Assembly Language using the Double Dabble Method. This code is in 8080 8085 assembly language, but is applicable to any processor.

;================================================================================
;********************* BINARY TO BCD CONVERSION *************************
; NAME: BIN2BCD (v1.0)
; FUNCTION: CONVERTS BINARY VALUE TO BCD USING DOUBLE-DABBLE METHOD
; INPUTS: 16 BIT BINARY VALUE IN HL
; OUTPUTS: 5 CHARACTER BCD VALUE ACROSS C,D,E REGISTERS
; USER IO:
; DESTROYS:A,B,C,D,E,F/F'S
; CALLS:
; DESCRIPTION: USING THE DOUBLE DABBLE METHOD, CONVERTS BINARY VALUE TO BCD
; LEAVING RESULT IN REGISTERS C,D,E WITH C BEING THE MOST SIGNIFICANT NIBBLE
; SHOULD RETURN WITH HL ROTATED THROUGH UNTIL IT IS RESTORED TO ORIGINAL INPUT
; NOTE: UTILITY DOES NOT REQUIRE DAA INSTRUCTION
;================================================================================

BIN2BCD:
MVI B,16D ;SET UP BIT COUNTER
XRA A ;CLEAR ACCUMULATOR AND OUTPUT REGISTERS
MOV C,A ;CLEAR OUTPUT REGISTERS. C IS MSNIBBLE, E IS LSNIBBLE
MOV D,A
MOV E,A
B2BCD_LOOP: ;MAIN LOOP TO PROCESS EACH INPUT BIT

MOV A,E ;GET LOWEST BYTE
CALL DABBLE ;DABBLE IF NECESSARY
MOV E,A ; RESTORE TO REGISTER
MOV A,D ;GET LOWEST BYTE
CALL DABBLE ;DABBLE IF NECESSARY
MOV D,A ; RESTORE TO REGISTER
MOV A,C ;GET LOWEST BYTE
CALL DABBLE ;DABBLE IF NECESSARY
MOV C,A ; RESTORE TO REGISTER

SHIFT: ;ALL DABBLED, NOW DOUBLE BY LEFT SHIFT OF C,D,E,H,L
MOV A,H ;PRESERVE INPUT VALUE BY FULL ROTATE OF HL. GET BIT 15 FIRST
RAL ;SAVE BIT 15 IN CARRY BUT DO NOT SAVE ROTATED BYTE
MOV A,L ;GET LOW BYTE OF INPUT
RAL ;ROTATE MSBIT (BIT 7) INTO CARRY (AND BIT 15 INTO BIT 0)
MOV L,A ;SAVE SHIFTED LOW BYTE
MOV A,H ;GET HIGH BYTE
RAL ;BIT 15 into CARRY, BIT 7 into BIT 8
MOV H,A ;AND SAVE HIGH BYTE. ROTATION OF INPUT IS DONE, WORKING BIT IN CARRY
MOV A,E ;CONTINUE SHIFTING INTO OUTPUT REGISTERS, LOWEST OUTPUT BYTE INTO ACC
RAL ;SHIFT LEFT SO INPUT BIT 15 IN LSBIT OF OUTPUT
MOV E,A ;AND SAVE LEAVING BIT 7 IN CARRY
MOV A,D ;GET MIDDLE OUTPUT REGISTER
RAL ;SHIFT BIT 7 INTO BIT 8, BIT 15 INTO CARRY
MOV D,A ;SAVE MIDDLE BYTE
MOV A,C ;GET HIGHEST BYTE
RAL ;MOVE BIT 15 INTO BIT 16 POSITION
MOV C,A ;AND SAVE

DCR B ;ALL DONE WITH THIS BIT, DECREMENT BIT COUNTER
RZ ;IF ZERO, WE ARE COMPLETELY DONE SO RETURN
JMP B2BCD_LOOP ; OTHERWISE DO THE NEXT BIT

DABBLE: ;ADD THREE TO ANY NIBBLE THAT IS 5 OR MORE
PUSH B ;NEED ONE MORE REGISTER SO SAVE BC
MOV B,A ;SAVE AN COPY OF DABBLE BYTE
ANI 0FH ;CLEAR TOP NIBBLE
CPI 05H ;TEST IF WE NEED TO DABBLE THIS NIBBLE. 5 OR GREATER?
MOV A,B ;FLAG IS SET, SO OK TO GET BACK ORIGINAL BYTE BEFORE JUMP
JC DABBLE_HIGH ; NO, IT IS BELOW FIVE. CONTINUE WITH HIGH NIBBLE
ADI 03H ; ADD THREE
MOV B,A ;AND RESAVE
DABBLE_HIGH:
ANI 0F0H ;CLEAR LOW NIBBLE
CPI 50H ;TEST IF WE NEED TO DABBLE THIS NIBBLE. IS NIBBLE 5 OR MORE?
MOV A,B ;FLAG IS SET, GET ORIGINAL BYTE BACK
JC DABBLE_DONE ; NO, IT IS BELOW FIVE, CLEAN UP AND DONE
ADI 30H ; YES, ADD 3 TO HIGH NIBBLE
DABBLE_DONE:
POP B ;RESTORE THE BC
RET