Is this a good way for unconditional jump?

Question

I have a function f( ) in a file func.c and functions f1( ), f2( ), f3() , f4( ) in another file funcs.h. (Assume that all the functions receive/return values without any loss of generality).

1. Function f( ) calls f4( )
2. f4( ) calls f1( ), f2( ), f3( ) in some arbitrary order, among themselves
3. At some point of time during the execution, f3() detects the completion of the algorithm and it has to "terminate" the execution of the algorithm. In a standalone case, it should exit out of the program after printing the solutions.But here, I need f3( ) to return to f( ).

This is my solution:

In this scenario, I cannot simply return to f4() (the original function called by f(), since there is already a function call stack of f1(), f2(), f3(),f4(), waiting to be "popped"). So, what I did is:

1. I did a setjmp( ) in f() before calling f4( )
2. And then, I did a longjmp( ) in f3( ) when I detected the completion of the algorithm

My question is: Is this the correct way to achieve this in this scenario?

Answer 1

TBH I personally find its better to return a bool from the function and if the return is true then return true from the function below and so on until it gets back to the original function. This unwinds the stack correctly, which im not sure setjmp/longjmp does.

In general though if you aren't going to go on and do stuff after the f() function returns it should work anyway. I'd just argue its not a very good way to do things as someone reading the code will not find it as obvious as the functions returning bool back up the stack.

Answer 2

f4( ) calls f1( ), f2( ), f3( ) in some arbitrary order, among themselves

What do you mean by "arbitrary order"? Unless you're writing a multi-threaded program, the order in which 1,2, and 3 are called should be deterministic; functions are executed synchronously in C.

Answer 3

You didn't mention what you are doing or what algorithm are you implementing but...

You could use a global structure with function pointers which f1,f2,f3,f4 knows it existence and from f4() you call f1() doing something like:

global.functionPointers[0]("parameters.for.f1");

Answer 4

Don't you still need a flag to know that you shouldn't call f4 again the second time?

int solution_found=0;

f(){
  setjmp();
  if (!solution_found)
    f4();
  /* continue here... */
}

Apart from that, setjmp/longjmp may be expensive calls. They also have a price in terms of readability of your program. I would certainly consider having f1,... pop themselves out of the stack the normal way instead, if I was you.

Answer 5

You can use getcontext/setcontext. They may be viewed as an advanced version of setjmp/longjmp; whereas the latter allows only a single non-local jump up the stack, setcontext allows the creation of multiple cooperative threads of control, each with its own stack.

Also refer to other related calls such as makecontext(), swapcontext().
Here is one sample code to show how to use these functions (Sorry for bad coding). Hope this helps you.

    #include <stdio.h>
    #include <ucontext.h>

    void func(void);

    int  x = 0;
    ucontext_t context, *cp = &context;

    int main(void) {

      getcontext(cp);
      if (!x) {
        printf("getcontext has been called\n");
        func();
      }
      else {
        printf("setcontext has been called\n");
      }

    }

    void func(void) {

      x++;
      setcontext(cp);

    }

  Output:

  getcontext has been called    
  setcontext has been called

Answer 6

I would do it something like this:

struct solution { ... }

solution *f() {
    solution *result;
    if (something) {
        result = f3();
        if (result != NULL)
            return result;
    }
    else {
        result = f3();
        if (result != NULL)
            return result;
    }
    return f();
}

Or whatever your algorithm might be.