Language FoundationsC Programming Deep DiveHard

Exception Handling with setjmp/longjmp

Master the fundamental concepts of c programming deep dive through this focused micro-challenge.

~90 minutes C Programming Deep Dive Ready to learn

Topic Overview

Non-Local Jumps Without Exceptions

C has no try/catch, but setjmp/longjmp from <setjmp.h> snapshot the register and stack state, then restore it later. CPython uses this for signal handling; Lua's lua_error unwinds via a similar mechanism; libpng jumps back to a central error handler when a callback fails.

c
Loading…

setjmp returns 0 on first entry; after longjmp, it returns the value you passed (never 0, so 0 means "first time")
Locals in skipped stack frames may be wrong unless marked volatile
Close files and free heap before jumping, or leak

Building TRY/CATCH Macros

The exercise wraps this in macros that read like exceptions. Under the hood it is still a switch around setjmp.

For this exercise, you will implement TRY, CATCH, THROW, and FINALLY around file and calculation errors. This task asks you to treat longjmp as exceptional-only control flow, because using it like goto across functions is how production code corrupts stacks.

Keep the relevant man page, ABI doc, or Rust reference chapter open while you work. When your output disagrees with the reference implementation on the same machine, the mismatch is usually an alignment rule, an off-by-one terminator, or a register slot you misread in GDB.

Implementation Task

Your Task

C has no exceptions, but setjmp/longjmp can build them. Define TRY, CATCH(e), FINALLY, ETRY and THROW(e) macros: TRY calls setjmp, THROW calls longjmp with the exception code, the matching CATCH runs, and FINALLY always runs. Use them with two functions:

read_file(name) throws FILE_ERROR for an empty name;
calculate(x) throws CALCULATION_ERROR for 0, and otherwise returns 100 / x.

Input

One word: file, calc, success or nested. Anything else (or empty input) runs all four in that order.

Output

mode	scenario	output
`file`	`read_file("")` inside TRY, catching FILE_ERROR	`Caught file error`, then `Cleanup code`
`calc`	`calculate(0)`, catching CALCULATION_ERROR	`Caught calculation error`, then `Cleanup code`
`success`	`calculate(10)`	`Success! Result: 10`, then `Cleanup code`
`nested`	a second, local `jmp_buf`: `setjmp` then `longjmp` to it	`Nested exception handled`

The statement after a throwing call must never run.

Example

Input:

c
Loading…

Output:

c
Loading…

Requirements

THROW must unwind from inside a called function back to the TRY. That is the whole point of longjmp.
FINALLY runs on both the success path and the error path.

Hidden tests cover a calculation error, the success path and a nested jump buffer.