SALVE DEVO SVOLGERE QUESTO ESERCIZIO IN ASSEMBLER MIPS
.data
intestazione: .asciiz "Esercizio1 Studenti "
welcome: .asciiz "Inserire una stringa contenente al massimo 100 caratteri:\n"
codifica .asciiz "La codifica risulta:\n "
string: .space 100
.text
.globl main
main:
li $v0, 4 #stampa dell'intestazione del programma
la $a0, intestazione
syscall
li $v0, 4 #stampa della stringa welcome
la $a0, welcome
syscall
la $a0, string #In $a0 viene caricato l'indirizzo in cui andrà salavata la stringa
li $a1, 100 # Nel registro $a1 viene caricata la lunghezza massima della stringa
li $v0, 8 #Si scrive la stringa
syscall
li $v0, 4 #stampa del messaggio che precede la stringa derivante dalla codifica della stringa in input
la $a0, codifica
syscall
move $t0, $zero #Si inizializza il registro $t0,utilizzato come indirizzo d'arrivo per il metodo findWs
move $t1, $zero #Si inizializza il registro $t1,utilizzato come indirizzo di partenza per il metodo findWs
move $t2, $zero #Si inizializza il registro $t0,nel quale sarà salvato la lunghezza di ogni singola parola costituente la stringa da decodificare
move $t3, $zero #Si inizializza il registro $t0,nel quale verrà salvato il risultato per i confronti dei caratteri
li $t4, 32 #si inizializza il registro $t4,come variabile di supporto per il confronto per lo spazio
li $t5,10 #Si inizailizza il registro $t5,che conterra il valore di conforonto per vedere se si è arrivati al termine della stringa.
jr $ra
findWs:
move $t1, $t0 # Aggiorna l'indirizzo di partenza per il Load Byte ponendolo uguale a quello di arrivo (della parola precedente) per iniziare a leggere una nuova parola
move $t2, $zero # Azzero il contatore prima di cercare una nuova parola
findW:# Legge una parola tenendo traccia di quanto è lunga, dell'indirizzo di partenza e di quello di arrivo
lb $t3, string($t0) # Carico un byte della stringa inserita in $t3
beq $t3, $t5, linker # Guarda se sono arrivato alla fine della stringa
beq $t3, $t4, linker # Guarda se sono arrivato ad uno spazio ( quindi la parola è finita)
add $t2, $t2, 1 # Incrementa il count se ho trovato un carattere
add $t0, $t0, 1 # Incremento l'indirizzo perche ho trovato un carattere
j findW # La parola non è ancora finita perciò continua a contare
linker: # Valuto la parola trovata e decido se può essere codificata o meno
addi $t0, $t0, 1 # Incremento l'inidirizzo al byte successivo per la prossima parola
beq $t2, $zero, findWs # Controllo doppio spazio
slti $s1, $t2, 5 # Se il contatore ($t2) è minore di 5 metti 1 in $s1 (Se la parola è piu lunga di quattro stampa ?)
li $t7, 1 # Imposta valore di confronto
bne $s1, $t7, printq # Se non è uguale a uno vuol dire che la parola è maggiore di 4, stampa ?
slti $s1, $t2, 3 # Guardo se è minore di 3
beq $s1, $t7, printq # Se è uguale a 1 la parola ha meno di 3 caratteri e non mi interessa, stampo ?
lb $t3, string($t1) # Carico il primo carattere della parola trovata
li $t7, 117
beq $t3, $t7, uno # Se il byte è uguale a "u" vai al metodo uno
li $t7, 100
beq $t3, $t7, due # Se il byte è uguale a "d" vai al metodo due
li $t7, 110
beq $t3, $t7, nove # Se il bte è uguale a "n" vai al metoddo nove
j printq # Se non è nessuno dei tre printa ? e inizia dalla prossima parola
uno:
addi $t1, $t1, 1 # Scorri la parola
lb $t3, string($t1) # Leggi il prossimo byte
li $t7, 110
bne $t3, $t7, printq # Se non è uguale a "n" stamap ?
addi $t1, $t1, 1 # Scorri la l'indirizzo
lb $t3, string($t1) # Carica il byte
li $t7, 111
bne $t3, $t7, printq # Se non è uguale a "o" stampa ?
addi $t1, $t1, 1 # Scorri l'indirizzo
lb $t3, string($t1) # Carica byte
beq $t3, $t4, printOne # Se è spazio stampa 1
beq $t3, $t5, printOne # Se è fine parola stampa 1
j printq # Se non è nessuno dei due stampa ?
due:
addi $t1, $t1, 1 # Scorro la parola a partire dal secondo carattere
lb $t3, string($t1) # Carico il byte da analizzare
li $t7, 117
bne $t3, $t7, printq # Se non è uguale a "u" stampo ?
addi $t1, $t1, 1 # Scorro l'indirizzo della parola
lb $t3, string($t1) # Carico il byte
li $t7, 101
bne $t3, $t7, printq # Se non è uguale a "e" stampa ?
addi $t1, $t1, 1 # Scorri l'indirizzo
lb $t3, string($t1) # Carica byte
beq $t3, $t4, printTwo # Se è spazio stampa 1
beq $t3, $t5, printTwo # Se è fine parola stampa 1
j printq # Se non è nessuno dei due stampa ?
nove:
addi $t1, $t1, 1 # Scorro la parola
lb $t3, string($t1) # Carico il byte
li $t7, 111
bne $t3, $t7, printq # Se non è uguale a "o" stampa ?
addi $t1, $t1, 1 # Scorro la parola
lb $t3, string($t1) # Carico il byte
li $t7, 118
bne $t3, $t7, printq # Se non è uguale a "v" stampa ?
addi $t1, $t1, 1 # Scorro la parola
lb $t3, string($t1) # Carico il byte
li $t7, 101
bne $t3, $t7, printq # Se non è uguale a "e" stampa ?
addi $t1, $t1, 1 # Scorri l'indirizzo
lb $t3, string($t1) # Carica byte
beq $t3, $t4, printNine # Se è spazio stampa nove
beq $t3, $t5, printNine # Se è fine parola stampa nove
j printq # Se non è nessuno dei due stampa ?
printq:
li $a0, 63 # Carico il punto interrogativo
li $v0, 11 # Lo stampo
syscall
beq $t3, $t5, exit # Se è fine parola esci
j findWs
printOne:
li $a0, 1
li $v0, 1
syscall
beq $t3, $t5, exit # Se è fine parola esci
j findWs
printTwo:
li $a0, 2
li $v0, 1
syscall
beq $t3, $t5, exit # Se è fine parola esci
j findWs
printNine:
li $a0, 9
li $v0, 1
syscall
beq $t3, $t5, exit # Se è fine parola esci
j findWs
exit:
li $v0, 10
syscall