# Programma che copia tramite una procedura gli interi positivi
# contenuti nell’array (elem) in un secondo array (pos_el)

	.data
elem:	.space 40			# alloca 40 byte per array elem
pos_el:	.space 40		# alloca 40 byte per array pos_el
prompt:	.asciiz "Inserire il successivo elemento \n"
msg:	.asciiz "Gli elementi positivi sono \n"

	.text
	.globl main

main:	la $s0, elem		# Mantiene in memoria l'indirizzo elem
	la $s1, pos_el		# Mantiene in memoria l'indirizzo di pos_el
	li $s2, 40			# $s0 dimensione di elem in byte.
	
# Ciclo di lettura dei 10 numeri interi
	move $t0, $s0		# indice di ciclo
	add $t1, $t0, $s2 	# $t1 posizione finale di elem (fine ciclo)
loop:	li $v0, 4  			# $v0 codice della print_string 
	la $a0, prompt 		# $a0 indirizzo della stringa 
	syscall			# stampa la stringa prompt	

	# Lettura dell’intero
	li $v0, 5			# $v0 codice della read_int
	syscall		 	# legge l’intero e lo carica in $v0

	sw $v0, 0($t0)		# memorizza l’intero in elem
	addi $t0, $t0, 4
	bne $t0, $t1, loop
	
# Fine della lettura, ora prepara gli argomenti per la proc.
	move $a0, $s0		# $a0 ind. array elem. 
	move $a1, $s1		# $a1 ind. array pos_el 
	move $a2, $s2		# $a2 dim. in byte dell’array 

# Chiamata della procedura cp_pos	
	jal cp_pos		# restituisce il numero di byte 
				# occupati dagli interi pos in $v0

# Gli indirizzi in cui e’ racchiuso pos_elem vanno da $s2 a $t2
	add $t2, $s1, $v0 	# $t2 ind. ultimo byte di pos_el
	move $t0, $s1		# $t0 indice di ciclo su pos_el

# stampa degli elementi positivi
loop_w:	
	beq $t0, $t2, exit_main
	li $v0, 1			# $v0 codice della print_integer
	lw $a0, 0($t0)    	# $a0 intero da stampare
	syscall	  	  	# stampa dell’intero
	addi $t0, $t0, 4
	j loop_w
              
exit_main:	li $v0, 10		# $v0 codice della exit
		syscall		# esce dal programma


# Questa procedura esamina l’array elem ($a0) contenente $a2/4 elementi 
# Resituisce in $v0, il numero di byte occupati dagli interi positivi ed in
# pos_el gli interi positivi.
# $a0 elem, $a1 pos_elem e $a2 numero byte di elem.
cp_pos:	addi $sp, $sp, -12	# allocazione dello stack
		sw $s0, 0($sp)
		sw $s1, 4($sp)
		sw $s2, 8($sp)

		move $s0, $a0		# $s0 indice di ciclo su elem
		add $s1, $a0, $a2		# $s1 ind. ultimo byte dell’array elem
						#		(fine ciclo)
		move $s2, $a1		# $s2 indice di ciclo su pos_el

next:		beq $s1, $s0, exit	# se esaminato tutti gli elementi di elem
						#	salta alla fine del ciclo (exit).

		lw $s3, 0($s0)		# carica l’elemento da elem
		addi $s0, $s0, 4		# posiziona sull’elemento succ. di elem
		ble $s3, $zero, next	# se $s2 <= 0 va all’elemento succ. di elem

		sw $s3, 0($s2)		# Memorizzo il numero in pos_elem
		addi $s2, $s2, 4		# posiziona sull’elemento succ. di pos_elem
		j next			# esamina l’elemento successivo di elem

exit:		sub $v0, $s2, $a1		# $v0 num. di interi pos. (in byte)
		lw $s0, 0($sp)
		lw $s1, 4($sp)
		lw $s2, 8($sp)		
		addi $sp,$sp,12		# deallocazione dello stack
		jr $ra			# restituisce il controllo al chiamante
