/* <setjmp.h> — 저장한 자리로 되돌아가기. 흐름을 눈으로 따라간다. */
#include <setjmp.h>
#include <stdio.h>

static jmp_buf env;

static void deep(int level)
{
    printf("  going in to depth %d\n", level);
    if (level == 3) {
        puts("  trouble at depth 3 - longjmp(env, 42)");
        longjmp(env, 42);        /* 여기서 돌아가지 않는다 */
    }
    if (level < 5) deep(level + 1);   /* 조건을 두어야 컴파일러가 무한 재귀로 보지 않는다 */
    printf("  leaving depth %d normally\n", level);  /* 도달하지 않는다 */
}

int main(void)
{
    /* setjmp 는 *두 번* 값을 내놓는 것처럼 보인다:
       ① 직접 불렸을 때 0, ② longjmp 로 돌아왔을 때 그 val */
    int rc = setjmp(env);

    if (rc == 0) {
        puts("① setjmp returned 0 - meaning the place was saved");
        deep(1);
        puts("we never get here");
    } else {
        printf("② setjmp returned %d - so we came back through longjmp\n", rc);
    }

    /* longjmp(env, 0) 을 불러도 setjmp 는 0 을 돌려주지 않는다 — 1 이 된다 */
    static int once;
    if (!once) {
        once = 1;
        puts("\ntrying longjmp(env, 0):");
        longjmp(env, 0);
    }
    printf("\nsizeof(jmp_buf) = %zu bytes\n", sizeof(jmp_buf));
    return 0;
}

/* longjmp 로 돌아왔을 때 지역 변수는 어떻게 되는가 — volatile 이 필요한 이유. */
#include <setjmp.h>
#include <stdio.h>

static jmp_buf env;

static void fail(void) { longjmp(env, 1); }

int main(void)
{
    /* 표준의 규칙(§7.13.2.1): setjmp 를 부른 함수의 자동 변수 중
       ① volatile 이 아니고
       ② setjmp 와 longjmp 사이에 값이 바뀐 것
       은 longjmp 로 돌아왔을 때 *표현이 정해지지 않는다*.
       그 밖의 모든 객체는 longjmp 를 부른 시점의 값을 그대로 가진다. */
    int                 plain    = 1;    /* 위험: 자동 + 비 volatile */
    volatile int        guarded  = 1;    /* 안전: volatile */
    static int          statik   = 1;    /* 안전: 정적 저장 기간 */

    if (setjmp(env) == 0) {
        plain   = 2;                     /* setjmp 와 longjmp 사이에서 바꾼다 */
        guarded = 2;
        statik  = 2;
        puts("setting all three to 2, then longjmp");
        fail();
    }

    printf("\nafter coming back through longjmp:\n");
    printf("  plain   (automatic, not volatile) = %d   <- the standard guarantees nothing\n",
           plain);
    printf("  guarded (automatic, volatile)     = %d   <- guaranteed\n", guarded);
    printf("  statik  (static)                  = %d   <- guaranteed\n", statik);

#ifdef __OPTIMIZE__
    puts("\n(this build has optimization on. Notice that plain went back to 1 -");
    puts(" the compiler had kept that variable in a register.)");
#else
    puts("\n(this build has optimization off. plain reads 2 as well, but that is not guaranteed -");
    puts(" build the same code with -O2 and it prints 1. We checked.)");
#endif
    puts("the rule is one line: a local that must survive a longjmp gets");
    puts("volatile.");
    return 0;
}

/* longjmp 뒤에 포인터가 옛 값으로 되돌아가면 — 누수와 이중 해제의 경로. */
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>

static jmp_buf  env;
static void    *recorded;       /* malloc 이 실제로 돌려준 주소(정적이라 안전) */

[[noreturn]] static void fail(void) { longjmp(env, 1); }

int main(void)
{
    char          *risky = NULL;   /* 자동 + 비 volatile — 위험한 자리 */
    char *volatile safe  = NULL;   /* 포인터 자체를 volatile 로 */

    if (setjmp(env) == 0) {
        risky    = malloc(64);
        safe     = risky;
        recorded = risky;
        if (!risky) return 1;
        puts("64 bytes taken with malloc. Then something fails deep down.");
        fail();
    }

    /* 되돌아왔다. 두 변수가 같은 주소를 가리키고 있는가? */
    printf("is risky still the real allocation address? %s\n",
           (void *)risky == recorded ? "yes" : "no - it snapped back to the old value");
    printf("is safe  still the real allocation address? %s\n",
           (void *)safe  == recorded ? "yes" : "no - it snapped back to the old value");

#ifdef __OPTIMIZE__
    puts("\n(this build has optimization on. Notice that risky went back to the null it held at setjmp.");
    puts(" free(risky) then frees a null pointer, does nothing, and the 64 bytes leak for good.)");
#else
    puts("\n(this build has optimization off. Both survived, but risky is not guaranteed to -");
    puts(" build the same code with -O2 and risky goes back to null. We checked.)");
#endif

    free((void *)safe);            /* volatile 쪽으로 푼다 — 이것만이 계약 안 */
    puts("freed exactly once with free(safe).");
    return 0;
}

/* 예외 흉내 — libjpeg 계열이 쓰는 오류 처리 무늬, 그리고 그 대가. */
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ── libjpeg 의 error manager 를 줄여 옮긴 모양 ──────────────────
   구조체 안에 jmp_buf 를 넣어 두고, 깊은 곳에서 오류가 나면 그리로 뛴다.
   실제 libjpeg 의 setup_error_handler / png_jmpbuf 가 이 무늬다. */
typedef struct {
    jmp_buf env;
    char    message[64];
    int     code;
} error_ctx;

static error_ctx *current;          /* 지금 활성인 문맥(전역 하나) */

[[noreturn]] static void throw_error(int code, const char *msg)
{
    snprintf(current->message, sizeof current->message, "%s", msg);
    current->code = code;
    longjmp(current->env, 1);       /* 호출자의 setjmp 자리로 */
}

/* 깊은 곳의 함수들 — 오류를 값으로 돌려주지 않는다 */
static int parse_header(const char *s)
{
    if (strncmp(s, "IMG", 3) != 0) throw_error(2, "the magic number does not match");
    return 3;
}

static int parse_size(const char *s)
{
    int n = atoi(s);
    if (n <= 0)      throw_error(3, "the size is zero or less");
    if (n > 1000000) throw_error(4, "the size is too large");
    return n;
}

/* ── 흐름을 감싸는 쪽 ──────────────────────────────────────────── */
static int load_image(const char *text, char *err, size_t errcap)
{
    error_ctx ctx = { .code = 0 };
    error_ctx *saved = current;
    current = &ctx;

    /* 여기서 자원을 잡는다 — longjmp 로 돌아오면 *직접* 풀어야 한다 */
    void *buffer = malloc(1024);
    if (!buffer) { current = saved; return -1; }

    volatile int result;            /* longjmp 를 건너 살아남는다 */
    if (setjmp(ctx.env) == 0) {
        int off = parse_header(text);
        int n   = parse_size(text + off);
        printf("  ok: size %d\n", n);
        result = n;
    } else {
        snprintf(err, errcap, "%s (code %d)", ctx.message, ctx.code);
        result = -1;
    }

    free(buffer);                   /* 두 경로 모두 여기를 지난다 — 설계의 핵심 */
    current = saved;
    return result;
}

int main(void)
{
    const char *cases[] = { "IMG640", "BMP640", "IMG0", "IMG9999999" };
    for (size_t i = 0; i < sizeof cases / sizeof *cases; i++) {
        char err[96] = "";
        printf("input \"%s\":\n", cases[i]);
        int rc = load_image(cases[i], err, sizeof err);
        if (rc < 0) printf("  failed: %s\n", err);
    }

    puts("\nthree conditions make this pattern work:");
    puts("  ① every release of a resource sits in *one place*, inside the function that called setjmp");
    puts("  ② locals that must survive the longjmp are declared volatile");
    puts("  ③ longjmp happens only while the function that called setjmp is still alive");
    return 0;
}