#include <stdio.h>
#include <stdint.h>
#include <string.h>

int main(void)
{
    uint32_t value = 0x12345678u;
    unsigned char bytes[4];

    memcpy(bytes, &value, sizeof value);   /* 표현을 바이트로 들여다본다 */

    printf("value: 0x%08X\n", value);
    printf("memory order: %02X %02X %02X %02X\n",
           bytes[0], bytes[1], bytes[2], bytes[3]);
    printf("this machine is %s-endian\n",
           bytes[0] == 0x78 ? "little" : "big");

    struct padded {
        char  tag;      /* 1바이트 */
        int   count;    /* 4바이트 — 정렬 때문에 앞에 빈틈이 생긴다 */
    };
    printf("1 + 4 = 5, but sizeof = %zu\n", sizeof(struct padded));
    return 0;
}

/* 같은 비트를 다른 타입으로 보는 세 가지 방법 — 그리고 각각의 계약. */
#include <stdint.h>
#include <stdio.h>
#include <string.h>

union bits { float f; uint32_t u; };

static void show(const char *how, uint32_t u)
{
    printf("  %-28s 0x%08X  (sign %u, exponent %3u, significand 0x%06X)\n",
           how, u, u >> 31, (u >> 23) & 0xFFu, u & 0x7FFFFFu);
}

int main(void)
{
    float f = 1.5f;
    printf("reading the bits of the float %.1f as a 32-bit integer\n\n", (double)f);

    /* ① 공용체 — C 에서는 허용된다.
         마지막에 쓴 멤버가 아닌 멤버를 읽으면 '표현을 다시 해석'한다. */
    union bits b = { .f = f };
    show("through a union", b.u);

    /* ② memcpy — 어디서나 계약 안이다. 최적화하면 명령 하나로 접힌다. */
    uint32_t u;
    memcpy(&u, &f, sizeof u);
    show("through memcpy", u);

    /* ③ 포인터 캐스트 — *이것만 계약 밖이다*(엄격한 앨리어싱, 56장).
         값이 같아 보여도 컴파일러가 순서를 바꿀 권리를 갖는다.
         아래 줄은 보이기 위해 적었을 뿐, 쓰면 안 되는 형태다. */
    puts("  through a pointer cast          *(uint32_t *)&f - outside the contract, not shown");

    puts("\n[the other direction is the same]");
    union bits c = { .u = 0x40490FDBu };   /* 원주율에 가까운 비트 */
    printf("  0x40490FDB seen as a float is %.7f\n", (double)c.f);
    float g;
    memcpy(&g, &c.u, sizeof g);
    printf("  moved with memcpy it is also %.7f\n", (double)g);

    puts("\n[where C and C++ part ways]");
    puts("  C   : reading another member of a union is allowed (the representation is reinterpreted).");
    puts("  C++ : reading a member that is not the 'active' one is undefined behaviour.");
    puts("  in a header shared by both languages, memcpy is the safer spelling.");

    puts("\n[careful: not every bit pattern is a value]");
    union bits nan_bits = { .u = 0x7FC00000u };
    printf("  0x7FC00000 → %f (NaN)\n", (double)nan_bits.f);
    puts("  integers and floats are usually harmless, but some types have 'trap representations'.");
    return 0;
}

#include <stdio.h>
#include <stdint.h>

/* 실무에서 흔한 모양: 장치 레지스터 한 워드를 필드로 나눠 보고,
   같은 기억을 통째로 32비트 정수로도 본다. */
union control_reg {
    uint32_t raw;                 /* 통째로 읽고 쓰는 눈 */
    struct {
        uint32_t enable   : 1;    /* 비트 1개 */
        uint32_t mode     : 3;    /* 비트 3개 */
        uint32_t priority : 4;
        uint32_t reserved : 8;
        uint32_t counter  : 16;
    } f;                          /* 필드로 보는 눈 */
};

/* 구조체 안에 공용체를 넣는 실무 패턴: 태그 + 내용 */
enum msg_kind { MSG_INT, MSG_TEXT, MSG_POINT };

struct message {
    enum msg_kind kind;           /* 어느 눈으로 볼지 알려 주는 태그 */
    unsigned      flags : 4;      /* 작은 상태 몇 개 */
    unsigned      urgent : 1;
    union {                       /* 이름 없는 공용체 (C11) */
        int  number;
        char text[16];
        struct { int x, y; } point;
    };
};

static void show(const struct message *m)
{
    printf("kind=%d flags=%u urgent=%u -> ", (int)m->kind, m->flags, m->urgent);
    switch (m->kind) {
        case MSG_INT:   printf("number %d\n", m->number); break;
        case MSG_TEXT:  printf("text \"%s\"\n", m->text); break;
        case MSG_POINT: printf("point (%d, %d)\n", m->point.x, m->point.y); break;
    }
}

int main(void)
{
    union control_reg r = { .raw = 0 };
    r.f.enable = 1;
    r.f.mode = 5;
    r.f.priority = 9;
    r.f.counter = 1000;

    printf("raw   = 0x%08x\n", r.raw);
    printf("fields: enable=%u mode=%u priority=%u counter=%u\n",
           r.f.enable, r.f.mode, r.f.priority, r.f.counter);

    /* 통째로 쓰고 필드로 읽기 — 같은 기억을 두 눈으로 본다 */
    r.raw = 0x000A0013u;
    printf("after raw write: enable=%u mode=%u priority=%u counter=%u\n",
           r.f.enable, r.f.mode, r.f.priority, r.f.counter);

    printf("sizeof(union control_reg) = %zu\n", sizeof r);

    struct message a = { .kind = MSG_INT, .flags = 3, .urgent = 1, .number = 42 };
    struct message b = { .kind = MSG_TEXT, .flags = 0, .urgent = 0 };
    for (int i = 0; i < 5; i++) b.text[i] = "hello"[i];
    b.text[5] = '\0';
    struct message c = { .kind = MSG_POINT, .flags = 8, .urgent = 0,
                         .point = { .x = 3, .y = -7 } };
    show(&a); show(&b); show(&c);
    printf("sizeof(struct message) = %zu\n", sizeof(struct message));
    return 0;
}

/* 2바이트 조합형 한글 — 한 워드를 초성·중성·종성으로 쪼갠 실제 사례.
   (유니코드 설명이 목적이므로 이 예제에는 한글이 들어간다.) */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

/* 조합형 낱자 이름표. 코드값 0·1 은 채움/미사용이라 비워 둔다. */
static const char *const CHO[32] = {
    [2]="G", [3]="GG", [4]="N", [5]="D", [6]="DD", [7]="R", [8]="M",
    [9]="B", [10]="BB", [11]="S", [12]="SS", [13]="NG", [14]="J",
    [15]="JJ", [16]="C", [17]="K", [18]="T", [19]="P", [20]="H",
};
static const char *const JUNG[32] = {
    [3]="A", [4]="AE", [5]="YA", [6]="YAE", [7]="EO",
    [10]="E", [11]="YEO", [12]="YE",
    [13]="O", [14]="WA", [15]="WAE",
    [18]="OE", [19]="YO", [20]="U", [21]="WEO", [22]="WE", [23]="WI",
    [26]="YU", [27]="EU", [28]="YI", [29]="I",
};
static const char *const JONG[32] = {
    [1]="(none)", [2]="G", [5]="N", [9]="L", [17]="M", [19]="B",
    [21]="S", [23]="NG", [29]="H",
};

/* ① 시프트와 마스크로 뽑는다 — 표준이 정확히 약속하는 길 */
static void split_by_shift(uint16_t w)
{
    unsigned cho  = (w >> 10) & 0x1f;
    unsigned jung = (w >>  5) & 0x1f;
    unsigned jong =  w        & 0x1f;
    printf("  shift/mask: mark=%u lead=%2u(%-2s) vowel=%2u(%-3s) tail=%2u(%s)\n",
           (unsigned)(w >> 15), cho, CHO[cho] ? CHO[cho] : "?",
           jung, JUNG[jung] ? JUNG[jung] : "?",
           jong, JONG[jong] ? JONG[jong] : "?");
}

/* ② 비트 필드 + 공용체로 본다 — 편하지만 배치는 구현이 정한다 */
union johab {
    uint16_t raw;
    struct {
        uint16_t jong : 5;   /* 이 순서가 표준의 약속이 아니다 */
        uint16_t jung : 5;
        uint16_t cho  : 5;
        uint16_t mark : 1;
    } f;
};

int main(void)
{
    /* "가" 와 "한" 의 조합형 코드 — 실제 표에서 가져온 값이다. */
    const uint16_t GA  = 0x8861;   /* 1 00010 00011 00001 */
    const uint16_t HAN = 0xD065;   /* 1 10100 00011 00101 */

    printf("가 = 0x%04X, 한 = 0x%04X\n\n", GA, HAN);
    puts("가:");   split_by_shift(GA);
    puts("한:");   split_by_shift(HAN);

    union johab u = { .raw = GA };
    printf("\n'가' seen through bit fields: mark=%u lead=%u vowel=%u tail=%u\n",
           u.f.mark, u.f.cho, u.f.jung, u.f.jong);
    puts("  (on this compiler it came out the same as the shift/mask version.");
    puts("   That is because this implementation fills bits from the low end; the standard does not promise it.)");

    /* ③ 둘째 바이트가 ASCII 와 겹친다 — 조합형의 유명한 함정 */
    unsigned char bytes[3] = { (unsigned char)(GA >> 8),
                               (unsigned char)(GA & 0xff), 0 };
    printf("\nthe two bytes of '가': %02X %02X\n", bytes[0], bytes[1]);
    printf("  the second byte 0x%02X is ASCII '%c' - so searching for 'a' byte by byte\n",
           bytes[1], bytes[1]);
    printf("  lands inside a character: strchr result = %s\n",
           strchr((char *)bytes, 'a') ? "found (false positive)" : "not found");
    return 0;
}