42 #include <private/qstringconverter_p.h>
45 #include "private/qsimd_p.h"
46 #include "private/qstringiterator_p.h"
47 #include "private/qtools_p.h"
52 #ifndef QT_BOOTSTRAPPED
53 #include <QtCore/qvarlengtharray.h>
57 #if __has_include(<bit>) && __cplusplus > 201703L
65 static const uchar utf8bom[] = { 0xef, 0xbb, 0xbf };
67 #if (defined(__SSE2__) && defined(QT_COMPILER_SUPPORTS_SSE2)) \
68 || defined(__ARM_NEON__)
69 static Q_ALWAYS_INLINE
uint qBitScanReverse(
unsigned v) noexcept
71 #if defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L
72 return std::bit_width(
v) - 1;
78 result ^=
sizeof(unsigned) * 8 - 1;
84 #if defined(__SSE2__) && defined(QT_COMPILER_SUPPORTS_SSE2)
85 static inline bool simdEncodeAscii(
uchar *&
dst,
const char16_t *&nextAscii,
const char16_t *&
src,
const char16_t *
end)
90 __m256i
data = _mm256_loadu_si256(
reinterpret_cast<const __m256i *
>(
src));
91 __m128i data1 = _mm256_castsi256_si128(
data);
92 __m128i data2 = _mm256_extracti128_si256(
data, 1);
94 __m128i data1 = _mm_loadu_si128((
const __m128i*)
src);
95 __m128i data2 = _mm_loadu_si128(1+(
const __m128i*)
src);
106 __m128i
packed = _mm_packus_epi16(data1, data2);
107 __m128i nonAscii = _mm_cmpgt_epi8(
packed, _mm_setzero_si128());
113 ushort n = ~_mm_movemask_epi8(nonAscii);
118 nextAscii =
src + qBitScanReverse(
n) + 1;
129 __m128i
data = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(
src));
131 __m128i nonAscii = _mm_cmpgt_epi8(
packed, _mm_setzero_si128());
134 _mm_storel_epi64(
reinterpret_cast<__m128i *
>(
dst),
packed);
136 uchar n = ~_mm_movemask_epi8(nonAscii);
138 nextAscii =
src + qBitScanReverse(
n) + 1;
153 __m128i
data = _mm_loadu_si128((
const __m128i*)
src);
156 const int BitSpacing = 2;
158 const __m256i extended = _mm256_cvtepu8_epi16(
data);
160 uint n = _mm256_movemask_epi8(extended);
163 _mm256_storeu_si256((__m256i*)
dst, extended);
167 const int BitSpacing = 1;
174 _mm_storeu_si128((__m128i*)
dst, _mm_unpacklo_epi8(
data, _mm_setzero_si128()));
175 _mm_storeu_si128(1+(__m128i*)
dst, _mm_unpackhi_epi8(
data, _mm_setzero_si128()));
189 n = qBitScanReverse(
n);
190 nextAscii =
src + (
n / BitSpacing) + 1;
196 __m128i
data = _mm_loadl_epi64(
reinterpret_cast<const __m128i *
>(
src));
200 _mm_storeu_si128(
reinterpret_cast<__m128i *
>(
dst), _mm_unpacklo_epi8(
data, _mm_setzero_si128()));
207 n = qBitScanReverse(
n);
208 nextAscii =
src +
n + 1;
221 const __m256i
mask = _mm256_set1_epi8(0x80);
223 __m256i
data = _mm256_loadu_si256(
reinterpret_cast<const __m256i *
>(
src));
233 nextAscii =
src + qBitScanReverse(
n) + 1;
242 __m128i
data = _mm_loadu_si128(
reinterpret_cast<const __m128i*
>(
src));
253 nextAscii =
src + qBitScanReverse(
n) + 1;
278 static void simdCompareAscii(
const char8_t *&src8,
const char8_t *end8,
const char16_t *&src16,
const char16_t *end16)
287 __m128i data8 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(src8 +
offset));
290 __m256i data16 = _mm256_loadu_si256(
reinterpret_cast<const __m256i *
>(src16 +
offset));
293 __m256i datax8 = _mm256_cvtepu8_epi16(data8);
294 mask = _mm256_movemask_epi8(datax8);
299 __m256i latin1cmp = _mm256_cmpeq_epi16(datax8, data16);
300 mask = ~_mm256_movemask_epi8(latin1cmp);
305 __m128i datalo16 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(src16 +
offset));
306 __m128i datahi16 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(src16 +
offset) + 1);
309 __m128i datalo8 = _mm_unpacklo_epi8(data8, _mm_setzero_si128());
310 __m128i datahi8 = _mm_unpackhi_epi8(data8, _mm_setzero_si128());
313 __m128i latin1cmplo = _mm_cmpeq_epi16(datalo8, datalo16);
314 __m128i latin1cmphi = _mm_cmpeq_epi16(datahi8, datahi16);
315 mask = _mm_movemask_epi8(latin1cmphi) << 16;
316 mask |=
ushort(_mm_movemask_epi8(latin1cmplo));
322 mask = _mm_movemask_epi8(data8);
331 auto cmp_lt_16 = [&
mask, &
offset](
int n, __m128i data8, __m128i data16) {
334 unsigned sizemask = (1U << (2 *
n)) - 1;
337 data8 = _mm_unpacklo_epi8(data8, _mm_setzero_si128());
340 __m128i latin1cmp = _mm_cmpeq_epi16(data8, data16);
341 mask = ~_mm_movemask_epi8(latin1cmp) & sizemask;
342 mask |= _mm_movemask_epi8(data8);
349 __m128i data8 = _mm_loadl_epi64(
reinterpret_cast<const __m128i *
>(src8 +
offset));
350 __m128i data16 = _mm_loadu_si128(
reinterpret_cast<const __m128i *
>(src16 +
offset));
351 cmp_lt_16(8, data8, data16);
356 __m128i data8 = _mm_cvtsi32_si128(qFromUnaligned<quint32>(src8 +
offset));
357 __m128i data16 = _mm_loadl_epi64(
reinterpret_cast<const __m128i *
>(src16 +
offset));
358 cmp_lt_16(4, data8, data16);
367 #elif defined(__ARM_NEON__)
368 static inline bool simdEncodeAscii(
uchar *&
dst,
const char16_t *&nextAscii,
const char16_t *&
src,
const char16_t *
end)
370 uint16x8_t maxAscii = vdupq_n_u16(0x7f);
371 uint16x8_t mask1 = { 1, 1 << 2, 1 << 4, 1 << 6, 1 << 8, 1 << 10, 1 << 12, 1 << 14 };
372 uint16x8_t mask2 = vshlq_n_u16(mask1, 1);
377 uint16x8x2_t
in = vld2q_u16(
reinterpret_cast<const uint16_t *
>(
src));
381 uint16_t nonAscii = vaddvq_u16(vandq_u16(vcgtq_u16(
in.val[0], maxAscii), mask1))
382 | vaddvq_u16(vandq_u16(vcgtq_u16(
in.val[1], maxAscii), mask2));
385 uint16x8_t
out = vsliq_n_u16(
in.val[0],
in.val[1], 8);
388 vst1q_u8(
dst, vreinterpretq_u8_u16(
out));
394 nextAscii =
src + qBitScanReverse(nonAscii) + 1;
408 uint8x8_t msb_mask = vdup_n_u8(0x80);
409 uint8x8_t add_mask = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 };
411 uint8x8_t
c = vld1_u8(
src);
412 uint8_t
n = vaddv_u8(vand_u8(vcge_u8(
c, msb_mask), add_mask));
415 vst1q_u16(
reinterpret_cast<uint16_t *
>(
dst), vmovl_u8(
c));
428 n = qBitScanReverse(
n);
429 nextAscii =
src +
n + 1;
444 uint8x8_t msb_mask = vdup_n_u8(0x80);
445 uint8x8_t add_mask = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 };
447 uint8x8_t
c = vld1_u8(
src);
448 uint8_t
n = vaddv_u8(vand_u8(vcge_u8(
c, msb_mask), add_mask));
455 nextAscii =
src + qBitScanReverse(
n) + 1;
464 static void simdCompareAscii(
const char8_t *&,
const char8_t *,
const char16_t *&,
const char16_t *)
468 static inline bool simdEncodeAscii(
uchar *,
const char16_t *,
const char16_t *,
const char16_t *)
473 static inline bool simdDecodeAscii(char16_t *,
const uchar *,
const uchar *,
const uchar *)
484 static void simdCompareAscii(
const char8_t *&,
const char8_t *,
const char16_t *&,
const char16_t *)
498 const char16_t *
src =
reinterpret_cast<const char16_t *
>(
in.data());
502 const char16_t *nextAscii =
end;
503 if (simdEncodeAscii(
dst, nextAscii,
src,
end))
508 int res = QUtf8Functions::toUtf8<QUtf8BaseTraits>(
u,
dst,
src,
end);
513 }
while (
src < nextAscii);
549 const char16_t *
src =
reinterpret_cast<const char16_t *
>(uc);
553 if (
state->remainingChars) {
557 state->state_data[0] = 0;
558 state->remainingChars = 0;
569 const char16_t *nextAscii =
end;
574 char16_t uc = *
src++;
575 int res = QUtf8Functions::toUtf8<QUtf8BaseTraits>(uc,
cursor,
src,
end);
581 ++
state->invalidChars;
585 ++
state->invalidChars;
588 state->remainingChars = 1;
589 state->state_data[0] = uc;
591 return reinterpret_cast<char *
>(
cursor);
593 }
while (
src < nextAscii);
596 return reinterpret_cast<char *
>(
cursor);
639 char16_t *
dst =
reinterpret_cast<char16_t *
>(
buffer);
646 if (!simdDecodeAscii(
dst, nextAscii,
src,
end)) {
657 if (simdDecodeAscii(
dst, nextAscii,
src,
end))
662 int res = QUtf8Functions::fromUtf8<QUtf8BaseTraits>(
b,
dst,
src,
end);
667 }
while (
src < nextAscii);
671 return reinterpret_cast<QChar *
>(
dst);
708 char16_t *
dst =
reinterpret_cast<char16_t *
>(
out);
714 if (
state->remainingChars || !headerdone) {
716 uchar remainingCharsData[4];
718 qsizetype newCharsToCopy = qMin<qsizetype>(
sizeof(remainingCharsData) - remainingCharsCount,
end -
src);
720 memset(remainingCharsData, 0,
sizeof(remainingCharsData));
721 memcpy(remainingCharsData, &
state->state_data[0], remainingCharsCount);
722 memcpy(remainingCharsData + remainingCharsCount,
src, newCharsToCopy);
725 res = QUtf8Functions::fromUtf8<QUtf8BaseTraits>(remainingCharsData[0],
dst,
begin,
726 static_cast<const uchar *
>(remainingCharsData) + remainingCharsCount + newCharsToCopy);
728 ++
state->invalidChars;
729 *
dst++ = replacement;
734 state->remainingChars = remainingCharsCount + newCharsToCopy;
735 memcpy(&
state->state_data[0], remainingCharsData,
state->remainingChars);
737 }
else if (!headerdone) {
739 if (
dst[-1] == 0xfeff)
747 src +=
res - remainingCharsCount;
752 if (
len > 2 &&
src[0] == utf8bom[0] &&
src[1] == utf8bom[1] &&
src[2] == utf8bom[2])
761 if (
src >= nextAscii && simdDecodeAscii(
dst, nextAscii,
src,
end))
765 res = QUtf8Functions::fromUtf8<QUtf8BaseTraits>(
ch,
dst,
src,
end);
768 ++
state->invalidChars;
769 *
dst++ = replacement;
777 ++
state->invalidChars;
780 ++
state->invalidChars;
782 state->remainingChars = 0;
789 state->remainingChars = 0;
792 return reinterpret_cast<QChar *
>(
dst);
807 bool isValidAscii =
true;
810 if (
src >= nextAscii)
811 src = simdFindNonAscii(
src,
end, nextAscii);
820 isValidAscii =
false;
822 int res = QUtf8Functions::fromUtf8<QUtf8NoOutputTraits>(
b, output,
src,
end);
825 return {
false,
false };
827 }
while (
src < nextAscii);
830 return {
true, isValidAscii };
835 auto src1 =
reinterpret_cast<const char8_t *
>(utf8.data());
836 auto end1 = src1 + utf8.size();
837 auto src2 =
reinterpret_cast<const char16_t *
>(utf16.data());
838 auto end2 = src2 + utf16.size();
841 simdCompareAscii(src1, end1, src2, end2);
843 if (src1 < end1 && src2 < end2) {
844 char32_t uc1 = *src1++;
845 char32_t uc2 = *src2++;
848 char32_t *output = &uc1;
849 int res = QUtf8Functions::fromUtf8<QUtf8BaseTraitsNoAscii>(uc1, output, src1, end1);
862 return int(uc1) - int(uc2);
864 }
while (src1 < end1 && src2 < end2);
867 return (end1 > src1) - int(end2 > src2);
873 auto src1 =
reinterpret_cast<const uchar *
>(utf8.
data());
874 auto end1 = src1 + utf8.
size();
875 auto src2 =
reinterpret_cast<const uchar *
>(
s.latin1());
876 auto end2 = src2 +
s.size();
878 while (src1 < end1 && src2 < end2) {
880 char32_t *output = &uc1;
881 int res = QUtf8Functions::fromUtf8<QUtf8BaseTraits>(
b, output, src1, end1);
887 char32_t uc2 = *src2++;
889 return int(uc1) - int(uc2);
893 return (end1 > src1) - (end2 > src2);
928 qToBigEndian<char16_t>(
in.data(),
in.length(),
out);
930 qToLittleEndian<char16_t>(
in.data(),
in.length(),
out);
932 state->remainingChars = 0;
934 return out + 2*
in.length();
948 const char *chars =
in.data();
955 const char *
end = chars +
len;
961 state->remainingChars = 1;
971 if (!headerdone ||
state->remainingChars) {
973 if (
state->remainingChars)
1005 qFromBigEndian<char16_t>(chars, nPairs,
out);
1007 qFromLittleEndian<char16_t>(chars, nPairs,
out);
1011 state->remainingChars = 0;
1012 if ((
end - chars) & 1) {
1016 state->remainingChars = 1;
1051 out[2] = (char)0xfe;
1052 out[3] = (char)0xff;
1054 out[0] = (char)0xff;
1055 out[1] = (char)0xfe;
1067 if (
state->remainingChars == 1) {
1068 auto character =
state->state_data[
Data];
1072 state->remainingChars = 0;
1073 goto decode_surrogate;
1079 ucs4 =
ch.unicode();
1086 state->remainingChars = 1;
1111 result.resize((
in.size() + 7) >> 1);
1120 const char *chars =
in.data();
1126 const char *
end = chars +
len;
1129 memcpy(tuple, &
state->state_data[
Data], 4);
1132 if (
state->remainingChars +
len < 4) {
1134 while (chars <
end) {
1135 tuple[
state->remainingChars] = *chars;
1136 ++
state->remainingChars;
1140 memcpy(&
state->state_data[
Data], tuple, 4);
1150 state->remainingChars = 0;
1154 tuple[
num++] = *chars++;
1157 if (tuple[0] == 0xff && tuple[1] == 0xfe && tuple[2] == 0 && tuple[3] == 0) {
1159 }
else if (tuple[0] == 0 && tuple[1] == 0 && tuple[2] == 0xfe && tuple[3] == 0xff) {
1167 char32_t
code = (endian ==
BigEndianness) ? qFromBigEndian<char32_t>(tuple) : qFromLittleEndian<char32_t>(tuple);
1183 while (chars <
end) {
1184 tuple[
num++] = *chars++;
1186 char32_t
code = (endian ==
BigEndianness) ? qFromBigEndian<char32_t>(tuple) : qFromLittleEndian<char32_t>(tuple);
1199 memcpy(&
state->state_data[
Data], tuple, 4);
1206 #if defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED)
1210 const char *chars =
in.data();
1222 copyLocation =
state->remainingChars;
1223 extra += copyLocation;
1226 char *mbcs =
new char[newLength];
1228 mbcs[newLength-1] = 0;
1229 mbcs[newLength-2] = 0;
1230 memcpy(&(mbcs[copyLocation]), chars,
length);
1233 mbcs[0] = (char)
state->state_data[0];
1234 state->remainingChars = 0;
1236 const char *mb = mbcs;
1237 const char *
next = 0;
1239 while ((
next = CharNextExA(CP_ACP, mb, 0)) != mb) {
1241 int charlength =
next - mb;
1242 int len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS, mb, charlength, wc, 2);
1246 int r = GetLastError();
1248 if (
r == ERROR_NO_UNICODE_TRANSLATION && mb == (mbcs+newLength -3) &&
state) {
1249 state->remainingChars = 1;
1250 state->state_data[0] = (char)*mb;
1265 const char *mb =
in.data();
1275 char state_data = 0;
1276 int remainingChars = 0;
1280 state_data = (char)
state->state_data[0];
1281 remainingChars =
state->remainingChars;
1285 if (
state && remainingChars) {
1287 prev[0] = state_data;
1290 len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
1291 prev, 2, wc.data(), wc.length());
1295 state->remainingChars = 0;
1305 while (!(
len=MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
1306 mb, mblen, wc.data(), wc.length()))) {
1307 int r = GetLastError();
1308 if (
r == ERROR_INSUFFICIENT_BUFFER) {
1309 const int wclen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
1312 }
else if (
r == ERROR_NO_UNICODE_TRANSLATION) {
1314 while (mblen > 1 && !(mb[mblen-1]))
1317 if ((mblen <= 1) || (remainingChars && state_data))
1318 return convertToUnicodeCharByChar(
in,
state);
1320 state_data = mb[mblen-1];
1325 qWarning(
"MultiByteToWideChar: Cannot convert multibyte text");
1338 state->state_data[0] = (char)state_data;
1339 state->remainingChars = remainingChars;
1366 while (!(
len=WideCharToMultiByte(CP_ACP, 0, (
const wchar_t*)
ch, uclen,
1367 mb.data(), mb.size()-1, 0, &used_def)))
1369 int r = GetLastError();
1370 if (
r == ERROR_INSUFFICIENT_BUFFER) {
1371 mb.resize(1+WideCharToMultiByte(CP_ACP, 0,
1372 (
const wchar_t*)
ch, uclen,
1373 0, 0, 0, &used_def));
1380 "WideCharToMultiByte: Cannot convert multibyte text (error %d): %ls\n",
1381 r,
reinterpret_cast<const wchar_t*
>(
QString(
ch, uclen).utf16()));
1470 return out +
in.size();
1487 *
out = (char)
in[
i].cell();
1492 state->invalidChars += invalid;
1499 memcpy(
out,
s.constData(),
s.length()*
sizeof(
QChar));
1500 return out +
s.length();
1506 memcpy(
out,
s.constData(),
s.length());
1507 return out +
s.length();
1654 {
"UTF-16LE", fromUtf16LE, fromUtf16Len, toUtf16LE, toUtf16Len },
1655 {
"UTF-16BE", fromUtf16BE, fromUtf16Len, toUtf16BE, toUtf16Len },
1656 {
"UTF-32", fromUtf32, fromUtf32Len, toUtf32, toUtf32Len },
1657 {
"UTF-32LE", fromUtf32LE, fromUtf32Len, toUtf32LE, toUtf32Len },
1658 {
"UTF-32BE", fromUtf32BE, fromUtf32Len, toUtf32BE, toUtf32Len },
1659 {
"ISO-8859-1", fromLatin1, fromLatin1Len, toLatin1, toLatin1Len },
1660 {
"Locale", fromLocal8Bit, fromUtf8Len, toLocal8Bit, toUtf8Len }
1664 static bool nameMatch(
const char *
a,
const char *
b)
1667 if (*
a ==
'-' || *
a ==
'_') {
1671 if (*
b ==
'-' || *
b ==
'_') {
1702 iface = encodingInterfaces + int(
e.value());
1746 if (nameMatch(encodingInterfaces[
i].
name,
name))
1749 if (nameMatch(
name,
"latin1"))
1751 return std::nullopt;
1765 if (arraySize > 3) {
1766 char32_t uc = qFromUnaligned<char32_t>(
data.data());
1771 if (expectedFirstCharacter) {
1780 if (arraySize > 2) {
1781 if (memcmp(
data.data(), utf8bom,
sizeof(utf8bom)) == 0)
1785 if (arraySize > 1) {
1786 char16_t uc = qFromUnaligned<char16_t>(
data.data());
1791 if (expectedFirstCharacter) {
1799 return std::nullopt;
1831 while (++pos2 <
header.size()) {
1833 if (
ch ==
'\"' ||
ch ==
'\'' ||
ch ==
'>' ||
ch ==
'/') {
1839 if (
name ==
"unicode")
1841 if (!
name.isEmpty())
1855 return encodingInterfaces[int(
e)].
name;
small capitals from c petite p scientific f u
small capitals from c petite p scientific i
[1]
The QByteArray class provides an array of bytes.
qsizetype size() const noexcept
const char * constData() const noexcept
void truncate(qsizetype pos)
constexpr qsizetype size() const noexcept
constexpr const_pointer data() const noexcept
The QChar class provides a 16-bit Unicode character.
static constexpr QChar fromUcs2(char16_t c) noexcept
static constexpr char32_t surrogateToUcs4(char16_t high, char16_t low) noexcept
static constexpr bool requiresSurrogates(char32_t ucs4) noexcept
static constexpr auto fromUcs4(char32_t c) noexcept
static constexpr char16_t highSurrogate(char32_t ucs4) noexcept
constexpr bool isLowSurrogate() const noexcept
static constexpr char16_t lowSurrogate(char32_t ucs4) noexcept
constexpr bool isHighSurrogate() const noexcept
The QLatin1String class provides a thin wrapper around an US-ASCII/Latin-1 encoded string literal.
static Q_CORE_EXPORT std::optional< Encoding > encodingForHtml(QByteArrayView data)
static Q_CORE_EXPORT const char * nameForEncoding(Encoding e)
static Q_CORE_EXPORT std::optional< Encoding > encodingForName(const char *name)
QSTRINGCONVERTER_CONSTEXPR QStringConverter()
static Q_CORE_EXPORT std::optional< Encoding > encodingForData(QByteArrayView data, char16_t expectedFirstCharacter=0)
The QString class provides a Unicode character string.
The QStringView class provides a unified view on UTF-16 strings with a read-only subset of the QStrin...
QTextStream & bom(QTextStream &stream)
constexpr Initialization Uninitialized
constexpr char toAsciiLower(char ch) noexcept
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro vuzp8 reg2 vuzp d d ®2 endm macro vzip8 reg2 vzip d d ®2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
[3]
QT_POPCOUNT_RELAXED_CONSTEXPR uint qCountLeadingZeroBits(quint32 v) noexcept
constexpr uint qCountTrailingZeroBits(quint32 v) noexcept
#define QByteArrayLiteral(str)
size_t qstrlen(const char *str)
constexpr QStaticByteArrayMatcher< N > qMakeStaticByteArrayMatcher(const char(&pattern)[N]) noexcept
typedef QByteArray(EGLAPIENTRYP PFNQGSGETDISPLAYSPROC)()
constexpr T qToBigEndian(T source)
constexpr T qToLittleEndian(T source)
QT_BEGIN_INCLUDE_NAMESPACE typedef unsigned char uchar
GLenum GLuint GLenum GLsizei length
GLboolean GLboolean GLboolean b
GLsizei const GLfloat * v
[13]
GLboolean GLboolean GLboolean GLboolean a
[7]
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLenum GLuint GLenum GLsizei const GLchar * buf
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
GLenum GLuint GLintptr offset
GLint GLint GLint GLint GLint GLint GLint GLbitfield mask
GLuint GLenum GLsizei GLsizei GLint GLint GLboolean packed
QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator begin(const QRegularExpressionMatchIterator &iterator)
void qt_from_latin1(char16_t *dst, const char *str, size_t size) noexcept
QTextStream out(stdout)
[7]
QHttpRequestHeader header("GET", QUrl::toPercentEncoding("/index.html"))
[1]
static QString convertToUnicode(QByteArrayView in, QStringConverter::State *state)
static QByteArray convertFromUnicode(QStringView in, QStringConverter::State *state)
Q_CORE_EXPORT void clear()
static Q_CORE_EXPORT QString convertToUnicode(QByteArrayView, QStringConverter::State *, DataEndianness=DetectEndianness)
static Q_CORE_EXPORT QByteArray convertFromUnicode(QStringView, QStringConverter::State *, DataEndianness=DetectEndianness)
static Q_CORE_EXPORT QByteArray convertFromUnicode(QStringView, QStringConverter::State *, DataEndianness=DetectEndianness)
static QChar * convertToUnicode(QChar *out, QByteArrayView, QStringConverter::State *state, DataEndianness endian)
static const int EndOfString
static Q_CORE_EXPORT QByteArray convertFromUnicode(QStringView in)
static ValidUtf8Result isValidUtf8(QByteArrayView in)
static Q_CORE_EXPORT QChar * convertToUnicode(QChar *buffer, QByteArrayView in) noexcept
static int compareUtf8(QByteArrayView utf8, QStringView utf16) noexcept
static void appendUtf16(const NoOutput &, char16_t)
static void appendUcs4(const NoOutput &, char32_t)