.text
        .globl main

main:
        subu $sp,$sp,8
        sw $ra,4($sp)
        li $v0,4
        la $a0,prompt1
        syscall
        jal sum3IntTest
        li $v0,4
        la $a0,prompt2
        syscall
        jal sum3CopyTest
        li $v0,4
        la $a0,prompt3
        syscall
        jal strCopyTest
        li $v0,4
        la $a0,prompt4
        syscall
        jal extractStrTest
        li $v0,4
        la $a0,prompt5
        syscall
        jal binOpTest
        li $v0,4
        la $a0,prompt6
        syscall
        jal binExpTest
        li $v0,4
        la $a0,prompt7
        syscall
        jal insertAtTest
        li $v0,4
        la $a0,prompt8
        syscall
        jal makeSpaceTest
        li $v0,4
        la $a0,prompt9
        syscall
        jal delimIdxTest
        li $v0,4
        la $a0,prompt10
        syscall
        jal extractStr2Test
        li $v0,4
        la $a0,prompt11
        syscall
        jal seqGenTest
        li $v0,4
        la $a0,prompt12
        syscall
        jal seqArrayTest
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
prompt1:.asciiz "\nsum3IntTest: "
prompt2:.asciiz "\nsum3CopyTest: "
prompt3:.asciiz "\nstrCopyTest: "
prompt4:.asciiz "\nextractStrTest: "
prompt5:.asciiz "\nbinOpTest: "
prompt6:.asciiz "\nbinExpTest: "
prompt7:.asciiz "\ninsertAtTest: "
prompt8:.asciiz "\nmakeSpaceTest: "
prompt9:.asciiz "\ndelimIdxTest: "
prompt10:.asciiz "\nextractStr2Test: "
prompt11:.asciiz "\nseqGenTest: "
prompt12:.asciiz "\nseqArrayTest: "


        .text


# esercizio 1
#       $a0 array di interi a 16 bit con segno
#       $a1 intero a 32 bit senza segno

sum3Int:
        li $v0,0
        beqz $a1,end1
loop1:  lh $t0,($a0)
        add $v0,$v0,$t0
        addu $a0,$a0,2
        subu $a1,$a1,1
        bgtz $a1,loop1
end1:   jr $ra


# esercizio 2

sum3IntTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,array1
        lw $a1,int1
        jal sum3Int
        move $a0,$v0
        li $v0,1
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
int1:   .word 3
array1: .half 1,32,12


        .text

# esercizio 3
#       $a0 array di interi a 16 bit con segno
#       $a1 intero a 32 bit senza segno

sum3Copy:
        subu $sp,$sp,16
        sw $ra,12($sp)
        sw $s0,8($sp)
        sw $s1,4($sp)
        move $s0,$a0
        move $s1,$a1
        beqz $a1,end2
loop2:  li $a1,3
        jal sum3Int
        move $a0,$v0
        li $v0,1
        syscall
        addu $s0,$s0,6
        subu $s1,$s1,3
        move $a0,$s0
        move $a1,$s1
        bgtz $a1,loop2

end2:   lw $s0,4($sp)
        lw $s1,8($sp)
        lw $ra,12($sp)
        addu $sp,$sp,16
        jr $ra


# esercizio 4

sum3CopyTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,array2
        lw $a1,len2
        jal sum3Copy
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
len2:   .word 12
array2: .half 1,32,12,3,6,1,0,3,3,3,4,2


        .text

# esercizio 1
#       $a0 puntatore ad una stringa
#       $a1 indice 1
#       $a2 indice 2
#       $a3 puntatore ad un buffer

strCopy:
        bgt $a1,$a2,end3
        addu $a1,$a0,$a1
        addu $a2,$a0,$a2
loop3:  lbu $t1,($a1)
        sb $t1,($a3)
        addu $a1,$a1,1
        addu $a3,$a3,1
        ble $a1,$a2,loop3
end3:   sb $0,($a3)
        jr $ra


# esercizio 2

strCopyTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,str3
        lbu $a1,idx3
        lbu $a2,idx3+1
        la $a3,buf3
        jal strCopy
        la $a0,buf3
        li $v0,4
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
str3:   .asciiz "uno %due% tre"
idx3:   .byte 5,7
buf3:   .space 256

        .text

# esercizio 3
#       $a0 puntatore ad una stringa
#       $a1 delimitatore
#       $a2 puntatore ad un buffer

extractStr:
        subu $sp,$sp,8
        sw $ra,4($sp)
        move $t0,$a0
loop4:  lbu $t2,($t0)
        addu $t0,$t0,1
        bne $t2,$a1,loop4

        addu $t1,$t0,-2
loop5:  addu $t1,$t1,1
        lbu $t2,1($t1)
        bne $t2,$a1,loop5

        move $a3,$a2
        subu $a1,$t0,$a0
        subu $a2,$t1,$a0
        jal strCopy

        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra


# esercizio 4

extractStrTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,str5
        lbu $a1,idx5
        la $a2,buf5
        jal extractStr
        la $a0,buf5
        li $v0,4
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
str5:   .asciiz "uno %due% tre"
idx5:   .byte '%'
buf5:   .space 256



        .text

# esercizio 1
#       $a0 0 o 1
#       $a1 intero a 32bit con segno
#       $a2 intero a 32bit con segno

binOp:
        bnez $a0,sub6
        add $v0,$a1,$a2
        jr $ra
sub6:   sub $v0,$a1,$a2
        jr $ra


# esercizio 2

binOpTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        lw $a0,int6
        lw $a1,int6+4
        lw $a2,int6+8
        jal binOp
        move $a0,$v0
        li $v0,1
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
int6:   .word 0,5,7


        .text

# esercizio 3
#       $a0 puntatore array di interi a 32 bit con segno

binExp:
        subu $sp,$sp,8
        sw $ra,4($sp)
        sw $s0,0($sp)

        lw $v0,($a0)
        addu $s0,$a0,4

loop7:  lw $a0,($s0)
        beq $a0,2,end7
        move $a1,$v0
        lw $a2,4($s0)
        jal binOp
        addu $s0,$s0,8
        j loop7

end7:   lw $s0,0($sp)
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra


# esercizio 4

binExpTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,array7
        jal binExp
        move $a0,$v0
        li $v0,1
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
array7: .word 5,0,7,0,3,1,5,2


        .text

# esercizio 1
#       $a0 puntatore ad un buffer stringa
#       $a1 puntatore a stringa
#       $a2 indice

insertAt:
        addu $a0,$a0,$a2
loop8:  lbu $t0,($a1)
        beqz $t0,end8
        sb $t0,($a0)
        addu $a0,$a0,1
        addu $a1,$a1,1
        j loop8
end8:   jr $ra


# esercizio 2

insertAtTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,buffer8
        la $a1,str8
        lw $a2,idx8
        jal insertAt
        la $a0,buffer8
        li $v0,4
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
idx8:   .word 9
buffer8:.asciiz "scrivere funzione"
        .space 256
str8:   .asciiz "una "

        .text

# esercizio 3
#       $a0 puntatore ad un buffer stringa
#       $a1 indice
#       $a2 spostamento

makeSpace:
        addu $a1,$a0,$a1
        move $a0,$a1
loop9:  lbu $t0,($a0)
        beqz $t0,next9
        addu $a0,$a0,1
        j loop9

next9:  addu $a2,$a0,$a2
loop9a: sb $t0,($a2)
        subu $a2,$a2,1
        subu $a0,$a0,1
        lbu $t0,($a0)
        bge $a0,$a1,loop9a
        jr $ra


# esercizio 4

makeSpaceTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,buffer9
        lw $a1,idx9
        lw $a2,idx9+4
        jal makeSpace
        la $a0,buffer9
        li $v0,4
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
idx9:   .word 8,4
buffer9:.asciiz "scrivere funzione"
        .space 256


        .text

# esercizio 5
#       $a0 puntatore ad una stringa
#       $a1 delimitatore

delimIdx:
        subu $t0,$a0,1
loop10: addu $t0,$t0,1
        lbu $t2,($t0)
        bne $t2,$a1,loop10

        move $t1,$t0
loop11: addu $t1,$t1,1
        lbu $t2,($t1)
        bne $t2,$a1,loop11

        subu $v0,$t0,$a0
        subu $v1,$t1,$a0
        jr $ra


# esercizio 6

delimIdxTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,str11
        lbu $a1,ch11
        jal delimIdx
        move $a0,$v0
        li $v0,1
        syscall
        move $a0,$v1
        syscall
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
str11:  .asciiz "uno due tre"
ch11:   .byte ' '


        .text

# esercizio 7
#       $a0 puntatore ad una stringa
#       $a1 delimitatore

extractStr2:
        subu $sp,$sp,8
        sw $ra,4($sp)

        sw $a0,0($sp)
        jal delimIdx
        lw $a0,0($sp)

        addu $a1,$a0,$v1
        addu $a0,$a0,$v0
        addu $a0,$a0,1
        lbu $t0,($a1)
        sb $0,($a1)
        li $v0,4
        syscall
        sb $t0,($a1)

        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra


# esercizio 8

extractStr2Test:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,str11
        lbu $a1,ch11
        jal extractStr2
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra


        .text

# esercizio 9
#       $a0 intero a 8 bit senza segno
#       $a1 intero a 8 bit senza segno

seqGen: move $t0,$a0
        li $v0,1
        beqz $a1,end12
loop12: syscall
        addu $a0,$a0,$t0
        subu $a1,$a1,1
        bgtz $a1,loop12
end12:  jr $ra


# esercizio 10

seqGenTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        lbu $a0,int12
        lbu $a1,int12+1
        jal seqGen
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
int12:  .byte 3,5


        .text

# esercizio 11
#       $a0 puntatore ad array di interi a 8 bit senza segno
#       $a1 intero a 8 bit senza segno

seqArray:
        subu $sp,$sp,16
        sw $ra,12($sp)
        sw $s0,8($sp)
        sw $s1,4($sp)
        move $s0,$a0
        move $s1,$a1

loop13: lbu $a0,($s0)
        beqz $a0,end13
        jal seqGen
        addu $s0,$s0,1
        move $a1,$s1
        j loop13

end13:  lw $s1,4($sp)
        lw $s0,8($sp)
        lw $ra,12($sp)
        addu $sp,$sp,16
        jr $ra


# esercizio 12

seqArrayTest:
        subu $sp,$sp,8
        sw $ra,4($sp)
        la $a0,array13
        lbu $a1,int13
        jal seqArray
        lw $ra,4($sp)
        addu $sp,$sp,8
        jr $ra

        .data
array13:.byte 1,2,3,0
int13:  .byte 4