Os algoritmos implementados até o presente momento são: inserção, busca e caminhamento em ordem.

Assim que eu terminar a "exclusão" posto aqui. :D

Trabalho apresentado na disciplina "Programação de Sistemas" da 2a série do curso de Ciência da Computação da Universidade Estadual de Maringá, ministrada pelo professor Munif Gebara Júnior.

Acadêmicos: Ewerton Daniel de Lima e Cezar Augustus Lamann

• Download abba.asm
• Enviar nova versão

Esconder código-fonte

.model small
.stack
.data
primeiro db 0,0
mensagem db 10,13,"Insira um valor (de 0 a 65535): $"
mensagemInsercao db "INSERINDO ELEMENTOS$",10,13
mensagemCaminhamento db 10,13,"CAMINHAMENTO EM ORDEM$",10,13
mensagemBusca db 10,13,"BUSCANDO ELEMENTO$",10,13
naoEncontrou db 10,13,"ITEM NÃO ENCONTRADO$",10,13
encontrou db 10,13,"ITEM ENCONTRADO$",10,13
numero db 6, 1, 0,0,0,0,0
resultado db 10,13,"00000$"

.code
entrada proc                         
    mov ax, seg mensagem
    mov ds, ax
    lea dx, mensagem
    mov ah, 09h
    int 21h

    mov ax, seg numero
    mov ds, ax
    lea dx, numero
    mov ah, 0Ah
    int 21h
  
    mov ch, 0
    mov cl, [numero+1]
    lea bx, numero
    inc bx
    add bx, cx
    mov dx, 1
    mov cx, 0
  
    calculo:
    sub [bx], 48
    mov ax, [bx]
    mov ah, 0
    push dx
    mul dx
    pop dx
    push ax
    mov ax, dx
    mov dx, 10
    mul dx
    mov dx, ax
    pop ax
    add cx, ax
    dec bl
    lea ax, numero
    inc ax
    cmp bx, ax
    jne calculo
    ret
entrada endp

saida proc
   mov bx, seg resultado
   mov ds, bx
   mov cx,5
   lea si,resultado+6
volta:
   mov dx,0
   mov bx,10
   div bx
   add dl,48
   mov [si],dl
   dec si
   loop volta
   mov ah,09h
   lea   dx,resultado
   int   21h
   ret
saida endp

caminhamento proc
    mov cx, 1
    camEsq:
    mov dx, ds
    cmp dx, 0
    je fimCaminhamento
    push dx
    inc cx
    mov bx, 0
    mov dh, [bx]
    inc bx
    mov dl, [bx]
    mov ds, dx
    jmp camEsq
    camDir:
    mov dx ,ds
    cmp dx, 0
    je fimCaminhamento
    mov bx, 4
    mov ah, [bx]
    inc bx
    mov al, [bx]
    
    mov bx, ds
    push bx
    push cx
    call saida
    pop cx
    pop bx
    mov ds, bx
    
    mov bx, 2
    mov dh, [bx]
    inc bx
    mov dl, [bx]
    mov ds, dx
    jmp camEsq

   fimCaminhamento:
   dec cx
   cmp cx, 0
   je fimfimCaminhamento
   pop dx
   mov ds, dx
   jmp camDir
   fimfimCaminhamento:
   ret      
caminhamento endp

proc inserir
    mov cx, 5

    ;INSERÇÃO
    mov ax, seg mensagemInsercao
    mov ds, ax
    lea dx, mensagemInsercao
    mov ah, 09h
    int 21h
    loopPrincipal:
    push cx
    call entrada
    mov ah, 48h
    mov bx, 1
    int 21h
    mov ds, ax
    mov bx, 0
    mov [bx], 0
    inc bx
    mov [bx], 0
    inc bx
    mov [bx], 0
    inc bx
    mov [bx], 0
    inc bx
    mov [bx], ch
    inc bx
    mov [bx], cl

    mov bx, seg primeiro
    mov ds, bx
    mov dh, [primeiro]
    mov dl, [primeiro+1]
    cmp dx, 0
    jne naoSerPrimeiro
    mov [primeiro], ah
    mov [primeiro+1], al
  
    jmp serPrimeiro
  
    naoSerPrimeiro:
    busca:
    mov ds, dx
    mov bx, 4
    mov dh, [bx]
    inc bx
    mov dl, [bx]
    cmp cx, dx
    jl  casoMenor
    casoMaior:
    mov bx, 2
    mov dh, [bx]
    inc bx
    mov dl, [bx]
    jp comparador
  
    casoMenor:
    mov bx, 0
    mov dh, [bx]
    inc bx
    mov dl, [bx]
     
    comparador:
    cmp dx, 0
     
    jne busca

    mov [bx], al
    dec bx
    mov [bx], ah
  
    serPrimeiro:
    pop cx
    loop loopPrincipal
   
    ;CAMINHAMENTO
    mov ax, seg mensagemCaminhamento
    mov ds, ax
    lea dx, mensagemCaminhamento
    mov ah, 09h
    int 21h

    mov bx, seg primeiro
    mov ds, bx
    mov dh, [primeiro]
    mov dl, [primeiro+1]
    mov ds, dx
    call caminhamento   
   
    ;BUSCA
    mov ax, seg mensagemBusca
    mov ds, ax
    lea dx, mensagemBusca
    mov ah, 09h
    int 21h
  
    call entrada
  
    mov bx, seg primeiro
    mov ds, bx
    mov dh, [primeiro]
    mov dl, [primeiro+1]
  
    busca2:
    mov ds, dx
    mov bx, 4
    mov dh, [bx]
    inc bx
    mov dl, [bx]
    cmp cx, dx
    je encontrar
    jl  casoMenor2
    casoMaior2:
    mov bx, 2
    mov dh, [bx]
    inc bx
    mov dl, [bx]
    jp comparador2
  
    casoMenor2:
    mov bx, 0
    mov dh, [bx]
    inc bx
    mov dl, [bx]
     
    comparador2:
    cmp dx, 0
    jne busca2
  
    mov ax, seg naoEncontrou
    mov ds, ax
    lea dx, naoEncontrou
    mov ah, 09h
    int 21h
    jp fim
  
    encontrar:
    mov ax, seg encontrou
    mov ds, ax
    lea dx, encontrou
    mov ah, 09h
    int 21h
  
    fim:
    mov ax, 4C00h
    int 21h   
endp inserir
end inserir

Calculadora em C com Assembly (multiplataforma)

Algoritmo de Raiz Quadrada Inteira em Assembly Puro para Linux x86 (NASM - Netwide Assembler)

Simples JIT (just in time) em C

Inverter uma string, Assembly8086

Retorna a diferença entre dois vetores em Assemly