/* 표를 실행 때 다섯 단계로 짓는다: 등록, 채우기, 검증, 봉인, 사용.
   종류는 `static const` 표가 아니라 자료로 들어온다(플러그인 목록이 그렇듯이).
   채우기는 기본값 -> 부모 -> 자기 칸 순서라, 종류는 다른 것만 적는다.
   봉인은 표가 든 쪽을 읽기 전용으로 바꾼다(POSIX mprotect).
   --write-after-seal 을 주면 봉인 뒤에 칸 하나를 고쳐 본다. */
#define _DEFAULT_SOURCE        /* MAP_ANONYMOUS: 리눅스와 BSD, POSIX 2024 */
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>

struct stream;
typedef int (*slot)(struct stream *);
enum { WRITE, FLUSH, CLOSE, SLOTS };
static const char *const slot_names[SLOTS] = { "write", "flush", "close" };
struct stream_ops { slot s[SLOTS]; };
struct stream { const struct stream_ops *ops; const char *kind; };

/* 행동들 --- 저마다 자기가 누구인지만 말한다 */
#define SAY(fn) static int fn(struct stream *st) { (void)st; return 0; }
SAY(stream_flush_nothing) SAY(stream_close) SAY(file_write) SAY(file_flush)
SAY(gzip_write) SAY(gzip_close) SAY(memory_write)
static const struct { slot fn; const char *name; } fn_names[] = {
    { stream_flush_nothing, "stream_flush_nothing" }, { stream_close, "stream_close" },
    { file_write, "file_write" }, { file_flush, "file_flush" },
    { gzip_write, "gzip_write" }, { gzip_close, "gzip_close" },
    { memory_write, "memory_write" },
};
static const char *name_of(slot f)
{
    for (size_t i = 0; i < sizeof fn_names / sizeof fn_names[0]; i++)
        if (fn_names[i].fn == f) return fn_names[i].name;
    return "(empty)";
}

/* 1. 등록: 플러그인 목록이 적을 만한 것 --- 이름, 부모, 자기 칸 */
struct kind_desc { const char *name, *parent; bool abstract; slot own[SLOTS]; };
static const struct kind_desc descs[] = {
    { "gzip-file", "file",   false, { [WRITE] = gzip_write, [CLOSE] = gzip_close } },
    { "file",      "stream", false, { [WRITE] = file_write, [FLUSH] = file_flush } },
    { "memory",    "stream", false, { [WRITE] = memory_write } },
    { "broken",    "stream", false, { [CLOSE] = gzip_close } },       /* write 빠짐 */
    { "stream",    nullptr,  true,
      { [FLUSH] = stream_flush_nothing, [CLOSE] = stream_close } },
};
#define KINDS (sizeof descs / sizeof descs[0])

static struct stream_ops *tables;       /* 따로 한 쪽에 둔다 --- 봉인할 수 있게 */
static bool built[KINDS], published[KINDS];
static size_t page;

static int find(const char *name)
{
    for (size_t i = 0; i < KINDS; i++)
        if (strcmp(descs[i].name, name) == 0) return (int)i;
    return -1;
}

/* 2. 채우기: 부모 먼저(재귀로) → 복사 → 자기 칸 */
static bool fill(int k, int depth)
{
    if (built[k]) return true;
    if (depth > (int)KINDS) return false;               /* 부모가 돌고 돈다 */
    struct stream_ops t = {};
    if (descs[k].parent) {
        int p = find(descs[k].parent);
        if (p < 0 || !fill(p, depth + 1)) return false;
        t = tables[p];
    }
    for (int s = 0; s < SLOTS; s++)
        if (descs[k].own[s]) t.s[s] = descs[k].own[s];
    tables[k] = t;
    built[k] = true;
    return true;
}

int main(int argc, char **argv)
{
    bool attack = argc > 1 && strcmp(argv[1], "--write-after-seal") == 0;
    long ps = sysconf(_SC_PAGESIZE);
    page = ps > 0 ? (size_t)ps : 4096;
    if (KINDS * sizeof *tables > page) { puts("too many tables for a page"); return 1; }
    tables = mmap(nullptr, page, PROT_READ | PROT_WRITE,
                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (tables == MAP_FAILED) { puts("mmap failed"); return 1; }

    for (int k = 0; k < (int)KINDS; k++)
        if (!fill(k, 0)) { printf("cannot build %s\n", descs[k].name); return 1; }
    puts("built (defaults -> parent -> own slots):");
    for (size_t k = 0; k < KINDS; k++) {
        printf("  %-10s", descs[k].name);
        for (int s = 0; s < SLOTS; s++)
            printf(s + 1 < SLOTS ? " %s=%-20s" : " %s=%s",
                   slot_names[s], name_of(tables[k].s[s]));
        puts(descs[k].abstract ? "  (abstract)" : "");
    }

    /* 3. 검증: 빈칸이 있는 종류는 내놓지 않는다. 추상 종류는 늘 */
    for (size_t k = 0; k < KINDS; k++) {
        published[k] = !descs[k].abstract;
        for (int s = 0; s < SLOTS && published[k]; s++)
            if (!tables[k].s[s]) {
                printf("verify: %s has no %s --- not published\n",
                       descs[k].name, slot_names[s]);
                published[k] = false;
            }
    }

    /* 4. 봉인: 여기부터 표는 읽기만 한다 */
    if (mprotect(tables, page, PROT_READ) != 0) { puts("mprotect failed"); return 1; }
    const struct stream_ops *sealed = tables;
    puts("sealed: the page holding the tables is read-only");

    /* 5. 사용 */
    for (size_t k = 0; k < KINDS; k++) {
        if (!published[k]) continue;
        struct stream st = { &sealed[k], descs[k].name };
        int r = st.ops->s[WRITE](&st) | st.ops->s[FLUSH](&st) | st.ops->s[CLOSE](&st);
        printf("use: a %s stream wrote, flushed and closed%s\n",
               st.kind, r ? " (error)" : "");
    }

    if (attack) {
        puts("now overwriting gzip-file's write slot...");
        fflush(stdout);
        tables[find("gzip-file")].s[WRITE] = memory_write;   /* 읽기 전용 쪽 */
        puts("the write went through");
    }
    munmap(tables, page);
    return 0;
}

/* 한 번 짓고 한 번 내놓는다: 스레드 여덟이 한꺼번에 표를 달라고 한다.
   call_once 는 짓는 함수를 정확히 한 번 돌리고, 부른 쪽은 모두 그것이 끝난 뒤에야
   돌아온다 --- 그래서 반쯤 채운 표를 보는 스레드가 없다. */
#include <stdatomic.h>
#include <stdio.h>
#include <threads.h>

struct ops { int (*area)(int); int (*perimeter)(int); };
static int sq_area(int s) { return s * s; }
static int sq_perimeter(int s) { return 4 * s; }

static struct ops table;                /* 실행 때 채우고, 그 뒤로는 읽기만 */
static once_flag table_once = ONCE_FLAG_INIT;
static atomic_int builds;

static void build(void)
{
    atomic_fetch_add(&builds, 1);
    table.area = sq_area;
    thrd_sleep(&(struct timespec){ .tv_nsec = 20'000'000 }, nullptr);  /* 느린 짓기 */
    table.perimeter = sq_perimeter;
}
static const struct ops *get_table(void)
{
    call_once(&table_once, build);
    return &table;
}

enum { THREADS = 8 };
static const struct ops *seen[THREADS];
static int answer[THREADS];
static int worker(void *arg)
{
    int i = *(int *)arg;
    seen[i] = get_table();
    answer[i] = seen[i]->area(3) + seen[i]->perimeter(3);  /* 두 칸 다 있다 */
    return 0;
}

int main(void)
{
    thrd_t t[THREADS];
    int id[THREADS];
    for (int i = 0; i < THREADS; i++) {
        id[i] = i;
        if (thrd_create(&t[i], worker, &id[i]) != thrd_success) {
            puts("thrd_create failed");
            return 1;
        }
    }
    for (int i = 0; i < THREADS; i++) thrd_join(t[i], nullptr);

    bool same = true, right = true;
    for (int i = 0; i < THREADS; i++) {
        same = same && seen[i] == seen[0];
        right = right && answer[i] == 9 + 12;
    }
    printf("%d threads asked; the builder ran %d time(s)\n",
           THREADS, atomic_load(&builds));
    printf("every thread got the same table: %s\n", same ? "yes" : "no");
    printf("every answer was area 9 + perimeter 12 = 21, both slots filled: %s\n",
           right ? "yes" : "no");
    return 0;
}

/* 뚱뚱한 포인터: 자료를 가리키는 포인터와 표를 가리키는 포인터를 함께 들고 다닌다.
   표가 객체 바깥에 있으니, 고칠 수 없는 타입에도 인터페이스를 붙인다 ---
   여기서는 표준 라이브러리의 struct tm 과 그냥 double.
   객체는 아무것도 치르지 않고, 그것을 가리키는 포인터마다 두 배로 넓어진다. */
#include <stdio.h>
#include <time.h>

struct printable_ops { void (*print)(const void *self); const char *type; };
struct printable { const void *self; const struct printable_ops *ops; };   /* 포인터 둘 */

static void print_tm(const void *self)
{
    const struct tm *t = self;
    printf("%04d-%02d-%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday);
}
static void print_double(const void *self) { printf("%.3f", *(const double *)self); }

/* 견주려고 둔 「vptr」 길: 표 포인터가 객체 안에 있다 */
struct point_ops;
struct point { const struct point_ops *ops; double x, y; };
struct point_ops { void (*print)(const struct point *); };
static void print_point(const struct point *p) { printf("(%g, %g)", p->x, p->y); }
static const struct point_ops point_ops = { print_point };
static void print_point_any(const void *self) { print_point(self); }

static const struct printable_ops tm_printable     = { print_tm, "struct tm" };
static const struct printable_ops double_printable = { print_double, "double" };
static const struct printable_ops point_printable  = { print_point_any, "struct point" };

static void print_all(const struct printable *xs, size_t n)
{
    for (size_t i = 0; i < n; i++) {
        printf("  %-13s ", xs[i].ops->type);
        xs[i].ops->print(xs[i].self);
        putchar('\n');
    }
}

int main(void)
{
    struct tm day = { .tm_year = 2026 - 1900, .tm_mon = 10, .tm_mday = 6 };
    double ratio = 1.618;
    struct point p = { &point_ops, 3, 4 };

    struct printable xs[] = {
        { &day, &tm_printable }, { &ratio, &double_printable }, { &p, &point_printable },
    };
    puts("one interface, three types --- two of them never heard of it:");
    print_all(xs, sizeof xs / sizeof xs[0]);

    printf("sizeof(struct tm) %zu, unchanged; sizeof(double) %zu, unchanged\n",
           sizeof day, sizeof ratio);
    printf("sizeof(struct point) %zu --- it carries its own table pointer\n", sizeof p);
    printf("a plain pointer %zu bytes, a fat pointer %zu bytes\n",
           sizeof(void *), sizeof(struct printable));
    return 0;
}

/* (인터페이스, 구체 타입) 쌍마다 표 하나 --- 처음 쓸 때 실행 때 짓고 해시 표에 둔다.
   Go 의 itab 의 생각을 C 로.
   타입은 메서드를 이름으로 늘어놓을 뿐, 어느 인터페이스를 만족하는지 말하지 않는다.
   맞지 않은 쌍도 캐시한다 --- 다시 물으면 다시 짓지 않고 찾기만 한다. */
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef double (*fn)(const void *self);
struct method { const char *name; fn f; };
struct type  { const char *name; const struct method *methods; size_t n; };
struct iface { const char *name; const char *const *wants; size_t n; };
struct itab  { const struct iface *in; const struct type *ty; bool ok; fn fun[4]; };

/* ---- 캐시: 열린 주소법, 열쇠는 포인터 쌍 ---- */
enum { SLOTS = 64 };
static struct itab *cache[SLOTS];
static unsigned builds, hits;

static size_t hash(const struct iface *in, const struct type *ty)
{
    uintptr_t h = (uintptr_t)in * 31 ^ (uintptr_t)ty;
    return (size_t)(h ^ h >> 7) % SLOTS;
}
static struct itab *build(const struct iface *in, const struct type *ty)
{
    struct itab *t = calloc(1, sizeof *t);
    if (!t) return nullptr;
    *t = (struct itab){ in, ty, true, {} };
    builds++;
    for (size_t w = 0; w < in->n && w < 4; w++) {          /* 이름으로, 차례대로 맞춘다 */
        fn found = nullptr;
        for (size_t m = 0; m < ty->n; m++)
            if (strcmp(ty->methods[m].name, in->wants[w]) == 0) found = ty->methods[m].f;
        if (!found) { t->ok = false; break; }
        t->fun[w] = found;
    }
    return t;
}
static const struct itab *get_itab(const struct iface *in, const struct type *ty)
{
    size_t i = hash(in, ty);
    for (size_t probes = 0; probes < SLOTS; probes++, i = (i + 1) % SLOTS) {
        if (!cache[i]) return cache[i] = build(in, ty);   /* 처음이면 짓고 둔다 */
        if (cache[i]->in == in && cache[i]->ty == ty) { hits++; return cache[i]; }
    }
    return nullptr;                                         /* 캐시가 찼다 */
}

/* ---- 인터페이스를 모르는 타입들 ---- */
struct circle { double r; };
struct label  { const char *text; };
static double circle_area(const void *s)
{ const struct circle *c = s; return 3.0 * c->r * c->r; }
static double circle_perimeter(const void *s)
{ const struct circle *c = s; return 6.0 * c->r; }
static double label_length(const void *s)
{ const struct label *l = s; return (double)strlen(l->text); }

static const struct method circle_m[] = {
    { "area", circle_area }, { "perimeter", circle_perimeter },
};
static const struct method label_m[]  = { { "length", label_length } };
static const struct type circle_t = { "circle", circle_m, 2 };
static const struct type label_t  = { "label", label_m, 1 };

static const char *const shape_wants[] = { "area", "perimeter" };
static const struct iface shape_i = { "Shape", shape_wants, 2 };

/* 인터페이스 값: itab 과 자료 --- 뚱뚱한 포인터 */
struct shape_value { const struct itab *tab; const void *data; };
static bool as_shape(const struct type *ty, const void *data, struct shape_value *out)
{
    const struct itab *t = get_itab(&shape_i, ty);
    if (!t || !t->ok) return false;
    *out = (struct shape_value){ t, data };
    return true;
}

int main(void)
{
    struct circle cs[] = { { 1 }, { 2 }, { 0.5 } };
    struct label lb = { "hello" };
    for (size_t i = 0; i < 3; i++) {
        struct shape_value v;
        if (as_shape(&circle_t, &cs[i], &v))
            printf("circle %.1f as Shape: area %.2f, perimeter %.2f\n",
                   cs[i].r, v.tab->fun[0](v.data), v.tab->fun[1](v.data));
    }
    for (int i = 0; i < 2; i++) {
        struct shape_value v;
        bool ok = as_shape(&label_t, &lb, &v);
        printf("label as Shape: %s\n", ok ? "yes" : "no --- it has no area");
    }
    printf("tables built %u (one per pair, the failure too), cache hits %u\n",
           builds, hits);
    for (size_t i = 0; i < SLOTS; i++) free(cache[i]);
    return 0;
}

/* 이름(셀렉터)으로 찾는 디스패치 --- Smalltalk · Objective-C 의 길을 C 로.
   1. 메시지 이름은 한 번 인턴해 정수 셀렉터로 바꾼다.
   2. 클래스의 메서드 목록을 훑고, 없으면 부모로 올라간다.
   3. 찾은 것은 클래스별 캐시에 넣는다. 다음부터는 캐시에서 끝난다.
   4. 끝내 없으면 「모르는 메시지」 처리기로 넘긴다(포워딩).
   5. 실행 때 메서드를 더하면 세대 번호를 올려 모든 캐시를 한꺼번에 버린다. */
#include <stdio.h>
#include <string.h>

#define MAX_SELECTORS 32
#define MAX_METHODS   8
#define CACHE_SLOTS   8

struct object;
typedef double (*imp)(struct object *self);

struct method { unsigned sel; imp fn; };
struct cache_slot { unsigned sel; imp fn; unsigned epoch; };
struct class {
    const char *name;
    struct class *parent;
    struct method methods[MAX_METHODS];
    unsigned n_methods;
    struct cache_slot cache[CACHE_SLOTS];
};
struct object { struct class *isa; double size; };

/* ---- 셀렉터 인턴 ---- */
static const char *selector_names[MAX_SELECTORS];
static unsigned n_selectors;
static unsigned intern(const char *name)
{
    for (unsigned i = 0; i < n_selectors; i++)
        if (strcmp(selector_names[i], name) == 0) return i + 1;
    if (n_selectors == MAX_SELECTORS) return 0;
    selector_names[n_selectors++] = name;
    return n_selectors;                       /* 0 은 「셀렉터 없음」으로 남긴다 */
}

/* ---- 찾기 ---- */
static unsigned epoch = 1;                    /* 메서드가 바뀔 때마다 오른다 */
static unsigned slow_lookups, cache_hits;

static imp lookup_slow(const struct class *c, unsigned sel)
{
    slow_lookups++;
    for (; c; c = c->parent)
        for (unsigned i = 0; i < c->n_methods; i++)
            if (c->methods[i].sel == sel) return c->methods[i].fn;
    return nullptr;
}
static imp lookup(struct class *c, unsigned sel)
{
    struct cache_slot *slot = &c->cache[sel % CACHE_SLOTS];
    if (slot->sel == sel && slot->epoch == epoch) { cache_hits++; return slot->fn; }
    imp fn = lookup_slow(c, sel);
    *slot = (struct cache_slot){ sel, fn, epoch };     /* 「없음」도 캐시한다 */
    return fn;
}
static bool add_method(struct class *c, const char *name, imp fn)
{
    if (c->n_methods == MAX_METHODS) return false;
    c->methods[c->n_methods++] = (struct method){ intern(name), fn };
    epoch++;                                  /* 모든 클래스의 캐시가 한꺼번에 낡는다 */
    return true;
}

/* ---- 보내기 ---- */
static double does_not_understand(struct object *self, unsigned sel)
{
    printf("  %s does not understand '%s'\n", self->isa->name,
           sel ? selector_names[sel - 1] : "(selector table full)");
    return 0;
}
static double send(struct object *self, const char *message)
{
    unsigned sel = intern(message);
    imp fn = sel ? lookup(self->isa, sel) : nullptr;
    return fn ? fn(self) : does_not_understand(self, sel);
}

/* ---- 클래스들 ---- */
static double shape_describe(struct object *self)
{ printf("  a %s of size %g\n", self->isa->name, self->size); return 0; }
static double circle_area(struct object *self) { return 3.0 * self->size * self->size; }
static double square_area(struct object *self) { return self->size * self->size; }
static double shape_perimeter(struct object *self) { return 4.0 * self->size; }

static struct class shape  = { .name = "Shape" };
static struct class circle = { .name = "Circle", .parent = &shape };
static struct class square = { .name = "Square", .parent = &shape };

int main(void)
{
    add_method(&shape, "describe", shape_describe);
    add_method(&circle, "area", circle_area);
    add_method(&square, "area", square_area);

    struct object things[] = { { &circle, 2 }, { &square, 3 }, { &circle, 1 } };
    puts("send 'describe' (inherited) and 'area' (own) to each:");
    for (size_t i = 0; i < sizeof things / sizeof things[0]; i++) {
        send(&things[i], "describe");
        printf("  area = %g\n", send(&things[i], "area"));
    }
    printf("slow lookups %u, cache hits %u\n\n", slow_lookups, cache_hits);

    puts("send 'perimeter', which nobody defines yet:");
    send(&things[0], "perimeter");
    send(&things[0], "perimeter");            /* 「없음」도 캐시에서 나온다 */
    printf("slow lookups %u, cache hits %u\n\n", slow_lookups, cache_hits);

    puts("add 'perimeter' to Shape at run time, then send again:");
    add_method(&shape, "perimeter", shape_perimeter);
    printf("  perimeter = %g\n", send(&things[0], "perimeter"));
    printf("  perimeter = %g\n", send(&things[1], "perimeter"));
    printf("slow lookups %u, cache hits %u\n", slow_lookups, cache_hits);
    return 0;
}