setjump() and longjump() in C

The setjmp() and longjmp() functions are used together to perform non-local jumps in a C program. It allows you to jump back to a previously set jump point from anywhere in the program.

The setjmp() function saves the current execution environment or context into a jmp_buf variable. It stores things like the stack pointer, registers, etc. It returns 0 when first called.

The longjmp() function restores the execution context saved by a previous setjmp() call. After that, it returns, so execution resumes from the setjmp() call. However, this time, setjmp() will return a non-zero value indicating that longjmp() was called rather than returning from a direct call to setjmp().

It lets you jump to a previously saved point somewhere in the call stack. It can be useful for error-handling scenarios where you want to cleanly unwind from some deeply nested function calls.

For example, setjmp() could save an environment at the top level of a program. Then, deep in some nested function, if an error occurs, longjmp() can jump back to the top level where setjmp() was called without having to return from each nested function layer.

Basic Syntax:

Here is the basic syntax for setjmp() and longjmp():

setjmp():

#include <setjmp.h>

int setjmp(jmp_buf env);

'env': It is pointer to a jmp_buf, which saves the environment context.
Returns: It returns 0 when first called, non-zero when returned to by longjmp().

longjmp():

#include <setjmp.h>

void longjmp(jmp_buf env, int val);

'env': A jmp_buf saved by a previous setjmp() call.
'val': The non-zero value to return from setjmp().
No return value (never returns)

Working of setjmp():

Here is an explanation of how setjmp() works to set up a jump point in a C program:

Setting up a Jump Point

The setjmp() function saves the current execution state/context into an environment buffer specified by the 'jmp_buf env' parameter. This saved state includes things like:

Stack pointer
Register values
Program counter - the point of return

It saved 'jmp_buf env', representing a jump point or checkpoint that can later be returned to with 'longjmp()'.

First call to 'setjmp()'

When 'setjmp()' is first called, it saves the environment described above and returns 0. After that, execution continues normally after the 'setjmp()' call. So, the first time, it just sets up the checkpoint to jump back to later.

Subsequent calls

If 'longjmp()' is called later on to jump back, 'setjmp()' will essentially be called a second time when the environment is restored. After that, the 'setjmp()' will return a non-zero value. This non-zero return value was passed as the 'val' parameter to 'longjmp()'.

In summary, the first call saves the environment and returns 0. Subsequent calls caused by 'longjmp()' return the non-zero value from 'longjmp(env, val)' to signal that a jump occurred. The code can check if 'setjmp()' returns 0 or not to see if it is the first call or a jump back.

setjmp() and longjmp() implement non-local jumps, allowing to handle errors/recovery by jumping out of nested calls to a saved point.

Usage of longjmp():

Here is an explanation of how longjmp() is used to perform non-local jumps in C programs:

Performing Non-Local Jumps

The 'longjmp()' function restores the execution context previously saved with a call to 'setjmp()'. It effectively jumps execution to the point where 'setjmp()' was called.

However, instead of 'setjmp()' returns 0 like the first time, after 'longjmp()' jumps back, 'setjmp()' will return a non-zero value, allowing the program to detect that a jump occurred.

longjmp() Parameters

The 'longjmp()' takes two parameters:

The 'jmp_buf env' is the saved environment buffer stored by a previous 'setjmp()' call. It contains the context to jump back to.
'int val': This int value gets returned from 'setjmp()' after longjmp() jumps back. Typically, a non-zero error code is used to signal an error.

This non-local jump capacity provides a very flexible way for error handling and recovery in complex situations.

Error Handling with setjmp() and longjmp():

A common use case for setjmp()/longjmp() is to handle errors in deeply nested function calls.

For example:

jmp_buf env;
int error;

error = setjmp(env); 

if(error == 0){
  // first time call 
  nestedFunc1(); 

}else{  
  //Handle error 
  printf("Error code: %d", error);
}

void nestedFunc1(){
   // do work
   
   longjmp(env, 1); // jump back on error
}

It allows nestFunc1() to return immediately to the error handling block when trouble occurs by doing a non-local jump.

Best Practices:

Check the error return value from setjmp() to distinguish between the first call and the longjmp() jump back.
Avoid memory leaks by freeing allocated memory before longjmp().
Declaring env variables as volatile because the longjmp() call can lead to unexpected behaviour otherwise.
Do not call longjmp() from within a signal handler.

Pitfalls:

Resources like memory allocations may not be properly released with abrupt jumps.
Stack unwinding does not occur properly, leading to unexpected behaviour sometimes.

In summary, setjmp()/longjmp provides a method for non-local returns, but care must be taken to avoid side effects or leaks when handling errors.

Scope and Limitations:

Here are some key points about the scope & limitations of appropriately using setjmp() and longjmp():

Appropriate Uses

Error handling and recovery in complex, deeply nested function flows.
Environment recovery after catastrophic errors.
Non-local jumps are required for program control flow.
Switching between execution contexts.

Discouraged Uses

As a general program flow control mechanism (use sparingly).
Setjmp/longjmp prevents some compiler optimizations.
In place of returns or breaking out of loops.
In signal handlers or multi-threaded code.
When memory allocation/free discipline can't be maintained.

Limitations

Flowing exceptions across call frames usually require language support.
Stack unwinding does not happen automatically.
Resource/memory leaks more likely to occur.
Debugging can be harder across non-local jumps.
Implementation-dependent behaviour in some cases.

Examples and Code Snippets:

Here are some practical examples and code snippets illustrating the usage of setjmp() and longjmp() in different contexts:

Example: 1

#include <stdio.h>
#include <setjmp.h>

jmp_buf jump_buffer;

void foo() {
    if (setjmp(jump_buffer) != 0) {
        //Handle error
        printf("Error handled in foo()\n");
        return;
    }

    // Normal code execution
    printf("Executing foo()\n");

    // Simulate an error
    longjmp(jump_buffer, 1);
}

int main() {
    printf("Start of main()\n");
    foo();
    printf("End of main()\n");

    return 0;
}

Output:

Start of main()
Executing foo()
Error handled in foo()
End of main()

Example 2: Non-local Jump Across Functions

#include <stdio.h>
#include <setjmp.h>

jmp_buf jump_buffer;

void bar() {
    printf("Inside bar()\n");
    longjmp(jump_buffer, 1);  // Non-local jump to setjmp() in main()
}

void foo() {
    printf("Inside foo()\n");
    bar();  // This call will be skipped after the longjmp
    printf("Exiting foo()\n");
}

int main() {
    if (setjmp(jump_buffer) != 0) {
        // Jumped back from longjmp()
        printf("Jumped back to main() from longjmp()\n");
    } else {
        printf("Start of main()\n");
        foo();
        printf("End of main()\n");
    }

    return 0;
}

Output:

Start of main()
Inside foo()
Inside bar()
Jumped back to main() from longjmp()
End of main()

Example 3: Resource Cleanup

#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>

jmp_buf jump_buffer;

void cleanup() {
    // Cleanup code
    printf("Performing cleanup...\n");
}

void risky_operation() {
    // Simulating a risky operation
    printf("Performing a risky operation...\n");
    longjmp(jump_buffer, 1);  // Jump to cleanup() without completing the operation
}

int main() {
    if (setjmp(jump_buffer) == 0) {
        // Normal code execution
        printf("Start of main()\n");
        risky_operation();
        printf("End of main()\n");
    } else {
        // Jumped back from longjmp(), perform cleanup
        cleanup();
    }

    return 0;
}

Output:

Start of main()
Performing a risky operation...
Performing cleanup...

These examples showcase setjmp() and longjmp() for error handling, non-local jumps, and resource cleanup in different contexts. They provide a practical understanding of how these functions can be applied in real-world scenarios.