add huge numbers.asm

name "huge"

; this example shows how to add huge unpacked bcd numbers.

; this allows to over come the 16 bit and even 32 bit limitation.
; because 32 digit decimal value holds over 100 bits!
; with some effort the number of digits can be increased.

org     100h

; skip data:
jmp     code

; the number of digits in numbers:
; it's important to reserve 0 as most significant digit, to avoid overflow.
; so if you need to operate with 250 digit values, you need to declare len = 251
len     equ     32

; every decimal digit is stored in a separate byte.

; first number is: 423454612361234512344535179521
num1    db      0,0,4,2,3,4,5,4,6,1,2,3,6,1,2,3,4,5,1,2,3,4,4,5,3,5,1,7,9,5,2,1
; second number is: 712378847771981123513137882498
num2    db      0,0,7,1,2,3,7,8,8,4,7,7,7,1,9,8,1,1,2,3,5,1,3,1,3,7,8,8,2,4,9,8

; we will calculate this:

; sum = num1 + num2

; 423454612361234512344535179521 + 712378847771981123513137882498 =
;              = 1135833460133215635857673062019

sum     db      len dup(0) ; declare array to keep the result.

; you may check the result on paper, or click Start , then Run, then type "calc" and hit enter key.

code:   nop ; entry point (nop does nothing, it's nope).

; digit pointer:
xor     bx, bx

; setup the loop:
mov     cx, len 
mov 	bx, len-1  ; point to lest significant digit!
        
next_digit:

        ; add digits:
        mov     al, num1[bx]
        adc     al, num2[bx]
        
        ; this is a very useful instruction that
        ; adjusts the value of addition
        ; to be string compatible
        aaa
        
        ; aaa stands for ascii add adjust.
        ; --- algorithm behind aaa ---
        ; if low nibble of al > 9 or af = 1 then:
	;     al = al + 6 
	;     ah = ah + 1 
	;     af = 1 
	;     cf = 1 
	; else
	;     af = 0 
        ;     cf = 0 
        ;
        ; in both cases: clear the high nibble of al.         
        ; --- end of aaa logic ---
        
        ; store result:
        mov     sum[bx], al
        
        ; point to next digit:
        dec     bx
        
        loop    next_digit

; include carry in result (if any):
adc     sum[bx], 0


; print out the result:
mov     cx, len

; start printing from most significant digit:
mov     bx, 0

print_d:
        mov     al, sum[bx]
        ; convert to ascii char:
        or      al, 30h

        mov     ah, 0eh
        int     10h
        
        inc     bx
        
        loop    print_d

; wait for any key press:
mov ah, 0
int 16h

ret  ; stop