/* Five kinds of character constant and string — type, element size, bytes. */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <uchar.h>
#include <wchar.h>

/* Lay out any array, one element at a time, in hex.
   char is signed on many implementations (chapter 27), so mask to the element
   width — otherwise 0xED shows up as FFFFFFED. */
#define DUMP(label, arr)                                                     \
    do {                                                                     \
        printf("  %-10s %zu-byte elements x %zu:", (label),                  \
               sizeof (arr)[0], sizeof (arr) / sizeof (arr)[0]);             \
        for (size_t i = 0; i < sizeof (arr) / sizeof (arr)[0]; i++)          \
            printf(" %0*llX", (int)(sizeof (arr)[0] * 2),                    \
                   (unsigned long long)(arr)[i]                              \
                   & ((1ULL << (8 * sizeof (arr)[0])) - 1));                 \
        putchar('\n');                                                       \
    } while (0)

int main(void)
{
    puts("[character constants] the same 'A' written five ways");
    printf("  %-14s type size %zu, value %d\n",  "'A'",   sizeof('A'), 'A');
    printf("  %-14s type size %zu, value %ld\n", "L'A'",  sizeof(L'A'), (long)L'A');
    printf("  %-14s type size %zu, value %u\n",  "u'A'",  sizeof(u'A'), (unsigned)u'A');
    printf("  %-14s type size %zu, value %u\n",  "U'A'",  sizeof(U'A'), (unsigned)U'A');
    printf("  %-14s type size %zu, value %u\n",  "u8'A'", sizeof(u8'A'), (unsigned)u8'A');
    puts("  ('A' is an int — in C a character constant is not a char)");

    puts("\n[strings] the single letter \"한\" written five ways");
    static const char     s_plain[] =   "한";
    static const char8_t  s_u8[]    = u8"한";
    static const char16_t s_u16[]   =  u"한";
    static const char32_t s_u32[]   =  U"한";
    static const wchar_t  s_wide[]  =  L"한";
    DUMP("char",     s_plain);
    DUMP("char8_t",  s_u8);
    DUMP("char16_t", s_u16);
    DUMP("char32_t", s_u32);
    DUMP("wchar_t",  s_wide);

    puts("\n[a character beyond the BMP] U+1F600 (grinning face)");
    static const char     e_plain[] =   "\U0001F600";
    static const char16_t e_u16[]   =  u"\U0001F600";
    static const char32_t e_u32[]   =  U"\U0001F600";
    static const wchar_t  e_wide[]  =  L"\U0001F600";
    DUMP("char",     e_plain);
    DUMP("char16_t", e_u16);   /* <- two elements: a surrogate pair */
    DUMP("char32_t", e_u32);
    DUMP("wchar_t",  e_wide);
    puts("  Only char16_t needs two — 16 bits cannot hold it, so it splits.");

    puts("\n[what the implementation declares]");
#ifdef __STDC_ISO_10646__
    printf("  __STDC_ISO_10646__ = %ldL — wchar_t values are Unicode code points\n",
           (long)__STDC_ISO_10646__);
#else
    puts("  no __STDC_ISO_10646__ — the wchar_t encoding is implementation-defined (Windows)");
#endif
#ifdef __STDC_UTF_16__
    puts("  __STDC_UTF_16__  = 1 — char16_t is UTF-16");
#endif
#ifdef __STDC_UTF_32__
    puts("  __STDC_UTF_32__  = 1 — char32_t is UTF-32");
#endif
    printf("  sizeof(wchar_t) = %zu, WCHAR_MIN = %ld, WCHAR_MAX = %lld\n",
           sizeof(wchar_t), (long)WCHAR_MIN, (long long)WCHAR_MAX);
    return 0;
}

/* mbrtowc — bytes turning into wchar_t, one step at a time. */
#include <errno.h>
#include <locale.h>
#include <stdlib.h>          /* MB_CUR_MAX */
#include <stdio.h>
#include <string.h>
#include <wchar.h>

/* The four kinds of return value, in words */
static const char *explain(size_t r)
{
    if (r == 0)           return "hit the null character (returns 0)";
    if (r == (size_t)-1)  return "invalid sequence (errno=EILSEQ)";
    if (r == (size_t)-2)  return "not a whole character yet — needs more";
    return "consumed this many bytes and produced one character";
}

static void walk(const char *label, const char *s, size_t len)
{
    mbstate_t st;
    memset(&st, 0, sizeof st);      /* the initial conversion state */

    printf("\n[%s] %zu bytes:", label, len);
    for (size_t i = 0; i < len; i++) printf(" %02X", (unsigned char)s[i]);
    puts("");

    size_t pos = 0;
    while (pos < len) {
        wchar_t wc = 0;
        errno = 0;
        size_t r = mbrtowc(&wc, s + pos, len - pos, &st);

        printf("  at %zu: mbrtowc -> ", pos);
        if (r == (size_t)-1)      printf("(size_t)-1   ");
        else if (r == (size_t)-2) printf("(size_t)-2   ");
        else                      printf("%-12zu", r);
        printf("%s", explain(r));

        if (r != (size_t)-1 && r != (size_t)-2)
            printf("  -> U+%04lX", (unsigned long)wc);
        puts("");

        if (r == (size_t)-1 || r == (size_t)-2) break;
        pos += (r == 0) ? 1 : r;
    }
}

int main(void)
{
    /* This one needs a UTF-8 locale — if there is none, say so and stop */
    const char *loc = setlocale(LC_CTYPE, "C.UTF-8");
    if (!loc) loc = setlocale(LC_CTYPE, "en_US.UTF-8");
    if (!loc) { puts("no UTF-8 locale — skipping this demonstration"); return 0; }
    printf("LC_CTYPE=%s, MB_CUR_MAX=%zu\n", loc, (size_t)MB_CUR_MAX);

    walk("two ASCII letters", "Hi", 2);
    walk("one Hangul syllable", "한", 3);
    walk("an emoji beyond the BMP", "\xF0\x9F\x98\x80", 4);

    /* A truncated character: two of three bytes -> (size_t)-2 */
    walk("a truncated character", "\xED\x95", 2);

    /* An invalid sequence: starting on a trail byte -> (size_t)-1 */
    walk("an invalid sequence", "\x9C\x41", 2);

    /* The state carries over: feed the pieces in two calls and they join */
    puts("\n[arriving in pieces, as from a stream] \"한\" fed as 2+1 bytes");
    mbstate_t st;
    memset(&st, 0, sizeof st);
    wchar_t wc = 0;
    size_t r1 = mbrtowc(&wc, "\xED\x95", 2, &st);
    printf("  first call (2 bytes): %s\n", explain(r1));
    size_t r2 = mbrtowc(&wc, "\x9C", 1, &st);
    printf("  second call (1 byte): %s -> U+%04lX\n", explain(r2), (unsigned long)wc);
    puts("  mbstate_t remembers how far it got, so the pieces join up.");
    return 0;
}