ciabatta/src/uchar.c

size_t mbrtoc16(
    char16_t   *restrict pc16,
    char const *restrict s,
    size_t               n,
    mbstate_t  *restrict ps
) {
    // Figure out the conversion state
    static mbstate_t static_mbstate = {0};
    if(ps == NULL) ps = &static_mbstate;
    if(s == NULL) {
        *ps = (mbstate_t) {0xd800};
        return 0;
    }
    // Check leftovers, using 0xd800 as "no leftover" marker because it
    // doesn't encode a valid character.
    if(ps->leftover == 0xd800) {
        // Decode the UTF-8 encoded codepoint
        char32_t code_point;
        int mblen = utf8_chdec((char8_t *)s, n, &code_point);
        if(mblen == UNI_ESTRLN) return (size_t)(-2);
        if(mblen <= 0) goto invalid_seq;
        // Encode the codepoint into UTF-16 string
        char16_t str[2];
        int c16len = utf16_chenc(str, 2, code_point);
        if(c16len <= 0) goto invalid_seq;
        // Assign the decoded UTF-16 character, decide leftover
        if(pc16 != NULL) *pc16 = str[0];
        ps->leftover = (c16len == 2? str[1] : 0xd800);
        return (size_t)mblen;
    }
    else {
        // Otherwise use and reset the leftover
        if(pc16 != NULL) *pc16 = ps->leftover;
        ps->leftover = 0xd800;
        return (size_t)(-3);
    }
invalid_seq:
    errno = EILSEQ;
    return (size_t)(-1);
}



size_t c16rtomb(
    char *restrict      s,
    char16_t            c16,
    mbstate_t *restrict ps
) {
    // Figure out conversion state
    static mbstate_t static_mbstate = {0};
    if(ps == NULL) ps = &static_mbstate;
    if(s == NULL) {
        *ps = (mbstate_t) {0xd800};
        return 0;
    }
    char32_t codepoint_to_write;
    // Check whether a high surrogate was detected in a previous call to the
    // function. If not, the high_surrogate value is 0xd800
    if(ps->high_surrogate == 0xd800) {
        // If c16 is a surrogate record it, or throw an error
        if(uni_is_hsur(c16)) {
            ps->high_surrogate = c16;
            return 0;
        }
        else if(uni_is_lsur(c16)) {
            goto invalid_char;
        }
        // We'll just write c16
        codepoint_to_write = c16;
    }
    // If high surrogate exists, the next character must be a low surrogate
    // so we'll write a codepoint made out of high and low surrogates
    else if(uni_is_lsur(c16)) {
        codepoint_to_write = uni_surtoc(ps->high_surrogate, c16);
    }
    else goto invalid_char;
    // Write the codepoint that we decided to write to multibyte string
    int written_len = utf8_chenc((char8_t *)s, 4, codepoint_to_write);
    if(written_len < 0) {
        goto invalid_char;
    }
    s[written_len] = 0;
    return (size_t)written_len;
invalid_char:
    errno = EILSEQ;
    return (size_t)(-1);
}

size_t mbrtoc32(
    char32_t   *restrict pc32,
    char const *restrict s,
    size_t               n,
    mbstate_t  *restrict ps
) {
    if(s == NULL) {
        return 0;
    }
    char32_t code_point;
    int mblen = utf8_chdec((char8_t *)s, n, &code_point);
    if(mblen == UNI_ESTRLN) return (size_t)(-2);
    if(mblen <= 0) {
        errno = EILSEQ;
        return (size_t)(-1);
    }
    *pc32 = code_point;
    if(code_point == 0) return 0;
    return (size_t)mblen;
}

size_t c32rtomb(
    char *restrict      s,
    char32_t            c32,
    mbstate_t *restrict ps
) {
    if(s == NULL) {
        *ps = (mbstate_t) {0};
        return 0;
    }
    int mblen = utf8_chenc((char8_t *)s, 4, c32);
    if(mblen <= 0) {
        errno = EILSEQ;
        return (size_t)(-1);
    }
    return (size_t)mblen;
}