// This comes from llvm's libcxx project. I've copied the code from there (with very minor modifications) for use with GCC and Clang when libcxx isn't being used.
#if (defined(__GNUC__) || defined(__clang__)) && !defined(_LIBCPP_VERSION)
#pragma once
#include <locale>
namespace std
{
enum codecvt_mode
{
consume_header = 4,
generate_header = 2,
little_endian = 1
};
// Valid UTF ranges
// UTF-32 UTF-16 UTF-8 # of code points
// first second first second third fourth
// 000000 - 00007F 0000 - 007F 00 - 7F 127
// 000080 - 0007FF 0080 - 07FF C2 - DF, 80 - BF 1920
// 000800 - 000FFF 0800 - 0FFF E0 - E0, A0 - BF, 80 - BF 2048
// 001000 - 00CFFF 1000 - CFFF E1 - EC, 80 - BF, 80 - BF 49152
// 00D000 - 00D7FF D000 - D7FF ED - ED, 80 - 9F, 80 - BF 2048
// 00D800 - 00DFFF invalid
// 00E000 - 00FFFF E000 - FFFF EE - EF, 80 - BF, 80 - BF 8192
// 010000 - 03FFFF D800 - D8BF, DC00 - DFFF F0 - F0, 90 - BF, 80 - BF, 80 - BF 196608
// 040000 - 0FFFFF D8C0 - DBBF, DC00 - DFFF F1 - F3, 80 - BF, 80 - BF, 80 - BF 786432
// 100000 - 10FFFF DBC0 - DBFF, DC00 - DFFF F4 - F4, 80 - 8F, 80 - BF, 80 - BF 65536
namespace UnicodeConverters
{
inline codecvt_base::result utf16_to_utf8(const uint16_t *frm, const uint16_t *frm_end, const uint16_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = 0xEF;
*to_nxt++ = 0xBB;
*to_nxt++ = 0xBF;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint16_t wc1 = *frm_nxt;
if (wc1 > Maxcode)
return codecvt_base::error;
if (wc1 < 0x0080)
{
if (to_end - to_nxt < 1)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc1);
}
else if (wc1 < 0x0800)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
}
else if (wc1 < 0xD800)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
}
else if (wc1 < 0xDC00)
{
if (frm_end - frm_nxt < 2)
return codecvt_base::partial;
uint16_t wc2 = frm_nxt[1];
if ((wc2 & 0xFC00) != 0xDC00)
return codecvt_base::error;
if (to_end - to_nxt < 4)
return codecvt_base::partial;
if (((((static_cast<unsigned long>(wc1) & 0x03C0) >> 6) + 1) << 16) + ((static_cast<unsigned long>(wc1) & 0x003F) << 10) + (wc2 & 0x03FF) > Maxcode)
return codecvt_base::error;
++frm_nxt;
uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
*to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4) | ((wc1 & 0x003C) >> 2));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc2 & 0x003F));
}
else if (wc1 < 0xE000)
return codecvt_base::error;
else
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
}
}
return codecvt_base::ok;
}
inline codecvt_base::result utf16_to_utf8(const uint32_t *frm, const uint32_t *frm_end, const uint32_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = 0xEF;
*to_nxt++ = 0xBB;
*to_nxt++ = 0xBF;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint16_t wc1 = static_cast<uint16_t>(*frm_nxt);
if (wc1 > Maxcode)
return codecvt_base::error;
if (wc1 < 0x0080)
{
if (to_end - to_nxt < 1)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc1);
}
else if (wc1 < 0x0800)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
}
else if (wc1 < 0xD800)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
}
else if (wc1 < 0xDC00)
{
if (frm_end - frm_nxt < 2)
return codecvt_base::partial;
uint16_t wc2 = static_cast<uint16_t>(frm_nxt[1]);
if ((wc2 & 0xFC00) != 0xDC00)
return codecvt_base::error;
if (to_end - to_nxt < 4)
return codecvt_base::partial;
if (((((static_cast<unsigned long>(wc1) & 0x03C0) >> 6) + 1) << 16) + ((static_cast<unsigned long>(wc1) & 0x003F) << 10) + (wc2 & 0x03FF) > Maxcode)
return codecvt_base::error;
++frm_nxt;
uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
*to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4) | ((wc1 & 0x003C) >> 2));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc2 & 0x003F));
}
else if (wc1 < 0xE000)
return codecvt_base::error;
else
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
}
}
return codecvt_base::ok;
}
inline codecvt_base::result utf8_to_utf16(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint16_t *to, uint16_t *to_end, uint16_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
frm_nxt += 3;
for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
{
uint8_t c1 = *frm_nxt;
if (c1 > Maxcode)
return codecvt_base::error;
if (c1 < 0x80)
{
*to_nxt = static_cast<uint16_t>(c1);
++frm_nxt;
}
else if (c1 < 0xC2)
return codecvt_base::error;
else if (c1 < 0xE0)
{
if (frm_end - frm_nxt < 2)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 2;
}
else if (c1 < 0xF0)
{
if (frm_end - frm_nxt < 3)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
switch (c1)
{
case 0xE0:
if ((c2 & 0xE0) != 0xA0)
return codecvt_base::error;
break;
case 0xED:
if ((c2 & 0xE0) != 0x80)
return codecvt_base::error;
break;
default:
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
}
if ((c3 & 0xC0) != 0x80)
return codecvt_base::error;
uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 3;
}
else if (c1 < 0xF5)
{
if (frm_end - frm_nxt < 4)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
uint8_t c4 = frm_nxt[3];
switch (c1)
{
case 0xF0:
if (c2 < 0x90 || c2 > 0xBF)
return codecvt_base::error;
break;
case 0xF4:
if ((c2 & 0xF0) != 0x80)
return codecvt_base::error;
break;
default:
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
}
if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
return codecvt_base::error;
if (to_end - to_nxt < 2)
return codecvt_base::partial;
if ((((static_cast<unsigned long>(c1) & 7) << 18) + ((static_cast<unsigned long>(c2) & 0x3F) << 12) + ((static_cast<unsigned long>(c3) & 0x3F) << 6) + (c4 & 0x3F)) > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint16_t>(0xD800 | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6) | ((c2 & 0x0F) << 2) | ((c3 & 0x30) >> 4));
*++to_nxt = static_cast<uint16_t>(0xDC00 | ((c3 & 0x0F) << 6) | (c4 & 0x3F));
frm_nxt += 4;
}
else
return codecvt_base::error;
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline codecvt_base::result utf8_to_utf16(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint32_t *to, uint32_t *to_end, uint32_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
frm_nxt += 3;
for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
{
uint8_t c1 = *frm_nxt;
if (c1 > Maxcode)
return codecvt_base::error;
if (c1 < 0x80)
{
*to_nxt = static_cast<uint32_t>(c1);
++frm_nxt;
}
else if (c1 < 0xC2)
return codecvt_base::error;
else if (c1 < 0xE0)
{
if (frm_end - frm_nxt < 2)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint32_t>(t);
frm_nxt += 2;
}
else if (c1 < 0xF0)
{
if (frm_end - frm_nxt < 3)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
switch (c1)
{
case 0xE0:
if ((c2 & 0xE0) != 0xA0)
return codecvt_base::error;
break;
case 0xED:
if ((c2 & 0xE0) != 0x80)
return codecvt_base::error;
break;
default:
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
}
if ((c3 & 0xC0) != 0x80)
return codecvt_base::error;
uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint32_t>(t);
frm_nxt += 3;
}
else if (c1 < 0xF5)
{
if (frm_end - frm_nxt < 4)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
uint8_t c4 = frm_nxt[3];
switch (c1)
{
case 0xF0:
if (c2 < 0x90 || c2 > 0xBF)
return codecvt_base::error;
break;
case 0xF4:
if ((c2 & 0xF0) != 0x80)
return codecvt_base::error;
break;
default:
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
}
if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
return codecvt_base::error;
if (to_end - to_nxt < 2)
return codecvt_base::partial;
if ((((static_cast<unsigned long>(c1) & 7) << 18) + ((static_cast<unsigned long>(c2) & 0x3F) << 12) + ((static_cast<unsigned long>(c3) & 0x3F) << 6) + (c4 & 0x3F)) > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint32_t>(0xD800 | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6) | ((c2 & 0x0F) << 2) | ((c3 & 0x30) >> 4));
*++to_nxt = static_cast<uint32_t>( 0xDC00 | ((c3 & 0x0F) << 6) | (c4 & 0x3F));
frm_nxt += 4;
}
else
return codecvt_base::error;
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline int utf8_to_utf16_length(const uint8_t *frm, const uint8_t *frm_end, size_t mx, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
auto frm_nxt = frm;
if ((mode & consume_header) && frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
frm_nxt += 3;
for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t)
{
uint8_t c1 = *frm_nxt;
if (c1 > Maxcode)
break;
if (c1 < 0x80)
++frm_nxt;
else if (c1 < 0xC2)
break;
else if (c1 < 0xE0)
{
if (frm_end - frm_nxt < 2 || (frm_nxt[1] & 0xC0) != 0x80)
break;
uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (frm_nxt[1] & 0x3F));
if (t > Maxcode)
break;
frm_nxt += 2;
}
else if (c1 < 0xF0)
{
if (frm_end - frm_nxt < 3)
break;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
switch (c1)
{
case 0xE0:
if ((c2 & 0xE0) != 0xA0)
return static_cast<int>(frm_nxt - frm);
break;
case 0xED:
if ((c2 & 0xE0) != 0x80)
return static_cast<int>(frm_nxt - frm);
break;
default:
if ((c2 & 0xC0) != 0x80)
return static_cast<int>(frm_nxt - frm);
}
if ((c3 & 0xC0) != 0x80)
break;
if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
break;
frm_nxt += 3;
}
else if (c1 < 0xF5)
{
if (frm_end - frm_nxt < 4 || mx - nchar16_t < 2)
break;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
uint8_t c4 = frm_nxt[3];
switch (c1)
{
case 0xF0:
if (c2 < 0x90 || c2 > 0xBF)
return static_cast<int>(frm_nxt - frm);
break;
case 0xF4:
if ((c2 & 0xF0) != 0x80)
return static_cast<int>(frm_nxt - frm);
break;
default:
if ((c2 & 0xC0) != 0x80)
return static_cast<int>(frm_nxt - frm);
}
if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
break;
if ((((static_cast<unsigned long>(c1) & 7) << 18) + ((static_cast<unsigned long>(c2) & 0x3F) << 12) + ((static_cast<unsigned long>(c3) & 0x3F) << 6) + (c4 & 0x3F)) > Maxcode)
break;
++nchar16_t;
frm_nxt += 4;
}
else
break;
}
return static_cast<int>(frm_nxt - frm);
}
inline codecvt_base::result ucs4_to_utf8(const uint32_t *frm, const uint32_t *frm_end, const uint32_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = 0xEF;
*to_nxt++ = 0xBB;
*to_nxt++ = 0xBF;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint32_t wc = *frm_nxt;
if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
return codecvt_base::error;
if (wc < 0x000080)
{
if (to_end - to_nxt < 1)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc);
}
else if (wc < 0x000800)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
}
else if (wc < 0x010000)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xE0 | (wc >> 12));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x003F));
}
else // if (wc < 0x110000)
{
if (to_end - to_nxt < 4)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xF0 | (wc >> 18));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x03F000) >> 12));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x000FC0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x00003F));
}
}
return codecvt_base::ok;
}
inline codecvt_base::result utf8_to_ucs4(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint32_t *to, uint32_t *to_end, uint32_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
frm_nxt += 3;
for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
{
uint8_t c1 = *frm_nxt;
if (c1 < 0x80)
{
if (c1 > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint32_t>(c1);
++frm_nxt;
}
else if (c1 < 0xC2)
return codecvt_base::error;
else if (c1 < 0xE0)
{
if (frm_end - frm_nxt < 2)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
uint32_t t = static_cast<uint32_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 2;
}
else if (c1 < 0xF0)
{
if (frm_end - frm_nxt < 3)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
switch (c1)
{
case 0xE0:
if ((c2 & 0xE0) != 0xA0)
return codecvt_base::error;
break;
case 0xED:
if ((c2 & 0xE0) != 0x80)
return codecvt_base::error;
break;
default:
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
}
if ((c3 & 0xC0) != 0x80)
return codecvt_base::error;
uint32_t t = static_cast<uint32_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 3;
}
else if (c1 < 0xF5)
{
if (frm_end - frm_nxt < 4)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
uint8_t c4 = frm_nxt[3];
switch (c1)
{
case 0xF0:
if (c2 < 0x90 || c2 > 0xBF)
return codecvt_base::error;
break;
case 0xF4:
if ((c2 & 0xF0) != 0x80)
return codecvt_base::error;
break;
default:
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
}
if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
return codecvt_base::error;
uint32_t t = static_cast<uint32_t>(((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) | ((c3 & 0x3F) << 6) | (c4 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 4;
}
else
return codecvt_base::error;
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline int utf8_to_ucs4_length(const uint8_t *frm, const uint8_t *frm_end, size_t mx, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
auto frm_nxt = frm;
if ((mode & consume_header) && frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
frm_nxt += 3;
for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
{
uint8_t c1 = *frm_nxt;
if (c1 < 0x80)
{
if (c1 > Maxcode)
break;
++frm_nxt;
}
else if (c1 < 0xC2)
break;
else if (c1 < 0xE0)
{
if (frm_end - frm_nxt < 2 || (frm_nxt[1] & 0xC0) != 0x80)
break;
if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
break;
frm_nxt += 2;
}
else if (c1 < 0xF0)
{
if (frm_end - frm_nxt < 3)
break;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
switch (c1)
{
case 0xE0:
if ((c2 & 0xE0) != 0xA0)
return static_cast<int>(frm_nxt - frm);
break;
case 0xED:
if ((c2 & 0xE0) != 0x80)
return static_cast<int>(frm_nxt - frm);
break;
default:
if ((c2 & 0xC0) != 0x80)
return static_cast<int>(frm_nxt - frm);
}
if ((c3 & 0xC0) != 0x80)
break;
if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
break;
frm_nxt += 3;
}
else if (c1 < 0xF5)
{
if (frm_end - frm_nxt < 4)
break;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
uint8_t c4 = frm_nxt[3];
switch (c1)
{
case 0xF0:
if (c2 < 0x90 || c2 > 0xBF)
return static_cast<int>(frm_nxt - frm);
break;
case 0xF4:
if ((c2 & 0xF0) != 0x80)
return static_cast<int>(frm_nxt - frm);
break;
default:
if ((c2 & 0xC0) != 0x80)
return static_cast<int>(frm_nxt - frm);
}
if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
break;
if ((((c1 & 0x07u) << 18) | ((c2 & 0x3Fu) << 12) | ((c3 & 0x3Fu) << 6) | (c4 & 0x3Fu)) > Maxcode)
break;
frm_nxt += 4;
}
else
break;
}
return static_cast<int>(frm_nxt - frm);
}
inline codecvt_base::result ucs2_to_utf8(const uint16_t *frm, const uint16_t *frm_end, const uint16_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = 0xEF;
*to_nxt++ = 0xBB;
*to_nxt++ = 0xBF;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint16_t wc = *frm_nxt;
if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
return codecvt_base::error;
if (wc < 0x0080)
{
if (to_end - to_nxt < 1)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc);
}
else if (wc < 0x0800)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
}
else // if (wc <= 0xFFFF)
{
if (to_end - to_nxt < 3)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(0xE0 | (wc >> 12));
*to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
*to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x003F));
}
}
return codecvt_base::ok;
}
inline codecvt_base::result utf8_to_ucs2(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint16_t *to, uint16_t *to_end, uint16_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
frm_nxt += 3;
for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
{
uint8_t c1 = *frm_nxt;
if (c1 < 0x80)
{
if (c1 > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint16_t>(c1);
++frm_nxt;
}
else if (c1 < 0xC2)
return codecvt_base::error;
else if (c1 < 0xE0)
{
if (frm_end - frm_nxt < 2)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 2;
}
else if (c1 < 0xF0)
{
if (frm_end - frm_nxt < 3)
return codecvt_base::partial;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
switch (c1)
{
case 0xE0:
if ((c2 & 0xE0) != 0xA0)
return codecvt_base::error;
break;
case 0xED:
if ((c2 & 0xE0) != 0x80)
return codecvt_base::error;
break;
default:
if ((c2 & 0xC0) != 0x80)
return codecvt_base::error;
}
if ((c3 & 0xC0) != 0x80)
return codecvt_base::error;
uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 3;
}
else
return codecvt_base::error;
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline int utf8_to_ucs2_length(const uint8_t *frm, const uint8_t *frm_end, size_t mx, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
auto frm_nxt = frm;
if ((mode & consume_header) && frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
frm_nxt += 3;
for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
{
uint8_t c1 = *frm_nxt;
if (c1 < 0x80)
{
if (c1 > Maxcode)
break;
++frm_nxt;
}
else if (c1 < 0xC2)
break;
else if (c1 < 0xE0)
{
if (frm_end - frm_nxt < 2 || (frm_nxt[1] & 0xC0) != 0x80)
break;
if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
break;
frm_nxt += 2;
}
else if (c1 < 0xF0)
{
if (frm_end - frm_nxt < 3)
break;
uint8_t c2 = frm_nxt[1];
uint8_t c3 = frm_nxt[2];
switch (c1)
{
case 0xE0:
if ((c2 & 0xE0) != 0xA0)
return static_cast<int>(frm_nxt - frm);
break;
case 0xED:
if ((c2 & 0xE0) != 0x80)
return static_cast<int>(frm_nxt - frm);
break;
default:
if ((c2 & 0xC0) != 0x80)
return static_cast<int>(frm_nxt - frm);
}
if ((c3 & 0xC0) != 0x80)
break;
if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
break;
frm_nxt += 3;
}
else
break;
}
return static_cast<int>(frm_nxt - frm);
}
inline codecvt_base::result ucs4_to_utf16be(const uint32_t *frm, const uint32_t *frm_end, const uint32_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = 0xFE;
*to_nxt++ = 0xFF;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint32_t wc = *frm_nxt;
if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
return codecvt_base::error;
if (wc < 0x010000)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc >> 8);
*to_nxt++ = static_cast<uint8_t>(wc);
}
else
{
if (to_end - to_nxt < 4)
return codecvt_base::partial;
uint16_t t = static_cast<uint16_t>(0xD800 | ((((wc & 0x1F0000) >> 16) - 1) << 6) | ((wc & 0x00FC00) >> 10));
*to_nxt++ = static_cast<uint8_t>(t >> 8);
*to_nxt++ = static_cast<uint8_t>(t);
t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
*to_nxt++ = static_cast<uint8_t>(t >> 8);
*to_nxt++ = static_cast<uint8_t>(t);
}
}
return codecvt_base::ok;
}
inline codecvt_base::result utf16be_to_ucs4(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint32_t *to, uint32_t *to_end, uint32_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
frm_nxt += 2;
for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[0] << 8) | frm_nxt[1]);
if ((c1 & 0xFC00) == 0xDC00)
return codecvt_base::error;
if ((c1 & 0xFC00) != 0xD800)
{
if (c1 > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint32_t>(c1);
frm_nxt += 2;
}
else
{
if (frm_end - frm_nxt < 4)
return codecvt_base::partial;
uint16_t c2 = static_cast<uint16_t>((frm_nxt[2] << 8) | frm_nxt[3]);
if ((c2 & 0xFC00) != 0xDC00)
return codecvt_base::error;
uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 4;
}
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline int utf16be_to_ucs4_length(const uint8_t *frm, const uint8_t *frm_end, size_t mx, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
auto frm_nxt = frm;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
frm_nxt += 2;
for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[0] << 8) | frm_nxt[1]);
if ((c1 & 0xFC00) == 0xDC00)
break;
if ((c1 & 0xFC00) != 0xD800)
{
if (c1 > Maxcode)
break;
frm_nxt += 2;
}
else
{
if (frm_end - frm_nxt < 4)
break;
uint16_t c2 = static_cast<uint16_t>((frm_nxt[2] << 8) | frm_nxt[3]);
if ((c2 & 0xFC00) != 0xDC00)
break;
uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
if (t > Maxcode)
break;
frm_nxt += 4;
}
}
return static_cast<int>(frm_nxt - frm);
}
inline codecvt_base::result ucs4_to_utf16le(const uint32_t *frm, const uint32_t *frm_end, const uint32_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = 0xFF;
*to_nxt++ = 0xFE;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint32_t wc = *frm_nxt;
if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
return codecvt_base::error;
if (wc < 0x010000)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc);
*to_nxt++ = static_cast<uint8_t>(wc >> 8);
}
else
{
if (to_end - to_nxt < 4)
return codecvt_base::partial;
uint16_t t = static_cast<uint16_t>(0xD800 | ((((wc & 0x1F0000) >> 16) - 1) << 6) | ((wc & 0x00FC00) >> 10));
*to_nxt++ = static_cast<uint8_t>(t);
*to_nxt++ = static_cast<uint8_t>(t >> 8);
t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
*to_nxt++ = static_cast<uint8_t>(t);
*to_nxt++ = static_cast<uint8_t>(t >> 8);
}
}
return codecvt_base::ok;
}
inline codecvt_base::result utf16le_to_ucs4(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint32_t *to, uint32_t *to_end, uint32_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
frm_nxt += 2;
for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[1] << 8) | frm_nxt[0]);
if ((c1 & 0xFC00) == 0xDC00)
return codecvt_base::error;
if ((c1 & 0xFC00) != 0xD800)
{
if (c1 > Maxcode)
return codecvt_base::error;
*to_nxt = static_cast<uint32_t>(c1);
frm_nxt += 2;
}
else
{
if (frm_end - frm_nxt < 4)
return codecvt_base::partial;
uint16_t c2 = static_cast<uint16_t>((frm_nxt[3] << 8) | frm_nxt[2]);
if ((c2 & 0xFC00) != 0xDC00)
return codecvt_base::error;
uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
if (t > Maxcode)
return codecvt_base::error;
*to_nxt = t;
frm_nxt += 4;
}
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline int utf16le_to_ucs4_length(const uint8_t *frm, const uint8_t *frm_end, size_t mx, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
auto frm_nxt = frm;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
frm_nxt += 2;
for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[1] << 8) | frm_nxt[0]);
if ((c1 & 0xFC00) == 0xDC00)
break;
if ((c1 & 0xFC00) != 0xD800)
{
if (c1 > Maxcode)
break;
frm_nxt += 2;
}
else
{
if (frm_end - frm_nxt < 4)
break;
uint16_t c2 = static_cast<uint16_t>((frm_nxt[3] << 8) | frm_nxt[2]);
if ((c2 & 0xFC00) != 0xDC00)
break;
uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
if (t > Maxcode)
break;
frm_nxt += 4;
}
}
return static_cast<int>(frm_nxt - frm);
}
inline codecvt_base::result ucs2_to_utf16be(const uint16_t *frm, const uint16_t *frm_end, const uint16_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = 0xFE;
*to_nxt++ = 0xFF;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint16_t wc = *frm_nxt;
if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
return codecvt_base::error;
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc >> 8);
*to_nxt++ = static_cast<uint8_t>(wc);
}
return codecvt_base::ok;
}
inline codecvt_base::result utf16be_to_ucs2(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint16_t *to, uint16_t *to_end, uint16_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
frm_nxt += 2;
for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[0] << 8) | frm_nxt[1]);
if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
return codecvt_base::error;
*to_nxt = c1;
frm_nxt += 2;
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline int utf16be_to_ucs2_length(const uint8_t *frm, const uint8_t *frm_end, size_t mx, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
auto frm_nxt = frm;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
frm_nxt += 2;
for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[0] << 8) | frm_nxt[1]);
if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
break;
frm_nxt += 2;
}
return static_cast<int>(frm_nxt - frm);
}
inline codecvt_base::result ucs2_to_utf16le(const uint16_t *frm, const uint16_t *frm_end, const uint16_t *&frm_nxt, uint8_t *to, uint8_t *to_end, uint8_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if (mode & generate_header)
{
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = 0xFF;
*to_nxt++ = 0xFE;
}
for (; frm_nxt < frm_end; ++frm_nxt)
{
uint16_t wc = *frm_nxt;
if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
return codecvt_base::error;
if (to_end - to_nxt < 2)
return codecvt_base::partial;
*to_nxt++ = static_cast<uint8_t>(wc);
*to_nxt++ = static_cast<uint8_t>(wc >> 8);
}
return codecvt_base::ok;
}
inline codecvt_base::result utf16le_to_ucs2(const uint8_t *frm, const uint8_t *frm_end, const uint8_t *&frm_nxt, uint16_t *to, uint16_t *to_end, uint16_t *&to_nxt, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
frm_nxt = frm;
to_nxt = to;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
frm_nxt += 2;
for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[1] << 8) | frm_nxt[0]);
if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
return codecvt_base::error;
*to_nxt = c1;
frm_nxt += 2;
}
return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
}
inline int utf16le_to_ucs2_length(const uint8_t *frm, const uint8_t *frm_end, size_t mx, unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = static_cast<codecvt_mode>(0))
{
auto frm_nxt = frm;
if ((mode & consume_header) && frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
frm_nxt += 2;
for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
{
uint16_t c1 = static_cast<uint16_t>((frm_nxt[1] << 8) | frm_nxt[0]);
if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
break;
frm_nxt += 2;
}
return static_cast<int>(frm_nxt - frm);
}
}
template<> class codecvt<char16_t, char, mbstate_t> : public locale::facet, public codecvt_base
{
public:
typedef char16_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit codecvt(size_t __refs = 0) : locale::facet(__refs) { }
result out(state_type &__st, const intern_type *__frm, const intern_type *__frm_end, const intern_type *&__frm_nxt, extern_type *__to, extern_type *__to_end, extern_type *&__to_nxt) const
{
return this->do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
}
result unshift(state_type &__st, extern_type *__to, extern_type *__to_end, extern_type *&__to_nxt) const
{
return this->do_unshift(__st, __to, __to_end, __to_nxt);
}
result in(state_type &__st, const extern_type *__frm, const extern_type *__frm_end, const extern_type *&__frm_nxt, intern_type *__to, intern_type *__to_end, intern_type *&__to_nxt) const
{
return this->do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
}
int encoding() const throw()
{
return this->do_encoding();
}
bool always_noconv() const throw()
{
return this->do_always_noconv();
}
int length(state_type &__st, const extern_type *__frm, const extern_type *__end, size_t __mx) const
{
return this->do_length(__st, __frm, __end, __mx);
}
int max_length() const throw()
{
return this->do_max_length();
}
static locale::id id;
protected:
explicit codecvt(const char *, size_t __refs = 0) : locale::facet(__refs) { }
~codecvt() { }
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint16_t *>(frm);
auto _frm_end = reinterpret_cast<const uint16_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint16_t *>(to);
auto _to_end = reinterpret_cast<uint16_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_utf16_length(_frm, _frm_end, mx);
}
virtual int do_max_length() const throw() { return 4; }
};
template<> class codecvt<char32_t, char, mbstate_t> : public locale::facet, public codecvt_base
{
public:
typedef char32_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit codecvt(size_t __refs = 0) : locale::facet(__refs) { }
result out(state_type &__st, const intern_type *__frm, const intern_type *__frm_end, const intern_type *&__frm_nxt, extern_type *__to, extern_type *__to_end, extern_type *&__to_nxt) const
{
return this->do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
}
result unshift(state_type &__st, extern_type *__to, extern_type *__to_end, extern_type *&__to_nxt) const
{
return this->do_unshift(__st, __to, __to_end, __to_nxt);
}
result in(state_type &__st, const extern_type *__frm, const extern_type *__frm_end, const extern_type *&__frm_nxt, intern_type *__to, intern_type *__to_end, intern_type *&__to_nxt) const
{
return this->do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
}
int encoding() const throw()
{
return this->do_encoding();
}
bool always_noconv() const throw()
{
return this->do_always_noconv();
}
int length(state_type &__st, const extern_type *__frm, const extern_type *__end, size_t __mx) const
{
return this->do_length(__st, __frm, __end, __mx);
}
int max_length() const throw()
{
return this->do_max_length();
}
static locale::id id;
protected:
explicit codecvt(const char *, size_t __refs = 0) : locale::facet(__refs) { }
~codecvt() { }
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_ucs4_length(_frm, _frm_end, mx);
}
virtual int do_max_length() const throw() { return 4; }
};
template<class _Elem> class __codecvt_utf8;
template<> class __codecvt_utf8<wchar_t> : public codecvt<wchar_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef wchar_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
#ifdef _WIN32
auto _frm = reinterpret_cast<const uint16_t *>(frm);
auto _frm_end = reinterpret_cast<const uint16_t *>(frm_end);
#else
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
#endif
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::
#ifdef _WIN32
ucs2_to_utf8
#else
ucs4_to_utf8
#endif
(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
#ifdef _WIN32
auto _to = reinterpret_cast<uint16_t *>(to);
auto _to_end = reinterpret_cast<uint16_t *>(to_end);
#else
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
#endif
auto _to_nxt = _to;
auto r = UnicodeConverters::
#ifdef _WIN32
utf8_to_ucs2
#else
utf8_to_ucs4
#endif
(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_ucs4_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 7;
return 4;
}
};
template<> class __codecvt_utf8<char16_t> : public codecvt<char16_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char16_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint16_t *>(frm);
auto _frm_end = reinterpret_cast<const uint16_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint16_t *>(to);
auto _to_end = reinterpret_cast<uint16_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_ucs2_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 6;
return 3;
}
};
template<> class __codecvt_utf8<char32_t> : public codecvt<char32_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char32_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_ucs4_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 7;
return 4;
}
};
template<class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = static_cast<codecvt_mode>(0)> class codecvt_utf8 : public __codecvt_utf8<_Elem>
{
public:
explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) { }
~codecvt_utf8() { }
};
template<class _Elem, bool _LittleEndian> class __codecvt_utf16;
template<> class __codecvt_utf16<wchar_t, false> : public codecvt<wchar_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef wchar_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf16be_to_ucs4_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 6;
return 4;
}
};
template<> class __codecvt_utf16<wchar_t, true> : public codecvt<wchar_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef wchar_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf16le_to_ucs4_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 6;
return 4;
}
};
template<> class __codecvt_utf16<char16_t, false> : public codecvt<char16_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char16_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint16_t *>(frm);
auto _frm_end = reinterpret_cast<const uint16_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint16_t *>(to);
auto _to_end = reinterpret_cast<uint16_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf16be_to_ucs2_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 4;
return 2;
}
};
template<> class __codecvt_utf16<char16_t, true> : public codecvt<char16_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char16_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint16_t *>(frm);
auto _frm_end = reinterpret_cast<const uint16_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint16_t *>(to);
auto _to_end = reinterpret_cast<uint16_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf16le_to_ucs2_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 4;
return 2;
}
};
template<> class __codecvt_utf16<char32_t, false> : public codecvt<char32_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char32_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf16be_to_ucs4_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 6;
return 4;
}
};
template<> class __codecvt_utf16<char32_t, true> : public codecvt<char32_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char32_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf16le_to_ucs4_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 6;
return 4;
}
};
template<class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = static_cast<codecvt_mode>(0)> class codecvt_utf16 : public __codecvt_utf16<_Elem, _Mode & little_endian>
{
public:
explicit codecvt_utf16(size_t __refs = 0) : __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) { }
~codecvt_utf16() { }
};
template<class _Elem> class __codecvt_utf8_utf16;
template<> class __codecvt_utf8_utf16<wchar_t> : public codecvt<wchar_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef wchar_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_utf16_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 7;
return 4;
}
};
template<> class __codecvt_utf8_utf16<char32_t> : public codecvt<char32_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char32_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint32_t *>(frm);
auto _frm_end = reinterpret_cast<const uint32_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint32_t *>(to);
auto _to_end = reinterpret_cast<uint32_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_utf16_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 7;
return 4;
}
};
template<> class __codecvt_utf8_utf16<char16_t> : public codecvt<char16_t, char, mbstate_t>
{
unsigned long _Maxcode_;
codecvt_mode _Mode_;
public:
typedef char16_t intern_type;
typedef char extern_type;
typedef mbstate_t state_type;
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode, codecvt_mode _Mode) : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode), _Mode_(_Mode) { }
protected:
virtual result do_out(state_type &, const intern_type *frm, const intern_type *frm_end, const intern_type *&frm_nxt, extern_type *to, extern_type *to_end, extern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint16_t *>(frm);
auto _frm_end = reinterpret_cast<const uint16_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint8_t *>(to);
auto _to_end = reinterpret_cast<uint8_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_in(state_type &, const extern_type *frm, const extern_type *frm_end, const extern_type *&frm_nxt, intern_type *to, intern_type *to_end, intern_type *&to_nxt) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
auto _frm_nxt = _frm;
auto _to = reinterpret_cast<uint16_t *>(to);
auto _to_end = reinterpret_cast<uint16_t *>(to_end);
auto _to_nxt = _to;
auto r = UnicodeConverters::utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, this->_Maxcode_, this->_Mode_);
frm_nxt = frm + (_frm_nxt - _frm);
to_nxt = to + (_to_nxt - _to);
return r;
}
virtual result do_unshift(state_type &, extern_type *to, extern_type *, extern_type *&to_nxt) const
{
to_nxt = to;
return noconv;
}
virtual int do_encoding() const throw() { return 0; }
virtual bool do_always_noconv() const throw() { return false; }
virtual int do_length(state_type &, const extern_type *frm, const extern_type *frm_end, size_t mx) const
{
auto _frm = reinterpret_cast<const uint8_t *>(frm);
auto _frm_end = reinterpret_cast<const uint8_t *>(frm_end);
return UnicodeConverters::utf8_to_utf16_length(_frm, _frm_end, mx, this->_Maxcode_, this->_Mode_);
}
virtual int do_max_length() const throw()
{
if (this->_Mode_ & consume_header)
return 7;
return 4;
}
};
template<class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = static_cast<codecvt_mode>(0)> class codecvt_utf8_utf16 : public __codecvt_utf8_utf16<_Elem>
{
public:
explicit codecvt_utf8_utf16(size_t __refs = 0) : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) { }
~codecvt_utf8_utf16() {}
};
};
#endif