org 0x7e00

jmp 0x0000:start

data:
blank equ ' '
selection equ '>'
option db 1 ;posição de seleção do ponteiro (1 <= option <= 16)
flag db 0 ;diz se os valores selecionados vão para o primeiro
termo ou pro segundo
first db 0 ;primeiro operando
operador db '_' ;operador selecionado
second db 0 ;segundo operando
resultado db 0 ;resultado da operação
termo db " ", 0 ;transforma os termos, o operador e o resultado em
strings para serem posicionadas na calculadora

top db "_____________________________________________",0 ;primeira linha da

calculadora
s db "|__________|__________|__________|__________|| | |
| || x1 | x2 | x3 | x+ ||__________|__________|
__________|__________|| | | | || x4 |
x5 | x6 | x- ||__________|__________|__________|__________||
| | | || x7 | x8 | x9 | x* ||
__________|__________|__________|__________|| | | |
|| xC | x0 | x= | x/ ||__________|__________|__________|
__________|", 0

putchar:
mov ah, 0xe ;config para printar
int 10h
ret
%macro _putchar 1
pusha
mov al, %1
call putchar
popa
%endmacro

ln:
mov al, 0xa ;pula uma linha, mas a posição do cursor não volta para o início
da prox linha
call putchar
mov al, 0xd ;volta a posição do cursor para o início
call putchar
ret

print:
.l:
lodsb
cmp al, 0
je .e
call putchar
jmp .l
.e:
ret
%macro _print 1
pusha
mov si, %1
call print
 popa
%endmacro

reverse:
xor cx, cx ; zerar contador
.loop1: ; botar string na stack
lodsb
cmp al, 0
je .endloop1
inc cl
push ax
jmp .loop1
.endloop1:
.loop2: ; remover string da stack
pop ax
stosb
loop .loop2
ret
%macro _reverse 1
mov si, %1
mov di, %1
call reverse
%endmacro

limpar_termo: ;zera o conteúdo de termo

mov cx, 1
mov di, termo
.l:
cmp cl, 11
je .e
mov ax, ' '
stosb
inc cl
jmp .l
.e:
ret

int_to_str:
cmp ax, 0
je .is_zero
mov bx, 10
.l:
cmp ax, 0
je .end
xor dx, dx
div bx
xchg ax, dx
add al, 48
stosb
xchg ax, dx
jmp .l
.end:
_reverse termo
ret
.is_zero:
add al, 48
stosb
ret
%macro _int_to_str 2 ;uma string que vai receber um inteiro
 mov di, %1
mov si, %2
lodsb
call int_to_str
%endmacro

%macro _print_termos 0
call ln
_putchar '|'
call limpar_termo
_int_to_str termo, first
_print termo
_putchar '|'
call limpar_termo
mov di, termo
xor cx, cx
mov ax, ' '
.l:
inc cl
stosb
cmp cl, 5
jl .l
mov si, operador
lodsb
stosb
_print termo
_putchar '|'
call limpar_termo
_int_to_str termo, second
_print termo
_putchar '|'
call limpar_termo
_int_to_str termo, resultado
_print termo
_putchar '|'
call ln
%endmacro

calculator_print:
mov si, s
mov cl, 1
mov dl, 1
.l:
lodsb
inc cl
cmp cl, 46
je .nl
cmp al, 'x'
je .sel
cmp al, 0
je .e
call putchar
jmp .l
.nl:
mov cl, 1
call putchar
call ln
jmp .l
.sel: ;responsável por identificar a opção selecionada
 inc cl
push si
mov si, option
lodsb
cmp dl, al
je .sel2

pop si
_putchar blank
lodsb
call putchar
inc dl
jmp .l

.sel2:
pop si
_putchar selection
lodsb
call putchar
inc dl
jmp .l
.e:
ret
clear: ; mov bl, color
; set the cursor to top left-most corner of screen
mov bl, 15
mov dx, 0
mov bh, 0
mov ah, 0x2
int 0x10

; print 2000 blank chars to clean

mov cx, 2000
mov bh, 0
mov al, 0x20 ; blank char
mov ah, 0x9
int 0x10

; reset cursor to top left-most corner of screen

mov dx, 0
mov bh, 0
mov ah, 0x2
int 0x10
ret

getchar: ;recebe um char do teclado

mov ah, 0x0 ;config para ler
int 16h
ret

division: ;a operação de divisão me deixou na mão, ent fiz a minha

xor cx, cx ;limpa o contador
mov si, second
lodsb
mov bx, ax ;pega o segundo operando e guarda tanto em bx quanto em dx
mov dx, ax
mov si, first
lodsb ;pega o primeiro operando
cmp al, bl
 jl .menor
.loop1:
inc cl
add bl, dl
cmp al, bl
jl .fim

jmp .loop1
.menor: ;resultado 0
xor ax, ax
mov di, resultado
stosb
ret
.fim:
mov ax, cx
mov di, resultado
stosb
ret

func:
mov si, option
lodsb

;seleção de operações
cmp al, 4
je .adi
cmp al, 8
je .subt
cmp al, 12
je .multi
cmp al, 16
je .divi

;seleção de números
mov bx, 1
cmp al, 1 ;selecionou o num 1
je .achou ;se o número em option for 1, então o valor selecionado foi o 1,
guardado em bx
mov bx, 2
cmp al, 2
je .achou
mov bx, 3
cmp al, 3
je .achou
mov bx, 4 ;veja q o num salvo em bx n corresponde ao da seleção, pois existem
opções q n são nums
cmp al, 5
je .achou
mov bx, 5
cmp al, 6
je .achou
mov bx, 6
cmp al, 7
je .achou
mov bx, 7
cmp al, 9
je .achou
mov bx, 8
cmp al, 10
 je .achou
mov bx, 9
cmp al, 11
je .achou
mov bx, 0
cmp al, 14
je .achou

;selecionou o '='
cmp al, 15
je .equal_to

;a última opção é C de clear

xor ax, ax
mov di, first
stosb
mov di, second
stosb
mov di, resultado
stosb
mov di, flag
stosb
mov ax, '_'
mov di, operador
stosb
ret

.achou:
mov si, flag
lodsb
cmp al, 0 ;ainda estamos lendo o primeiro termo
je .primeiro
cmp al, 1
je .segundo

.primeiro:
mov si, first
lodsb ;pega o valor em first e multiplica por 10 para colocar o novo valor
selecionado nas dezenas
mov cx, 10
mul cx
add ax, bx
mov di, first
stosb ;depois guarda o novo valor
ret

.segundo:
mov si, second
lodsb
mov cx, 10
mul cx
add ax, bx
mov di, second
stosb
ret

.adi: ;operador + selecionado

mov di, operador
mov ax, '+'
 stosb
jmp .next_termo
.subt:
mov di, operador
mov ax, '-'
stosb
jmp .next_termo
.multi:
mov di, operador
mov ax, '*'
stosb
jmp .next_termo
.divi:
mov di, operador
mov ax, '/'
stosb
jmp .next_termo

.next_termo: ;quando selecionarmos um operador mudamos a flag pra dizer que

vamos começar a ler o próximo termo
mov di, flag
mov ax, 1 ;segundo termo
stosb
ret

.equal_to:
mov si, operador
lodsb
mov cx, ax ;em cx ficará a operação que realizaremos
mov si, second
lodsb
mov bx, ax ;em bx o segundo termo da operação
mov si, first
lodsb ;em ax o primeiro termo

cmp cl, '+'

je .a
cmp cl, '-'
je .s
cmp cl, '*'
je .m
cmp cl, '/'
je .d

.a:
add ax, bx
mov di, resultado
stosb
ret
.s:
sub ax, bx
mov di, resultado
stosb
ret
.m:
mul bx
mov di, resultado
stosb
ret
 .d:
call division
ret

read_mov:
mov di, option
mov si, option

call getchar
cmp al, 'a'
je .esq
cmp al, 'd'
je .dir
cmp al, 's'
je .bai
cmp al, 'w'
je .cim
cmp al, 13 ;tecla enter
je .ent
jmp .impossible

.esq:
lodsb
cmp al, 1
je .impossible
sub al, 1
stosb
ret

.dir:
lodsb
cmp al, 16
je .impossible
add al, 1
stosb
ret

.bai:
lodsb
cmp al, 12
jg .impossible
add al, 4
stosb
ret

.cim:
lodsb
cmp al, 5
jl .impossible
sub al, 4
stosb
ret

.ent:
call func
ret

.impossible:
ret
start:
xor ax, ax
mov ds, ax
mov es, ax

.main_loop:
call clear
_print top
_print_termos
call calculator_print
;_print operador
call read_mov
jmp .main_loop

jmp $