/* 직렬화를 정직하게 건너뛰기: 기억 속 배치가 *곧* 형식일 때.
   고정 폭 멤버, 넓은 것부터, 숨은 패딩 없음, 오프셋은 static_assert 로 못박는다 ---
   그래서 다른 컴파일러나 옵션이면 다른 바이트를 조용히 쓰는 대신 빌드가 멈춘다.
   바이트 순서는 여전히 기계의 것이다: 그것도 확인한다. */
#include <stdbit.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

struct wire_header {            /* 같은 기계의 두 프로세스가 나눠 쓴다 */
    uint64_t sequence;
    uint32_t length;
    uint16_t kind;
    uint8_t  flags;
    uint8_t  version;
};
static_assert(sizeof(struct wire_header) == 16, "layout changed");
static_assert(offsetof(struct wire_header, length)  == 8);
static_assert(offsetof(struct wire_header, kind)    == 12);
static_assert(offsetof(struct wire_header, flags)   == 14);
static_assert(offsetof(struct wire_header, version) == 15);
static_assert(__STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_LITTLE__,
              "this format is little endian; a big-endian build must convert");

struct careless {               /* 같은 멤버를 아무렇게나 늘어놓은 것 */
    uint8_t  flags;
    uint64_t sequence;
    uint16_t kind;
    uint32_t length;
    uint8_t  version;
};

int main(void)
{
    printf("wire_header: %zu bytes, no padding (8 + 4 + 2 + 1 + 1)\n",
           sizeof(struct wire_header));
    printf("careless   : %zu bytes for the same 16 bytes of members\n",
           sizeof(struct careless));
    printf("  offsets: flags %zu, sequence %zu, kind %zu, length %zu, version %zu\n",
           offsetof(struct careless, flags), offsetof(struct careless, sequence),
           offsetof(struct careless, kind), offsetof(struct careless, length),
           offsetof(struct careless, version));
    return 0;
}

/* 끈적한 오류 표시를 단 쓰는 커서와 읽는 커서.
   모든 put/get 이 남은 자리를 확인한다. 한 번 확인에 걸리면 커서가 「bad」가 되고,
   그 뒤의 호출은 아무것도 하지 않는다. 부르는 쪽은 끝에서 한 번만 확인한다. */
#include <stdint.h>
#include <stdio.h>
#include <string.h>

struct wcur { unsigned char *p; size_t cap, len; bool bad; };
struct rcur { const unsigned char *p; size_t len, pos; bool bad; };

static void put_bytes(struct wcur *w, const void *src, size_t n)
{
    if (w->bad || n > w->cap - w->len) { w->bad = true; return; }
    memcpy(w->p + w->len, src, n);
    w->len += n;
}
static void put_u8(struct wcur *w, uint8_t v) { put_bytes(w, &v, 1); }
static void put_u16le(struct wcur *w, uint16_t v)
{
    unsigned char b[2] = { (unsigned char)v, (unsigned char)(v >> 8) };
    put_bytes(w, b, 2);
}
static void put_u32le(struct wcur *w, uint32_t v)
{
    unsigned char b[4] = { (unsigned char)v, (unsigned char)(v >> 8),
                           (unsigned char)(v >> 16), (unsigned char)(v >> 24) };
    put_bytes(w, b, 4);
}

static const unsigned char *take(struct rcur *r, size_t n)
{
    if (r->bad || n > r->len - r->pos) { r->bad = true; return nullptr; }
    const unsigned char *at = r->p + r->pos;
    r->pos += n;
    return at;
}
static uint8_t get_u8(struct rcur *r)
{ const unsigned char *b = take(r, 1); return b ? b[0] : 0; }
static uint16_t get_u16le(struct rcur *r)
{ const unsigned char *b = take(r, 2); return b ? (uint16_t)(b[0] | b[1] << 8) : 0; }
static uint32_t get_u32le(struct rcur *r)
{
    const unsigned char *b = take(r, 4);
    return b ? (uint32_t)b[0] | (uint32_t)b[1] << 8
             | (uint32_t)b[2] << 16 | (uint32_t)b[3] << 24 : 0;
}

struct player { uint32_t id; uint16_t level; uint8_t name_len; char name[32]; };

static void encode(struct wcur *w, const struct player *pl)
{
    put_u32le(w, pl->id);
    put_u16le(w, pl->level);
    put_u8(w, pl->name_len);              /* 길이가 먼저 간다 */
    put_bytes(w, pl->name, pl->name_len);
}

static bool decode(struct rcur *r, struct player *pl)
{
    pl->id = get_u32le(r);
    pl->level = get_u16le(r);
    pl->name_len = get_u8(r);
    if (pl->name_len >= sizeof pl->name) r->bad = true;   /* 형식 자신의 상한 */
    const unsigned char *s = take(r, r->bad ? 0 : pl->name_len);
    if (r->bad) return false;             /* 확인은 한 번, 모든 읽기 뒤에 */
    memcpy(pl->name, s, pl->name_len);
    pl->name[pl->name_len] = '\0';
    return true;
}

int main(void)
{
    struct player in = { .id = 0x01020304, .level = 7, .name_len = 5, .name = "alice" };
    unsigned char buf[64];
    struct wcur w = { .p = buf, .cap = sizeof buf };
    encode(&w, &in);
    printf("encoded %zu bytes:", w.len);
    for (size_t i = 0; i < w.len; i++) printf(" %02X", buf[i]);
    printf("\n  (sizeof(struct player) is %zu ---"
           " the bytes are the format, not the struct)\n\n",
           sizeof(struct player));

    struct player out;
    struct rcur r = { .p = buf, .len = w.len };
    printf("whole message   : %s", decode(&r, &out) ? "ok" : "rejected");
    printf("  -> id %08X, level %u, name \"%s\"\n",
           (unsigned)out.id, out.level, out.name);

    r = (struct rcur){ .p = buf, .len = w.len - 2 };          /* 짧게 자른다 */
    printf("two bytes short : %s\n", decode(&r, &out) ? "ok" : "rejected");

    unsigned char lie[64];
    memcpy(lie, buf, w.len);
    lie[6] = 200;                                             /* 길이가 거짓말을 한다 */
    r = (struct rcur){ .p = lie, .len = w.len };
    printf("length says 200 : %s\n", decode(&r, &out) ? "ok" : "rejected");

    unsigned char tiny[8];
    w = (struct wcur){ .p = tiny, .cap = sizeof tiny };
    encode(&w, &in);
    printf("8-byte buffer   : writer is %s after %zu bytes\n",
           w.bad ? "bad" : "fine", w.len);
    return 0;
}

/* 가변 길이 정수(128진, 「LEB128」·프로토콜 버퍼 방식)와 지그재그.
   바이트마다 값 7비트, 낮은 묶음이 먼저. 맨 위 비트는 「뒤에 바이트가 더 있다」.
   작은 수는 바이트를 적게 쓴다. */
#include <stdint.h>
#include <stdio.h>

static size_t put_varint(unsigned char *out, uint64_t v)
{
    size_t n = 0;
    do {
        unsigned char b = v & 0x7F;
        v >>= 7;
        out[n++] = b | (v ? 0x80 : 0);      /* 더 있는가? 맨 위 비트를 켠다 */
    } while (v);
    return n;
}

/* 읽은 바이트 수를 돌려준다. 입력이 잘렸거나 너무 길면 0. */
static size_t get_varint(const unsigned char *in, size_t len, uint64_t *v)
{
    uint64_t x = 0;
    for (size_t i = 0; i < len && i < 10; i++) {          /* 64비트는 많아야 10바이트 */
        uint64_t part = in[i] & 0x7F;
        if (i == 9 && part > 1) return 0;                  /* 64비트에 들어가지 않는다 */
        x |= part << (7 * i);
        if (!(in[i] & 0x80)) { *v = x; return i + 1; }
    }
    return 0;
}

/* 지그재그: 0,-1,1,-2,2 … -> 0,1,2,3,4 … 작은 음수도 작게 남는다 */
/* 음수를 오른쪽으로 밀지 않는다: 그것은 구현 정의다 */
static uint64_t zigzag(int64_t n)
{ uint64_t u = (uint64_t)n; return (u << 1) ^ (0 - (u >> 63)); }
static int64_t  unzigzag(uint64_t u) { return (int64_t)(u >> 1) ^ -(int64_t)(u & 1); }

static void show(const char *label, uint64_t v)
{
    unsigned char b[10];
    size_t n = put_varint(b, v);
    printf("  %-22s ->", label);
    for (size_t i = 0; i < n; i++) printf(" %02X", b[i]);
    printf("   (%zu byte%s)\n", n, n == 1 ? "" : "s");
}

int main(void)
{
    puts("[varint]");
    show("1", 1);
    show("127", 127);
    show("128", 128);
    show("150", 150);
    show("300", 300);
    show("UINT32_MAX", UINT32_MAX);
    show("-1 as uint64_t", (uint64_t)-1);

    puts("\n[zigzag, then varint]");
    for (int64_t n = -2; n <= 2; n++) {
        char label[32];
        snprintf(label, sizeof label, "%lld -> %llu", (long long)n,
                 (unsigned long long)zigzag(n));
        show(label, zigzag(n));
    }

    puts("\n[reading back]");
    unsigned char good[] = { 0xAC, 0x02 };
    unsigned char cut[]  = { 0xAC };              /* 「더 있다」 하고 아무것도 없다 */
    unsigned char runaway[11] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                                  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };
    uint64_t v = 0;
    size_t n = get_varint(good, sizeof good, &v);
    printf("  AC 02            -> %llu (%zu bytes)\n", (unsigned long long)v, n);
    printf("  AC               -> %s\n",
           get_varint(cut, sizeof cut, &v) ? "ok" : "rejected: cut short");
    printf("  FF x10, 01       -> %s\n",
           get_varint(runaway, sizeof runaway, &v) ? "ok" : "rejected: too long");
    printf("  unzigzag(3)      -> %lld\n", (long long)unzigzag(3));
    return 0;
}

/* 작은 파일 형식: 매직, 판 번호, 그리고 태그·길이·값 필드들.
   판 1 을 위해 만든 읽는 쪽이 판 2 가 쓴 파일을 만나, 들어 본 적 없는 필드를
   건너뛴다 --- 필드마다 자기 길이를 말하기 때문이다. */
#include <stdint.h>
#include <stdio.h>
#include <string.h>

enum { TAG_NAME = 1, TAG_SCORE = 2, TAG_COLOUR = 3 /* 판 2 에서 더함 */ };
enum { MAX_FIELD = 64 };                    /* 형식의 약속: 이보다 긴 필드는 없다 */

static const unsigned char magic[4] = { 'P', 'C', 'B', 0x1A };

static size_t put_field(unsigned char *out, uint8_t tag, const void *v, uint8_t len)
{
    out[0] = tag; out[1] = len;
    memcpy(out + 2, v, len);
    return 2u + len;
}

static size_t write_v2(unsigned char *out)
{
    size_t n = 0;
    memcpy(out, magic, 4); n += 4;
    out[n++] = 2;                                         /* 판 번호 */
    n += put_field(out + n, TAG_NAME, "alice", 5);
    n += put_field(out + n, TAG_COLOUR, "\xFF\x80\x00", 3);   /* 판 2 의 새 필드 */
    unsigned char score[4] = { 0x39, 0x05, 0, 0 };        /* 1337, 리틀 엔디안 */
    n += put_field(out + n, TAG_SCORE, score, 4);
    return n;
}

/* 판 1 의 읽는 쪽: NAME 과 SCORE 만 안다. */
static int read_v1(const unsigned char *in, size_t len)
{
    if (len < 5 || memcmp(in, magic, 4) != 0) { puts("  not our file"); return 0; }
    unsigned version = in[4];
    printf("  version %u file\n", version);
    size_t pos = 5;
    while (pos < len) {
        if (len - pos < 2) { puts("  rejected: field header cut short"); return 0; }
        unsigned tag = in[pos], flen = in[pos + 1];
        if (flen > MAX_FIELD)
            { printf("  rejected: field of %u bytes\n", flen); return 0; }
        if (flen > len - pos - 2)
            { puts("  rejected: field runs past the end"); return 0; }
        const unsigned char *v = in + pos + 2;
        switch (tag) {
        case TAG_NAME:
            printf("  name  = %.*s\n", (int)flen, (const char *)v);
            break;
        case TAG_SCORE:
            if (flen != 4) { puts("  rejected: score is not 4 bytes"); return 0; }
            printf("  score = %u\n", (unsigned)(v[0] | v[1] << 8
                                     | (uint32_t)v[2] << 16 | (uint32_t)v[3] << 24));
            break;
        default:
            printf("  (skipped unknown tag %u, %u bytes)\n", tag, flen);
        }
        pos += 2u + flen;
    }
    return 1;
}

int main(void)
{
    unsigned char file[128];
    size_t n = write_v2(file);
    printf("[a version-2 file, %zu bytes, read by a version-1 reader]\n", n);
    read_v1(file, n);

    puts("\n[the same file with the last field's length raised to 9]");
    file[n - 5] = 9;
    read_v1(file, n);

    puts("\n[a field that claims 200 bytes]");
    file[6] = 200;
    read_v1(file, n);
    return 0;
}

/* 바이트에서 32비트 빅 엔디안 값을 읽는 두 방법.
      어느 쪽도 결과가 기계의 바이트 순서에 따라 달라지지 않는다. (2)는 리틀 · 빅 엔디안 기계만 다룬다. */
#include <stdint.h>
#include <string.h>

/* (1) 시프트: 이식되는 C, 표준 밖의 것이 없다 */
uint32_t get_u32be_shift(const unsigned char *p)
{
    return (uint32_t)p[0] << 24 | (uint32_t)p[1] << 16
         | (uint32_t)p[2] << 8  | (uint32_t)p[3];
}

/* (2) uint32_t 에 memcpy 한 뒤, 이 기계가 리틀 엔디안이면 바이트를 뒤집는다.
   __builtin_bswap32 는 GCC·Clang 확장이다. MSVC 에서는 _byteswap_ulong. */
#include <stdbit.h>
uint32_t get_u32be_bswap(const unsigned char *p)
{
    uint32_t v;
    memcpy(&v, p, sizeof v);
#if __STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_LITTLE__
        v = __builtin_bswap32(v);
#elif __STDC_ENDIAN_NATIVE__ != __STDC_ENDIAN_BIG__
#error "byte order is neither little nor big endian"
#endif
    return v;
}

/* 시프트로 리틀 엔디안 --- 리틀 엔디안 기계에서는 그냥 읽기 하나 */
uint32_t get_u32le_shift(const unsigned char *p)
{
    return (uint32_t)p[0] | (uint32_t)p[1] << 8
         | (uint32_t)p[2] << 16 | (uint32_t)p[3] << 24;
}

/* 필드마다 쓰기와, 먼저 버퍼 하나에 모으기.
   `sink` 는 호출마다 비싼 것을 대신한다 --- 소켓의 send(), 파일의 write(), USB 전송.
   여기서는 세기만 한다. */
#include <stdint.h>
#include <stdio.h>
#include <string.h>

static unsigned long calls, bytes;
static void sink(const void *p, size_t n) { (void)p; calls++; bytes += n; }

struct point { int32_t x, y; uint16_t id; };

static void put_le(unsigned char *b, uint32_t v, int n)
{ for (int i = 0; i < n; i++) b[i] = (unsigned char)(v >> (8 * i)); }

/* (1) 필드마다 따로 나간다 */
static void send_each(const struct point *pts, size_t count)
{
    unsigned char b[4];
    for (size_t i = 0; i < count; i++) {
        put_le(b, (uint32_t)pts[i].x, 4);  sink(b, 4);
        put_le(b, (uint32_t)pts[i].y, 4);  sink(b, 4);
        put_le(b, pts[i].id, 2);           sink(b, 2);
    }
}

/* (2) 버퍼를 채우고, 차면 보내고, 끝에 한 번 더 */
static void send_batched(const struct point *pts, size_t count)
{
    unsigned char buf[4096];
    size_t used = 0;
    for (size_t i = 0; i < count; i++) {
        if (sizeof buf - used < 10) { sink(buf, used); used = 0; }
        put_le(buf + used, (uint32_t)pts[i].x, 4);
        put_le(buf + used + 4, (uint32_t)pts[i].y, 4);
        put_le(buf + used + 8, pts[i].id, 2);
        used += 10;
    }
    if (used) sink(buf, used);
}

int main(void)
{
    static struct point pts[10000];
    for (size_t i = 0; i < 10000; i++)
        pts[i] = (struct point){ (int32_t)i, -(int32_t)i, (uint16_t)i };

    send_each(pts, 10000);
    unsigned long each = calls;
    printf("field by field : %6lu calls, %lu bytes\n", calls, bytes);
    calls = bytes = 0;
    send_batched(pts, 10000);
    printf("4 KiB buffer   : %6lu calls, %lu bytes\n", calls, bytes);
    printf("\nsame bytes, one call where there were %lu.\n", each / calls);
    puts("If one call costs a trip into the kernel, that is where the time goes.");
    puts("stdio's FILE does this for you; a raw socket does not.");
    return 0;
}

/* 적의를 품은 입력이 할 수 있는 거짓말 셋과, 그것을 거절하는 확인.
   여기서는 아무것도 넘치지 않는다: 확인하지 않은 쪽은 계산해서 인쇄만 한다. */
#include <stdckdint.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* (1) 머리말이 너비 × 높이 × 4 바이트라고 한다. 32비트로 곱하면 넘쳐 되돈다. */
static void image_size(uint32_t w, uint32_t h)
{
    uint32_t naive = w * h * 4u;      /* 부호 없음: 되돌 뿐 UB 아님 --- 경고도 없다 */
    size_t checked;
    bool over = ckd_mul(&checked, (size_t)w, (size_t)h)
             || ckd_mul(&checked, checked, (size_t)4);
    printf("  %10u x %-10u naive 32-bit size %10u",
           (unsigned)w, (unsigned)h, (unsigned)naive);
    if (over) puts("   checked: refused (does not fit in size_t)");
    else if (checked > 256u << 20)
        printf("   checked: %zu, refused (over the 256 MiB limit)\n", checked);
    else printf("   checked: %zu, accepted\n", checked);
}

/* (2) 개수가 「항목 10억 개가 뒤따른다」고 하는데 입력에는 몇 바이트뿐이다.
   할당하기 *전에* 그 주장을 실제로 있는 것과 견준다. */
static void read_items(uint32_t claimed, size_t bytes_left, size_t item_size)
{
    printf("  claims %10u items, %3zu bytes left: ", (unsigned)claimed, bytes_left);
    if (claimed > bytes_left / item_size) { puts("refused before malloc"); return; }
    void *p = malloc((size_t)claimed * item_size);
    puts(p ? "allocated" : "allocation failed");
    free(p);
}

/* (3) 중첩: 0x01 은 목록을 열고 0x02 는 닫는다. 재귀로 읽는 쪽에는
   깊이 상한이 필요하다 --- 없으면 0x01 이 길게 이어진 입력이 스택을 다 쓴다. */
enum { MAX_DEPTH = 32 };
static const unsigned char *parse_list(const unsigned char *p,
                                       const unsigned char *end, int depth, bool *ok)
{
    if (depth > MAX_DEPTH) { *ok = false; return end; }
    while (p < end && *ok) {
        if (*p == 0x01) p = parse_list(p + 1, end, depth + 1, ok);
        else if (*p == 0x02) return p + 1;
        else p++;
    }
    return p;
}

int main(void)
{
    puts("[1] sizes from a header");
    image_size(640, 480);
    image_size(65536, 16385);
    image_size(0x40000000u, 4);
    image_size(UINT32_MAX, UINT32_MAX);

    puts("\n[2] counts from a header (8-byte items)");
    read_items(3, 24, 8);
    read_items(1000000000u, 24, 8);

    puts("\n[3] nesting depth");
    static unsigned char deep[100000];
    for (size_t i = 0; i < sizeof deep; i++) deep[i] = 0x01;
    unsigned char fine[] = { 0x01, 0x01, 0x07, 0x02, 0x02 };
    bool ok = true;
    parse_list(fine, fine + sizeof fine, 0, &ok);
    printf("  5 bytes, depth 2       : %s\n", ok ? "accepted" : "refused");
    ok = true;
    parse_list(deep, deep + sizeof deep, 0, &ok);
    printf("  100000 opens in a row  : %s at depth %d\n",
           ok ? "accepted" : "refused", MAX_DEPTH + 1);
    return 0;
}