Ensamblador

Programación. Lenguaje Código Máquina. Código Ensamblador. Registros de Memoria. Instrucciones. Lenguaje de Nivel Bajo. Programación Experta

  • Enviado por: Hades
  • Idioma: castellano
  • País: España España
  • 18 páginas
publicidad
cursos destacados
Cantabria en la Época Contemporánea. Política, Sociedad, Economía y Territorio
UNED
¿Te gustaría conocer los aspectos más relevantes de la historia de Cantabria? Conoce el origen y causas de su...
Solicita InformaciÓn

Oposiciones de Geografía e Historia
Master-D
¿Quieres convertirte en profesor de geografía e historia? Master-D te ayuda a aprobar la oposición para que puedas...
Solicita InformaciÓn

publicidad

#ESTA PARTE DEL CODIGO NO CREEMOS NECESARIO EXPLICARLA DEBIDO A QUE LA #HICIESTEIS VOSOTROS

########################################

# Segmento de datos

########################################

.data 0x10010000

# Reservamos espacio para almacenar las matrices

# las matrices pueden inicializarse aquí y así se evita la tediosa labor de cargar su valor

# cada vez que se pretenda depurar errores.

A: .space 104

B: .space 104

C: .space 104

# se almacenan diferentes menús

pantalla: .ascii "\n Fundamentos de Computadores "

.ascii "\n Telemática "

.ascii "\n Cartagena. Curso 2000/01 "

.ascii "\n\n"

.ascii "\n ---------------------------- "

.ascii "\n Opciones "

.ascii "\n ---------------------------- "

.ascii "\n 1. Introducir una matriz."

.ascii "\n 2. Visualizar una matriz."

.ascii "\n 3. Calcular la traspuesta."

.ascii "\n 4. Determinante."

.ascii "\n 5. Sumar dos matrices."

.ascii "\n 6. Multiplicar por escalar."

.ascii "\n 7. Salir del programa."

.ascii "\n\n"

.ascii "\n ---------------------------- "

.asciiz "\n\t Seleccione alguna de las opciones: "

# Se almacenan las direcciones a las que saltar en función de la opción seleccionada

etiquetas_menu: .word opcion1, opcion2, opcion3, opcion4, opcion5, opcion6, opcion7

# Menú de introducción

elegir_matriz: .ascii "\n ---------------------------- "

.ascii "\n Opciones "

.ascii "\n ---------------------------- "

.ascii "\n 1. Introducir matriz A. "

.ascii "\n 2. Introducir matriz B. "

.ascii "\n\n"

.ascii "\n ---------------------------- "

.asciiz "\n\t Seleccione la matriz que desea introducir: "

etiquetas_mat: .word opcionA, opcionB

# Menú de visualización

v_elegir_matriz: .ascii "\n ---------------------------- "

.ascii "\n Opciones "

.ascii "\n ---------------------------- "

.ascii "\n 1. Visualizar matriz A. "

.ascii "\n 2. Visualizar matriz B. "

.ascii "\n 3. Visualizar matriz C. "

.ascii "\n\n"

.ascii "\n ---------------------------- "

.asciiz "\n\t Seleccione la matriz que desea visualizar: "

etiquetas_vmat: .word v_opcionA, v_opcionB, v_opcionC,

ret: .asciiz "\n"

tab: .asciiz "\t"

# identificadores de matriz

matrizA: .asciiz "A"

matrizB: .asciiz "B"

matrizC: .asciiz "C"

datosde: .asciiz "Datos de la matriz "

abrecor: .asciiz "["

cierracor: .asciiz "]= "

coma: .asciiz ", "

numerofilas: .asciiz "Introduzca el número de filas: "

numerocolumnas: .asciiz "Introduzca el número de columnas: "

# mensajes de error

mensajerror: .asciiz "\nLa matriz que desea visualizar NO TIENE datos."

mmensajeerror: .asciiz "\nNo puede multiplicar dos matrices que no tengan igual número de filas y columnas respectivamente."

smensajeerror: .asciiz "\nNo puede sumar/restar dos matrices que no tengan igual dimensión."

Det_error: .asciiz "\nNo puede calcularse un determinate superior a 3x3."

peticionescalar: .asciiz "\nIntroduzca el escalar por el que desea multiplicar la matriz A: "

# Opciones implementadas

opc1: .asciiz "Procedimiento para introducir una mátriz"

opc2: .asciiz "Procedimiento para visualizar una mátriz"

opc3: .asciiz "Procedimiento para calcular la traspuesta de la matriz A y la guarda en C"

opc4: .asciiz "Procedimiento para calcular el determinante"

opc5: .asciiz "Procedimiento para sumar dos matrices. 0 Suma 1 Resta "

opc6: .asciiz "Procedimiento para multiplicar por escalar"

opc7: .asciiz "Procedimiento para salir del programa"

#MESAJES QUE SE MUESTRAN EN LA VENTANA CUANDO SE EJECUTA EL CÓDIGO

mensajedepu: .asciiz "\nHasta aquí ha llegado bien." #ESTE ES BUESTRO

mensaje_det: .asciiz "El determinante de A es : "

########################################

#

# Segmento de código

#

########################################

# Programa principal.....

# Se muestra el menú de opciones posibles y se espera que el usuario seleccione una de ellas

.text

.globl __start

__start:

jal limpiar

jal mostrar_menu

li $8, 4

addi $2, $2, -1

mult $8, $2

mflo $9

la $10, etiquetas_menu

add $11, $10, $9

lw $11, 0($11)

jr $11

opcion1: jal introducir

j __start

opcion2: jal visualizar

j __start

opcion3: jal traspu

j __start

opcion4: jal determinante

j __start

opcion5: jal sumar

j __start

opcion6: jal multescalar

j __start

opcion7: jal abandonar

#rutina de comprobacion de la existencia de datos

#dentro de la matriz

vacio: la $4,mensajerror

li $2,4

syscall

li $2,5

syscall

jr $31

########################################

# Muestra el menú de opciones y

# recoge la opción seleccionada.

# Sale del menú cuando se selecciona

# una opción posible.

########################################

mostrar_menu: addi $29, $29, -8 #PARA ELLO USAMOS UNA PILA

sw $8, 4($29)

sw $31, 0($29)

li $2, 4

la $4, pantalla

syscall

li $2, 5

syscall

slti $8, $2, 8 #máxima opción 7

beq $8, $0, mostrar_menu

lw $8, 4($29)

lw $31, 0($29)

addi $29, $29, 8

jr $31

########################################

# Opcion1. Introducir una matriz

########################################

introducir: addi $29, $29, -8

sw $8, 4($29)

sw $31, 0($29)

li $2, 4

la $4, opc1

syscall

li $2, 4

la $4, elegir_matriz

syscall

li $2, 5

syscall

slti $8, $2, 3

beq $8, $0, introducir

li $8, 4

addi $2, $2, -1

mult $8, $2

mflo $9

la $10, etiquetas_mat

add $11, $10, $9

lw $11, 0($11)

jal limpiar

jr $11

opcionA: la $4, A

la $5, matrizA

jal pedir

jal pausa

jal continuar

opcionB: la $4, B

la $5, matrizB

jal pedir

jal pausa

jal continuar

continuar: lw $8, 4($29)

lw $31, 0($29)

addi $29, $29, 8

jr $31

########################################

# Pedir matriz

# en $4 se pasa la dirección de la matriz a cargar

# en $5 tenemos el identificador

# los datos de entrada se almacenan de la siguiente forma

# Primero destinando media palabra para ello el número de filas de la matriz

# Segundo destinando media palabra para ello el número de columnas de la matriz

# Seguidamente se almacenan cada una de las componentes de la matriz destinando un byte

########################################

pedir: addi $sp, $sp, -20

sw $10, 16($sp) # número de columnas

sw $9, 12($sp) # número de filas

sw $8, 8($sp) # registro intermedio

sw $4, 4($sp)

sw $5, 0($sp)

li $2, 4

la $4, datosde

syscall

li $2, 4

lw $4, 0($sp)

syscall

li $2, 4

la $4, ret

syscall

fil: li $2, 4

la $4, numerofilas

syscall

li $2, 5

syscall

blez $2, fil

lw $8, 4($sp)

sh $2, 0($8)

move $9, $2

col: li $2, 4

la $4, numerocolumnas

syscall

li $2, 5

syscall

blez $2, col

lw $8, 4($sp)

sh $2, 2($8)

move $10, $2

lw $8, 4($sp)

addi $8, $8, 4

# repetir hasta número de filas

li $11, 0

rep_i: li $12, 0

rep_j: li $2, 4

lw $4, 0($sp)

syscall

li $2, 4

la $4, abrecor

syscall

li $2, 1

move $4, $11

syscall

li $2, 4

la $4, coma

syscall

li $2, 1

move $4, $12

syscall

li $2, 4

la $4, cierracor

syscall

li $2, 5

syscall

# Guardar el dato recogido.........................................

sb $2, 0($8)

add $8, $8, 1

addi $12, $12, 1

bne $12, $10, rep_j

li $2, 4

la $4, ret

syscall

addi $11, $11, 1

bne $11, $9, rep_i

lw $10, 16($sp) # número de columnas

lw $9, 12($sp) # número de filas

lw $8, 8($sp)

lw $4, 4($sp)

lw $5, 0($sp)

addi $sp, $sp, 20

jr $31

########################################

# Opcion2. Visualizar una matriz

########################################

visualizar: addi $29, $29, -8

sw $8, 4($29)

sw $31, 0($29)

li $2, 4

la $4, opc1

syscall

li $2, 4

la $4, v_elegir_matriz

syscall

li $2, 5

syscall

slti $8, $2, 4

beq $8, $0, visualizar

li $8, 4

addi $2, $2, -1

mult $8, $2

mflo $9

la $10, etiquetas_vmat

add $11, $10, $9

lw $11, 0($11)

jal limpiar

jr $11

v_opcionA: la $4, A

la $5, matrizA

li $6, 0

jal mostrar

jal pausa

jal continuar

v_opcionB: la $4, B

la $5, matrizB

li $6, 0

jal mostrar

jal pausa

jal continuar

v_opcionC: la $4, C

la $5, matrizC

li $6, 1

jal mostrar

jal pausa

jal continuar

# OPCION D ELIMINADA POR QUE NO NECESITAMOS USARLA

# YA QUE PASAMOS LOS DATOS SIEMPRE A LA MATRIZ “C”

jr $31

########################################

# mostrar: Procedimiento que muestra la matriz pasada como argumento

# entradas: $4: dirección donde comienza la matriz a mostrar

# $5: identificador de la matriz a visualizar

########################################

mostrar: addi $sp, $sp, -20

sw $10, 16($sp) # número de columnas

sw $9, 12($sp) # número de filas

sw $8, 8($sp) # registro intermedio

sw $4, 4($sp)

sw $5, 0($sp)

li $2, 4

la $4, datosde

syscall

li $2, 4

lw $4, 0($sp)

syscall

li $2, 4

la $4, ret

syscall

lw $8, 4($sp)

lh $9, 0($8)

lh $10, 2($8)

addi $8, $8, 4

beq $9, $0, verror

beq $10, $0, verror

j vcontinuar

verror: li $2, 4

la $4, mensajerror

syscall

j vsalir

vcontinuar:

# repetir hasta número de filas

li $11, 0

vrep_i: li $12, 0

vrep_j: li $2, 4

lw $4, 0($sp)

syscall

li $2, 4

la $4, abrecor

syscall

li $2, 1

move $4, $11

syscall

li $2, 4

la $4, coma

syscall

li $2, 1

move $4, $12

syscall

li $2, 4

la $4, cierracor

syscall

beq $6, $0, vbyte

# Cargar el dato correspondiente.........................................

# La matriz de resultado de operaciones C no tiene como componentes #datos de tipo byte

# sino palabra, por ello si deseamos ver la matriz C debemos acceder a #palabra e ir de 4 en 4

lw $4, 0($8)

add $8, $8, 4

j vcont

vbyte: lb $4, 0($8)

add $8, $8, 1

vcont: li $2, 1

syscall

li $2, 4

la $4, tab

syscall

addi $12, $12, 1

bne $12, $10, vrep_j

li $2, 4

la $4, ret

syscall

addi $11, $11, 1

bne $11, $9, vrep_i

vsalir: lw $10, 16($sp) # número de columnas

lw $9, 12($sp) # número de filas

lw $8, 8($sp)

lw $4, 4($sp)

lw $5, 0($sp)

addi $sp, $sp, 20

jr $31

########################################

# Opcion3. Calcular la traspuesta

# Procedimiento que calcula la traspuesta de A y la guarda en C

########################################

traspu:

li $2, 4

la $4, opc3

syscall

# implementar aquí......................

addi $sp,$sp,-4 #AQUI RESERVAMOS UNA PALABRA EN PILA

sw $31,0($sp) #AQUI GUARDAMOS LA POSCION DE RETORNO EN PILA

lh $9,A #LEEMOS LOS PRIMEROS BYTES DE LA MATRIZ A

beqz $9, vacio #SI NO HAY FILAS ESTA VACIA SI HAY

lh $10,A+2 #LEEMOS LA SEGUNDA Y ULTIMA PALBRA Y

sh $10,C #GUARDAMOS ENTONCES LAS DIMENSIONES EN “C”

sh $9,C+2 #FILAS Y COLUMNAS C Y C+2

la $13,A+4 #CARGAMOS EL PRIMER ELEMENTO MATRIZ A

li $11,0 #POMEMOS A 0 EL REG 11 DONDE METEREMOS DATOS

columnas: li $12,0 #INICIALIZAMOS LAS COLUMNAS A 0

trasponer: lb $14,0($13) #CARGAMOS EN $14 EL PRIMER BYTE DE MATRIZ A

move $4,$9 #CARGAMOS EN LOS DATOS EN LOS REGISTROS $4 $6 $5

move $6,$11 #QUE SON LOS QUE HEMOS USADO EN LA RUTINA

move $5,$12 #POSICION PARA CALCULAR LA POSICION DE LOS

li $7,4 #DATOS DENTRO DE LA MATRIZ Y PODER GIRARLA

jal posicion #AQUÍ LLAMAMOS A LA SUBSODICHA RUTINA

la $15,C #AL VOLVER DE LA RUTINA CARGAMOS C EN $15

add $15,$15,$2 #Y LE SUMAMOS (i*n+j)*tamaño+4 == DESPLAZAMIENTO

sw $14,0($15) #ALMACENAMOS EL ELEMENTO Y PASAMOS AL SIGUIENTE

addi $13,$13,1 #Y PASAMOS AL SIGUIENTE ELEMENTO DE A FILA

addi $12,$12,1 # Y TAMBIEN COLUMNA

bne $12, $10,trasponer #SI NO HEMOS LLEGADO AL FIN REPETIMOS

addi $11,$11,1 #INCREMENTAMOS LAS FILAS Y SI NO SON IGUAL

bne $11,$9,columnas #A LAS COLUMNAS DICHAS AL PRINCIPIO SEGUIMOS

lw $31,0($sp) #SI HEMOS LLEGADO AL FINAL, LEEMOS LA DIREC DE

addi $sp,$sp,4 #RETORNO DE LA PILA Y VOLVEMOS AL MENU PRINCIPAL

jr $31

########################################

#Opcion 4: Calcular el determinante de A ########################################

determinante:li $2, 4 #AQUÍ EMPEZAMOS A IMPLEMENTAR LA FUNCION QUE

la $4, opc4 #CALCULA EL VALOR DEL DETERMINANTE DE LA

syscall #MATRIZ "A"

la $4,A #LEEMOS LA DIRECCION DE LA MATRIZ

li $16,-1 #Y CARGAMOS LOS VALORES PARA PODER HACER

li $17,1 #UNA COMPARACION Y PODER ASI DECIDIR SU

li $18,2 #RANGO Y LLEVAR LOS DATOS AL METODO NECESARIO

li $19,3 #TAMBIEN HEMOS CARGADO EL -1 PARA HACER RESTAS

lb $5,2($4) #LEEMOS LAS COLUMNAS DE LA MATRIZ "A" (A=$4)

beq $5,$0, vacio #SI NO HAY COLUMNAS NO HAY MATRIZ =ERROR VACIO

lb $6,0($4) #SI HAY COLUMNAS LEEMOS LA FILAS QUE HAY

beq $6,$0, vacio #SI NO HAY FILAS NO HAY MATRIZ = ERROR DE VACIO

bne $5,$6, error_det #SI LAS FILAS<> A LAS COLUMNAS NO SE PUEDE

beq $5,$17, orden_1 #AQUÍ CALCULAMOS EL ORDEN DE LA MATRIZ SI ES

beq $5,$18, orden_2 #DE ORDEN1, 2, Ó 3 PARA ELEGIR LA RUTINA DE

beq $5,$19, orden_3 #CALCULO APROPIADA, SI ES IGUAL O MAYOR QUE

bge $5,4, error_det #ORDEN 4 ERROR NO PUEDO CALCULARLO (Bge)

orden_1: lb $7,4($4) #SI SU ORDEN ES UNO NO HAY TU TIA EL DATOS ES

j result #ES EL RESULTADO Y LO PASAMOS EN $7

orden_2: lb $8,4($4) #PASAMOS LA PARATE ALTA DE $4=A HACIA $8

lb $9,7($4) #LEMOS EL DATO 1,1 Y 2,2 DE LA MATRIZ

mult $8,$9 #AQUI LOS MULTIPLICAMOS Y SU RESULTADO

mflo $5 #NOS LO COGEMOS DE LO Y GUARDAMOS EN $5

lb $8,5($4) #LEEMOS EL DATO 1,2 Y TAMBIEN LEEMOS

lb $9,6($4) #EL DATO 2,1 DE LA MATRIZ Y A CONTINUACION

mult $8,$9 #LOS MULTIPLICAMOS Y EL RESULTADO LO MOVEMOS

mflo $6 #DE LO HACIA $6 DONDE LO MULTIPLICAMOS POR

mult $6,$16 #EL REGISTRO $16 QUE VALE -1 Y RESTAMOS LOS

mflo $6 #LOS DOS TERMINOS CON UNA SIMPLE SUMA PORQUE

add $7,$6,$5 #LE HEMOS CAMBIADO EL SIGNO Y GURADAMOS EL

j result #RESULTADO EN $7 PARA IPRIMIRLO EN PANTALLA

orden_3: lb $8,4($4) #SI EL DETERMINANTE ES DE ORDEN 3 USAMOS SARROUS

lb $9,8($4) #LEEMOS EL DATO 1,1 Y 2,2 LO MULTPLICO A CONTINUA

mult $8,$9 #CION Y EL RESULTADO TRAIGO DE LO A $9 Y LEO EL

mflo $9 #BIT QUE ME QUEDA DE LA DIAGONAL PPAL EL 3,3 Y

lb $8,12($4) #LO MULTIPLICO POR EL RESULTADO DE ANTES Y ESTO

mult $8,$9 #QUE ME DA LO GUARDO EN EL REGISTRO $5

mflo $5

lb $8,5($4) #SEGUIMOS CON SARROUS, AQUI LEEMOS LOS DATOS

lb $9,9($4) # LEEMOS EL DATO 1,2 Y EL 2,3 LOS MULTIPLICAMOS

mult $8,$9 #Y EL RESULTADO NOS LO TRAEMOS DE LO Y LO

mflo $9 #PASAMOS AL REGISTRO $9 QUE LO MULTIPLICAMOS

lb $8,10($4) #CON ESTE DATO QUE COGEMOS DE A POSICION 3,1

mult $8,$9 #Y EL RESULTADO LO ALMACENAMOS DESDE LO

mflo $6 # AL REGISTRO $6 Y SUMAMOS LOS DOS PRIMEROS

add $7,$5,$6 #RESULTADOS Y LOS GUARDAMOS EN $7

lb $8,6($4) #AQUI HACEMOS EL SEGUNDO TRIANGULO CON LOS DATOS

lb $9,7($4) #CORRESPONDIENTES A LAS POSICIONES 1,3 Y 2,1 DE

mult $8,$9 #LA MATRIZ, LOS MULTIPLICO Y GUARDO SU RESULTADO

mflo $9 #EN EL REGISTRO $9

lb $8,11($4) #AQUI LEO EL DATO DE LA MATRIZ 3,2 PARA MULTIPLI

mult $8,$9 #CARLO POR EL RESULTADO ANTERIOR, PARA SUMMARLO

mflo $6 # AL VALOR QUE OBTUBE LA DIAGONAL Y DEL PRIMER

add $7,$6,$7 #TRIANGULO, Y LO GUARDO TODO EN $7

lb $8,6($4) #AHORA CALCULO LA DIAGONAL INVERSA CON LOS DATOS

lb $9,8($4) #QUE EN TEORIA OCUPAN LA POSICION 1,3 MULTIPLICADO

mult $8,$9 #POR EL DE LA POSICION 2,2 Y RECOJO EL RESULTADO

mflo $9 #EL REGISTRO $9, A CONTINUACION SIGO CALCULANDO

lb $8,10($4) #EL ULTIMO DATO DE LA DIAGONAL INVERSA EL 3,1

mult $8,$9 #Y AQUI LO MULTIPLICO POR EL VALOR DE EL PRODUCTO

mflo $9 #DE LOS DOS ANTERIORES EL RESULTADO LO CARGO EN $9

mult $9,$16 #CON ESTO LO MULTPLICO POR -1 Y LO HAGO NEGATIVO

mflo $6 #PARA ASÍ NO TENER QUE RESTAR, SOLO LO SUMO A $6

add $7,$6,$7 #QUE ES EL RESULTADO DE ANTES AL CUAL TENGO QUE

#SEGUIR RESTANDOLE EL RESULTADO DE LOS 2 TRIANGULO

lb $8,5($4) #AQUI LEO LOS DATOS 1,2 Y 2,1 PARA EMPEZAR A

lb $9,7($4) #CALCULAR EL PRIMER TIRIANGULO,

mult $8,$9 #LOS MULTIPLICO Y EL RESULTADO ME LO TRAIGO

mflo $9 #Y LO GUARDO EN $9

lb $8,12($4) #AQUI CALCULO EL TERCER VERTICE DE LA POSICION

mult $8,$9 #3,3 Y LO SUMO A LO ANTERIOR GUARDANDOLO TODO

mflo $9 #EN $9, A CONTINUACION LO MULTIPLICO POR -1

mult $9,$16 #PARA HACER UNA SUMA EN VEZ DE UNA RESTA

mflo $6

add $7,$6,$7 #Y AQUI SE LO SUMO A LOS VALORES ANTERIORES

lb $8,4($4) #POR FIN CALCULO EL ULTIMO TRIANGULO CORRESPO

lb $9,9($4) #DIENTE A LOS DATOS DE LAS POSICIONES 1,1

mult $8,$9 #2,3 Y 3,2 REPITIENDO LAS OPERACIONES COMO

mflo $9

lb $8,11($4)

mult $8,$9 #ANTES Y MULTIPLICANDO EL VALOR OBTENIDO

mflo $9 #POR -1 SUMANDOLO AL TOTAL QUE LLEVAVA Y

mult $9,$16

mflo $6 #LO GUARDO EN EL REGISTRO $7

add $7,$6,$7

bne $10,255,result #AQUÍ SALTA A LA RUTINA PARA MOSTRAR LA SOLUCION

jr $31

result: move $10,$0 #PONEMOS A CERO $10

li $2, 4 #INTRODUCIMOS UN SALTO DE CARRO

la $4, ret

syscall

li $2, 4

la $4, mensaje_det #PONEMOS LA FRASE DEL RESULTADO

syscall

move $4,$7 #MOVEMOS EL RESULTADO A $4 PARA PODER

li $2,1

syscall

li $2, 5 #IMPRIMIRLO EN PANTALLA

syscall

jr $31 #AQUÍ VOLVEMOS AL MENU PPAL

error_det: move $10,$0 #SI POR CASUALIDAD NOS DA UNA ERROR

la $4,det_error #DEL ORDEN AQUÍ TRATAMOS ESE ERROR

li $2,4 #DANDO UN MESAJE EN PANTALLA

syscall

li $2,5 #CON ESTO METEMOS UNA PAUSA

syscall

jr $31 #CON ESTO REGRESAMOS AL MENU PPAL

########################################

# Pausa

########################################

pausa:

li $2, 5

syscall

jr $31

########################################

# Limpiar la pantalla

# introduce 25 "\n"

########################################

limpiar: addi $29, $29, -8

sw $9, 4($29)

sw $8, 0($29)

li $8, 0

bucle: li $2, 4

la $4, ret

syscall

addi $8, $8, 1

slti $9, $8, 25

beq $9, $0, bucle

lw $9, 4($29)

lw $8, 0($29)

addi $29, $29, 8

jr $31

########################################

# Opcion 5: Sumar dos matrices (c <= a+b)

########################################

sumar:

li $2,4

la $4,opc5

syscall

# implementar aquí......................

li $2,5 #AQUI PEDIMOS EL NUMERO 1=RESTA 0=SUMA

syscall

move $7,$2 #Y LO GUARDAMOS EN $7

la $4,A #LEEMOS LAS 3 MATRICES A, B Y C

la $5,B

la $6,C

lh $9,0($4) #LEEMOS LAS FILASDE A

lh $11,0($5) #Y TAMBIEN LAS DE B

beqz $9, vacio #COMPROBAMOS SI A O B ESTAN VACIAS Y

beqz $11, vacio #SI LO ESTAN VAMOS A LA RUTINA VACIO

lh $10,2($4) #SINO ESTAN VACIAS LEEMOS LAS COLUMNAS

lh $12,2($5) #DE AMBAS MATRICES

bne $9,$11,error1 #SI NO COINCIDEN LAS FILAS O LAS

bne $10,$12,error1 #COLUMNAS DE AMBAS VAMOS A ERROR1

sh $9,0($6) #SI SI COINCIDEN SALVAMOS EN C EL NUMERO

sh $10,2($6) #DE FILAS Y DE COLUMNAS

addi $4,$4,4 #Y SUMAMOS MEDIA PALABRA A TODAS LAS

addi $5,$5,4 #MATRICES PARA EMPEZAR A COLOCARLE ELEMENTOS

addi $6,$6,4

li $11,0 #RESETEO EL REGISTRO $11

filas: li $12,0 #Y TAMBIEN EL 12 PARA RENICIAR LAS FILAS

colum: lb $13,0($4) #LAS COLUMNAS DE LAS MATRICES A Y B

lb $14,0($5)

beq $7,$0,suma #SI $7 VALE 0 SALTA A LA RUTINA SUMA

li $24,1 #SINO COGEMOS Y PONEMOS $24 (pqsi)LO PONEMOS

bgt $7,$24, __start #A 1 Y SI $7>1 SALTA A __start PORQUE

sub $15,$13,$14 #EL USUARIO SE HA EQUIVOCADO, Y SI ES IGUAL A 1

j sigue #RESTAMOS A MENOS B Y LO GUARDAMOS EN $15

suma: add $15,$13,$14 #AQUÍ SUMAMOS A +B

sigue: sw $15,0($6) #UNA VEZ SUMADOS LOS PRIMEROS VALORES

addi $4,$4,1 #INCREMENTAMOS UNA POSICION EN CADA

addi $5,$5,1 #MATRIZ, LA A Y LA B

addi $6,$6,4 #Y PREPARAMOS LA MATRIZ C PARA PASARLE LOS DATOS

addi $12,$12,1 #Y SUMAMOS UNO AL REGISTRO $12 QUE TENIAMOS A 0

bne $12,$10,colum #DONDE LE PASAMOS EL VALOR DE LAS COLUMNAS

addi $11,$11,1 #AQUÍ TAMBIEN PREPARAMOS $11 PARA PASARLE

bne $11,$9,filas #EL VALOR DE LAS FILAS

li $2,5 #AQUI METEMOS UN ENTERO E FORMA DE PAUSA

syscall

jr $31 #Y SIN NADA MAS QUE OFRECER NOS VAMOS

error1: li $2,4 #AQUÍ DESARROLLAMOS LA RUTINA DE ERROR SI

la $4,smensajeerror

syscall #LAS MATRICES NO LLEGAN A SER CUADRADAS

li $2,5

syscall

jr $31

########################################

# Opcion 6: Multiplicar por un escalar (C <= e*A)

########################################

multescalar: li $2, 4

la $4, opc6

syscall

# implementar aquí......................

li $2,4 #PREPARAMOS PARA LEER UNA CADENA

la $4,peticionescalar

syscall #IMPRIMIMOS EN PANTALLA LA PETICION DEL Nº

li $2,5 #LEEMOS EL NUMERITO

syscall

move $5,$2 #PONEMOS EL NUMERITO EN $5

la $8,A #LEEMOS LA DIRECCION DE LA MATRIZ A

la $13,C #Y COMO LA DE C TAMBIEN

lh $9,0($8) #LEEMOS LAS DIMENSIONES DE A Y GUARDAMOS

lh $10,2($8) #LA PARTE BAJA EN $9 Y LA ALTA EN $10

sh $9,0($13) #Y SALVAMOS LA PARTE BAJA DE A EN C

beqz $9, vacio #COMPROBAMOS QUE NO ESTA VACIA SINO ERROR

sh $10,2($13) #SALVAMOS LA PARTE ALTA DE A EN C (COLUMNASDE C)

addi $8,$8,4 #INCREMENTAMOS 4 PARA LEER LOS DATOS DE A

addi $13,$13,4 #TAMBIEN INCREMENTAMOS C PARA PREPARARLA

li $11,0 #YRESETEAMOS $11 QUE NOS HACE FALTA

rep_fil: li $12,0 #PONEMOS LAS FILAS A CERO

rep_col: lb $4,0($8) #Y CARGAMOS EL PRIMER DATO DE A EN $4

mul $7,$5,$4 #MULTIPLICAMOS ESE DATO POR EL ESCALAR

addi $8,$8,1 #INCREMENTAMOS LA MATRIZ A EN 1

sw $7,0($13) #Y LO SALVAOS EN LA PRIMERA POSICION DE C

addi $13,$13,4 #INCREMENTAMOS C PARA LA NUEVA PALABRA

addi $12,$12,1 #INCREMENTAMOS LAS COLUMNAS

bne $12,$10,rep_col #SI COLUMNAS DE A DISTINTO DE C REPITE

addi $11,$11,1 #INCREMENTO LAS FILAS

bne $11,$9,rep_fil #Y SI NO LLEGO TODAVIA REPITO EL BUCLE

jr $31

########################################

# Opcion 7: Salir del programa. (Exit)

########################################

abandonar:

li $2,4 #CON ESTO COMO QUE TERMINAMOS YA QUE ESTA BIEN

la $4,opc7

syscall

li $2,4 #UNA PAUSA TONTA

la $4,ret

syscall

li $2, 10 #Y NOS SALIMOS DEL PROGRAMA ***ADIOS****

syscall

########################################

# Posición de memoria

# Procedimiento que devuelve el desplazamiento

# que ocupará el dato cuyas coordenadas se pasan como argumento

# entradas: $4: numero de columnas

# $5: i

# $6: j

# $7: tamaño

# salida: $2: desplazamiento: ((i*n+j)*tamaño+4)

########################################

posicion:

# utilizo el mismo procedimiento para acceder a datos de tipo byte o palabra

# la unica diferencia es que se haya utilizado el parámetro 4 ($7) no metiendo

# nada (0 = utilizado para direccionar bytes ) o pasando 4 (utilizado para acceder a palabras)

beq $7, $0, ini #AQUI IMPLEMETAMOS UNOS CONTADORES PARA ESCANEAR

j cont #LAS MATRICES Y ASÍ SABER EN QUE POSICION STAN

ini: add $7, $0, 1 #LOS DATOS Y PODER TRASPONERLOS .

cont: mult $4, $5 # i*n

mflo $2 #AQUI APLICAMOS LA FORMULA QUE NOS

add $2, $2, $6 # i*n+j #INDICASTEIS ARRIBA PARA CALCULARLO

mult $2, $7

mflo $2

add $2, $2, 4 # (i*n+j)*tamaño+4

move $7, $0

jr $31 #CON ESTO NOS VOLVEMOS AL MENU PRINCIPAL (por si habia dudas)

#######################Aquí se acabó todo ################################

INDICE DE COLORES

plantilla original

codigo fuente realizado por nosotros

comentarios esplicativo del codigo fuente

comentarios diversos

CODIGO

FUENTE

EJECUTABLE