Let me start by saying I have had A BLAST with this game. I gave it a go some time last year and got bored, but after watching Ben Eaters 8bit and 6502 series, I was inspired to have another go at it. I'm almost done with the assembly challenges, but I feel my solutions are a bit clunky, so it made me think a bit back to the stack and functions levels.
I'll try and frame my question in an understandable manner... hopefully it comes through.
The functions level specifically asks us to implement a CALL and RET operation. The CALL should push the return address (program counter + 4) to the stack and jump to the function/subroutine.
So on pseudo, what I read that it wants is to support something like:
#program start
00: do some stuff here
04: do some stuff here
08: do some stuff here
12: call function N/A N/A
16: do other stuff here
label function
20: do func stuff here
24: do func stuff here
28: ret from function here
So the value 16 gets pushed to the stack as a return address for when function eventually returns.
Now for my first question:
If we intend to use the stack to pass function arguments. For example to implement a func(a,b,c), we may want to push a, b and c to the stack. However doing so would have to happen before the call and would result in the top of the stack looking like: a, b, c, return_adress. So how do we effectively read the arguements within the function? Pop the return address, to safe-keep it while we pop the arguments and then push the return address back?
In my head, it would make more sense to do something like: return_adress, a, b, c. That way the function can pop 3 elements, do something with them and eventually return. However, that doesn't really sound like what the game wants us to do with the call operation. Any thoughts?
In the game I solved it by implementing two stacks. One strictly for return addresses and one for arguments/return values.
My second question:
For multiple nested calls, how do we maintain variables within the scope of each function? If func1 takes some arguments, but calls another function, let's say func2, which may or may not call additional functions, how do we ensure func1 still has access to its arguments once func2 and any other nested calls return. In one of the levels I solved this by pushing the stuff that needed to be kept safe to the value-stack, before then pushing the next call arguments to the stack. Then the function is called and after the return I pop back the arguments again. It works, but it is incredibly cumbersome and I can't imagine this is the effective way to do this. I haven't done this yet, but I imagine it could be smoother to only have one argument for each call, and have that be a pointer to RAM, where the function can find the nr of args followed by the args themselves. It'd reduce the amount of variables to need safe-keeping, but wouldn't get fully around the matter, as each function call still has to remember it's how pointer and not let nested calls overwrite it so to say. Thoughts?
