Revision control
++ // Copyright (C) 2020 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:critical reason:data-parser
++
++ #if 0
++ // keep existing syncqt header working after the move of the class
++ // into qstringconverter_base
++ #pragma qt_class(QStringConverter)
++ #endif
++
++ #ifndef QSTRINGCONVERTER_H
++ #define QSTRINGCONVERTER_H
++
++ #include <QtCore/qstringconverter_base.h>
++ #include <QtCore/qstring.h>
++ #include <QtCore/qstringbuilder.h>
++
++ QT_BEGIN_NAMESPACE
++
++ class QStringEncoder : public QStringConverter
++ {
++ protected:
++ constexpr explicit QStringEncoder(const Interface *i) noexcept
++ : QStringConverter(i)
++ {}
++ public:
++ constexpr QStringEncoder() noexcept
++ : QStringConverter()
++ {}
++ constexpr explicit QStringEncoder(Encoding encoding, Flags flags = Flag::Default)
++ : QStringConverter(encoding, flags)
++ {}
++ explicit QStringEncoder(QAnyStringView name, Flags flags = Flag::Default)
++ : QStringConverter(name, flags)
++ {}
++
++ template<typename T>
++ struct DecodedData
++ {
++ QStringEncoder *encoder;
++ T data;
++ operator QByteArray() const { return encoder->encodeAsByteArray(data); }
++ };
++ Q_WEAK_OVERLOAD
++ DecodedData<const QString &> operator()(const QString &str)
++ { return DecodedData<const QString &>{this, str}; }
++ DecodedData<QStringView> operator()(QStringView in)
++ { return DecodedData<QStringView>{this, in}; }
++ Q_WEAK_OVERLOAD
++ DecodedData<const QString &> encode(const QString &str)
++ { return DecodedData<const QString &>{this, str}; }
++ DecodedData<QStringView> encode(QStringView in)
++ { return DecodedData<QStringView>{this, in}; }
++
++ qsizetype requiredSpace(qsizetype inputLength) const
++ { return iface ? iface->fromUtf16Len(inputLength) : 0; }
++ char *appendToBuffer(char *out, QStringView in)
++ {
++ if (!iface) {
++ state.invalidChars = 1;
++ return out;
++ }
++ return iface->fromUtf16(out, in, &state);
++ }
++
++ using FinalizeResult = FinalizeResultChar<char>;
++ [[nodiscard]] Q_CORE_EXPORT FinalizeResult finalize(char *out, qsizetype maxlen);
++ [[nodiscard]] FinalizeResult finalize() { return finalize(nullptr, 0); }
++
++ private:
++ QByteArray invalidateAndReturnNull()
++ {
++ // ensure that hasError returns true
++ state.invalidChars = 1;
++ return QByteArray();
++ }
++ QByteArray encodeAsByteArrayImpl(QStringView in)
++ {
++ QByteArray result(iface->fromUtf16Len(in.size()), Qt::Uninitialized);
++ char *out = result.data();
++ out = iface->fromUtf16(out, in, &state);
++ result.truncate(out - result.constData());
++ return result;
++ }
++ QByteArray encodeAsByteArray(QStringView in)
++ {
++ return iface ? encodeAsByteArrayImpl(in) : invalidateAndReturnNull();
++ }
++ };
++
++ class QStringDecoder : public QStringConverter
++ {
++ protected:
++ constexpr explicit QStringDecoder(const Interface *i) noexcept
++ : QStringConverter(i)
++ {}
++ public:
++ constexpr explicit QStringDecoder(Encoding encoding, Flags flags = Flag::Default)
++ : QStringConverter(encoding, flags)
++ {}
++ constexpr QStringDecoder() noexcept
++ : QStringConverter()
++ {}
++ explicit QStringDecoder(QAnyStringView name, Flags f = Flag::Default)
++ : QStringConverter(name, f)
++ {}
++
++ template<typename T>
++ struct EncodedData
++ {
++ QStringDecoder *decoder;
++ T data;
++ operator QString() const { return decoder->decodeAsString(data); }
++ };
++ Q_WEAK_OVERLOAD
++ EncodedData<const QByteArray &> operator()(const QByteArray &ba)
++ { return EncodedData<const QByteArray &>{this, ba}; }
++ EncodedData<QByteArrayView> operator()(QByteArrayView ba)
++ { return EncodedData<QByteArrayView>{this, ba}; }
++ Q_WEAK_OVERLOAD
++ EncodedData<const QByteArray &> decode(const QByteArray &ba)
++ { return EncodedData<const QByteArray &>{this, ba}; }
++ EncodedData<QByteArrayView> decode(QByteArrayView ba)
++ { return EncodedData<QByteArrayView>{this, ba}; }
++
++ qsizetype requiredSpace(qsizetype inputLength) const
++ { return iface ? iface->toUtf16Len(inputLength) : 0; }
++ QChar *appendToBuffer(QChar *out, QByteArrayView ba)
++ {
++ if (!iface) {
++ state.invalidChars = 1;
++ return out;
++ }
++ return iface->toUtf16(out, ba, &state);
++ }
++ char16_t *appendToBuffer(char16_t *out, QByteArrayView ba)
++ { return reinterpret_cast<char16_t *>(appendToBuffer(reinterpret_cast<QChar *>(out), ba)); }
++
++
++ using FinalizeResult = FinalizeResultChar<char16_t>;
++ using FinalizeResultQChar = FinalizeResultChar<QChar>;
++ [[nodiscard]] FinalizeResultQChar finalize(QChar *out, qsizetype maxlen)
++ {
++ auto r = finalize(reinterpret_cast<char16_t *>(out), maxlen);
++ return {reinterpret_cast<QChar *>(r.next), r.invalidChars, r.error};
++ }
++ [[nodiscard]] Q_CORE_EXPORT FinalizeResult finalize(char16_t *out, qsizetype maxlen);
++ [[nodiscard]] FinalizeResult finalize()
++ {
++ return finalize(static_cast<char16_t *>(nullptr), 0);
++ }
++
++ Q_CORE_EXPORT static QStringDecoder decoderForHtml(QByteArrayView data);
++
++ private:
++ QString invalidateAndReturnNull()
++ {
++ // ensure that hasError returns true
++ state.invalidChars = 1;
++ return QString();
++ }
++ QString decodeAsStringImpl(QByteArrayView in)
++ {
++ QString result(iface->toUtf16Len(in.size()), Qt::Uninitialized);
++ const QChar *out = iface->toUtf16(result.data(), in, &state);
++ result.truncate(out - result.constData());
++ return result;
++ }
++ QString decodeAsString(QByteArrayView in)
++ {
++ return iface ? decodeAsStringImpl(in) : invalidateAndReturnNull();
++ }
++ };
++
++
++ #if defined(QT_USE_FAST_OPERATOR_PLUS) || defined(QT_USE_QSTRINGBUILDER)
++ template <typename T>
++ struct QConcatenable<QStringDecoder::EncodedData<T>>
++ : private QAbstractConcatenable
++ {
++ typedef QChar type;
++ typedef QString ConvertTo;
++ enum { ExactSize = false };
++ static qsizetype size(const QStringDecoder::EncodedData<T> &s) { return s.decoder->requiredSpace(s.data.size()); }
++ static inline void appendTo(const QStringDecoder::EncodedData<T> &s, QChar *&out)
++ {
++ out = s.decoder->appendToBuffer(out, s.data);
++ }
++ };
++
++ template <typename T>
++ struct QConcatenable<QStringEncoder::DecodedData<T>>
++ : private QAbstractConcatenable
++ {
++ typedef char type;
++ typedef QByteArray ConvertTo;
++ enum { ExactSize = false };
++ static qsizetype size(const QStringEncoder::DecodedData<T> &s) { return s.encoder->requiredSpace(s.data.size()); }
++ static inline void appendTo(const QStringEncoder::DecodedData<T> &s, char *&out)
++ {
++ out = s.encoder->appendToBuffer(out, s.data);
++ }
++ };
++
++ template <typename T>
++ QString &operator+=(QString &a, const QStringDecoder::EncodedData<T> &b)
++ {
++ qsizetype len = a.size() + QConcatenable<QStringDecoder::EncodedData<T>>::size(b);
++ a.reserve(len);
++ QChar *it = a.data() + a.size();
++ QConcatenable<QStringDecoder::EncodedData<T>>::appendTo(b, it);
++ a.resize(qsizetype(it - a.constData())); //may be smaller than len
++ return a;
++ }
++
++ template <typename T>
++ QByteArray &operator+=(QByteArray &a, const QStringEncoder::DecodedData<T> &b)
++ {
++ qsizetype len = a.size() + QConcatenable<QStringEncoder::DecodedData<T>>::size(b);
++ a.reserve(len);
++ char *it = a.data() + a.size();
++ QConcatenable<QStringEncoder::DecodedData<T>>::appendTo(b, it);
++ a.resize(qsizetype(it - a.constData())); //may be smaller than len
++ return a;
++ }
++ #endif
++
++ template <typename InputIterator>
++ void QString::assign_helper_char8(InputIterator first, InputIterator last)
++ {
++ static_assert(!QString::is_contiguous_iterator_v<InputIterator>,
++ "Internal error: Should have been handed over to the QAnyStringView overload."
++ );
++
++ using ValueType = typename std::iterator_traits<InputIterator>::value_type;
++ constexpr bool IsFwdIt = std::is_convertible_v<
++ typename std::iterator_traits<InputIterator>::iterator_category,
++ std::forward_iterator_tag
++ >;
++
++ resize(0);
++ // In case of not being shared, there is the possibility of having free space at begin
++ // even after the resize to zero.
++ if (const auto offset = d.freeSpaceAtBegin())
++ d.setBegin(d.begin() - offset);
++
++ if constexpr (IsFwdIt)
++ reserve(static_cast<qsizetype>(std::distance(first, last)));
++
++ auto toUtf16 = QStringDecoder(QStringDecoder::Utf8);
++ auto availableCapacity = d.constAllocatedCapacity();
++ auto *dst = d.data();
++ auto *dend = d.data() + availableCapacity;
++
++ while (true) {
++ if (first == last) { // ran out of input elements
++ Q_ASSERT(!std::less<>{}(dend, dst));
++ d.size = dst - d.begin();
++ return;
++ }
++ const ValueType next = *first; // decays proxies, if any
++ const auto chunk = QUtf8StringView(&next, 1);
++ // UTF-8 characters can have a maximum size of 4 bytes and may result in a surrogate
++ // pair of UTF-16 code units. In the input-iterator case, we don't know the size
++ // and would need to always reserve space for 2 code units. To keep our promise
++ // of 'not allocating if it fits', we have to pre-check this condition.
++ // We know that it fits in the forward-iterator case.
++ if constexpr (!IsFwdIt) {
++ constexpr qsizetype Pair = 2;
++ char16_t buf[Pair];
++ const qptrdiff n = toUtf16.appendToBuffer(buf, chunk) - buf;
++ if (dend - dst < n) { // ran out of allocated memory
++ const auto offset = dst - d.begin();
++ reallocData(d.constAllocatedCapacity() + Pair, QArrayData::Grow);
++ // update the pointers since we've re-allocated
++ availableCapacity = d.constAllocatedCapacity();
++ dst = d.data() + offset;
++ dend = d.data() + availableCapacity;
++ }
++ dst = std::copy_n(buf, n, dst);
++ } else { // take the fast path
++ dst = toUtf16.appendToBuffer(dst, chunk);
++ }
++ ++first;
++ }
++ }
++
++ QT_END_NAMESPACE
++
++ #endif