// // utf8Conversion.hpp // // Created by jief the 24 Feb 2020. // #include "unicode_conversions.h" #include // for memcpy #ifndef MIN #define MIN(a, b) ((a) < (b) ? (a) : (b)) #endif #if __WCHAR_MAX__ <= 0xFFFFu #define wchar_cast char16_t #else #define wchar_cast char32_t #endif #ifndef wchar_cast #error wchar_cast #endif // //size_t char32_len_from_wchar(const wchar_t* s) //{ //#if __WCHAR_MAX__ <= 0xFFFFu // return char32_len((const char16_t*)s); //#else // return char32_len((const char32_t*)s); //#endif //} // //size_t wchar_len(const wchar_t* s) //{ //#if __WCHAR_MAX__ <= 0xFFFFu // return char16_len((const char16_t*)s); //#else // return char32_len((const char32_t*)s); //#endif //} static inline int is_surrogate(char16_t uc) { return (uc - 0xd800u) < 2048u; } static inline int is_high_surrogate(char16_t uc) { return (uc & 0xfffffc00) == 0xd800; } static inline int is_low_surrogate(char16_t uc) { return (uc & 0xfffffc00) == 0xdc00; } static inline char32_t surrogate_to_utf32(char16_t high, char16_t low) { return char32_t((high << 10) + low - 0x35fdc00); // Safe cast, it fits in 32 bits } #define halfBase 0x0010000UL #define halfMask 0x3FFUL #define halfShift 10 /* used for shifting by 10 bits */ #define UNI_SUR_HIGH_START 0xD800u #define UNI_SUR_LOW_START 0xDC00u /************************************************************* utf8 - char32 *********************************************************/ /* * Size of an UTF32 char when represented in UTF8 * Return value : size */ size_t utf8_size_of_utf32_char(char32_t c) { if ( c == 0 ) return 0; else if ( c <= 0x7f ) return 1; else if ( c <= 0x7ff ) return 2; else if ( c <= 0xFFFF ) return 3; else return 4; } /* * Increment size and return a pointer to the next char * Return value : pointer to the end of string or at the error */ const char32_t* utf8_size_of_utf32_char_ptr(const char32_t *s, size_t* size) { if ( *s == 0 ) return s; *size += utf8_size_of_utf32_char(*s++); return s; } /* * Store an utf32 char in dst, if there is enough room (dst_max_len is >= size of utf32 char) * If there is enough room, dst_max_len is decrement and dst is increment and returned * If there isn't enough room, dst_max_len is set to 0 and dst is returned */ char* get_utf8_from_char32(char* dst, size_t* dst_max_len, char32_t utf32_char) { #ifdef JIEF_DEBUG char* dst_debug = dst; (void)dst_debug; #endif if ( *dst_max_len <= 0 ) return dst; /* assertion: utf32_char is a single UTF-4 value */ int bits = 0; // just to silence the warning if (utf32_char < 0x80) { *dst++ = (char)utf32_char; *dst_max_len -= 1; bits = -6; } else if (utf32_char < 0x800) { if ( *dst_max_len < 2 ) { *dst_max_len = 0; return dst; } *dst++ = (char)(((utf32_char >> 6) & 0x1F) | 0xC0); *dst_max_len -= 1; bits = 0; } else if (utf32_char < 0x10000) { if ( *dst_max_len < 3 ) { *dst_max_len = 0; return dst; } *dst++ = (char)(((utf32_char >> 12) & 0x0F) | 0xE0); *dst_max_len -= 1; bits = 6; } else { if ( *dst_max_len < 4 ) { *dst_max_len = 0; return dst; } *dst++ = (char)(((utf32_char >> 18) & 0x07) | 0xF0); *dst_max_len -= 1; bits = 12; } for ( ; /* *dst_max_len > 0 && */ bits >= 0 ; bits -= 6 ) { // no need to check dst_max_len, it's made before *dst++ = (char)(((utf32_char >> bits) & 0x3F) | 0x80); *dst_max_len -= 1; } #ifdef JIEF_DEBUG if ( *dst_max_len > 0 ) *dst = 0; #endif return dst; } /* Number Bits for First Last Byte 1 Byte 2 Byte 3 cByte 4 of bytes code point 1 7 U+0000 U+007F 0xxxxxxx 2 11 U+0080 U+07FF 110xxxxx 10xxxxxx 3 16 U+0800 U+FFFF 1110xxxx 10xxxxxx 10xxxxxx 4 21 U+10000 U+10FFFF[12] 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ /* * char32 will be set to 0 at the end of string or at error * Return value : pointer to the end of string or at the error */ const char* get_char32_from_utf8_string(const char* s, char32_t* char32) { if ( !*s ) { *char32 = 0; return s; } char32_t c; if (*s & 0x80) { if ((*(s+1) & 0xc0) != 0x80) { // 0xc0 = 0b11000000. Equivalent to if ( *(s+1) != 0x10xxxxxx ) // Finished in the middle of an utf8 multibyte char char32 = 0; return s; } if ((*s & 0xe0) == 0xe0) { // 0xe0 == 0b11100000. Equivalent to if ( *(s) == 0x111xxxxx ) // Here, it's a 3 or 4 bytes // Byte 3 has to be 0x10xxxxxx if ((*(s+2) & 0xc0) != 0x80) { // 0xc0 = 0b11000000. Equivalent to if ( *(s+2) != 0x10xxxxxx ) // Finished in the middle of an utf8 multibyte char char32 = 0; return s; } if ((*s & 0xf0) == 0xf0) { // 0xf0 = 0b1111xxxx. Equivalent to if ( *(s) == 0x1111xxxx ) // Here, it's a 4 bytes // Byte 4 has to be 0x10xxxxxx if ((*s & 0xf8) != 0xf0 || (*(s+3) & 0xc0) != 0x80) { // 0xf8 = 0b11111xxx. Equivalent to if ( *(s) != 0x11110xxx || *(s+3) != 0x10xxxxxx ) // Finished in the middle of an utf8 multibyte char char32 = 0; return s; } /* 4-byte code */ c = char32_t((*s & 0x7) << 18); // & result type is int. We know it fits in 32 bits. Safe to cast to char32_t c |= char32_t((*(s+1) & 0x3f) << 12); c |= char32_t((*(s+2) & 0x3f) << 6); c |= *(s+3) & 0x3f; s += 4; } else { /* 3-byte code */ c = char32_t((*s & 0xf) << 12); c |= char32_t((*(s+1) & 0x3f) << 6); c |= *(s+2) & 0x3f; s += 3; } } else { /* 2-byte code */ c = char32_t((*s & 0x1f) << 6); c |= *(s+1) & 0x3f; s += 2; } } else { /* 1-byte code */ c = (unsigned char)(*s); // in case we compiled with signed char s += 1; } *char32 = c; return s; } /* * Size in bytes of an utf32 string if it were converted to utf8 * Return value : pointer to the end of string or at the error */ size_t utf8_size_of_utf32_string(const char32_t* s) { if ( !s ) return 0; size_t size = 0; while ( *s ) s = utf8_size_of_utf32_char_ptr(s, &size); return size; } /* * Size in bytes of an utf32 string of len char if it were converted to utf8 * Return value : pointer to the end of string or at the error */ size_t utf8_size_of_utf32_string_len(const char32_t* s, size_t len) { if ( !s || len <= 0 ) return 0; // <= in case size_t is signed size_t size = 0; while ( *s && len > 0 ) { s = utf8_size_of_utf32_char_ptr(s, &size); len --; } return size; } size_t utf32_size_of_utf8_string(const char* s) { if ( !s ) return 0; size_t size = 0; char32_t char32; s = get_char32_from_utf8_string(s, &char32); while ( char32 ) { size += 1; s = get_char32_from_utf8_string(s, &char32); } return size; } size_t utf32_size_of_utf8_string_len(const char* s, size_t len) { if ( !s || len <= 0 ) return 0; // <= in case size_t is signed size_t size = 0; char32_t char32; s = get_char32_from_utf8_string(s, &char32); while ( char32 && len > 0 ) { size += 1; s = get_char32_from_utf8_string(s, &char32); len --; } return size; } size_t utf32_string_from_utf8_string(char32_t* dst, size_t dst_max_len, const char* s) { if ( !s && dst_max_len == 0 ) return 0; char32_t* p = dst; char32_t* p_max = dst + dst_max_len - 1; char32_t char32; s = get_char32_from_utf8_string(s, &char32); while ( char32 != 0 && p < p_max ) { *p++ = char32; s = get_char32_from_utf8_string(s, &char32); } *p = 0; return (size_t)(p-dst); } size_t utf8_string_from_utf32_string(char* dst, size_t dst_max_len, const char32_t *s) { if ( !s || dst_max_len <= 1 ) { if ( dst_max_len > 0 ) *dst = 0; return 0; } dst_max_len -= 1; char* p = dst; while ( *s && dst_max_len > 0 ) { p = get_utf8_from_char32(p, &dst_max_len, *s++); } *p = 0; return (size_t)(p-dst); } /************************************************************* utf8 - char16 *********************************************************/ //static size_t utf16_size_of_utf32_char(char32_t c); /* * Increment size * Return value : pointer to the end of string or at the error */ const char16_t* utf8_size_of_utf16_char_ptr(const char16_t *s, size_t* size) { char32_t c; s = get_char32_from_utf16_string(s, &c); if ( c == 0 ) return s; *size += utf8_size_of_utf32_char(c); return s; } /* * Size in bytes of an utf16 string if it were converted to utf8 * Return value : pointer to the end of string or at the error */ size_t utf8_size_of_utf16_string(const char16_t* s) { if ( !s ) return 0; size_t size = 0; while ( *s ) s = utf8_size_of_utf16_char_ptr(s, &size); return size; } /* * Size in bytes of an utf16 string of len char if it were converted to utf8 * Return value : pointer to the end of string or at the error */ size_t utf8_size_of_utf16_string_len(const char16_t* s, size_t len) { if ( !s || len <= 0 ) return 0; // <= in case size_t is signed size_t size = 0; while ( *s && len > 0 ) { s = utf8_size_of_utf16_char_ptr(s, &size); len --; } return size; } size_t utf16_size_of_utf8_string(const char* s) { if ( !s ) return 0; size_t size = 0; char32_t char32; s = get_char32_from_utf8_string(s, &char32); while ( char32 ) { size += utf16_size_of_utf32_char(char32); s = get_char32_from_utf8_string(s, &char32); } return size; } size_t utf16_size_of_utf8_string_len(const char* s, size_t len) { if ( !s || len <= 0 ) return 0; // <= in case size_t is signed size_t size = 0; char32_t char32; s = get_char32_from_utf8_string(s, &char32); while ( char32 && len > 0 ) { size += utf16_size_of_utf32_char(char32); len --; s = get_char32_from_utf8_string(s, &char32); } return size; } size_t utf8_string_from_utf16_string(char* dst, size_t dst_max_len, const char16_t *s) { if ( !s || dst_max_len <= 0 ) return 0; char* p = dst; dst_max_len -= 1; while ( *s && dst_max_len > 0 ) { char32_t utf32_char; s = get_char32_from_utf16_string(s, &utf32_char); p = get_utf8_from_char32(p, &dst_max_len, utf32_char); } *p = 0; return (size_t)(p-dst); } size_t utf16_string_from_utf8_string(char16_t* dst, size_t dst_max_len, const char* s) { if ( dst_max_len == 0 ) return 0; dst_max_len -= 1; // size_t dst_len = 0; char16_t* p = dst; char16_t* p_max = dst + dst_max_len; char32_t char32; s = get_char32_from_utf8_string(s, &char32); while ( char32 && p < p_max ) { if ( char32 == 0 ) return (size_t)(p-dst); char16_t char16_1, char16_2; get_char16_from_char32(char32, &char16_1, &char16_2); if ( char16_2 != 0 ) { if ( p < p_max-1 ) { *p++ = char16_1; *p++ = char16_2; }else{ *p = 0; return (size_t)(p-dst); } }else{ *p++ = char16_1; } s = get_char32_from_utf8_string(s, &char32); } *p = 0; return (size_t)(p-dst); } /************************************************************* utf16 - utf32 *********************************************************/ size_t utf16_size_of_utf32_char(char32_t c) { if ( c <= 0xFFFF) return 1; else return 2; } void get_char16_from_char32(char32_t char32, char16_t* char16_1, char16_t* char16_2) { if ( char32 <= 0xFFFF) { *char16_1 = (char16_t)char32; *char16_2 = 0; } else { char32 -= halfBase; *char16_1 = (char16_t)((char32 >> halfShift) + UNI_SUR_HIGH_START); *char16_2 = (char16_t)((char32 & halfMask) + UNI_SUR_LOW_START); } } char32_t get_char32_from_char16(char16_t char16_1, char16_t char16_2) { if (!is_surrogate(char16_1)) { return char16_1; } else { if (is_high_surrogate(char16_1) && is_low_surrogate(char16_2)) { return surrogate_to_utf32(char16_1, char16_2); } else { return 0; } } } /* * char32 will be set to 0 at the end of string or at error * Return value : pointer to the end of string or at the error */ const char16_t* get_char32_from_utf16_string(const char16_t* s, char32_t* char32) { const char16_t char16_1 = *s++; if (!is_surrogate(char16_1)) { *char32 = char16_1; return s; } else { if (is_high_surrogate(char16_1) && is_low_surrogate(*s)) { *char32 = surrogate_to_utf32(char16_1, *s++); return s; } else { *char32 = 0; if ( !is_high_surrogate(char16_1) ) return s-1; return s; } } } size_t utf16_size_of_utf32_string(const char32_t *s) { if ( !s ) return 0; size_t size = 0; while ( *s ) size += utf16_size_of_utf32_char(*s++); return size; } size_t utf16_size_of_utf32_string_len(const char32_t *s, size_t len) { if ( !s ) return 0; size_t size = 0; while ( *s && len > 0 ) { size += utf16_size_of_utf32_char(*s++); len--; } return size; } size_t utf32_size_of_utf16_string(const char16_t *s) { if ( !s ) return 0; size_t size = 0; char32_t char32; s = get_char32_from_utf16_string(s, &char32); while ( char32 ) { size += 1; s = get_char32_from_utf16_string(s, &char32); } return size; } size_t utf32_size_of_utf16_string_len(const char16_t *s, size_t len) { if ( !s || len <= 0 ) return 0; // <= in case size_t is signed size_t size = 0; char32_t char32; s = get_char32_from_utf16_string(s, &char32); while ( char32 && len > 0 ) { size += 1; s = get_char32_from_utf16_string(s, &char32); len --; } return size; } size_t utf16_string_from_utf32_string(char16_t* dst, size_t dst_max_len, const char32_t *s) { if ( dst_max_len == 0 ) return 0; char16_t* p = dst; char16_t* p_max = dst + dst_max_len - 1; while ( *s && p < p_max ) { char16_t char16_1, char16_2; get_char16_from_char32(*s++, &char16_1, &char16_2); if ( char16_2 != 0 ) { if ( p < p_max-1 ) { *p++ = char16_1; *p++ = char16_2; }else{ *p = 0; return (size_t)(p-dst); } }else{ *p++ = char16_1; } } *p = 0; return (size_t)(p-dst); } size_t utf32_string_from_utf16_string(char32_t* dst, size_t dst_max_len, const char16_t *s) { if ( dst_max_len == 0 ) return 0; char32_t* p = dst; char32_t* p_max = dst + dst_max_len - 1; while ( *s && p < p_max ) { char32_t c; s = get_char32_from_utf16_string(s, &c); if ( c == 0 ) return (size_t)(p-dst); *p++ = c; } *p = 0; return (size_t)(p-dst); } /************************************************************* utf8 - wchar_t *********************************************************/ size_t utf8_size_of_wchar_string(const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf8_size_of_utf16_string((wchar_cast*)s); #else return utf8_size_of_utf32_string((wchar_cast*)s); #endif } size_t utf8_size_of_wchar_string_len(const wchar_t* s, size_t len) { #if __WCHAR_MAX__ <= 0xFFFFu return utf8_size_of_utf16_string_len((wchar_cast*)s, len); #else return utf8_size_of_utf32_string_len((wchar_cast*)s, len); #endif } size_t wchar_size_of_utf8_string(const char* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf8_string(s); #else return utf32_size_of_utf8_string(s); #endif } size_t wchar_size_of_utf8_string_len(const char* s, size_t len) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf8_string_len(s, len); #else return utf32_size_of_utf8_string_len(s, len); #endif } size_t utf8_string_from_wchar_string(char* dst, size_t dst_max_len, const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf8_string_from_utf16_string(dst, dst_max_len, (char16_t*)s); #else return utf8_string_from_utf32_string(dst, dst_max_len, (char32_t*)s); #endif } size_t wchar_string_from_utf8_string(wchar_t* dst, size_t dst_max_len, const char* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_string_from_utf8_string((char16_t*)dst, dst_max_len, s); #else return utf32_string_from_utf8_string((char32_t*)dst, dst_max_len, s); #endif } /************************************************************* utf16 - wchar_t *********************************************************/ size_t utf16_size_of_wchar_string(const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf16_string((wchar_cast*)s); #else return utf16_size_of_utf32_string((wchar_cast*)s); #endif } size_t utf16_size_of_wchar_string_len(const wchar_t* s, size_t len) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf16_string_len((wchar_cast*)s, len); #else return utf16_size_of_utf32_string_len((wchar_cast*)s, len); #endif } size_t wchar_size_of_utf16_string(const char16_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf16_string(s); #else return utf32_size_of_utf16_string(s); #endif } size_t wchar_size_of_utf16_string_len(const char16_t* s, size_t len) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf16_string_len(s, len); #else return utf32_size_of_utf16_string_len(s, len); #endif } size_t utf16_string_from_wchar_string(char16_t* dst, size_t dst_max_len, const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_string_from_utf16_string(dst, dst_max_len, (char16_t*)s); #else return utf16_string_from_utf32_string(dst, dst_max_len, (char32_t*)s); #endif } size_t wchar_string_from_utf16_string(wchar_t* dst, size_t dst_max_len, const char16_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_string_from_utf16_string((char16_t*)dst, dst_max_len, s); #else return utf32_string_from_utf16_string((char32_t*)dst, dst_max_len, s); #endif } /************************************************************* utf32 - wchar_t *********************************************************/ size_t utf32_size_of_wchar_string(const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf32_size_of_utf16_string((wchar_cast*)s); #else return utf32_size_of_utf32_string((wchar_cast*)s); #endif } size_t utf32_size_of_wchar_string_len(const wchar_t* s, size_t len) { #if __WCHAR_MAX__ <= 0xFFFFu return utf32_size_of_utf16_string_len((wchar_cast*)s, len); #else return utf32_size_of_utf32_string_len((wchar_cast*)s, len); #endif } size_t wchar_size_of_utf32_string(const char32_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf32_string(s); #else return utf32_size_of_utf32_string(s); #endif } size_t wchar_size_of_utf32_string_len(const char32_t* s, size_t len) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf32_string_len(s, len); #else return utf32_size_of_utf32_string_len(s, len); #endif } size_t utf32_string_from_wchar_string(char32_t* dst, size_t dst_max_len, const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf32_string_from_utf16_string(dst, dst_max_len, (char16_t*)s); #else return utf32_string_from_utf32_string(dst, dst_max_len, (char32_t*)s); #endif } size_t wchar_string_from_utf32_string(wchar_t* dst, size_t dst_max_len, const char32_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_string_from_utf32_string((char16_t*)dst, dst_max_len, s); #else return utf32_string_from_utf32_string((char32_t*)dst, dst_max_len, s); #endif } /************************************************************* no conversion *********************************************************/ // Not efficient. Could be map to the ones provided by operating system size_t utf8_size_of_utf8_string(const char* s) { const char* p = s; while ( *p++ ); return (size_t)(p-s-1); } size_t utf8_size_of_utf8_string_len(const char* s, size_t len) { if ( !s || len <= 0 ) return 0; char32_t char32 = 1; const char* p = s; // = get_char32_from_utf8_string(s, &char32); while ( char32 && len > 0 ) { p = get_char32_from_utf8_string(p, &char32); len -= 1; } return (uintptr_t(p)-uintptr_t(s)); } size_t utf16_size_of_utf16_string(const char16_t* s) { const char16_t* p = s; while ( *p++ ); return (size_t)(p-s-1); } size_t utf16_size_of_utf16_string_len(const char16_t* s, size_t len) { if ( !s ) return 0; size_t size = 0; char32_t char32; s = get_char32_from_utf16_string(s, &char32); while ( char32 && len > 0 ) { size += utf16_size_of_utf32_char(char32); s = get_char32_from_utf16_string(s, &char32); len -= 1; } return size; } size_t utf32_size_of_utf32_string(const char32_t* s) { const char32_t* p = s; while ( *p++ ); return (size_t)(p-s-1); } size_t utf32_size_of_utf32_string_len(const char32_t* s, size_t len) { const char32_t* p = s; while ( *p++ && len > 0 ) len -= 1; return (size_t)(p-s-1); } size_t wchar_size_of_wchar_string(const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf16_string((char16_t*)s); #else return utf32_size_of_utf32_string((char32_t*)s); #endif } size_t wchar_size_of_wchar_string_len(const wchar_t* s, size_t len) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_size_of_utf16_string_len((char16_t*)s, len); #else return utf32_size_of_utf32_string_len((char32_t*)s, len); #endif } size_t utf8_string_from_utf8_string(char* dst, size_t dst_max_len, const char *s) { if ( !s || dst_max_len <= 1 ) { if ( dst_max_len > 0 ) *dst = 0; return 0; } dst_max_len -= 1; char* p = dst; char32_t char32; s = get_char32_from_utf8_string(s, &char32); while ( char32 && dst_max_len > 0 ) { p = get_utf8_from_char32(p, &dst_max_len, char32); s = get_char32_from_utf8_string(s, &char32); } *p = 0; return uintptr_t(p)-uintptr_t(dst)-1; } size_t utf16_string_from_utf16_string(char16_t* dst, size_t dst_max_len, const char16_t *s) { if ( !s || dst_max_len <= 1 ) { if ( dst_max_len > 0 ) *dst = 0; return 0; } size_t s_len = utf16_size_of_utf16_string(s); if ( dst_max_len > s_len ) dst_max_len = s_len; else dst_max_len -= 1; memcpy((void*)dst, (void*)s, dst_max_len * sizeof(char16_t)); dst[dst_max_len] = 0; return dst_max_len * sizeof(char16_t); } size_t utf32_string_from_utf32_string(char32_t* dst, size_t dst_max_len, const char32_t *s) { if ( !s || dst_max_len <= 1 ) { if ( dst_max_len > 0 ) *dst = 0; return 0; } size_t s_len = utf32_size_of_utf32_string(s); if ( dst_max_len > s_len ) dst_max_len = s_len; else dst_max_len -= 1; memcpy((void*)dst, (void*)s, dst_max_len * sizeof(char32_t)); dst[dst_max_len] = 0; return dst_max_len * sizeof(char32_t); } size_t wchar_string_from_wchar_string(wchar_t* dst, size_t dst_max_len, const wchar_t *s) { #if __WCHAR_MAX__ <= 0xFFFFu return utf16_string_from_utf16_string((char16_t*)dst, dst_max_len, (char16_t*)s); #else return utf32_string_from_utf32_string((char32_t*)dst, dst_max_len, (char32_t*)s); #endif } /****** convenience *****/ size_t length_of_wchar_string(const wchar_t* s) { #if __WCHAR_MAX__ <= 0xFFFFu return length_of_utf16_string((char16_t*)s); #else return length_of_utf32_string((char32_t*)s); #endif }