Programa de TASM para determinar si un número corresponde a un año bisiesto o no. MASM/TASM program that determines if a given number corresponds to a leap year or not. This program was made for homework and shared to flex ;)

Bisiesto.asm

; TITULO: anio bisiesto
ideal
dosseg
model small
stack 256

dataseg
    codsal  db  0
    ; Mis variables {
    anio    dw  2400
    r       db  ?
    ;}

codeseg
    proc PrintDecimal
        push ax
        push bx
        push cx
        push dx
        
        ; check if negative
        test ax,08000h
        jz PositiveAx
                
        ;  put '-' on the screen
        push ax
        mov dl,'-'
        mov ah,2
        int 21h
        pop ax
        
        neg ax ; make it positive
        PositiveAx:
            mov cx,0   ; will count how many time we did push 
            mov bx,10  ; the divider

        put_mode_to_stack:
            xor dx,dx
            div bx
            add dl,30h
            ; dl is the current LSB digit 
            ; we cant push only dl so we push all dx
            push dx    
            inc cx
            cmp ax,9   ; check if it is the last time to div
            jg put_mode_to_stack
            
            cmp ax,0
            jz pop_next  ; jump if ax was totally 0
            add al,30h  
            mov dl, al    
            mov ah, 2h
            int 21h        ; show first digit MSB

        pop_next: 
            pop ax    ; remove all rest LIFO (reverse) (MSB to LSB)
            mov dl, al
            mov ah, 2h
            int 21h        ; show all rest digits
            loop pop_next
            
            pop dx
            pop cx
            pop bx
            pop ax
            
        ret
    endp PrintDecimal
inicio:
    mov ax, @data
    mov ds, ax
    
    ; ###################### ALGORITMO ######################## {
    ; Aqui usaremos la instruccion div, con un operando de tamanio palabra:
    ; Esta operacion divide 'dx:ax' entre ese operando
    ; Ese operando debe ser un registro o una localidad. No puede ser inmediato
    ; así que moveremos el año que queremos dividir a 'ax'
    mov ax, [anio]
    ; y limpiaremos dx
    xor dx, dx
    ; Cuando lo dividimos, el sobrante se guarda en 'dx'
    ; Copiamos el número 4 a 'bx' para dividir el anio entre 4
    mov bx, 4
    ; dividimos. Recuerda que se esta dividiendo dx:ax (donde guardamos el anio) entre bx (el 4)
    div bx
    ; Comparamos el sobrante con 0
    cmp dx, 0
    jne NoEs ; Si el sobrante NO es igual a 0, entonces no es bisiesto, asi que saltamos a NoEs
    ; Si el sobrante es igual a 0, hacemos lo siguiente {
        ; volvemos a copiar el anio a 'ax' y lo dividimos entre 400 para ver si es divisible
        mov ax, [anio]
        ; No olvides limpiar 'dx' de nuevo
        xor dx, dx
        ; Copiamos el 400 a bx
        mov bx, 400
        div bx
        ; El sobrante se ha guardado en 'dx' (otra vez) y veremos si es igual a 0 (o sea si el anio es divisible entre 400)
        cmp dx, 0
        je SiEs ; si el sobrante es 0, entonces el anio es divisible entre 400, 100 y 4, asi que saltamos a SiEs
        ; Si no, puede que sea divisible entre 4 y 100, o solo divisible entre 4. Lo averiguaremos {
            ; Volvemos a copiar anio a 'ax'
            mov ax, [anio]
            ; Y limpiamos 'dx' otra vez
            xor dx, dx
            ; Copiamos 100 a 'bx' para hacer la division
            mov bx, 100
            ; Dividimos entre dx:ax (anio) entre bx (100) para que el sobrante se guarde en 'ah'
            div bx
            ; comparamos el sobrante con 0
            cmp dx, 0
            je NoEs ; Si el sobrante es 0, entonces el anio es divisible entre 4 y 100, asi que no es bisiesto. Entonces saltamos a NoEs
            ; Si el sobrante no es 0, entonces solo es divisible entre 4. Entonces saltamos a SiEs
                jmp SiEs
        ; }
    ; }
    NoEs:
        mov [r], 'N'
        jmp salir
    SiEs:
        mov [r], 'S'
        jmp salir
    ; } 

salir:
    mov ah, 04Ch
    mov al, [codsal]
    int 21h
end inicio