Can 1 return invoke 2 returns? - c

Question

This is mostly theoretical question as there's not much use in it.
consider this situation :
function a() {
return;
}
function b(){
a();
}
Can you invoke a return in a parent function from a child one?
Now in this case you can simpley do return a(); and that will happen but let's say you're intrested of not preforming a return.
I know that when translating it to assembly this doesn't make sense, in this case u can use goto but we all know how dangerous that is.
My logic says that if you can preform a continue from a child loop that will invoke continue on the parent, this should be the same, but loops doesn't affect the stack so it makes sense that continue does work.
I am wondering if there's any way to handle this case witjout using events or the oop approach?

Answer 1

The traditional C solution is the longjmp function, which can jump an arbitrary way up the stack. Mind you, there have always been people who were wise enough not to use it, and it has been largely succeeded by exception handling.

Answer 2

You could use a macro instead of a function.
#define a() ... return ...
A use case would be asserts that are not completely removed in a release build, but abort a function:
#define REQUIRE(x) do { assert((x)); if (!(x)) return; } while (0)
You can also hack something in assembler to get the stackframe of the calling functions and use the return address from there:
void return2(){
void * frame;
#if (defined(x86_64) || defined(__x86_64__))
__asm__(
"pop %rbp\n" //skip over stack frame of return2
"mov %rsp, %rbp\n"
"pop %rax\n"
"pop %rbp\n" //skip over stack frame of caller
"mov %rsp, %rbp\n"
"pop %rax\n"
);
#else
#error only implmented for amd64...
#endif
}
Then
void a(){
printf("a 0\n");
return2();
printf("a 1\n");
}
void b(){
printf("b 0\n");
a();
printf("b 1\n");
}
int main(int argc, char* argv[])
{
printf("main 0\n");
b();
printf("main 1\n");
return 0;
}
prints
main 0
b 0
a 0
main 1
This is the most dangerous solution from all (and it fails if gcc inlines something or removes the stackframe at higher optimization levels. But you could add a check that examines the instructions, if they were optimized )

Answer 3

If you are on Windows using MSVC, you can use exceptions (Strucured Exception Handling, SEH) to achive something similar. On other platforms you can use setjmp/longjmp, as thiton said.
With SEH, you could do something like the following (haven't tried it since I have no Windows with Visual Studio ready):
#include "stdio.h"
#include "Windows.h"
void func_b() {
printf("In func_b()\n");
// return safely to main
RaiseException(1, EXCEPTION_NONCONTINUABLE, 0, NULL);
printf("At end of func_b()\n");
}
void func_a() {
printf("In func_a()\n");
func_b();
printf("At end of func_a()\n");
}
void main() {
printf("In func_a()\n");
__try {
func_a();
}
__except (GetExceptionCode() == 1) {
printf ("Early return to main()\n");
}
printf("At end of main()\n");
}
The RaiseException call causes control to go up the stack until the exception is caught, in main(). This is not really "return^2", because the calling function (main) has to play along. In general, you'll also need cooperation of the functions you want to jump through (here func_a), since they might do stuff and need cleanup. Just saying "return from func_b, and stop whatever func_a was doing and return from that, too" can be very dangerous. If you use exceptions, however, you can wrap your code in func_a in try/finally clause:
FILE* f;
__try {
f = fopen("file.txt", "r");
func_b();
}
__finally {
fclose(f);
printf("Cleanup for func_a()\n");
}
This is of course much nicer in languages that natively support exceptions (C++, Python, Java, ...), and don't just have it bolted on as a proprietary extension.
Note that some people regard it as bad practice to use exceptions for control flow, and say exceptions should be reserved for truely exceptional events (like IO errors). There are a buch of cases where it does make sense (e.g. you're parsing something, and realize deep down the stack that you have to rewind and parse something differently, you can throw a custom exception). In general, I'd say try not to be too clever, and try not to do things that will confuse readers of your program. When it seems you need to use some trick like this, there's often a way to restructure the program to do it in a way that's natural for the language. Or maybe the language your using is not a good choice for the problem.