#================================================================================================
# Nie można zmieniać mojego kodu.
# Wasz kod powinien się pojawić tylko w przeznaczonych do tego miejscach.
# Skrót # ... oznacza, że w tym miejscu mogę dopisać dowolne rozkazy i pseudorozkazy
# Podstawowym zagadnieniem dzisiejszych zajęć jest wywoływanie podprogramów (procedur).
#================================================================================================
.data
nl: .asciiz "\n"
UBAW: .asciiz "\nZaczynamy rock-and-roll !\n"
THATALL: .asciiz "\n\nThat's all folks!\n"
NCLASSES: .asciiz "\nChociaz z przyjemnoscia spotkamy sie na nastepnych zajeciach."
INTRO: .ascii "\nProsze wprowadzic\n"
.asciiz "Lancuch do bufora BUFOREK: "
INTRO1: .ascii "\nProsze wprowadzic\n"
.asciiz "Lancuch do bufora SPACE: "
Len: .asciiz "\nDlugosc stringa BUFOREK jest równa - "
rev: .asciiz "To jest revers stringa w BUFOREK - "
sdigit: .asciiz "\nSuma wszystkich cyferek w buforze BUFOREK jest rowna - "
.align 2
BUFOREK: .space 256
SPACE: .space 256
.text
#===============================================================
# Oblicz sumę wszystkich cyfr występujących we wprowadzonym przez
# użytkownika łańcuchu BUFOREK.
# Podprogram spodziewa się długości łańcucha w $a0.
# Suma ma być zwrócona w $v0.
#===============================================================
summation:
#------ początek Waszej sekwencji rozkazów ---------------------
# Pamiętaj o skomentowaniu każdej linii poniższego kodu!
sw $ra, 0($sp)
addi $sp, $sp, -4
# ...
# (nie wolno kasować tej linii) Tutaj oblicz sumę cyferek występujących w stringu
# ...

li $v0, 0
li $s1, 0

DigitSumLoop:
lb $t0, BUFOREK($s1)
addi $s1, $s1, 1
blt $t0, 58, isDigit
ble $s1, $a0, DigitSumLoop

j DigitSumLoopEnd

isDigit:
bgt $t0, 47, yesIsDigit
j DigitSumLoop

yesIsDigit:
addi $t0, $t0, -48
add $v0, $v0, $t0
j DigitSumLoop

DigitSumLoopEnd:
li $s1, 0 #resetuje licznik s1
addi $sp, $sp, 4
lw $ra, 0($sp)
#------ end of your sequence of instructions -------------------
jr $ra # rozkaz należy wykorzystać (musi się wykonać)
#===============================================================
# Podprogram DetermineLength powinien obliczyć długość stringa
# wprowadzonego do BUFOREK przez użytkownika.
# Podprogram powinien zwrócić długość w rejestrze $v0.
#===============================================================
DetermineLength:
#------ początek Waszej sekwencji rozkazów ---------------------
# Pamiętaj o skomentowaniu każdej linii poniższego kodu!
#
# ...
# (nie wolno kasować tej linii) Oblicz długość stringa w BUFOREK
sw $ra, 0($sp)
addi $sp, $sp, -4

li $s0, 0

DetermineLengthLoop:
addi $s0, $s0, 1
lb $t0, BUFOREK($s0)
bgt $t0, 1, DetermineLengthLoop
subi $s0, $s0, 1 #odejmujemy 1 od policzonej liczby zeby nie liczyc entera

move $a0, $s0
# ...
# (nie wolno kasować tej linii) wywołaj procedure summation (zwraca sume w rejestrze $v0)
jal summation
move $t2, $v0
# ...
# (nie wolno kasować tej linii) wyświetl komunikat sdigit wraz z wyświetleniem sumy cyferek

li $v0, 4
la $a0, sdigit
syscall

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

addi $sp, $sp, 4
lw $ra, 0($sp)
# ...
#------ tutaj kończy się Wasz kod ------------------------------
jr $ra
#===============================================================
# Procedura revers powinna wyświetlić wszystkie znaki z bufora BUFOREK
# Długość powinna być w rejestrze $a0
# POCZYNAJĄC od ostatniego (czyli należy wyświetlić string w odwrotnej kolejności).
#===============================================================
reverse:
#------ początek Waszej sekwencji rozkazów ---------------------
# Pamiętaj o skomentowaniu każdej linii poniższego kodu!

sw $ra, 0($sp)
addi $sp, $sp, -4

move $s1, $a0 #ładujemy licbe znaków do licznika s1

li $v0, 11
reverseLoop:
subi $s1, $s1, 1
lb $a0, BUFOREK($s1)
syscall
bge $s1, 0, reverseLoop

addi $sp, $sp, 4
lw $ra, 0($sp)
#
#------ tutaj kończy się Wasz kod ------------------------------
jr $ra
.globl main
main: jal sub0 # wywołanie podprogramu sub0
#------ początek Waszej sekwencji rozkazów ---------------------
# Pamiętaj o skomentowaniu każdej linii poniższego kodu!
#
# ...
# (nie wolno kasować tej linii) wywołaj procedurę DetermineLength
jal DetermineLength
# ...
# (nie wolno kasować tej linii) Wyświetl komunikat spod etykiety Len:
# (nie wolno kasować tej linii) Pamiętaj o skomentowaniu każdej linii poniższego kodu!
li $v0, 4
la $a0, Len
syscall

# ...
# (nie wolno kasować tej linii) Wyświetl długość stringa wprowadzonego do BUFOREK.
# (nie wolno kasować tej linii) Po jego wyswietleniu wyprowadź nową linię.

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

# ...
# (nie wolno kasować tej linii) Wyświetl komunikat spod etykiety rev:


li $v0, 4
la $a0, nl
syscall
la $a0, rev
syscall

move $a0, $s0 #przenosimy do a0 dlugosc stringa buforek
# ...
# (nie wolno kasować tej linii) wywołaj procedure reverse
jal reverse
# ...
# (nie wolno kasować tej linii) Wyświelt stringa spod etykiety THATALL

li $v0, 4
la $a0, THATALL
syscall
# ...
#------ tutaj kończy się Wasz kod ------------------------------
end: li $v0, 10 # terminate execution
syscall
#------------------------------------------------------------------------
# Podprogram Sub0 powinien wyświetlić komunikat spod etykiety UBAW, i zaraz
# po tym wywołać podprogram sub1.
#------------------------------------------------------------------------
sub0:
#------ początek Waszej sekwencji rozkazów ---------------------
# Pamiętaj o skomentowaniu każdej linii poniższego kodu!

sw $ra, 0($sp)
addi $sp, $sp, -4

# ...
# (nie wolno kasować tej linii) Tutaj wyświetl komunikat UBAW

li $v0, 4
la $a0, UBAW
syscall


# ...
# (nie wolno kasować tej linii) wywołaj podprogram sub1
jal sub1
# ...
# (nie wolno kasować tej linii) Wyświetl komunikat NCLASSES
li $v0, 4
la $a0, NCLASSES
syscall

addi $sp, $sp, 4
lw $ra, 0($sp)

# ...
#------ tutaj kończy się Wasz kod ------------------------------
jr $ra # należy wykonać ten rozkaz (wrócić do następnego rozkazu po jal sub0)
#-----------------------------------------------------------------------------
# Procedura sub1 powinna wyświetlić komunikat INTRO i zaraz po tym
# powinna wywołać podprogram sub2, który wypełnia BUFOREK łańcuchem wprowadzonym
# przez użytkownika.
# Następnie podprogram sub1 powinien wyswietlić także komunikat INTRO1 wypełnić
# bufor SPACE stringiem użytkownika wywołując sub2.
#-----------------------------------------------------------------------------
sub1:
#------ początek Waszej sekwencji rozkazów ---------------------
# Pamiętaj o skomentowaniu każdej linii poniższego kodu!
sw $ra, 0($sp)
addi $sp, $sp, -4
# ...
# (nie wolno kasować tej linii) Wyświelt stringa spod etykiety INTRO
li $v0, 4
la $a0, INTRO
syscall
# ...
# (nie wolno kasować tej linii) Wywołaj sub2 aby wypełnić bufor BUFOREK
la $a0, BUFOREK
jal sub2

# ...
# (nie wolno kasować tej linii) Wyświelt stringa spod etykiety INTRO1
li $v0, 4
la $a0, INTRO1
syscall
# ...
# (nie wolno kasować tej linii) Wywołaj sub2 aby wypełnić bufor SPACE
# (nie wolno kasować tej linii) Uwaga: Nic nie robimy z łańcuchem wprowadzonym do SPACE (fajnie?)

la $a0, SPACE
jal sub2

addi $sp, $sp, 4
lw $ra, 0($sp)
#------ tutaj kończy się Wasz kod ------------------------------
jr $ra # należy wykonać ten rozkaz (wrócić do następnego rozkazu po jal sub1)

#----- O jeju! podprogram gotowy do wykorzystania? Nie zupełnie! -----
sub2:
li $v0, 8
li $a1, 256 # rozmiar bufora
syscall
jr $ra
#--------------------------------------------------------