static void unicodeToEncodedUtf8(QString &result, ushort *&output, const ushort *begin,
const ushort *&input, const ushort *end, ushort decoded)
{
uint uc = decoded;
if (QChar::isHighSurrogate(uc)) {
if (input < end && QChar::isLowSurrogate(input[1]))
uc = QChar::surrogateToUcs4(uc, input[1]);
}
// note: we will encode bad UTF-16 to UTF-8
// but they don't get decoded back
// calculate the utf8 length
int utf8len = uc >= 0x10000 ? 4 : uc >= 0x800 ? 3 : 2;
// detach
if (!output) {
// we need 3 * utf8len for the encoded UTF-8 sequence
// but ensureDetached already adds 3 for the char we're processing
ensureDetached(result, output, begin, input, end, 3*utf8len - 3);
} else {
// verify that there's enough space or expand
int charsRemaining = end - input - 1; // not including this one
int pos = output - reinterpret_cast<const ushort *>(result.constData());
int spaceRemaining = result.size() - pos;
if (spaceRemaining < 3*charsRemaining + 3*utf8len) {
// must resize
result.resize(result.size() + 3*utf8len);
// we know that resize() above detached, so we bypass the reference count check
output = const_cast<ushort *>(reinterpret_cast<const ushort *>(result.constData()));
output += pos;
}
}
// write the sequence
if (uc < 0x800) {
// first of two bytes
uchar c = 0xc0 | uchar(uc >> 6);
*output++ = '%';
*output++ = encodeNibble(c >> 4);
*output++ = encodeNibble(c & 0xf);
} else {
const char* hexEncode(const uint8_t *data, const uint32_t data_len)
{
static char* buffer = NULL;
buffer=realloc(buffer, data_len*2+1);
if(buffer == NULL)
{
printf("hexEncode: failed to allocate %u bytes\n", data_len);
exit(1);
}
buffer[data_len*2] = '\0';
for(uint32_t i=0; i<data_len; ++i)
{
uint8_t byte = data[i];
buffer[i*2] = encodeNibble(byte>>4);
buffer[i*2+1] = encodeNibble(0x0F&byte);
}
return buffer;
}
