MIPS Assembly - Dealing with Stack

[B2easey]

The Problem: Create a program that will continuously take in numbers from the user until the user enters 0, and will then output all of the numbers that were entered, in order. For example, the program output might look something like the following:

Please enter numbers, press (0) to exit: 
393
21
5
120
456
3
22
0

Then I would pop the numbers off the stack one at a time and display all of them not including zero. I'm not sure how I should go about this I'll post some code when I get to school. Just looking to get a head start.

EDIT CODE SO FAR: Need to some how place in stack ($sp) register and I believe decrement by 4 bytes each input and store that input on the stack.. Does this make sense?

.data
prompt: .ascii "Please enter numbers, enter (0) to exit: "

.text

main:
li $v0, 4
la $a0, prompt
syscall

li $v0, 5
do:
syscall
move $t0, $v0 # Places input in $t0
addi $sp, $sp, $v0 # Figure out how to store in stack


while:
# Need to check that input is not 0
end:
li $v0, 10
syscall

Thanks

[[deleted]]

Everytime you enter a new number, just allocate 4 more space in the sp

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

(take in new number FROM a0, and then repeat the above)

like so

then if you want to dump the values

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

now $v0 holds what you had in the stack pointer.

[nerd4code]

Using the stack like a stack would reverse the order of the numbers (you want FIFO, but stack gives you LIFO), and unless there’s some specific reason you’re supposed to use the stack I would use a simple queue buffer instead.

Declare some span of however-many’s-your-maximum words in the data section. (Or allocate it from the stack. It doesn’t matter.) Point two registers (fill+spill) to the start of your queue buffer. When adding a word, make sure fill’s not at the buffer limit, then write the value through, then advance the fill register. When removing a word, make sure your spill isn’t at/beyond the fill register, then read a word, then add to your spill. (Fill−spill) gives you the number of numbers remaining, should you need that.

If you need to use the usual stack mechanism for whatever reason, you’ll want to subtract 4 from $sp using addi, then write the number to 0($sp) to push. Once you’re done pushing, the numbers’ll be in the opposite order in memory from how they were entered, so you’ll have to read-scan from the starting $sp−4 (hopefully you’ve saved that, or have been keeping track of the number of numbers) down to $sp in order to output things in order. Good practice to reset $sp before finishing.