stack segment para stack
        db 64 dup ('stack')
stack ends

data segment para 'data'
    ;variaveis

    line1 db "Insira o primeiro numero: $"
    line2 db "Insira o segundo numero: $"
    line3 db "Soma = $"
    newline db 0ah, 0dh, "$"

data ends

code segment para 'code'

;codigo
main proc far
    assume cs:code,ds:data,es:data,ss:stack
    push ds
    sub ax,ax
    push ax
    mov ax,data
    mov ds,ax
    mov es,ax

    ;codigo do main

    lea dx, line1
    call writeString
    call readH
    mov dx, bx
    push dx

    lea dx, newline
    call writeString

    lea dx, line2
    call writeString
    call readH

    lea dx, newline
    call writeString

    pop dx
    xor cx, cx
    add bx, dx
    adc cx, '0'
    push cx

    lea dx, line3
    call writeString


    pop dx
    call writeChar
    call writeH



    ret
main endp

;procedimentos

;escreve o bx em hexadecimal no ecra
writeH proc near
    mov ax, bx
    mov cl, 4
    rol ax, cl
    and al, 0fh
    call intToChar
    mov dl, al
    call writeChar

    mov ax, bx
    mov cl, 8
    rol ax, cl
    and al, 0fh
    call intToChar
    mov dl, al
    call writeChar

    mov ax, bx
    mov cl, 12
    rol ax, cl
    and al, 0fh
    call intToChar
    mov dl, al
    call writeChar

    mov ax, bx
    and al, 0fh
    call intToChar
    mov dl, al
    call writeChar

    ret
writeH endp

;escreve o char em dl no ecra
writeChar proc near
    mov ah, 2
    int 21h
    ret
writeChar endp


;le um numero em hexadecimal e retorna em bx; numero maximo de carateres = 4
readH proc near
    xor bx, bx
    mov cx, 4
    readH1:
        mov ah, 1
        int 21h
        cmp al, 0dh
        je exit
        push cx
        call checkHChar
        cmp cl, 1
        je readHInvalidChar
        pop cx
        shl bx, 1
        shl bx, 1
        shl bx, 1
        shl bx, 1
        call charToInt
        add bl, al
        loop readH1

    exit:
        ret

    readHInvalidChar:
        pop cx
        call backspace
        jmp readH1

readH endp

;verifica se o char em al e um algarismo da numeracao hexadecimal; retorna em cl 1 senao for algarismo hexadecimal e 0 se for
checkHChar proc near
    cmp al, '0'
    jl checkHCharExit
    cmp al, '9'
    jg checkHCharContinuacao1

    ;e um numero
    mov cl, 0
    ret

    checkHCharContinuacao1:
        cmp al, 'A'
        jl checkHCharExit
        cmp al, 'F'
        jg checkHCharContinuacao2

        ;e um char maiusculo e esta correto
        mov cl, 0
        ret

        checkHCharContinuacao2:
                cmp al, 'a'
                jl checkHCharExit
                cmp al, 'f'
                jg checkHCharExit

                ;e um char minusculo e esta correto
                mov cl, 0
                ret


    checkHCharExit:
        mov cl, 1
        ret

checkHChar endp

;apaga um char
backspace proc near
    ;move o cursor para tras
    mov dl, 8
    call writeChar
    ;coloca um espaco para apagar o char que la esta
    mov dl, 32
    call writeChar
    ;mete o cursor outra vez para tras
    mov dl, 8
    call writeChar

    ret
backspace endp

;recebe um int em al e retorna o char em al
intToChar proc near
    cmp al, 10
    jl intToCharExit

    add al, 55
    ret

    intToCharExit:
        add al, '0'
        ret
intToChar endp

;recebe um char em al e retorna o int em al
charToInt proc near
    cmp al, 'A'
    jl charToIntExit1
    cmp al, 'a'
    jl charToIntExit2

    sub al, 87
    ret

    charToIntExit2:
        sub al, 55
        ret

    charToIntExit1:
        sub al, '0'
        ret
charToInt endp

;escreve o que estiver no endereco de dx
writeString proc near
    mov ah, 09h
    int 21h
    ret
writeString endp

code ends
end