Sqrt8086.com.~asm

Name "Sqrt8086"

org 100h

.MODEL small

.STACK 512d

.DATA

readMsg db "Type a number to calculate the SquareRoot of it (Max: 65534):$"
overflowMsg db "The number must be lower than 65534!$"
loadingMsg db "Calculating...$"
resultMsg db "Average SquareRoot: $"
finishMsg db "Press any key to continue | Press ESC to exit:$"
stackCacheLevel1 dw 0
stackCacheLevel2 dw 0
inputArray db 6 DUP(?)
precisionFactor dw 100


.CODE

start:
call clearScreen

call read

mov cx, ax

call verifyNumber

lea dx, loadingMsg
call printString

mov ax, cx

call calcSqrt

mov cx, ax

call printCRLF
lea dx, resultMsg
call printString

mov ax, cx
call printFloat

call finish

ret
;call exit

; Saves registers state
saveState:
pop stackCacheLevel2
push ax
push bx
push cx
push dx
push stackCacheLevel2
ret


; Loads registers state
loadState:
pop stackCacheLevel2
pop dx
pop cx
pop bx
pop ax
push stackCacheLevel2
ret


; Reads a number from Cin with 5 characters max.
;@returns: Number -> AX
read:
pop stackCacheLevel1

lea dx, readMsg
call printString

call printCRLF

mov ah, 02
mov dl, 41
int 21h


xor bx, bx
lea si, inputArray
mov cx, 6
readLoop:

mov ah, 01
int 21h

cmp al, 13
je fnshRead

xor ah, ah
sub al, 48
mov [si], ax
inc si
inc bx ; BX = char length

Loop readLoop:
fnshRead:

lea si, inputArray
mov cx, bx
xor dx, dx
convertLoop:

mov ax, 10
mul dx ; AX = DX * 10

mov bx, [si]
xor bh, bh
inc si
add ax, bx ; AX = (DX * 10) + BX

mov dx, ax

Loop convertLoop
fnshConvert:
mov ax, dx

push stackCacheLevel1
ret


; Calculates the Sqrt of a 16 bit integer
; @args: source -> AX
; @returns: integer result -> AX, decimal result -> BX
calcSqrt:

pop stackCacheLevel1
push 0
push 0
push ax ; Stack = source

; aprox = (source / 200) + 2
xor dx, dx
mov bx, 200
div bx
add ax, 2
mov bx, ax

push ax ; Stack = aprx


; BX -> aprx
; CX -> source
calcLoop:

pop bx ; Stack = aprox(current)
pop cx ; Stack = source

; If aprx == aprx(cache) it means that the squareroot of source
;   is a floating point number, which is not supported by the 8068
;   and thus, can't be calculated precisely.
pop ax
cmp bx, ax
je fnshAvrgSqrt

; checking if aprx² == source
mov ax, bx ; AX = aprx
xor dx, dx
mul bx
cmp ax, cx
je fnshSqrt

pop dx ; Clearing aprx(decimal) as result was not achieved
push bx ; Store cache of aprx to be compared in the next loop iteration

; aprx(BX) = ((source(CX) / aprx) + aprx) / 2
mov ax, cx ; AX = source
xor dx, dx
div bx
add ax, bx
shr ax, 1
mov bx, ax

push cx ; Stack = source
push bx ; Stack = aprx(current)

; Stack = aprx * 100
mov dx, precisionFactor
mul dx
push ax

; aprox = ((source * 100 / aprx) + aprx * 100) / 2
mov ax, precisionFactor
mul cx ; source * 100

div bx ; (source * 100 / aprx)
mov cx, ax

mov ax, precisionFactor
mul bx

add ax, cx ; (source * 100 / aprx) + aprx * 100)
adc dx, 0  ; (source * 100 / aprx) + aprx * 100) + Carry

mov cx, 2
div cx ; AX = ((source * 100 / aprx) + aprx * 100) / 2

pop bx ; BX = aprx * 100 lower

sub ax, bx ; AX = (((source * 100 / aprx) + aprx * 100) / 2) - aprx * 100

pop bx ; BX = aprx
pop cx ; CX = source
pop dx ; DX = aprx(cache)

push ax ; Stack = aprx(decimal)
push dx
push cx
push bx

JMP calcLoop

; The result is an integer number
fnshSqrt:
mov ax, bx ; AX = aprox(Sqrt)
pop bx
xor bx, bx ; BX = Sqrt(decimal)
push stackCacheLevel1
ret

; The result is a floating point number
fnshAvrgSqrt:
mov ax, bx ; AX = aprox(Sqrt)
pop bx ; BX = Sqrt(decimal)
push stackCacheLevel1
ret

; printString a String in Cout.
; @args: String pointer -> DX
printString:

call printCRLF
mov ah, 09
int 21h
mov dx, 0
ret

; printString a 16Bit-Integer + 8Bit-Precision(decimal) Number
;@args: Number -> AX, Precision -> BX
printFloat:

call printNumber

mov ah, 02
mov dl, 46
int 21h

mov ax, bx
call printNumber

fnshprintFloat:
ret

; printString an Integer number.
;@args: Number -> AX
printNumber:

call saveState

cmp ax, 100
jae printThreeDigits
cmp ax, 10
jae printTwoDigits

; 1 digit:
printOneDigit:

mov ah, 02
mov dl, al
add dl, 48
int 21h

call loadState
ret

; 2 digits:
printTwoDigits:
aam
add ah, 48
add al, 48

mov cx, ax
mov ah, 02

mov dl, ch
int 21h

mov dl, cl
int 21h

call loadState
ret

; 3 digits:
printThreeDigits:

aam
mov dh, al
mov al, ah
mov ah, 0
aam

add ah, 48
add al, 48
add dh, 48

mov cx, ax
mov ah, 02

mov dl, ch
int 21h

mov dl, cl
int 21h

mov dl, dh
int 21h

call loadState
ret

verifyNumber:

cmp ax, 65534
jbe continue

; Overflow:
lea dx, overflowMsg
call printString
call finish

; Continue:
continue:
ret

; Printing CRLF (carriage return + line feed)
printCRLF:

call saveState

mov ah, 02
mov dl, 13
int 21h
mov dl, 10
int 21h

call loadState

ret

clearScreen:
xor ah, ah
mov al, 03h
int 10h
ret

finish:
lea dx, finishMsg
call printString

mov ah, 01
int 21h
cmp al, 27
jne start
ret

exit:
mov ah, 4Ch
int 21h
ret



; [SOURCE]: C:\Users\Mei\OneDrive\Code\Repositories\Sqrt8086\Sqrt8086.asm