# longjmp

From cppreference.com
< c‎ | program

Defined in header `<setjmp.h>` |  |
void longjmp( jmp_buf env, int status ); |  | (until C11)
_Noreturn void longjmp( jmp_buf env, int status ); |  | (since C11)

Loads the execution context `env` saved by a previous call to setjmp. This function does not return. Control is transferred to the call site of the macro setjmp that set up `env`. That setjmp then returns the value, passed as the `status`.

If the function that called setjmp has exited (whether by return or by a different `longjmp` higher up the stack), the behavior is undefined. In other words, only long jumps up the call stack are allowed.

Jumping across threads (if the function that called `setjmp` was executed by another thread) is also undefined behavior. | (since C11)

If when setjmp was called, a VLA or another variably-modified type variable was in scope and control left that scope, `longjmp` to that `setjmp` invokes undefined behavior even if control remained within the function.

On the way up the stack, `longjmp` does not deallocate any VLAs, memory leaks may occur if their lifetimes are terminated in this way:

    void g(int n)
    {
        int a[n]; // a may remain allocated
        h(n); // does not return
    }
    void h(int n)
    {
        int b[n]; // b may remain allocated
        longjmp(buf, 2); // might cause a memory leak for h's b and g's a
    }

(since C99)

### Parameters

env | - | variable referring to the execution state of the program saved by setjmp
status | - | the value to return from setjmp. If it is equal to ​0​, 1 is used instead

### Return value

(none)

### Notes

`longjmp` is intended for handling unexpected error conditions where the function cannot return meaningfully. This is similar to exception handling in other programming languages.

### Example

Run this code

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

    jmp_buf jump_buffer;

    noreturn void a(int count)
    {
        printf("a(%d) called\n", count);
        longjmp(jump_buffer, count+1); // will return count+1 out of setjmp
    }

    int main(void)
    {
        volatile int count = 0; // local vars must be volatile for setjmp
        if (setjmp(jump_buffer) != 9)
            a(count++);
    }

Output:

    a(0) called
    a(1) called
    a(2) called
    a(3) called
    a(4) called
    a(5) called
    a(6) called
    a(7) called
    a(8) called

### References

- C11 standard (ISO/IEC 9899:2011):

  - 7.13.2.1 The longjmp macro (p: 263-264)

- C99 standard (ISO/IEC 9899:1999):

  - 7.13.2.1 The longjmp macro (p: 244-245)

- C89/C90 standard (ISO/IEC 9899:1990):

  - 4.6.2.1 The longjmp function

### See also

setjmp | saves the context (function macro)
C++ documentation for longjmp

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=c/program/longjmp&oldid=78735"