power X^Y

.data
str1: .asciiz "Give integer X from 1 to 20 "
str2: .asciiz "Give integer Y from 0 to 5 "
errormsg: .asciiz "Out of range.\n"
nline: .asciiz "\n"
result1: .asciiz " raised to "
result2: .asciiz " gives: "
.text

error:
li $v0,4 #print string1
la $a0,errormsg
syscall
beq $s2,$zero,getX
j getY

.globl main
main:
addi $s0,$zero,21 #s0=21
addi $s1,$zero,6 #s1=6

getX:
addi $s2,$zero,0 #s2=0 to input x and 1 to input y
li $v0,4
la $a0,str1
syscall #print string1
li $v0,5
syscall #read int
slt $s3,$v0,$s0
beq $s3,$zero,error
blez $v0,error
move $t0,$v0

getY:
addi $s2,$zero,1
li $v0,4
la $a0,str2
syscall #print string2
li $v0,5
syscall #read int
slt $s3,$v0,$s1
beq $s3,$zero,error
bltz $v0,error

beq $t1,$zero,else #if (t1=0) t2=1, t1=y,t2=result
addi $t2,$zero,1
addi $s4,$zero,0

loop: #if s4slt $s5,$s4,$t1
beq $s5,$zero,printresult
#if $s1=0 goto printresult(s4=t1)
mul $t2,$t2,$t0 #t2=t2*t0
addi $s4,$s4,1
j loop

else:
addi $t2,$zero,1
j printresult

printresult:
li $v0,1
move $a0,$t0
syscall #print X
li $v0,4
la $a0,result1
syscall #print " raised to "
li $v0,1
move $a0,$t1
syscall #print Y
li $v0,4
la $a0,result2
syscall #print " gives "
li $v0,1
move $a0,$t2
syscall #print result(t2)
li $v0,10
syscall #exit
Read More

Converter numa Base diferente

.data
msg1: .asciiz "Inserir Valor (A > 0) : "
msg2: .asciiz "Inserir o valor para converter
(2<=B<=10): "

msg3: .asciiz "\nResultado : "
.text
.globl main
main:
addi $s0,$zero,2
addi $s1,$zero,10
getA:

li $v0,4
la $a0,msg1
syscall
li $v0,5
syscall
blt $v0,$zero,getA

move $t0,$v0
getB:

li $v0,4
la $a0,msg2
syscall
li $v0,5
syscall
blt $v0,$s0,getB
bgt $v0,$s1,getB

add $t1,$zero,$v0

li $v0,4
la $a0,msg3
syscall

add $a0,$zero,$t0
add $a1,$zero,$t1

jal convert

li $v0,10
syscall

convert:
#a0=A
#a1=B

addi $sp,$sp,-16

sw $s3,12($sp) #contador, usado

sw $s0,8($sp) #A
sw $s1,4($sp) #B
sw $ra,0($sp)

add $s0,$zero,$a0
add $s1,$zero,$a1

beqz $s0,end

div $t4,$s0,$s1 #t4=A/B
rem $t3,$s0,$s1 #t3=A%B
add $sp,$sp,-4
sw $t3,0($sp) #save t3

add $a0,$zero,$t4 #pass A/B
add $a1,$zero,$s1 #pass B
addi $s3,$s3,1
jal convert #call convert

end:

lw $ra,0($sp)
lw $s1,4($sp)
lw $s0,8($sp)
lw $s3,12($sp)
beqz $s3,done
lw $a0,16($sp)
li $v0,1
syscall
done:
addi $sp,$sp,20
jr $ra #return
Read More

Comparar Strings

.data
msg1:.asciiz "Please insert text (max 20 characters): "
msg2:.asciiz "\nNOT SAME"
msg3:.asciiz "\nSAME"
str1: .space 20
str2: .space 20
.text
.globl main
main:
addi $v0,4
la $a0,msg1
syscall
li $v0,8
la $a0,str1
addi $a1,$zero,20
syscall #got string 1
li $v0,4
la $a0,msg1
syscall
li $v0,8
la $a0,str2
addi $a1,$zero,20
syscall #got string 2

la $a0,str1 #pass address of str1
la $a1,str2 #pass address of str2
jal strcmp #call strcmp

beq $v0,$zero,ok #check result
li $v0,4
la $a0,msg2
syscall
j exit
ok:
li $v0,4
la $a0,msg3
syscall
exit:
li $v0,10
syscall

strcmp:
add $t0,$zero,$zero
add $t1,$zero,$a0
add $t2,$zero,$a1
loop:
lb $t3($t1) #load a byte from each string
lb $t4($t2)
beqz $t3,checkt2 #str1 end
beqz $t4,missmatch
slt $t5,$t3,$t4 #compare two bytes
bnez $t5,missmatch
addi $t1,$t1,1 #t1 points to the next byte of str1
addi $t2,$t2,1
j loop

missmatch:
addi $v0,$zero,1
j endfunction
checkt2:
bnez $t4,missmatch
add $v0,$zero,$zero

endfunction:
jr $ra
Read More

Menor de 3 numeros

.data
val1: .word 0x10
val2: .word 0x35
val3: .word 0x16
max: .word 0
# aux1 reside no registo $t1 do CPU
.text
.globl main
main:
la $t0, val1 # $t0 = val1
lw $t1, 0($t0) # aux1 = val1
lw $t2, 4($t0) # aux2 = val2
lw $t3, 8($t0) # aux3 = val3
bge $t2,$t1,endif # if( aux2 > aux1) {
move $t1,$t2 # aux1 = aux2
# }
endif: bge $t3,$t1, endfor
move $t1, $t3

endfor: sw $t1, 12($t0)


jr $ra
Read More

Numeros Primos

.data
array: .space 80
.text
.globl main

main: addu $s0,$ra,$0
lui $s1,0x1001
addi $s2,$s1,80
addi $t0,$0,2
addi $t5,$0,1
sw $t0,0($s1)
addi $s1,$s1,4

loop1: addi $t0,$t0,1
or $t1,$t0,$0

loop2: addi $t1,$t1,-1
slt $t4,$t5,$t1
bne $t4,$0,skip
sw $t0,0($s1)
addi $s1,$s1,4
beq $s1,$s2,exit
j loop1
skip: div $t0,$t1
mfhi $t3
bne $t3,$0,loop2
j loop1

exit: addu $ra, $0, $s0
jr $ra
Read More

Temperatura

.data

prompt: .asciiz "\n Introduzir Temperatura:" #string
confirm: .asciiz "\n Em Fahrenheit é : " #String
display1: .asciiz "\n Em centígrado é:" #string


fhtTemp: .word 0 #var1
CentiTemp: .word 0 #var2

.text
.globl main

main:
li $v0,4 #teste a primeira
la $a0,prompt #String
syscall #apresenta no ecra

li $v0,5
syscall
sw $v0,fhtTemp

li $v0,4
la $a0,confirm
syscall

li $v0,1
lw $a0,fhtTemp
syscall


#convert

lw $t1,fhtTemp
li $a1,32
sub $t2, $t1, $a1
li $a1,5

mult $t2,$a1
mflo $t3
li $a1,9
div $t4, $t3, $a1

#end

li $v0,4
la $a0, display1
syscall

li $v0,1
move $a0,$t4
syscall

li $v0,10
syscall
Read More

Inverter String

.data
.align 1
String: .space 14 #*change
msg1: .asciiz "Introduzir caracteres: "
msg2: .asciiz "\n"
msg3: .asciiz "String is: "
msg4: .asciiz "\nString Invertida: "
.text
.globl main
main:

addi $s0,$zero,13 #*change
addi $t0,$zero,0

in:
la $a0,msg2
li $v0,4
syscall

li $v0,4
la $a0,msg1
syscall
li $v0,12
syscall

add $t1,$v0,$zero
sb $t1,String($t0)
addi $t0,$t0,1
slt $t1,$s0,$t0
beq $t1,$zero,in

sb $zero,String($t0) #ending zero

la $a0,msg2
li $v0,4
syscall
la $a0,msg2
li $v0,4
syscall
la $a0,msg3
li $v0,4
syscall

la $a0,String
li $v0,4
syscall

addi $a1,$zero,14 #pass length-*change
jal stringreverse #reverse

la $a0,msg2
li $v0,4
syscall

la $a0,msg4
li $v0,4
syscall

la $a0,String
li $v0,4
syscall

li $v0,10
syscall


stringreverse:

add $t0,$a0,$zero #beginning address

add $t1,$zero,$zero #i=0
addi $t2,$a1,-1 #j=length-1

loop:

add $t3,$t0,$t1
lb $t4,0($t3) #lb String[i]

add $t5,$t0,$t2
lb $t6,0($t5) #lb String[j]

sb $t4,0($t5) #String[j]=String[i]
sb $t6,0($t3) #String[i]=String[j]

addi $t1,$t1,1 #i++
addi $t2,$t2,-1 #j--
#if i>=j break - $t1<$t2
slt $t6,$t2,$t1
beqz $t6,loop

jr $ra
Read More

Ordenar

.data
.align 2
lista: .space 40 #int lista[10]
prompt: .asciiz " Insira um inteiro " #char prompt[18]

.text
.globl main

#le a lista dos numeros a ordenar

main: la $a3,lista #a3=lista
li $t0,0 #i=0
readlp: la $a0,prompt
li $v0,4
syscall #puts prompt
li $v0,5
syscall #geti v0
sw $v0,0($a3)
add $a3,$a3,4
add $t0,$t0,1 #i=i+1
slt $t1,$t0,10 #if(t0<10) t1=1
bnez $t1,readlp
# ordenaçao da lista
li $t0,0 # i=0
for1: bge $t0,9,end_for1 # while (i<9)
la $s0,lista
sll $s1,$t0,2 #s1=i*4
add $s0,$s0,$s1 #s0=&(lista[i])
addi $t1,$t0,1 # j=i+1

for2: bge $t1,10,end_for2 # while (j<10)
la $s2,lista
sll $s1,$t1,2 #s1=j*4
add $s2,$s2,$s1 #s0=&(lista[j])
lw $t2,0($s0) # aux=lista[i]
lw $t3,0($s2) # aux1=lista[j]
if: ble $t2,$t3,end_if # if (aux>aux1)
sw $t3,0($s0) # lista[i]=aux1
sw $t2,0($s2) # lista[j]=aux

end_if: addi $t1,$t1,1 # j++
b for2
end_for2: addi $t0,$t0,1 # i++
b for1
end_for1: li $v0,10 # exit
syscall
Read More

Combinações / Factorial

#--------------------------------------------------
# codigo em linguagem c
#--------------------------------------------------
# main(void)
# {
# char s[20];
# int n,p,cmb;
# printf("Insira o n: ");
# get (s,20);
# n = atoi(s,20);
# printf(" Insira o p ");
# get(s,20);
# p = atoi(s,20);
# cmb = comb(n,p);
# printf(" combinações = ");
# itoa(comb,s,20); printf(s);
# }
#--------------------------------------------------
# int comb(int n, int p)
# {
# return fact(n) / (fact(p) * fact(n-p)
# }
#---------------------------------------------------
# int fact (int n) /* algoritimo não - recursivo */
# {
# int i;
# int fct = 1;
# if (n<=1)
# return 1;
# else
# for (i=2; i<=n; i++)
# fct = fct * i;
# return fct;
#---------------------------------------------------
.data
str: .space 20
prompt1: .asciiz"\nInsira o n: "
prompt2: .asciiz"\ninsira o p: "
prompt3: .asciiz"\nCombinações = "
prompt4: .asciiz"\nResto="
.text
.globl main
main: la $a0,prompt1
li $v0,4
syscall
la $a0,str #
li $v0,8 #
li $a1,20 # Leitura de n
syscall
jal atoi # invocação da função ATOI
move $s0,$v0 # n=atoi(s,20)=$s0
la $a0,prompt2
li $v0,4
syscall
la $a0,str
li $v0,8
li $a1,20 # Leitura de p
syscall
jal atoi # invocação da função ATOI
move $a1,$v0 # p=atoi(s,20)=$s1
move $a0,$s0
jal comb # leitura de Combinações(n,p)
move $s2,$v0 # $s2=comb(s,20)=cmb
la $a0,prompt3
li $v0,4
syscall
add $a0,$0,$s2
la $a1,str
li $a2,20
jal itoa # Invocação da função Itoa
la $a0,str
li $v0,4
syscall
li $v0,10
syscall
#-------------------------------------------------------------------------
# Função ATOI (Converte string para inteiro)
#
# Parametros de entrada n--> Tamanho da string
# *s-> Array de string
# Retorno num-->Nº imteiro $v0=$t4
#------------------------------------------------------------------------
atoi: addi $sp,$sp,-4
sw $ra,0($sp) # salvaguardar os registos
li $v0,0 # num=0
add $t1,$0,$a0 # p=s
add $t2,$a0,$a1 # s+n
while: lb $t3,0($t1) # *p
bgeu $t1,$t2,exit1 # if (p>=s+n) go to exit1
blt $t3,'0',exit1 # if (*p<'0') go to exit1
bgt $t3,'9',exit1 # if (*p>'9') go to exit1
sub $t4,$t3,'0' # digito= *p-'0'
mul $v0,$v0,10 # num=10*num
add $v0,$v0,$t4 # num=10*num+digito
addiu $t1,$t1,1
j while
exit1: lw $ra,0($sp)
addi $sp,$sp,4 # Repor os registos
jr $ra
#-----------------------------------------------------------------
# Função ITOA (Convert inteiro para string)
#
# Parametros de entrada n--> Nº inteiro
# s--> Array de strings para retorno
# Retorno --> String de caracteres
#-----------------------------------------------------------------
itoa: addi $sp,$sp,-4
sw $ra,0($sp) # salvaguardar os registos
li $t1,10
move $t0,$a0
move $t3,$a1
li $t4,0 # i=0
move $t5,$a0 # j=n
do: div $t5,$t1
mfhi $t2 # parte concernente ao resto
mflo $t0 # parte concernente ao quociente
add $t2,$t2,'0' # resto + '0'
sb $t2,0($t3)
addiu $t3,$t3,1
addi $t4,$t4,1
move $t5,$t0 # $t5=Quociente
bnez $t0,do
sb $0,($t3) # coloca caracter nulo
#----------------------------------------------------------------------
# procedimento troca
#-----------------------------------------------------------------------
move $t1,$t3 # ponteiro para o fim do array
addi $t1,$t1,-1
move $t2,$a1 # ponteiro para o inicio do array
if: ble $t1,$t2,fim # if($t1<=$t2) go to fim
lb $t4,0($t1)
lb $t5,0($t2)
sb $t5,0($t1)
sb $t4,0($t2)
addi $t2,$t2,1
addi $t1,$t1,-1
j if
fim: lw $ra,0($sp)
addi $sp,$sp,4 # Repor os registos
jr $ra
#-------------------------------------------------------------------
# Função Calculo de combinações
#
# Parametros de entrada : n,p
# Parametros de saida : cmb= n!/(p!(n-p)!)
#---------------------------------------------------------------------
comb: addi $sp,$sp,-12
sw $ra,0($sp)
sw $s0,4($sp)
sw $s1,8($sp) # salvaguardar os registos
move $s0,$a0 # n
move $s1,$a1 # p
sub $a0,$s0,$s1 # n-p
jal fact1
move $a0,$s1
move $s1,$v0 # fact(n-p)
jal fact1
mul $s1,$s1,$v0 # $s1=fact(p)*fact(n-p)
move $a0,$s0
jal fact1 # fact de (n)
div $v0,$v0,$s1 # fact(n) / fact(p)*fact(n-p)
lw $s1,8($sp) # Repor os registos
lw $s0,4($sp)
lw $ra,0($sp)
addi $sp,$sp,12
jr $ra
#-------------------------------------------------------------------------------------
# Função Factorial (não recursivo)
#
# Parametros de entrada : inteiro
# Parametros de saida : fact=fact*i
#-------------------------------------------------------------------------------------
fact1: li $v0,1 # fct=1
bgt $a0,$v0,fim1 # if(n<=1)
jr $ra # return fct
fim1: li $t0,2 # i=2
for: bgt $t0,$a0,fim2 # while (i <= n)
mul $v0,$v0,$t0 # fct=fct*i
addi $t0,$t0,1 # i++
b for
fim2: jr $ra # return fct
Read More

O maior de 3

.data

prompt1: .asciiz"introduza os três numeros:\n"
resultado: .asciiz"o maior é: "
.text
.globl main

main:
la $a0,prompt1
li $v0,4
syscall
li $v0,5
syscall
move $t0,$v0

li $v0,5
syscall
move $t1,$v0

li $v0,5
syscall
move $t2,$v0

sge $s0,$t0,$t1
else: bnez $s0,if1
sge $s0,$t1,$t2
bnez $s0,else1
move $t4,$t2 # max=$t2
j fim
else1: move $t4,$t1 # max=$t1
j fim

if1: sge $s0,$t1,$t2
bnez $s0,if2
sge $s0,$t2,$t0
bnez $s0,if3

if2: move $t4,$t0 # max=$t0
j fim
if3: move $t4,$t2 # max=$t2
j fim
fim: la $a0,resultado
li $v0,4
syscall
li $v0,1
move $a0,$t4
syscall
Read More

Pensa num número

##################################################################
#
# Programa em linguagem C
#
# void main(void)
# {
# char prompt[] = "1. Pensa num numero!\n2. Adiciona 3\n"
# "3. Multiplica o resultado por 2\n"
# "4. Subtrai o numero em que pensaste\n"
# "\n\t Qual o resultado? ";
# char result[] = "\nO numero em que pensaste e': ";
# int num;
#
# print_str( prompt );
# num = read_int();
# print_str( result );
# print_int( num - 6 );
# }
#
##################################################################
.data
prompt: .ascii "1. Pensa num numero!\n"
.ascii "2. Adiciona 3\n"
.ascii "3. Multiplica o resultado por 2\n"
.ascii "4. Subtrai o numero em que pensaste\n"
.asciiz "\n\tQual o resultado? "
result: .asciiz "\nO numero em que pensaste e': "
##################################################################
.text
.globl main
# int num; "num" reside no registo $t0
#
main: la $a0, prompt # $a0 = prompt
li $v0, 4 # $v0 = 4 (syscall "print_str")
syscall # print_str( prompt )
#
li $v0, 5 # $v0 = 5 (syscall "read_int")
syscall # read_int() (o valor lido é
# devolvido no reg. $v0)
move $t0, $v0 # $t0 = $v0 ( num = read_int() )
#
la $a0, result # $a0 = result
li $v0, 4 # $v0 = 4 (syscall "print_str")
syscall # print_str( result )
#
sub $a0, $t0, 6 # $a0 = $t0 - 6 ( $a0 = num - 6)
li $v0, 1 # $v0 = 1 (syscall "print_int")
syscall # print_int( num - 6 )
#
jr $ra # abandona o programa
#########################################
Read More

Calculo o maior dentro de uma STRING

.data
Lista: .word 10 30 15 27 94 40 1 4 9 20
max: .space 4

.text
.globl main

main: la $t0, Lista #t0=Lista[0]
lw $t1, 0($t0) #t1=Lista[0]
li $t2, 0 #i=0

For: bgt $t2,10,endfor
mul $t3, $t2, 4 #t3=4*i para andar de 4 em 4
add $t3, $t3, $t0 # adiciona o t3 para o t0 e guardo no t3

lw $t4,0($t3)
ble $t4, $t1, endif
move $t1, $t4

endif: add $t2, $t2, 1 #i++

j For

endfor: la $t4,max
sw $t1, 0($t4)

jr $ra
Read More

Virgula Flutuante

int main(void)
{
float res;
int val1;
val1 = 35;
res = (float)val1 / 100.0;
print_flat(res);
return 0;
}


.data
.text
.globl main

main:
li.s $f6, 10.0 #f6 =100.0
li $t0,35 #val=35
mtc1 $t0, $f4
cvt.s.w $f4, $f4 #float(val1)

div.s $f12, $f4, $f6 #res=float(val1)\100.0
li $v0,2 #print.float(res)
syscall
li.s $f0,0.0
jr $ra
Read More

Tabuada

.data

prompt1: .asciiz" ### TABUADA ###\n\n"
prompt2: .asciiz"\n Qual a tabuada que deseja ver "
prompt3: .asciiz" x "
prompt4: .asciiz" = "
prompt5: .asciiz" \n"

.text
.globl main
main:

la $a0, prompt1 #solicita a introdução do número
li $v0, 4
syscall

la $a0, prompt2 #solicita a introdução do número
li $v0, 4
syscall

li $v0, 5 #Lê o número do teclado
syscall
move $t1, $v0

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

li $t0, 1 # i=1


for: bgt $t0, 10, endfor

move $a0,$t1
li $v0, 1 #
syscall #

la $a0, prompt3 # x
li $v0, 4
syscall

move $a0,$t0
li $v0, 1 #
syscall #


la $a0, prompt4 # =
li $v0, 4
syscall



mul $t2, $t0, $t1
move $a0,$t2
li $v0, 1 #
syscall #


la $a0, prompt5 # \n
li $v0, 4
syscall

endif: add $t0, $t0, 1 # i++
j for
endfor:


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

li $v0, 5 #Lê o número do teclado
syscall
move $a0, $v0

jr $ra
Read More

programa que lê da consola 10 valores inteiros, armazenando-os no (..........)

.data
#
#lista: .space 40
#ms: .asciiz"Introduza 10 inteiros\n"
#ms1: .asciiz"A lista é:"
#n: .asciiz"..."
#
# .text
# .globl main
#
#
#main: la $a0,ms
# li $v0,4 # 4 print string
# syscall
#
# la $a3,lista # a3 ponteiro para a lista
# li $t0,0 # inicaliza o index a 0
#
#readme: li $v0,5 # 5 para read int
# syscall
# sw $v0,0($a3) #escreve v0 na primeira posicao de memoria
#
# add $a3,$a3,4 #incrementa de 4 em 4o $a3
#
# addi $t0,$t0,1 # i++
#
# blt $t0,10,readme #while i<10
#
# la $s0,lista #mover a lista para dentro do $s0
# li $t1,10
#
# la $a0,ms1 #escrever mensagem no ecra
# li $v0,4
# syscall
#
#for: lw $a0,0($s0) #Mostra a primeira posição do array
# li $v0,1
# syscall
#
# la $a0,n
# li $v0,4
# syscall
#
# addiu $s0,$s0,4
# sub $t1,$t1,1
# bnez $t1,for
# jr $ra
Read More

Bubble Sort

.data
A: .word 4,5,6,7,8,9,10,2,1,3 # declaracao array

.text
.globl Main
Main:
li $a0, 10 # parameter n
sll $a0, $a0, 2 # number of bytes in array A
outer:
sub $t0, $a0, 8 # $t0: j-1
li $t1, 0 # no swap yet
inner:
lw $t2, A+4($t0) # $t2 <- A[j]
lw $t3, A($t0) # $t3 <- A[j-1]
bgt $t2, $t3, no_swap # A[j] <= A[j-1]?
sw $t2, A($t0) # A[j-1] <- $t2 \ move bubble
sw $t3, A+4($t0) # A[j] <- $t3 / $t2 upwards
li $t1, 1 # swap occurred
no_swap:
sub $t0, $t0, 4 #proximo elemento do array (next array element)
bgez $t0, inner # more?
bnez $t1, outer # did we swap?
li $v0, 10 # exit
syscall
Read More

Divisão

#--------------------------------------------------
# LINGUAGEM C PARA CONTA DE DIVISAO
#--------------------------------------------------
#int main(void)
#{
# char str[20];
# int dividendo, divisor, quociente, resto;
# print_str("Insira o dividendo: "); /* syscall */
# read_str(str, 20); /* syscall */
# dividendo = atoi(str);
# print_str("Insira o divisor: ");
# read_str(str, 20);
# divisor = atoi(str);
# quociente = dividendo / divisor;
# resto = dividendo % divisor;
# print_str("Quociente = ");
# print_int(quociente); /* syscall */
# print_str("Resto = ");
# print_int(resto);
# return 0;
#}
#--------------------------------------------------------
.data
string: .space 20
texto1: .asciiz"\n\n\tInsira o dividendo: "
texto2: .asciiz"\n\tInsira o divisor: "
texto3: .asciiz"\n\tQuociente= "
texto4: .asciiz"\n\tResto= "
prompt1: .asciiz"\n\t****************************"
prompt2: .asciiz"\n\t**"
prompt3: .asciiz"\n\t* Copyrirght by Entroncamento*"
prompt4:: .asciiz"\n\t**"
prompt5: .asciiz"\n\t***********"


#--------------------------------------------------------
# ESCREVER O CABECALHO
#--------------------------------------------------------
.text
.globl main
main: la $a0,prompt1
li $v0,4
syscall
la $a0,prompt2
li $v0,4
syscall
la $a0,prompt3
li $v0,4
syscall
la $a0,prompt4
li $v0,4
syscall
la $a0,prompt5
li $v0,4
syscall
#--------------------------------------------------------
# FIM DO CABECALHO
#--------------------------------------------------------



la $a0,texto1
li $v0,4
syscall # Faz um print string para o ecrã do "insira o dividendo"

la $a0,string
li $v0,8
li $a1,20
syscall

jal atoi # Chama a função "Atoi"
move $s0,$v0 # s0 fica com o valor devolvido pela fução "Atoi"
la $a0,texto2
li $v0,4
syscall # Faz um print string para o ecrã do " Insira o divisor: "

la $a0,string
li $v0,8
li $a1,20
syscall

jal atoi # jal para armazenar o endereço de retorno das subrotinas
move $s1,$v0 # s1 toma o valor devolvido pela fucção ATOI
div $s0,$s1 # Divisao s0/s1
mfhi $s2 # copia o resto da divisão para dentro de $s2 para ficar guardado
mflo $s3 # copia o quociente da divisao para dentro de $s3 para ficar guardado
move $a0,$s3
la $a1,string

jal pointer
la $a0,texto3
li $v0,4
syscall
la $a0,string
li $v0,4
syscall # print quociente

move $a0,$s2
la $a1,string
jal pointer
la $a0,texto4
li $v0,4
syscall

la $a0,string
li $v0,4
syscall # resto
li $v0,10
syscall

############# ATOI ########################
atoi: li $v0,0 # num=0
add $t1,$0,$a0 # p=s
add $t2,$a0,$a1 # s+n


Enquanto: lb $t3,0($t1) # Lê da memória *p
bgeu $t1,$t2,sair # Salta para o endereço Label if (p>=s+n) go to exit1
blt $t3,'0',sair # Salta para o endereço Label se o conteúdo do registo Rsrc1 é menor que quantidade Src2if (*p<'0') go to sair
bgt $t3,'9',sair # if (*p>'9') go to exit1
sub $t4,$t3,'0' # digito= *p-'0'
mul $v0,$v0,10 # num=10*num
add $v0,$v0,$t4 # num=10*num+digito
addiu $t1,$t1,1 # Incrementa de 1 em 1 p++
j Enquanto
sair: jr $ra

pointer : add $sp,$sp,-4
sw $ra,0($sp)
li $t1,10
li $t5,0 # i=0
move $t3,$a0 # n
move $t4,$a1 # *s
do: div $t3,$t1 # n/10
mfhi $t2 # resto
mflo $t0 # quociente
add $t2,$t2,'0' # resto=resto+'0'
sb $t2,0($t4) # &s[0[=resto
addiu $t4,$t4,1 # *(s+1)
addi $t5,$t5,1 # i++
move $t3,$t0
bnez $t0,do # enquanto (quociente!=0)
sb $0,0($t4) # colocar caracter nulo

move $t1,$t4 # ponteiro para o fim da lista
addi $t1,$t1,-1
move $t2,$a1 # ponteiro para o inicio da lista
if: ble $t1,$t2,Fim
lb $t4,0($t1)
lb $t5,0($t2)
sb $t5,0($t1)
sb $t4,0($t2)
addi $t2,$t2,1
addi $t1,$t1,-1
j if
Fim: lw $ra,0($sp)
addi $sp,$sp,4
jr $ra
Read More