# REPASO DE LA PRÁCTICA Nº 1.

            .data

cad1:       .ascii  "Primer mensaje... "
cad2:       .asciiz "Segundo mensaje.\n"
ent8:       .byte   70,250,-5,0,-128
ent16:      .half   -4000,4000,70,250,-5,128
ent32:      .word   10000000,-10000000,-4000,4000,70,250,-5,0,128
real32:     .float  3.14159,-1234.5678,123.4e-7
real64:     .double 3.14159,-1234.5678,123.4e-7
cr:         .asciiz "\n"

            .text

            # PROGRAMA PRINCIPAL.
main:       li $v0,4
            la $a0,cad1
            syscall

            # Impresión del primer byte, el primer half y el
            # primer word, separados por un retorno de carro.
            
            li $v0,1
            lb $a0,ent8
            syscall
            jal imprime_cr      # El flujo de ejecución se desvía a la dirección
                                # "imprime_cr". Antes, se guarda en $ra el valor
                                # actual del contador de programa (registro PC)
                                # más 4 (PC apuntará a la dirección de la siguiente
                                # instrucción).
            li $v0,1
            lh $a0,ent16
            syscall
            jal imprime_cr      # Estamos REUTILIZANDO el código de "imprime_cr"
                                # (motivo de la existencia de los procedimientos).
            li $v0,1
            lw $a0,ent32
            syscall
            jal imprime_cr      

            # Impresión de todos los float.
            
            la $t0,real32       # $t0 <- Dirección de inicio de los float.
            addi $t2,$t0,12     # $t2 <- Dirección final de los float, más 1.
buclefloat: li $v0,2            # Imprimir el dato apuntado por $t0.
            l.s $f12,0($t0)
            syscall
            jal imprime_cr      # Imprimir retorno de carro.
            addi $t0,$t0,4      # $t0 <- $t0 + 4
            bne $t0,$t2,buclefloat

            # Impresión de todos los double.
            
            la $t0,real64       # $t0 <- Dirección de inicio de los double.
            addi $t2,$t0,24     # $t2 <- Dirección final de los double, más 1.
bucledouble:li $v0,3            # Imprimir el dato apuntado por $t0.
            l.d $f12,0($t0)
            syscall
            jal imprime_cr      # Imprimir retorno de carro.
            addi $t0,$t0,8      # $t0 <- $t0 + 8
            bne $t0,$t2,bucledouble
            
            j final             # Salto incondicional a la dirección "final", para
                                # así eludir la ejecución del procedimiento "imprime_cr".
                                
            # PROCEDIMIENTO "imprime_cr".
imprime_cr: li $v0,4
            la $a0,cr
            syscall
            jr $ra              # Saltar a la dirección guardada en el registro $ra
                                # (en $ra está la dirección de la instrucción que
                                # sigue al "jal imprime_cr" que desvió la ejecución
                                # a este procedimiento).
            
            # FIN DEL PROGRAMA.
final:      li $v0,10
            syscall