Why do I need setjmp longjmp functions?

The setjmp and longjmp functions are used almost for the same purpose, for which the new languages ​​have try/catch and throw constructions. The latter can call setjmp and longjmp in some implementations, at least in C ++.

Consider the following case of calling functions in a program: f1 calls f2 , and that in turn f3 , which calls itself 100 times recursively. Parameters, return addresses and local variables of each launched function will fall onto the stack. All this together is called the stack frame , and in our case 102 frames will be added to the stack.

The return address is the physical address of the instruction that must be executed next after the completion of the called function. This address is stored on the stack when the machine instruction is executed, which is called something like CALL and is restored when the instruction is executed, which is called something like RET .

The usual way to return to the f1 function from the nested function itself is that all functions are completed in the standard way, and they remove their frames from the stack one by one. This, as you know, is long. In the case of an exceptional situation, I would like to immediately go upstairs to where the global handling of exceptional situations occurs.

The normal way to do this is impossible, but in the old days, programmers came up with a fairly simple hack. The stack is just a memory, and the pointer to the top of the stack is one of the registers of the processor. When adding values ​​to the stack, everything that was there before remains unchanged, therefore, in order to restore the stack, it is enough just to return the pointer value to the one that, for example, the function f1 .

But in order to return it, you must first remember it. In fact, you also need to remember the pointer of the current instruction, because when you return, you must not only restore the stack, but also transfer control to the instruction inside the f1 function.

To do this, use the setjmp function:

 #define TOO_DEEP_RECURSION 1 jmp_buf env; int main() { int val; val = setjmp(env); if(val) { fprintf(stderr,"Возникла ошибка с кодом %d",val); return val; } recursive100(1); return 0; } recursive100(int level) { if (level == 100) longjmp(env, TOO_DEEP_RECURSION); recursive100(level + 1); } 

Since this is a hack, the code looks a bit strange, but you need to understand the principle. The first time you call setjmp function stores all the necessary pointers in the jmp_buf structure and returns 0. As you can see, in this case, the program continues in the standard way and it calls 100 functions recursively.

With the 100th call, we go back using longjmp . This function takes a structure as an input, extracts from it a pointer to the next instruction and a pointer to the top of the stack, and restores them. The second parameter is an integer, which should not be 0.

The control is passed back to main as if it had just returned from setjmp and the function returns the integer you passed to longjmp . This time it is not equal to 0, the function main displays an error message and stops.

There can be several longjmp functions in your program, each can return its own code, and based on the code, you can display different messages.

Naturally, you can create several jmp_buf variables, and organize complex return logic. It is important to remember two things:

1. Before calling longjmp the jmp_buf structure must be initialized via setjmp , otherwise the program’s behavior will be unpredictable.

2. With a quick return, only the stack is cleaned. There is no code to release other resources, such as freeing memory from a heap, closing files, closing sockets, and so on.

My version:

 typedef enum { NoException = 0, Exception, ArgumentException, NotImplementedException, /* ... */ } __exception_types; #define try /* ... */ #define catch(x) /* ... */ #define throw(x,...) /* ... */ #define finally /* ... */ 

Using:

 try { puts("throw(NotImplementedException) call..."); throw(NotImplementedException, "in future releases only"); } catch( NotImplementedException ) { printf("catch NotImplementedException" ); if( __exeption_with_msg ) { printf( ": %s", __exeption_msg ); } printf( "\n" ); } else { printf("exception %d)", __exception_type ); if( __exeption_with_msg ) { printf( ": %s", __exeption_msg ); } printf( "\n" ); } finally { puts( "finally() block" ); } 

Define the content I propose to come up with yourself :)