qxmlstream.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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
 
#include "QtCore/qxmlstream.h"
 
#if QT_CONFIG(xmlstream)
 
#include "qxmlutils_p.h"
#include <qdebug.h>
#include <qfile.h>
#include <stdio.h>
#include <qstringconverter.h>
#include <qstack.h>
#include <qbuffer.h>
#include <qscopeguard.h>
#include <qcoreapplication.h>
 
#include <private/qoffsetstringarray_p.h>
#include <private/qtools_p.h>
 
#include <iterator>
#include "qxmlstream_p.h"
#include "qxmlstreamparser_p.h"
#include <private/qstringconverter_p.h>
 
QT_BEGIN_NAMESPACE
 
using namespace QtPrivate;
using namespace Qt::StringLiterals;
using namespace QtMiscUtils;
 
enum { StreamEOF = ~0U };
 
namespace {
template <typename Range>
auto reversed(Range &r)
{
    struct R {
        Range *r;
        auto begin() { return std::make_reverse_iterator(std::end(*r)); }
        auto end() { return std::make_reverse_iterator(std::begin(*r)); }
    };
 
    return R{&r};
}
 
template <typename Range>
void reversed(const Range &&) = delete;
 
// implementation of missing QUtf8StringView methods for ASCII-only needles:
auto transform(QLatin1StringView haystack, char needle)
{
    struct R { QLatin1StringView haystack; char16_t needle; };
    return R{haystack, uchar(needle)};
}
 
auto transform(QStringView haystack, char needle)
{
    struct R { QStringView haystack; char16_t needle; };
    return R{haystack, uchar(needle)};
}
 
auto transform(QUtf8StringView haystack, char needle)
{
    struct R { QByteArrayView haystack; char needle; };
    return R{haystack, needle};
}
 
auto transform(QLatin1StringView haystack, QLatin1StringView needle)
{
    struct R { QLatin1StringView haystack; QLatin1StringView needle; };
    return R{haystack, needle};
}
 
auto transform(QStringView haystack, QLatin1StringView needle)
{
    struct R { QStringView haystack; QLatin1StringView needle; };
    return R{haystack, needle};
}
 
auto transform(QUtf8StringView haystack, QLatin1StringView needle)
{
    struct R { QLatin1StringView haystack; QLatin1StringView needle; };
    return R{QLatin1StringView{QByteArrayView{haystack}}, needle};
}
 
#define WRAP(method, Needle)                               \
    auto method (QAnyStringView s, Needle needle) noexcept \
    {                                                      \
        return s.visit([needle](auto s) {                  \
            auto r = transform(s, needle);                 \
            return r.haystack. method (r.needle);          \
        });                                                \
    }                                                      \
    /*end*/
 
WRAP(count, char)
WRAP(contains, char)
WRAP(contains, QLatin1StringView)
WRAP(endsWith, char)
WRAP(indexOf, QLatin1StringView)
 
} // unnamed namespace
 
QXmlStreamEntityResolver::~QXmlStreamEntityResolver()
{
}
 
QString QXmlStreamEntityResolver::resolveEntity(const QString& /*publicId*/, const QString& /*systemId*/)
{
    return QString();
}
 
 
QString QXmlStreamEntityResolver::resolveUndeclaredEntity(const QString &/*name*/)
{
    return QString();
}
 
#if QT_CONFIG(xmlstreamreader)
 
QString QXmlStreamReaderPrivate::resolveUndeclaredEntity(const QString &name)
{
    if (entityResolver)
        return entityResolver->resolveUndeclaredEntity(name);
    return QString();
}
 
 
 
void QXmlStreamReader::setEntityResolver(QXmlStreamEntityResolver *resolver)
{
    Q_D(QXmlStreamReader);
    d->entityResolver = resolver;
}
 
QXmlStreamEntityResolver *QXmlStreamReader::entityResolver() const
{
    Q_D(const QXmlStreamReader);
    return d->entityResolver;
}
 
 
 
QXmlStreamReader::QXmlStreamReader()
    : d_ptr(new QXmlStreamReaderPrivate(this))
{
}
 
QXmlStreamReader::QXmlStreamReader(QIODevice *device)
    : d_ptr(new QXmlStreamReaderPrivate(this))
{
    setDevice(device);
}
 
QXmlStreamReader::QXmlStreamReader(QAnyStringView data)
    : d_ptr(new QXmlStreamReaderPrivate(this))
{
    Q_D(QXmlStreamReader);
    data.visit([d](auto data) {
        if constexpr (std::is_same_v<decltype(data), QStringView>) {
            d->dataBuffer = data.toUtf8();
            d->decoder = QStringDecoder(QStringDecoder::Utf8);
            d->lockEncoding = true;
        } else if constexpr (std::is_same_v<decltype(data), QLatin1StringView>) {
            // Conversion to a QString is required, to avoid breaking
            // pre-existing (before porting to QAnyStringView) behavior.
            d->dataBuffer = QString::fromLatin1(data).toUtf8();
            d->decoder = QStringDecoder(QStringDecoder::Utf8);
            d->lockEncoding = true;
        } else {
            d->dataBuffer = QByteArray(data.data(), data.size());
        }
    });
}
 
QXmlStreamReader::QXmlStreamReader(const QByteArray &data, PrivateConstructorTag)
    : d_ptr(new QXmlStreamReaderPrivate(this))
{
    Q_D(QXmlStreamReader);
    d->dataBuffer = data;
}
 
QXmlStreamReader::~QXmlStreamReader()
{
    Q_D(QXmlStreamReader);
    if (d->deleteDevice)
        delete d->device;
}
 
void QXmlStreamReader::setDevice(QIODevice *device)
{
    Q_D(QXmlStreamReader);
    if (d->deleteDevice) {
        delete d->device;
        d->deleteDevice = false;
    }
    d->device = device;
    d->init();
 
}
 
QIODevice *QXmlStreamReader::device() const
{
    Q_D(const QXmlStreamReader);
    return d->device;
}
 
void QXmlStreamReader::addData(QAnyStringView data)
{
    Q_D(QXmlStreamReader);
    data.visit([this, d](auto data) {
        if constexpr (std::is_same_v<decltype(data), QStringView>) {
            d->lockEncoding = true;
            if (!d->decoder.isValid())
                d->decoder = QStringDecoder(QStringDecoder::Utf8);
            addDataImpl(data.toUtf8());
        } else if constexpr (std::is_same_v<decltype(data), QLatin1StringView>) {
            // Conversion to a QString is required, to avoid breaking
            // pre-existing (before porting to QAnyStringView) behavior.
            if (!d->decoder.isValid())
                d->decoder = QStringDecoder(QStringDecoder::Utf8);
            addDataImpl(QString::fromLatin1(data).toUtf8());
        } else {
            addDataImpl(QByteArray(data.data(), data.size()));
        }
    });
}
 
void QXmlStreamReader::addDataImpl(const QByteArray &data)
{
    Q_D(QXmlStreamReader);
    if (d->device) {
        qWarning("QXmlStreamReader: addData() with device()");
        return;
    }
    d->dataBuffer += data;
}
 
void QXmlStreamReader::clear()
{
    Q_D(QXmlStreamReader);
    d->init();
    if (d->device) {
        if (d->deleteDevice)
            delete d->device;
        d->device = nullptr;
    }
}
 
bool QXmlStreamReader::atEnd() const
{
    Q_D(const QXmlStreamReader);
    if (d->atEnd
        && ((d->type == QXmlStreamReader::Invalid && d->error == PrematureEndOfDocumentError)
            || (d->type == QXmlStreamReader::EndDocument))) {
        if (d->device)
            return d->device->atEnd();
        else
            return !d->dataBuffer.size();
    }
    return (d->atEnd || d->type == QXmlStreamReader::Invalid);
}
 
 
QXmlStreamReader::TokenType QXmlStreamReader::readNext()
{
    Q_D(QXmlStreamReader);
    if (d->type != Invalid) {
        if (!d->hasCheckedStartDocument)
            if (!d->checkStartDocument())
                return d->type; // synthetic StartDocument or error
        d->parse();
        if (d->atEnd && d->type != EndDocument && d->type != Invalid)
            d->raiseError(PrematureEndOfDocumentError);
        else if (!d->atEnd && d->type == EndDocument)
            d->raiseWellFormedError(QXmlStream::tr("Extra content at end of document."));
    } else if (d->error == PrematureEndOfDocumentError) {
        // resume error
        d->type = NoToken;
        d->atEnd = false;
        d->token = -1;
        return readNext();
    }
    d->checkToken();
    return d->type;
}
 
 
QXmlStreamReader::TokenType QXmlStreamReader::tokenType() const
{
    Q_D(const QXmlStreamReader);
    return d->type;
}
 
bool QXmlStreamReader::readNextStartElement()
{
    while (readNext() != Invalid) {
        if (isEndElement())
            return false;
        else if (isStartElement())
            return true;
    }
    return false;
}
 
void QXmlStreamReader::skipCurrentElement()
{
    int depth = 1;
    while (depth && readNext() != Invalid) {
        if (isEndElement())
            --depth;
        else if (isStartElement())
            ++depth;
    }
}
 
static constexpr auto QXmlStreamReader_tokenTypeString = qOffsetStringArray(
    "NoToken",
    "Invalid",
    "StartDocument",
    "EndDocument",
    "StartElement",
    "EndElement",
    "Characters",
    "Comment",
    "DTD",
    "EntityReference",
    "ProcessingInstruction"
);
 
static constexpr auto QXmlStreamReader_XmlContextString = qOffsetStringArray(
    "Prolog",
    "Body"
);
 
void QXmlStreamReader::setNamespaceProcessing(bool enable)
{
    Q_D(QXmlStreamReader);
    d->namespaceProcessing = enable;
}
 
bool QXmlStreamReader::namespaceProcessing() const
{
    Q_D(const QXmlStreamReader);
    return d->namespaceProcessing;
}
 
QString QXmlStreamReader::tokenString() const
{
    Q_D(const QXmlStreamReader);
    return QLatin1StringView(QXmlStreamReader_tokenTypeString.at(d->type));
}
 
static constexpr QLatin1StringView contextString(QXmlStreamReaderPrivate::XmlContext ctxt)
{
    return QLatin1StringView(QXmlStreamReader_XmlContextString.at(static_cast<int>(ctxt)));
}
 
#endif // feature xmlstreamreader
 
QXmlStreamPrivateTagStack::QXmlStreamPrivateTagStack()
{
    tagStack.reserve(16);
    tagStackStringStorage.reserve(32);
    tagStackStringStorageSize = 0;
    NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
    namespaceDeclaration.prefix = addToStringStorage(u"xml");
    namespaceDeclaration.namespaceUri = addToStringStorage(u"http://www.w3.org/XML/1998/namespace");
    initialTagStackStringStorageSize = tagStackStringStorageSize;
    tagsDone = false;
}
 
#if QT_CONFIG(xmlstreamreader)
 
QXmlStreamReaderPrivate::QXmlStreamReaderPrivate(QXmlStreamReader *q)
    :q_ptr(q)
{
    device = nullptr;
    deleteDevice = false;
    stack_size = 64;
    sym_stack = nullptr;
    state_stack = nullptr;
    reallocateStack();
    entityResolver = nullptr;
    init();
#define ADD_PREDEFINED(n, v) \
    do { \
        Entity e = Entity::createLiteral(n##_L1, v##_L1); \
        entityHash.insert(qToStringViewIgnoringNull(e.name), std::move(e)); \
    } while (false)
    ADD_PREDEFINED("lt", "<");
    ADD_PREDEFINED("gt", ">");
    ADD_PREDEFINED("amp", "&");
    ADD_PREDEFINED("apos", "'");
    ADD_PREDEFINED("quot", "\"");
#undef ADD_PREDEFINED
}
 
void QXmlStreamReaderPrivate::init()
{
    scanDtd = false;
    lastAttributeIsCData = false;
    token = -1;
    token_char = 0;
    isEmptyElement = false;
    isWhitespace = true;
    isCDATA = false;
    standalone = false;
    hasStandalone = false;
    tos = 0;
    resumeReduction = 0;
    state_stack[tos++] = 0;
    state_stack[tos] = 0;
    putStack.clear();
    putStack.reserve(32);
    textBuffer.clear();
    textBuffer.reserve(256);
    tagStack.clear();
    tagsDone = false;
    attributes.clear();
    attributes.reserve(16);
    lineNumber = lastLineStart = characterOffset = 0;
    readBufferPos = 0;
    nbytesread = 0;
    decoder = QStringDecoder();
    attributeStack.clear();
    attributeStack.reserve(16);
    entityParser.reset();
    hasCheckedStartDocument = false;
    normalizeLiterals = false;
    hasSeenTag = false;
    atEnd = false;
    inParseEntity = false;
    referenceToUnparsedEntityDetected = false;
    referenceToParameterEntityDetected = false;
    hasExternalDtdSubset = false;
    lockEncoding = false;
    namespaceProcessing = true;
    rawReadBuffer.clear();
    dataBuffer.clear();
    readBuffer.clear();
    tagStackStringStorageSize = initialTagStackStringStorageSize;
 
    type = QXmlStreamReader::NoToken;
    error = QXmlStreamReader::NoError;
    currentContext = XmlContext::Prolog;
    foundDTD = false;
}
 
/*
  Well-formed requires that we verify entity values. We do this with a
  standard parser.
 */
void QXmlStreamReaderPrivate::parseEntity(const QString &value)
{
    Q_Q(QXmlStreamReader);
 
    if (value.isEmpty())
        return;
 
 
    if (!entityParser)
        entityParser = std::make_unique<QXmlStreamReaderPrivate>(q);
    else
        entityParser->init();
    entityParser->inParseEntity = true;
    entityParser->readBuffer = value;
    entityParser->injectToken(PARSE_ENTITY);
    while (!entityParser->atEnd && entityParser->type != QXmlStreamReader::Invalid)
        entityParser->parse();
    if (entityParser->type == QXmlStreamReader::Invalid || entityParser->tagStack.size())
        raiseWellFormedError(QXmlStream::tr("Invalid entity value."));
 
}
 
inline void QXmlStreamReaderPrivate::reallocateStack()
{
    stack_size <<= 1;
    sym_stack = reinterpret_cast<Value*> (realloc(sym_stack, stack_size * sizeof(Value)));
    Q_CHECK_PTR(sym_stack);
    state_stack = reinterpret_cast<int*> (realloc(state_stack, stack_size * sizeof(int)));
    Q_CHECK_PTR(state_stack);
}
 
 
QXmlStreamReaderPrivate::~QXmlStreamReaderPrivate()
{
    free(sym_stack);
    free(state_stack);
}
 
 
inline uint QXmlStreamReaderPrivate::filterCarriageReturn()
{
    uint peekc = peekChar();
    if (peekc == '\n') {
        if (putStack.size())
            putStack.pop();
        else
            ++readBufferPos;
        return peekc;
    }
    if (peekc == StreamEOF) {
        putChar('\r');
        return 0;
    }
    return '\n';
}
 
inline uint QXmlStreamReaderPrivate::getChar()
{
    uint c;
    if (putStack.size()) {
        c = atEnd ? StreamEOF : putStack.pop();
    } else {
        if (readBufferPos < readBuffer.size())
            c = readBuffer.at(readBufferPos++).unicode();
        else
            c = getChar_helper();
    }
 
    return c;
}
 
inline uint QXmlStreamReaderPrivate::peekChar()
{
    uint c;
    if (putStack.size()) {
        c = putStack.top();
    } else if (readBufferPos < readBuffer.size()) {
        c = readBuffer.at(readBufferPos).unicode();
    } else {
        if ((c = getChar_helper()) != StreamEOF)
            --readBufferPos;
    }
 
    return c;
}
 
bool QXmlStreamReaderPrivate::scanUntil(const char *str, short tokenToInject)
{
    const qsizetype pos = textBuffer.size();
    const auto oldLineNumber = lineNumber;
 
    uint c;
    while ((c = getChar()) != StreamEOF) {
        /* First, we do the validation & normalization. */
        switch (c) {
        case '\r':
            if ((c = filterCarriageReturn()) == 0)
                break;
            Q_FALLTHROUGH();
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            Q_FALLTHROUGH();
        case '\t':
            textBuffer += QChar(c);
            continue;
        default:
            if (c < 0x20 || (c > 0xFFFD && c < 0x10000) || c > QChar::LastValidCodePoint ) {
                raiseWellFormedError(QXmlStream::tr("Invalid XML character."));
                lineNumber = oldLineNumber;
                return false;
            }
            textBuffer += QChar(c);
        }
 
 
        /* Second, attempt to lookup str. */
        if (c == uint(*str)) {
            if (!*(str + 1)) {
                if (tokenToInject >= 0)
                    injectToken(tokenToInject);
                return true;
            } else {
                if (scanString(str + 1, tokenToInject, false))
                    return true;
            }
        }
    }
    putString(textBuffer, pos);
    textBuffer.resize(pos);
    lineNumber = oldLineNumber;
    return false;
}
 
bool QXmlStreamReaderPrivate::scanString(const char *str, short tokenToInject, bool requireSpace)
{
    qsizetype n = 0;
    while (str[n]) {
        uint c = getChar();
        if (c != ushort(str[n])) {
            if (c != StreamEOF)
                putChar(c);
            while (n--) {
                putChar(ushort(str[n]));
            }
            return false;
        }
        ++n;
    }
    textBuffer += QLatin1StringView(str, n);
    if (requireSpace) {
        const qsizetype s = fastScanSpace();
        if (!s || atEnd) {
            qsizetype pos = textBuffer.size() - n - s;
            putString(textBuffer, pos);
            textBuffer.resize(pos);
            return false;
        }
    }
    if (tokenToInject >= 0)
        injectToken(tokenToInject);
    return true;
}
 
bool QXmlStreamReaderPrivate::scanAfterLangleBang()
{
    switch (peekChar()) {
    case '[':
        return scanString(spell[CDATA_START], CDATA_START, false);
    case 'D':
        return scanString(spell[DOCTYPE], DOCTYPE);
    case 'A':
        return scanString(spell[ATTLIST], ATTLIST);
    case 'N':
        return scanString(spell[NOTATION], NOTATION);
    case 'E':
        if (scanString(spell[ELEMENT], ELEMENT))
            return true;
        return scanString(spell[ENTITY], ENTITY);
 
    default:
        ;
    };
    return false;
}
 
bool QXmlStreamReaderPrivate::scanPublicOrSystem()
{
    switch (peekChar()) {
    case 'S':
        return scanString(spell[SYSTEM], SYSTEM);
    case 'P':
        return scanString(spell[PUBLIC], PUBLIC);
    default:
        ;
    }
    return false;
}
 
bool QXmlStreamReaderPrivate::scanNData()
{
    if (fastScanSpace()) {
        if (scanString(spell[NDATA], NDATA))
            return true;
        putChar(' ');
    }
    return false;
}
 
bool QXmlStreamReaderPrivate::scanAfterDefaultDecl()
{
    switch (peekChar()) {
    case 'R':
        return scanString(spell[REQUIRED], REQUIRED, false);
    case 'I':
        return scanString(spell[IMPLIED], IMPLIED, false);
    case 'F':
        return scanString(spell[FIXED], FIXED, false);
    default:
        ;
    }
    return false;
}
 
bool QXmlStreamReaderPrivate::scanAttType()
{
    switch (peekChar()) {
    case 'C':
        return scanString(spell[CDATA], CDATA);
    case 'I':
        if (scanString(spell[ID], ID))
            return true;
        if (scanString(spell[IDREF], IDREF))
            return true;
        return scanString(spell[IDREFS], IDREFS);
    case 'E':
        if (scanString(spell[ENTITY], ENTITY))
            return true;
        return scanString(spell[ENTITIES], ENTITIES);
    case 'N':
        if (scanString(spell[NOTATION], NOTATION))
            return true;
        if (scanString(spell[NMTOKEN], NMTOKEN))
            return true;
        return scanString(spell[NMTOKENS], NMTOKENS);
    default:
        ;
    }
    return false;
}
 
inline qsizetype QXmlStreamReaderPrivate::fastScanLiteralContent()
{
    qsizetype n = 0;
    uint c;
    while ((c = getChar()) != StreamEOF) {
        switch (ushort(c)) {
        case 0xfffe:
        case 0xffff:
        case 0:
            /* The putChar() call is necessary so the parser re-gets
             * the character from the input source, when raising an error. */
            putChar(c);
            return n;
        case '\r':
            if (filterCarriageReturn() == 0)
                return n;
            Q_FALLTHROUGH();
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            Q_FALLTHROUGH();
        case ' ':
        case '\t':
            if (normalizeLiterals)
                textBuffer += u' ';
            else
                textBuffer += QChar(c);
            ++n;
            break;
        case '&':
        case '<':
        case '\"':
        case '\'':
            if (!(c & 0xff0000)) {
                putChar(c);
                return n;
            }
            Q_FALLTHROUGH();
        default:
            if (c < 0x20) {
                putChar(c);
                return n;
            }
            textBuffer += QChar(ushort(c));
            ++n;
        }
    }
    return n;
}
 
inline qsizetype QXmlStreamReaderPrivate::fastScanSpace()
{
    qsizetype n = 0;
    uint c;
    while ((c = getChar()) != StreamEOF) {
        switch (c) {
        case '\r':
            if ((c = filterCarriageReturn()) == 0)
                return n;
            Q_FALLTHROUGH();
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            Q_FALLTHROUGH();
        case ' ':
        case '\t':
            textBuffer += QChar(c);
            ++n;
            break;
        default:
            putChar(c);
            return n;
        }
    }
    return n;
}
 
inline qsizetype QXmlStreamReaderPrivate::fastScanContentCharList()
{
    qsizetype n = 0;
    uint c;
    while ((c = getChar()) != StreamEOF) {
        switch (ushort(c)) {
        case 0xfffe:
        case 0xffff:
        case 0:
            putChar(c);
            return n;
        case ']': {
            isWhitespace = false;
            const qsizetype pos = textBuffer.size();
            textBuffer += QChar(ushort(c));
            ++n;
            while ((c = getChar()) == ']') {
                textBuffer += QChar(ushort(c));
                ++n;
            }
            if (c == 0) {
                putString(textBuffer, pos);
                textBuffer.resize(pos);
            } else if (c == '>' && textBuffer.at(textBuffer.size() - 2) == u']') {
                raiseWellFormedError(QXmlStream::tr("Sequence ']]>' not allowed in content."));
            } else {
                putChar(c);
                break;
            }
            return n;
        } break;
        case '\r':
            if ((c = filterCarriageReturn()) == 0)
                return n;
            Q_FALLTHROUGH();
        case '\n':
            ++lineNumber;
            lastLineStart = characterOffset + readBufferPos;
            Q_FALLTHROUGH();
        case ' ':
        case '\t':
            textBuffer += QChar(ushort(c));
            ++n;
            break;
        case '&':
        case '<':
            if (!(c & 0xff0000)) {
                putChar(c);
                return n;
            }
            Q_FALLTHROUGH();
        default:
            if (c < 0x20) {
                putChar(c);
                return n;
            }
            isWhitespace = false;
            textBuffer += QChar(ushort(c));
            ++n;
        }
    }
    return n;
}
 
// Fast scan an XML attribute name (e.g. "xml:lang").
inline std::optional<qsizetype> QXmlStreamReaderPrivate::fastScanName(Value *val)
{
    qsizetype n = 0;
    uint c;
    while ((c = getChar()) != StreamEOF) {
        if (n >= 4096) {
            // This is too long to be a sensible name, and
            // can exhaust memory, or the range of decltype(*prefix)
            raiseNamePrefixTooLongError();
            return std::nullopt;
        }
        switch (c) {
        case '\n':
        case ' ':
        case '\t':
        case '\r':
        case '&':
        case '#':
        case '\'':
        case '\"':
        case '<':
        case '>':
        case '[':
        case ']':
        case '=':
        case '%':
        case '/':
        case ';':
        case '?':
        case '!':
        case '^':
        case '|':
        case ',':
        case '(':
        case ')':
        case '+':
        case '*':
            putChar(c);
            if (val && val->prefix == n + 1) {
                val->prefix = 0;
                putChar(':');
                --n;
            }
            return n;
        case ':':
            if (val) {
                if (val->prefix == 0) {
                    val->prefix = qint16(n + 2);
                } else { // only one colon allowed according to the namespace spec.
                    putChar(c);
                    return n;
                }
            } else {
                putChar(c);
                return n;
            }
            Q_FALLTHROUGH();
        default:
            textBuffer += QChar(ushort(c));
            ++n;
        }
    }
 
    if (val)
        val->prefix = 0;
    qsizetype pos = textBuffer.size() - n;
    putString(textBuffer, pos);
    textBuffer.resize(pos);
    return 0;
}
 
enum NameChar { NameBeginning, NameNotBeginning, NotName };
 
static const char Begi = static_cast<char>(NameBeginning);
static const char NtBg = static_cast<char>(NameNotBeginning);
static const char NotN = static_cast<char>(NotName);
 
static const char nameCharTable[128] =
{
// 0x00
    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
// 0x10
    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
// 0x20 (0x2D is '-', 0x2E is '.')
    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
    NotN, NotN, NotN, NotN, NotN, NtBg, NtBg, NotN,
// 0x30 (0x30..0x39 are '0'..'9', 0x3A is ':')
    NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg,
    NtBg, NtBg, Begi, NotN, NotN, NotN, NotN, NotN,
// 0x40 (0x41..0x5A are 'A'..'Z')
    NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
// 0x50 (0x5F is '_')
    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
    Begi, Begi, Begi, NotN, NotN, NotN, NotN, Begi,
// 0x60 (0x61..0x7A are 'a'..'z')
    NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
// 0x70
    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
    Begi, Begi, Begi, NotN, NotN, NotN, NotN, NotN
};
 
static inline NameChar fastDetermineNameChar(QChar ch)
{
    ushort uc = ch.unicode();
    if (!(uc & ~0x7f)) // uc < 128
        return static_cast<NameChar>(nameCharTable[uc]);
 
    QChar::Category cat = ch.category();
    // ### some these categories might be slightly wrong
    if ((cat >= QChar::Letter_Uppercase && cat <= QChar::Letter_Other)
        || cat == QChar::Number_Letter)
        return NameBeginning;
    if ((cat >= QChar::Number_DecimalDigit && cat <= QChar::Number_Other)
                || (cat >= QChar::Mark_NonSpacing && cat <= QChar::Mark_Enclosing))
        return NameNotBeginning;
    return NotName;
}
 
inline qsizetype QXmlStreamReaderPrivate::fastScanNMTOKEN()
{
    qsizetype n = 0;
    uint c;
    while ((c = getChar()) != StreamEOF) {
        if (fastDetermineNameChar(QChar(c)) == NotName) {
            putChar(c);
            return n;
        } else {
            ++n;
            textBuffer += QChar(c);
        }
    }
 
    qsizetype pos = textBuffer.size() - n;
    putString(textBuffer, pos);
    textBuffer.resize(pos);
 
    return n;
}
 
void QXmlStreamReaderPrivate::putString(QStringView s, qsizetype from)
{
    if (from != 0) {
        putString(s.mid(from));
        return;
    }
    putStack.reserve(s.size());
    for (auto it = s.rbegin(), end = s.rend(); it != end; ++it)
        putStack.rawPush() = it->unicode();
}
 
void QXmlStreamReaderPrivate::putStringLiteral(QStringView s)
{
    putStack.reserve(s.size());
    for (auto it = s.rbegin(), end = s.rend(); it != end; ++it)
        putStack.rawPush() = ((LETTER << 16) | it->unicode());
}
 
void QXmlStreamReaderPrivate::putReplacement(QStringView s)
{
    putStack.reserve(s.size());
    for (auto it = s.rbegin(), end = s.rend(); it != end; ++it) {
        char16_t c = it->unicode();
        if (c == '\n' || c == '\r')
            putStack.rawPush() = ((LETTER << 16) | c);
        else
            putStack.rawPush() = c;
    }
}
void QXmlStreamReaderPrivate::putReplacementInAttributeValue(QStringView s)
{
    putStack.reserve(s.size());
    for (auto it = s.rbegin(), end = s.rend(); it != end; ++it) {
        char16_t c = it->unicode();
        if (c == '&' || c == ';')
            putStack.rawPush() = c;
        else if (c == '\n' || c == '\r')
            putStack.rawPush() = ' ';
        else
            putStack.rawPush() = ((LETTER << 16) | c);
    }
}
 
uint QXmlStreamReaderPrivate::getChar_helper()
{
    constexpr qsizetype BUFFER_SIZE = 8192;
    characterOffset += readBufferPos;
    readBufferPos = 0;
    if (readBuffer.size())
        readBuffer.resize(0);
    if (decoder.isValid())
        nbytesread = 0;
    if (device) {
        rawReadBuffer.resize(BUFFER_SIZE);
        qint64 nbytesreadOrMinus1 = device->read(rawReadBuffer.data() + nbytesread, BUFFER_SIZE - nbytesread);
        nbytesread += qMax(nbytesreadOrMinus1, qint64{0});
    } else {
        if (nbytesread)
            rawReadBuffer += dataBuffer;
        else
            rawReadBuffer = dataBuffer;
        nbytesread = rawReadBuffer.size();
        dataBuffer.clear();
    }
    if (!nbytesread) {
        atEnd = true;
        return StreamEOF;
    }
 
    if (!decoder.isValid()) {
        if (nbytesread < 4) { // the 4 is to cover 0xef 0xbb 0xbf plus
                              // one extra for the utf8 codec
            atEnd = true;
            return StreamEOF;
        }
        auto encoding = QStringDecoder::encodingForData(rawReadBuffer, char16_t('<'));
        if (!encoding)
            // assume utf-8
            encoding = QStringDecoder::Utf8;
        decoder = QStringDecoder(*encoding);
    }
 
    readBuffer = decoder(QByteArrayView(rawReadBuffer).first(nbytesread));
 
    if (lockEncoding && decoder.hasError()) {
        raiseWellFormedError(QXmlStream::tr("Encountered incorrectly encoded content."));
        readBuffer.clear();
        return StreamEOF;
    }
 
    readBuffer.reserve(1); // keep capacity when calling resize() next time
 
    if (readBufferPos < readBuffer.size()) {
        ushort c = readBuffer.at(readBufferPos++).unicode();
        return c;
    }
 
    atEnd = true;
    return StreamEOF;
}
 
XmlStringRef QXmlStreamReaderPrivate::namespaceForPrefix(QStringView prefix)
{
     for (const NamespaceDeclaration &namespaceDeclaration : reversed(namespaceDeclarations)) {
         if (namespaceDeclaration.prefix == prefix) {
             return namespaceDeclaration.namespaceUri;
         }
     }
 
#if 1
     if (namespaceProcessing && !prefix.isEmpty())
         raiseWellFormedError(QXmlStream::tr("Namespace prefix '%1' not declared").arg(prefix));
#endif
 
     return XmlStringRef();
}
 
/*
  uses namespaceForPrefix and builds the attribute vector
 */
void QXmlStreamReaderPrivate::resolveTag()
{
    const auto attributeStackCleaner = qScopeGuard([this](){ attributeStack.clear(); });
    const qsizetype n = attributeStack.size();
 
    if (namespaceProcessing) {
        for (DtdAttribute &dtdAttribute : dtdAttributes) {
            if (!dtdAttribute.isNamespaceAttribute
                || dtdAttribute.defaultValue.isNull()
                || dtdAttribute.tagName != qualifiedName
                || dtdAttribute.attributeQualifiedName.isNull())
                continue;
            qsizetype i = 0;
            while (i < n && symName(attributeStack[i].key) != dtdAttribute.attributeQualifiedName)
                ++i;
            if (i != n)
                continue;
            if (dtdAttribute.attributePrefix.isEmpty() && dtdAttribute.attributeName == "xmlns"_L1) {
                NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
                namespaceDeclaration.prefix.clear();
 
                const XmlStringRef ns(dtdAttribute.defaultValue);
                if (ns == "http://www.w3.org/2000/xmlns/"_L1 ||
                   ns == "http://www.w3.org/XML/1998/namespace"_L1)
                    raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));
                else
                    namespaceDeclaration.namespaceUri = ns;
            } else if (dtdAttribute.attributePrefix == "xmlns"_L1) {
                NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
                XmlStringRef namespacePrefix = dtdAttribute.attributeName;
                XmlStringRef namespaceUri = dtdAttribute.defaultValue;
                if (((namespacePrefix == "xml"_L1)
                     ^ (namespaceUri == "http://www.w3.org/XML/1998/namespace"_L1))
                    || namespaceUri == "http://www.w3.org/2000/xmlns/"_L1
                    || namespaceUri.isEmpty()
                    || namespacePrefix == "xmlns"_L1)
                    raiseWellFormedError(QXmlStream::tr("Illegal namespace declaration."));
 
                namespaceDeclaration.prefix = namespacePrefix;
                namespaceDeclaration.namespaceUri = namespaceUri;
            }
        }
    }
 
    tagStack.top().namespaceDeclaration.namespaceUri = namespaceUri = namespaceForPrefix(prefix);
 
    attributes.resize(n);
 
    for (qsizetype i = 0; i < n; ++i) {
        QXmlStreamAttribute &attribute = attributes[i];
        Attribute &attrib = attributeStack[i];
        XmlStringRef prefix(symPrefix(attrib.key));
        XmlStringRef name(symString(attrib.key));
        XmlStringRef qualifiedName(symName(attrib.key));
        XmlStringRef value(symString(attrib.value));
 
        attribute.m_name = name;
        attribute.m_qualifiedName = qualifiedName;
        attribute.m_value = value;
 
        if (!prefix.isEmpty()) {
            XmlStringRef attributeNamespaceUri = namespaceForPrefix(prefix);
            attribute.m_namespaceUri = XmlStringRef(attributeNamespaceUri);
        }
 
        for (qsizetype j = 0; j < i; ++j) {
            if (attributes[j].name() == attribute.name()
                && attributes[j].namespaceUri() == attribute.namespaceUri()
                && (namespaceProcessing || attributes[j].qualifiedName() == attribute.qualifiedName()))
            {
                raiseWellFormedError(QXmlStream::tr("Attribute '%1' redefined.").arg(attribute.qualifiedName()));
                return;
            }
        }
    }
 
    for (DtdAttribute &dtdAttribute : dtdAttributes) {
        if (dtdAttribute.isNamespaceAttribute
            || dtdAttribute.defaultValue.isNull()
            || dtdAttribute.tagName != qualifiedName
            || dtdAttribute.attributeQualifiedName.isNull())
            continue;
        qsizetype i = 0;
        while (i < n && symName(attributeStack[i].key) != dtdAttribute.attributeQualifiedName)
            ++i;
        if (i != n)
            continue;
 
 
 
        QXmlStreamAttribute attribute;
        attribute.m_name = dtdAttribute.attributeName;
        attribute.m_qualifiedName = dtdAttribute.attributeQualifiedName;
        attribute.m_value = dtdAttribute.defaultValue;
 
        if (!dtdAttribute.attributePrefix.isEmpty()) {
            XmlStringRef attributeNamespaceUri = namespaceForPrefix(dtdAttribute.attributePrefix);
            attribute.m_namespaceUri = XmlStringRef(attributeNamespaceUri);
        }
        attribute.m_isDefault = true;
        attributes.append(std::move(attribute));
    }
}
 
void QXmlStreamReaderPrivate::resolvePublicNamespaces()
{
    const Tag &tag = tagStack.top();
    qsizetype n = namespaceDeclarations.size() - tag.namespaceDeclarationsSize;
    publicNamespaceDeclarations.resize(n);
    for (qsizetype i = 0; i < n; ++i) {
        const NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.at(tag.namespaceDeclarationsSize + i);
        QXmlStreamNamespaceDeclaration &publicNamespaceDeclaration = publicNamespaceDeclarations[i];
        publicNamespaceDeclaration.m_prefix = namespaceDeclaration.prefix;
        publicNamespaceDeclaration.m_namespaceUri = namespaceDeclaration.namespaceUri;
    }
}
 
void QXmlStreamReaderPrivate::resolveDtd()
{
    publicNotationDeclarations.resize(notationDeclarations.size());
    for (qsizetype i = 0; i < notationDeclarations.size(); ++i) {
        const QXmlStreamReaderPrivate::NotationDeclaration &notationDeclaration = notationDeclarations.at(i);
        QXmlStreamNotationDeclaration &publicNotationDeclaration = publicNotationDeclarations[i];
        publicNotationDeclaration.m_name = notationDeclaration.name;
        publicNotationDeclaration.m_systemId = notationDeclaration.systemId;
        publicNotationDeclaration.m_publicId = notationDeclaration.publicId;
 
    }
    notationDeclarations.clear();
    publicEntityDeclarations.resize(entityDeclarations.size());
    for (qsizetype i = 0; i < entityDeclarations.size(); ++i) {
        const QXmlStreamReaderPrivate::EntityDeclaration &entityDeclaration = entityDeclarations.at(i);
        QXmlStreamEntityDeclaration &publicEntityDeclaration = publicEntityDeclarations[i];
        publicEntityDeclaration.m_name = entityDeclaration.name;
        publicEntityDeclaration.m_notationName = entityDeclaration.notationName;
        publicEntityDeclaration.m_systemId = entityDeclaration.systemId;
        publicEntityDeclaration.m_publicId = entityDeclaration.publicId;
        publicEntityDeclaration.m_value = entityDeclaration.value;
    }
    entityDeclarations.clear();
    parameterEntityHash.clear();
}
 
uint QXmlStreamReaderPrivate::resolveCharRef(int symbolIndex)
{
    bool ok = true;
    uint s;
    // ### add toXShort to XmlString?
    if (sym(symbolIndex).c == 'x')
        s = symString(symbolIndex, 1).view().toUInt(&ok, 16);
    else
        s = symString(symbolIndex).view().toUInt(&ok, 10);
 
    ok &= (s == 0x9 || s == 0xa || s == 0xd || (s >= 0x20 && s <= 0xd7ff)
           || (s >= 0xe000 && s <= 0xfffd) || (s >= 0x10000 && s <= QChar::LastValidCodePoint));
 
    return ok ? s : 0;
}
 
 
void QXmlStreamReaderPrivate::checkPublicLiteral(QStringView publicId)
{
//#x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
 
    const char16_t *data = publicId.utf16();
    uchar c = 0;
    qsizetype i;
    for (i = publicId.size() - 1; i >= 0; --i) {
        if (data[i] < 256)
            switch ((c = data[i])) {
            case ' ': case '\n': case '\r': case '-': case '(': case ')':
            case '+': case ',': case '.': case '/': case ':': case '=':
            case '?': case ';': case '!': case '*': case '#': case '@':
            case '$': case '_': case '%': case '\'': case '\"':
                continue;
            default:
                if (isAsciiLetterOrNumber(c))
                    continue;
            }
        break;
    }
    if (i >= 0)
        raiseWellFormedError(QXmlStream::tr("Unexpected character '%1' in public id literal.").arg(QChar(QLatin1Char(c))));
}
 
/*
  Checks whether the document starts with an xml declaration. If it
  does, this function returns \c true; otherwise it sets up everything
  for a synthetic start document event and returns \c false.
 */
bool QXmlStreamReaderPrivate::checkStartDocument()
{
    hasCheckedStartDocument = true;
 
    if (scanString(spell[XML], XML))
        return true;
 
    type = QXmlStreamReader::StartDocument;
    if (atEnd) {
        hasCheckedStartDocument = false;
        raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
    }
    return false;
}
 
void QXmlStreamReaderPrivate::startDocument()
{
    QString err;
    if (documentVersion != "1.0"_L1) {
        if (documentVersion.view().contains(u' '))
            err = QXmlStream::tr("Invalid XML version string.");
        else
            err = QXmlStream::tr("Unsupported XML version.");
    }
    qsizetype n = attributeStack.size();
 
    /* We use this bool to ensure that the pesudo attributes are in the
     * proper order:
     *
     * [23]     XMLDecl     ::=     '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' */
 
    for (qsizetype i = 0; err.isNull() && i < n; ++i) {
        Attribute &attrib = attributeStack[i];
        XmlStringRef prefix(symPrefix(attrib.key));
        XmlStringRef key(symString(attrib.key));
        XmlStringRef value(symString(attrib.value));
 
        if (prefix.isEmpty() && key == "encoding"_L1) {
            documentEncoding = value;
 
            if (hasStandalone)
                err = QXmlStream::tr("The standalone pseudo attribute must appear after the encoding.");
            if (!QXmlUtils::isEncName(value))
                err = QXmlStream::tr("%1 is an invalid encoding name.").arg(value);
            else {
                QByteArray enc = value.toString().toUtf8();
                if (!lockEncoding) {
                    decoder = QStringDecoder(enc.constData());
                    if (!decoder.isValid()) {
                        err = QXmlStream::tr("Encoding %1 is unsupported").arg(value);
                    } else {
                        readBuffer = decoder(QByteArrayView(rawReadBuffer).first(nbytesread));
                    }
                }
            }
        } else if (prefix.isEmpty() && key == "standalone"_L1) {
            hasStandalone = true;
            if (value == "yes"_L1)
                standalone = true;
            else if (value == "no"_L1)
                standalone = false;
            else
                err = QXmlStream::tr("Standalone accepts only yes or no.");
        } else {
            err = QXmlStream::tr("Invalid attribute in XML declaration: %1 = %2").arg(key).arg(value);
        }
    }
 
    if (!err.isNull())
        raiseWellFormedError(err);
    attributeStack.clear();
}
 
 
void QXmlStreamReaderPrivate::raiseError(QXmlStreamReader::Error error, const QString& message)
{
    this->error = error;
    errorString = message;
    if (errorString.isNull()) {
        if (error == QXmlStreamReader::PrematureEndOfDocumentError)
            errorString = QXmlStream::tr("Premature end of document.");
        else if (error == QXmlStreamReader::CustomError)
            errorString = QXmlStream::tr("Invalid document.");
    }
 
    type = QXmlStreamReader::Invalid;
}
 
void QXmlStreamReaderPrivate::raiseWellFormedError(const QString &message)
{
    raiseError(QXmlStreamReader::NotWellFormedError, message);
}
 
void QXmlStreamReaderPrivate::raiseNamePrefixTooLongError()
{
    // TODO: add a ImplementationLimitsExceededError and use it instead
    raiseError(QXmlStreamReader::NotWellFormedError,
               QXmlStream::tr("Length of XML attribute name exceeds implementation limits (4KiB "
                              "characters)."));
}
 
void QXmlStreamReaderPrivate::parseError()
{
 
    if (token == EOF_SYMBOL) {
        raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
        return;
    }
    const int nmax = 4;
    QString error_message;
    int ers = state_stack[tos];
    int nexpected = 0;
    int expected[nmax];
    if (token != XML_ERROR)
        for (int tk = 0; tk < TERMINAL_COUNT; ++tk) {
            int k = t_action(ers, tk);
            if (k <= 0)
                continue;
            if (spell[tk]) {
                if (nexpected < nmax)
                    expected[nexpected++] = tk;
            }
        }
 
    if (nexpected && nexpected < nmax) {
        //: '<first option>'
        QString exp_str = QXmlStream::tr("'%1'", "expected")
                .arg(QLatin1StringView(spell[expected[0]]));
        if (nexpected == 2) {
            //: <first option>, '<second option>'
            exp_str = QXmlStream::tr("%1 or '%2'", "expected")
                    .arg(exp_str, QLatin1StringView(spell[expected[1]]));
        } else if (nexpected > 2) {
            int s = 1;
            for (; s < nexpected - 1; ++s) {
                //: <options so far>, '<next option>'
                exp_str = QXmlStream::tr("%1, '%2'", "expected")
                        .arg(exp_str, QLatin1StringView(spell[expected[s]]));
            }
            //: <options so far>, or '<final option>'
            exp_str = QXmlStream::tr("%1, or '%2'", "expected")
                    .arg(exp_str, QLatin1StringView(spell[expected[s]]));
        }
        error_message = QXmlStream::tr("Expected %1, but got '%2'.")
                .arg(exp_str, QLatin1StringView(spell[token]));
    } else {
        error_message = QXmlStream::tr("Unexpected '%1'.").arg(QLatin1StringView(spell[token]));
    }
 
    raiseWellFormedError(error_message);
}
 
void QXmlStreamReaderPrivate::resume(int rule) {
    resumeReduction = rule;
    if (error == QXmlStreamReader::NoError)
        raiseError(QXmlStreamReader::PrematureEndOfDocumentError);
}
 
qint64 QXmlStreamReader::lineNumber() const
{
    Q_D(const QXmlStreamReader);
    return d->lineNumber + 1; // in public we start with 1
}
 
qint64 QXmlStreamReader::columnNumber() const
{
    Q_D(const QXmlStreamReader);
    return d->characterOffset - d->lastLineStart + d->readBufferPos;
}
 
qint64 QXmlStreamReader::characterOffset() const
{
    Q_D(const QXmlStreamReader);
    return d->characterOffset + d->readBufferPos;
}
 
 
QStringView QXmlStreamReader::text() const
{
    Q_D(const QXmlStreamReader);
    return d->text;
}
 
 
QXmlStreamNotationDeclarations QXmlStreamReader::notationDeclarations() const
{
    Q_D(const QXmlStreamReader);
    if (d->notationDeclarations.size())
        const_cast<QXmlStreamReaderPrivate *>(d)->resolveDtd();
    return d->publicNotationDeclarations;
}
 
 
QXmlStreamEntityDeclarations QXmlStreamReader::entityDeclarations() const
{
    Q_D(const QXmlStreamReader);
    if (d->entityDeclarations.size())
        const_cast<QXmlStreamReaderPrivate *>(d)->resolveDtd();
    return d->publicEntityDeclarations;
}
 
QStringView QXmlStreamReader::dtdName() const
{
   Q_D(const QXmlStreamReader);
   if (d->type == QXmlStreamReader::DTD)
       return d->dtdName;
   return QStringView();
}
 
QStringView QXmlStreamReader::dtdPublicId() const
{
   Q_D(const QXmlStreamReader);
   if (d->type == QXmlStreamReader::DTD)
       return d->dtdPublicId;
   return QStringView();
}
 
QStringView QXmlStreamReader::dtdSystemId() const
{
   Q_D(const QXmlStreamReader);
   if (d->type == QXmlStreamReader::DTD)
       return d->dtdSystemId;
   return QStringView();
}
 
int QXmlStreamReader::entityExpansionLimit() const
{
    Q_D(const QXmlStreamReader);
    return d->entityExpansionLimit;
}
 
void QXmlStreamReader::setEntityExpansionLimit(int limit)
{
    Q_D(QXmlStreamReader);
    d->entityExpansionLimit = limit;
}
 
QXmlStreamNamespaceDeclarations QXmlStreamReader::namespaceDeclarations() const
{
    Q_D(const QXmlStreamReader);
    if (d->publicNamespaceDeclarations.isEmpty() && d->type == StartElement)
        const_cast<QXmlStreamReaderPrivate *>(d)->resolvePublicNamespaces();
    return d->publicNamespaceDeclarations;
}
 
 
void QXmlStreamReader::addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaration)
{
    Q_D(QXmlStreamReader);
    QXmlStreamReaderPrivate::NamespaceDeclaration &namespaceDeclaration = d->namespaceDeclarations.push();
    namespaceDeclaration.prefix = d->addToStringStorage(extraNamespaceDeclaration.prefix());
    namespaceDeclaration.namespaceUri = d->addToStringStorage(extraNamespaceDeclaration.namespaceUri());
}
 
void QXmlStreamReader::addExtraNamespaceDeclarations(const QXmlStreamNamespaceDeclarations &extraNamespaceDeclarations)
{
    for (const auto &extraNamespaceDeclaration : extraNamespaceDeclarations)
        addExtraNamespaceDeclaration(extraNamespaceDeclaration);
}
 
 
QString QXmlStreamReader::readElementText(ReadElementTextBehaviour behaviour)
{
    Q_D(QXmlStreamReader);
    if (isStartElement()) {
        QString result;
        forever {
            switch (readNext()) {
            case Characters:
            case EntityReference:
                result.insert(result.size(), d->text);
                break;
            case EndElement:
                return result;
            case ProcessingInstruction:
            case Comment:
                break;
            case StartElement:
                if (behaviour == SkipChildElements) {
                    skipCurrentElement();
                    break;
                } else if (behaviour == IncludeChildElements) {
                    result += readElementText(behaviour);
                    break;
                }
                Q_FALLTHROUGH();
            default:
                if (d->error || behaviour == ErrorOnUnexpectedElement) {
                    if (!d->error)
                        d->raiseError(UnexpectedElementError, QXmlStream::tr("Expected character data."));
                    return result;
                }
            }
        }
    }
    return QString();
}
 
void QXmlStreamReader::raiseError(const QString& message)
{
    Q_D(QXmlStreamReader);
    d->raiseError(CustomError, message);
}
 
QString QXmlStreamReader::errorString() const
{
    Q_D(const QXmlStreamReader);
    if (d->type == QXmlStreamReader::Invalid)
        return d->errorString;
    return QString();
}
 
QXmlStreamReader::Error QXmlStreamReader::error() const
{
    Q_D(const QXmlStreamReader);
    if (d->type == QXmlStreamReader::Invalid)
        return d->error;
    return NoError;
}
 
QStringView QXmlStreamReader::processingInstructionTarget() const
{
    Q_D(const QXmlStreamReader);
    return d->processingInstructionTarget;
}
 
QStringView QXmlStreamReader::processingInstructionData() const
{
    Q_D(const QXmlStreamReader);
    return d->processingInstructionData;
}
 
 
 
QStringView QXmlStreamReader::name() const
{
    Q_D(const QXmlStreamReader);
    return d->name;
}
 
QStringView QXmlStreamReader::namespaceUri() const
{
    Q_D(const QXmlStreamReader);
    return d->namespaceUri;
}
 
QStringView QXmlStreamReader::qualifiedName() const
{
    Q_D(const QXmlStreamReader);
    return d->qualifiedName;
}
 
 
 
QStringView QXmlStreamReader::prefix() const
{
    Q_D(const QXmlStreamReader);
    return d->prefix;
}
 
QXmlStreamAttributes QXmlStreamReader::attributes() const
{
    Q_D(const QXmlStreamReader);
    return d->attributes;
}
 
#endif // feature xmlstreamreader
 
QXmlStreamAttribute::QXmlStreamAttribute()
{
    m_isDefault = false;
}
 
QXmlStreamAttribute::QXmlStreamAttribute(const QString &namespaceUri, const QString &name, const QString &value)
{
    m_namespaceUri = namespaceUri;
    m_name = m_qualifiedName = name;
    m_value = value;
    m_namespaceUri = namespaceUri;
}
 
QXmlStreamAttribute::QXmlStreamAttribute(const QString &qualifiedName, const QString &value)
{
    qsizetype colon = qualifiedName.indexOf(u':');
    m_name = qualifiedName.mid(colon + 1);
    m_qualifiedName = qualifiedName;
    m_value = value;
}
 
QXmlStreamNotationDeclaration::QXmlStreamNotationDeclaration()
{
}
 
QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration()
{
}
 
QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration(const QString &prefix, const QString &namespaceUri)
{
    m_prefix = prefix;
    m_namespaceUri = namespaceUri;
}
 
QXmlStreamEntityDeclaration::QXmlStreamEntityDeclaration()
{
}
 
QStringView QXmlStreamAttributes::value(QAnyStringView namespaceUri, QAnyStringView name) const noexcept
{
    for (const QXmlStreamAttribute &attribute : *this) {
        if (attribute.name() == name && attribute.namespaceUri() == namespaceUri)
            return attribute.value();
    }
    return QStringView();
}
 
QStringView QXmlStreamAttributes::value(QAnyStringView qualifiedName) const noexcept
{
    for (const QXmlStreamAttribute &attribute : *this) {
        if (attribute.qualifiedName() == qualifiedName)
            return attribute.value();
    }
    return QStringView();
}
 
void QXmlStreamAttributes::append(const QString &namespaceUri, const QString &name, const QString &value)
{
    append(QXmlStreamAttribute(namespaceUri, name, value));
}
 
void QXmlStreamAttributes::append(const QString &qualifiedName, const QString &value)
{
    append(QXmlStreamAttribute(qualifiedName, value));
}
 
#if QT_CONFIG(xmlstreamreader)
 
bool QXmlStreamReader::isWhitespace() const
{
    Q_D(const QXmlStreamReader);
    return d->type == QXmlStreamReader::Characters && d->isWhitespace;
}
 
bool QXmlStreamReader::isCDATA() const
{
    Q_D(const QXmlStreamReader);
    return d->type == QXmlStreamReader::Characters && d->isCDATA;
}
 
 
 
bool QXmlStreamReader::isStandaloneDocument() const
{
    Q_D(const QXmlStreamReader);
    return d->standalone;
}
 
bool QXmlStreamReader::hasStandaloneDeclaration() const
{
    Q_D(const QXmlStreamReader);
    return d->hasStandalone;
}
 
QStringView QXmlStreamReader::documentVersion() const
{
   Q_D(const QXmlStreamReader);
   if (d->type == QXmlStreamReader::StartDocument)
       return d->documentVersion;
   return QStringView();
}
 
QStringView QXmlStreamReader::documentEncoding() const
{
   Q_D(const QXmlStreamReader);
   if (d->type == QXmlStreamReader::StartDocument)
       return d->documentEncoding;
   return QStringView();
}
 
#endif // feature xmlstreamreader
 
#if QT_CONFIG(xmlstreamwriter)
 
class QXmlStreamWriterPrivate : public QXmlStreamPrivateTagStack
{
    QXmlStreamWriter *q_ptr;
    Q_DECLARE_PUBLIC(QXmlStreamWriter)
public:
    QXmlStreamWriterPrivate(QXmlStreamWriter *q);
    ~QXmlStreamWriterPrivate() {
        if (deleteDevice)
            delete device;
    }
 
    void write(QAnyStringView s);
    void writeEscaped(QAnyStringView, bool escapeWhitespace = false);
    bool finishStartElement(bool contents = true);
    void writeStartElement(QAnyStringView namespaceUri, QAnyStringView name);
    QIODevice *device;
    QString *stringDevice;
    uint deleteDevice :1;
    uint inStartElement :1;
    uint inEmptyElement :1;
    uint lastWasStartElement :1;
    uint wroteSomething :1;
    uint hasIoError :1;
    uint hasEncodingError :1;
    uint autoFormatting :1;
    std::string autoFormattingIndent;
    NamespaceDeclaration emptyNamespace;
    qsizetype lastNamespaceDeclaration;
 
    NamespaceDeclaration &findNamespace(QAnyStringView namespaceUri, bool writeDeclaration = false, bool noDefault = false);
    void writeNamespaceDeclaration(const NamespaceDeclaration &namespaceDeclaration);
 
    int namespacePrefixCount;
 
    void indent(int level);
private:
    void doWriteToDevice(QStringView s);
    void doWriteToDevice(QUtf8StringView s);
    void doWriteToDevice(QLatin1StringView s);
};
 
 
QXmlStreamWriterPrivate::QXmlStreamWriterPrivate(QXmlStreamWriter *q)
    : autoFormattingIndent(4, ' ')
{
    q_ptr = q;
    device = nullptr;
    stringDevice = nullptr;
    deleteDevice = false;
    inStartElement = inEmptyElement = false;
    wroteSomething = false;
    hasIoError = false;
    hasEncodingError = false;
    lastWasStartElement = false;
    lastNamespaceDeclaration = 1;
    autoFormatting = false;
    namespacePrefixCount = 0;
}
 
void QXmlStreamWriterPrivate::write(QAnyStringView s)
{
    if (device) {
        if (hasIoError)
            return;
 
        s.visit([&] (auto s) { doWriteToDevice(s); });
    } else if (stringDevice) {
        s.visit([&] (auto s) { stringDevice->append(s); });
    } else {
        qWarning("QXmlStreamWriter: No device");
    }
}
 
void QXmlStreamWriterPrivate::writeEscaped(QAnyStringView s, bool escapeWhitespace)
{
    QString escaped;
    escaped.reserve(s.size());
    s.visit([&] (auto s) {
        using View = decltype(s);
 
        auto it = s.begin();
        const auto end = s.end();
 
        while (it != end) {
            QLatin1StringView replacement;
            auto mark = it;
 
            while (it != end) {
                if (*it == u'<') {
                    replacement = "&lt;"_L1;
                    break;
                } else if (*it == u'>') {
                    replacement = "&gt;"_L1;
                    break;
                } else if (*it == u'&') {
                    replacement = "&amp;"_L1;
                    break;
                } else if (*it == u'\"') {
                    replacement = "&quot;"_L1;
                    break;
                } else if (*it == u'\t') {
                    if (escapeWhitespace) {
                        replacement = "&#9;"_L1;
                        break;
                    }
                } else if (*it == u'\n') {
                    if (escapeWhitespace) {
                        replacement = "&#10;"_L1;
                        break;
                    }
                } else if (*it == u'\v' || *it == u'\f') {
                    hasEncodingError = true;
                    break;
                } else if (*it == u'\r') {
                    if (escapeWhitespace) {
                        replacement = "&#13;"_L1;
                        break;
                    }
                } else if (*it <= u'\x1F' || *it >= u'\uFFFE') {
                    hasEncodingError = true;
                    break;
                }
                ++it;
            }
 
            escaped.append(View{mark, it});
            escaped.append(replacement);
            if (it != end)
                ++it;
        }
    } );
 
    write(escaped);
}
 
void QXmlStreamWriterPrivate::writeNamespaceDeclaration(const NamespaceDeclaration &namespaceDeclaration) {
    if (namespaceDeclaration.prefix.isEmpty()) {
        write(" xmlns=\"");
        write(namespaceDeclaration.namespaceUri);
        write("\"");
    } else {
        write(" xmlns:");
        write(namespaceDeclaration.prefix);
        write("=\"");
        write(namespaceDeclaration.namespaceUri);
        write("\"");
    }
}
 
bool QXmlStreamWriterPrivate::finishStartElement(bool contents)
{
    bool hadSomethingWritten = wroteSomething;
    wroteSomething = contents;
    if (!inStartElement)
        return hadSomethingWritten;
 
    if (inEmptyElement) {
        write("/>");
        QXmlStreamWriterPrivate::Tag tag = tagStack_pop();
        lastNamespaceDeclaration = tag.namespaceDeclarationsSize;
        lastWasStartElement = false;
    } else {
        write(">");
    }
    inStartElement = inEmptyElement = false;
    lastNamespaceDeclaration = namespaceDeclarations.size();
    return hadSomethingWritten;
}
 
QXmlStreamPrivateTagStack::NamespaceDeclaration &QXmlStreamWriterPrivate::findNamespace(QAnyStringView namespaceUri, bool writeDeclaration, bool noDefault)
{
    for (NamespaceDeclaration &namespaceDeclaration : reversed(namespaceDeclarations)) {
        if (namespaceDeclaration.namespaceUri == namespaceUri) {
            if (!noDefault || !namespaceDeclaration.prefix.isEmpty())
                return namespaceDeclaration;
        }
    }
    if (namespaceUri.isEmpty())
        return emptyNamespace;
    NamespaceDeclaration &namespaceDeclaration = namespaceDeclarations.push();
    if (namespaceUri.isEmpty()) {
        namespaceDeclaration.prefix.clear();
    } else {
        QString s;
        int n = ++namespacePrefixCount;
        forever {
            s = u'n' + QString::number(n++);
            qsizetype j = namespaceDeclarations.size() - 2;
            while (j >= 0 && namespaceDeclarations.at(j).prefix != s)
                --j;
            if (j < 0)
                break;
        }
        namespaceDeclaration.prefix = addToStringStorage(s);
    }
    namespaceDeclaration.namespaceUri = addToStringStorage(namespaceUri);
    if (writeDeclaration)
        writeNamespaceDeclaration(namespaceDeclaration);
    return namespaceDeclaration;
}
 
 
 
void QXmlStreamWriterPrivate::indent(int level)
{
    write("\n");
    for (int i = 0; i < level; ++i)
        write(autoFormattingIndent);
}
 
void QXmlStreamWriterPrivate::doWriteToDevice(QStringView s)
{
    constexpr qsizetype MaxChunkSize = 512;
    char buffer [3 * MaxChunkSize];
    QStringEncoder::State state;
    while (!s.isEmpty()) {
        const qsizetype chunkSize = std::min(s.size(), MaxChunkSize);
        char *end = QUtf8::convertFromUnicode(buffer, s.first(chunkSize), &state);
        doWriteToDevice(QUtf8StringView{buffer, end});
        s = s.sliced(chunkSize);
    }
    if (state.remainingChars > 0)
        hasEncodingError = true;
}
 
void QXmlStreamWriterPrivate::doWriteToDevice(QUtf8StringView s)
{
    QByteArrayView bytes = s;
    if (device->write(bytes.data(), bytes.size()) != bytes.size())
        hasIoError = true;
}
 
void QXmlStreamWriterPrivate::doWriteToDevice(QLatin1StringView s)
{
    constexpr qsizetype MaxChunkSize = 512;
    char buffer [2 * MaxChunkSize];
    while (!s.isEmpty()) {
        const qsizetype chunkSize = std::min(s.size(), MaxChunkSize);
        char *end = QUtf8::convertFromLatin1(buffer, s.first(chunkSize));
        doWriteToDevice(QUtf8StringView{buffer, end});
        s = s.sliced(chunkSize);
    }
}
 
QXmlStreamWriter::QXmlStreamWriter()
    : d_ptr(new QXmlStreamWriterPrivate(this))
{
}
 
QXmlStreamWriter::QXmlStreamWriter(QIODevice *device)
    : d_ptr(new QXmlStreamWriterPrivate(this))
{
    Q_D(QXmlStreamWriter);
    d->device = device;
}
 
QXmlStreamWriter::QXmlStreamWriter(QByteArray *array)
    : d_ptr(new QXmlStreamWriterPrivate(this))
{
    Q_D(QXmlStreamWriter);
    d->device = new QBuffer(array);
    d->device->open(QIODevice::WriteOnly);
    d->deleteDevice = true;
}
 
 
QXmlStreamWriter::QXmlStreamWriter(QString *string)
    : d_ptr(new QXmlStreamWriterPrivate(this))
{
    Q_D(QXmlStreamWriter);
    d->stringDevice = string;
}
 
QXmlStreamWriter::~QXmlStreamWriter()
{
}
 
 
void QXmlStreamWriter::setDevice(QIODevice *device)
{
    Q_D(QXmlStreamWriter);
    if (device == d->device)
        return;
    d->stringDevice = nullptr;
    if (d->deleteDevice) {
        delete d->device;
        d->deleteDevice = false;
    }
    d->device = device;
}
 
QIODevice *QXmlStreamWriter::device() const
{
    Q_D(const QXmlStreamWriter);
    return d->device;
}
 
void QXmlStreamWriter::setAutoFormatting(bool enable)
{
    Q_D(QXmlStreamWriter);
    d->autoFormatting = enable;
}
 
bool QXmlStreamWriter::autoFormatting() const
{
    Q_D(const QXmlStreamWriter);
    return d->autoFormatting;
}
 
void QXmlStreamWriter::setAutoFormattingIndent(int spacesOrTabs)
{
    Q_D(QXmlStreamWriter);
    d->autoFormattingIndent.assign(size_t(qAbs(spacesOrTabs)), spacesOrTabs >= 0 ? ' ' : '\t');
}
 
int QXmlStreamWriter::autoFormattingIndent() const
{
    Q_D(const QXmlStreamWriter);
    const QLatin1StringView indent(d->autoFormattingIndent);
    return indent.count(u' ') - indent.count(u'\t');
}
 
bool QXmlStreamWriter::hasError() const
{
    Q_D(const QXmlStreamWriter);
    return d->hasIoError || d->hasEncodingError;
}
 
void QXmlStreamWriter::writeAttribute(QAnyStringView qualifiedName, QAnyStringView value)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(d->inStartElement);
    Q_ASSERT(count(qualifiedName, ':') <= 1);
    d->write(" ");
    d->write(qualifiedName);
    d->write("=\"");
    d->writeEscaped(value, true);
    d->write("\"");
}
 
void QXmlStreamWriter::writeAttribute(QAnyStringView namespaceUri, QAnyStringView name, QAnyStringView value)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(d->inStartElement);
    Q_ASSERT(!contains(name, ':'));
    QXmlStreamWriterPrivate::NamespaceDeclaration &namespaceDeclaration = d->findNamespace(namespaceUri, true, true);
    d->write(" ");
    if (!namespaceDeclaration.prefix.isEmpty()) {
        d->write(namespaceDeclaration.prefix);
        d->write(":");
    }
    d->write(name);
    d->write("=\"");
    d->writeEscaped(value, true);
    d->write("\"");
}
 
void QXmlStreamWriter::writeAttribute(const QXmlStreamAttribute& attribute)
{
    if (attribute.namespaceUri().isEmpty())
        writeAttribute(attribute.qualifiedName(), attribute.value());
    else
        writeAttribute(attribute.namespaceUri(), attribute.name(), attribute.value());
}
 
 
void QXmlStreamWriter::writeAttributes(const QXmlStreamAttributes& attributes)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(d->inStartElement);
    Q_UNUSED(d);
    for (const auto &attr : attributes)
        writeAttribute(attr);
}
 
 
void QXmlStreamWriter::writeCDATA(QAnyStringView text)
{
    Q_D(QXmlStreamWriter);
    d->finishStartElement();
    d->write("<![CDATA[");
    while (!text.isEmpty()) {
        const auto idx = indexOf(text, "]]>"_L1);
        if (idx < 0)
            break;                   // no forbidden sequence found
        d->write(text.first(idx));
        d->write("]]"                // text[idx, idx + 2)
                 "]]><![CDATA["      // escape sequence to separate ]] and >
                 ">");               // text[idx + 2, idx + 3)
        text = text.sliced(idx + 3); // skip over "]]>"
    }
    d->write(text); // write remainder
    d->write("]]>");
}
 
 
void QXmlStreamWriter::writeCharacters(QAnyStringView text)
{
    Q_D(QXmlStreamWriter);
    d->finishStartElement();
    d->writeEscaped(text);
}
 
 
void QXmlStreamWriter::writeComment(QAnyStringView text)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(!contains(text, "--"_L1) && !endsWith(text, '-'));
    if (!d->finishStartElement(false) && d->autoFormatting)
        d->indent(d->tagStack.size());
    d->write("<!--");
    d->write(text);
    d->write("-->");
    d->inStartElement = d->lastWasStartElement = false;
}
 
 
void QXmlStreamWriter::writeDTD(QAnyStringView dtd)
{
    Q_D(QXmlStreamWriter);
    d->finishStartElement();
    if (d->autoFormatting)
        d->write("\n");
    d->write(dtd);
    if (d->autoFormatting)
        d->write("\n");
}
 
 
 
void QXmlStreamWriter::writeEmptyElement(QAnyStringView qualifiedName)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(count(qualifiedName, ':') <= 1);
    d->writeStartElement({}, qualifiedName);
    d->inEmptyElement = true;
}
 
 
void QXmlStreamWriter::writeEmptyElement(QAnyStringView namespaceUri, QAnyStringView name)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(!contains(name, ':'));
    d->writeStartElement(namespaceUri, name);
    d->inEmptyElement = true;
}
 
 
void QXmlStreamWriter::writeTextElement(QAnyStringView qualifiedName, QAnyStringView text)
{
    writeStartElement(qualifiedName);
    writeCharacters(text);
    writeEndElement();
}
 
void QXmlStreamWriter::writeTextElement(QAnyStringView namespaceUri, QAnyStringView name, QAnyStringView text)
{
    writeStartElement(namespaceUri, name);
    writeCharacters(text);
    writeEndElement();
}
 
 
void QXmlStreamWriter::writeEndDocument()
{
    Q_D(QXmlStreamWriter);
    while (d->tagStack.size())
        writeEndElement();
    d->write("\n");
}
 
void QXmlStreamWriter::writeEndElement()
{
    Q_D(QXmlStreamWriter);
    if (d->tagStack.isEmpty())
        return;
 
    // shortcut: if nothing was written, close as empty tag
    if (d->inStartElement && !d->inEmptyElement) {
        d->write("/>");
        d->lastWasStartElement = d->inStartElement = false;
        QXmlStreamWriterPrivate::Tag tag = d->tagStack_pop();
        d->lastNamespaceDeclaration = tag.namespaceDeclarationsSize;
        return;
    }
 
    if (!d->finishStartElement(false) && !d->lastWasStartElement && d->autoFormatting)
        d->indent(d->tagStack.size()-1);
    if (d->tagStack.isEmpty())
        return;
    d->lastWasStartElement = false;
    QXmlStreamWriterPrivate::Tag tag = d->tagStack_pop();
    d->lastNamespaceDeclaration = tag.namespaceDeclarationsSize;
    d->write("</");
    if (!tag.namespaceDeclaration.prefix.isEmpty()) {
        d->write(tag.namespaceDeclaration.prefix);
        d->write(":");
    }
    d->write(tag.name);
    d->write(">");
}
 
 
 
void QXmlStreamWriter::writeEntityReference(QAnyStringView name)
{
    Q_D(QXmlStreamWriter);
    d->finishStartElement();
    d->write("&");
    d->write(name);
    d->write(";");
}
 
 
void QXmlStreamWriter::writeNamespace(QAnyStringView namespaceUri, QAnyStringView prefix)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(prefix != "xmlns"_L1);
    if (prefix.isEmpty()) {
        d->findNamespace(namespaceUri, d->inStartElement);
    } else {
        Q_ASSERT(!((prefix == "xml"_L1) ^ (namespaceUri == "http://www.w3.org/XML/1998/namespace"_L1)));
        Q_ASSERT(namespaceUri != "http://www.w3.org/2000/xmlns/"_L1);
        QXmlStreamWriterPrivate::NamespaceDeclaration &namespaceDeclaration = d->namespaceDeclarations.push();
        namespaceDeclaration.prefix = d->addToStringStorage(prefix);
        namespaceDeclaration.namespaceUri = d->addToStringStorage(namespaceUri);
        if (d->inStartElement)
            d->writeNamespaceDeclaration(namespaceDeclaration);
    }
}
 
 
void QXmlStreamWriter::writeDefaultNamespace(QAnyStringView namespaceUri)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(namespaceUri != "http://www.w3.org/XML/1998/namespace"_L1);
    Q_ASSERT(namespaceUri != "http://www.w3.org/2000/xmlns/"_L1);
    QXmlStreamWriterPrivate::NamespaceDeclaration &namespaceDeclaration = d->namespaceDeclarations.push();
    namespaceDeclaration.prefix.clear();
    namespaceDeclaration.namespaceUri = d->addToStringStorage(namespaceUri);
    if (d->inStartElement)
        d->writeNamespaceDeclaration(namespaceDeclaration);
}
 
 
void QXmlStreamWriter::writeProcessingInstruction(QAnyStringView target, QAnyStringView data)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(!contains(data, "?>"_L1));
    if (!d->finishStartElement(false) && d->autoFormatting)
        d->indent(d->tagStack.size());
    d->write("<?");
    d->write(target);
    if (!data.isNull()) {
        d->write(" ");
        d->write(data);
    }
    d->write("?>");
}
 
 
 
void QXmlStreamWriter::writeStartDocument()
{
    writeStartDocument("1.0"_L1);
}
 
 
void QXmlStreamWriter::writeStartDocument(QAnyStringView version)
{
    Q_D(QXmlStreamWriter);
    d->finishStartElement(false);
    d->write("<?xml version=\"");
    d->write(version);
    if (d->device) // stringDevice does not get any encoding
        d->write("\" encoding=\"UTF-8");
    d->write("\"?>");
}
 
void QXmlStreamWriter::writeStartDocument(QAnyStringView version, bool standalone)
{
    Q_D(QXmlStreamWriter);
    d->finishStartElement(false);
    d->write("<?xml version=\"");
    d->write(version);
    if (d->device) // stringDevice does not get any encoding
        d->write("\" encoding=\"UTF-8");
    if (standalone)
        d->write("\" standalone=\"yes\"?>");
    else
        d->write("\" standalone=\"no\"?>");
}
 
 
void QXmlStreamWriter::writeStartElement(QAnyStringView qualifiedName)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(count(qualifiedName, ':') <= 1);
    d->writeStartElement({}, qualifiedName);
}
 
 
void QXmlStreamWriter::writeStartElement(QAnyStringView namespaceUri, QAnyStringView name)
{
    Q_D(QXmlStreamWriter);
    Q_ASSERT(!contains(name, ':'));
    d->writeStartElement(namespaceUri, name);
}
 
void QXmlStreamWriterPrivate::writeStartElement(QAnyStringView namespaceUri, QAnyStringView name)
{
    if (!finishStartElement(false) && autoFormatting)
        indent(tagStack.size());
 
    Tag &tag = tagStack_push();
    tag.name = addToStringStorage(name);
    tag.namespaceDeclaration = findNamespace(namespaceUri);
    write("<");
    if (!tag.namespaceDeclaration.prefix.isEmpty()) {
        write(tag.namespaceDeclaration.prefix);
        write(":");
    }
    write(tag.name);
    inStartElement = lastWasStartElement = true;
 
    for (qsizetype i = lastNamespaceDeclaration; i < namespaceDeclarations.size(); ++i)
        writeNamespaceDeclaration(namespaceDeclarations[i]);
    tag.namespaceDeclarationsSize = lastNamespaceDeclaration;
}
 
#if QT_CONFIG(xmlstreamreader)
void QXmlStreamWriter::writeCurrentToken(const QXmlStreamReader &reader)
{
    switch (reader.tokenType()) {
    case QXmlStreamReader::NoToken:
        break;
    case QXmlStreamReader::StartDocument:
        writeStartDocument();
        break;
    case QXmlStreamReader::EndDocument:
        writeEndDocument();
        break;
    case QXmlStreamReader::StartElement: {
        writeStartElement(reader.namespaceUri(), reader.name());
        const QXmlStreamNamespaceDeclarations decls = reader.namespaceDeclarations();
        for (const auto &namespaceDeclaration : decls) {
            writeNamespace(namespaceDeclaration.namespaceUri(),
                           namespaceDeclaration.prefix());
        }
        writeAttributes(reader.attributes());
             } break;
    case QXmlStreamReader::EndElement:
        writeEndElement();
        break;
    case QXmlStreamReader::Characters:
        if (reader.isCDATA())
            writeCDATA(reader.text());
        else
            writeCharacters(reader.text());
        break;
    case QXmlStreamReader::Comment:
        writeComment(reader.text());
        break;
    case QXmlStreamReader::DTD:
        writeDTD(reader.text());
        break;
    case QXmlStreamReader::EntityReference:
        writeEntityReference(reader.name());
        break;
    case QXmlStreamReader::ProcessingInstruction:
        writeProcessingInstruction(reader.processingInstructionTarget(),
                                   reader.processingInstructionData());
        break;
    default:
        Q_ASSERT(reader.tokenType() != QXmlStreamReader::Invalid);
        qWarning("QXmlStreamWriter: writeCurrentToken() with invalid state.");
        break;
    }
}
 
static constexpr bool isTokenAllowedInContext(QXmlStreamReader::TokenType type,
                                               QXmlStreamReaderPrivate::XmlContext loc)
{
    switch (type) {
    case QXmlStreamReader::StartDocument:
    case QXmlStreamReader::DTD:
        return loc == QXmlStreamReaderPrivate::XmlContext::Prolog;
 
    case QXmlStreamReader::StartElement:
    case QXmlStreamReader::EndElement:
    case QXmlStreamReader::Characters:
    case QXmlStreamReader::EntityReference:
    case QXmlStreamReader::EndDocument:
        return loc == QXmlStreamReaderPrivate::XmlContext::Body;
 
    case QXmlStreamReader::Comment:
    case QXmlStreamReader::ProcessingInstruction:
        return true;
 
    case QXmlStreamReader::NoToken:
    case QXmlStreamReader::Invalid:
        return false;
    }
 
    // GCC 8.x does not treat __builtin_unreachable() as constexpr
#if !defined(Q_CC_GNU_ONLY) || (Q_CC_GNU >= 900)
    Q_UNREACHABLE_RETURN(false);
#else
    return false;
#endif
}
 
bool QXmlStreamReaderPrivate::isValidToken(QXmlStreamReader::TokenType type)
{
    // Don't change currentContext, if Invalid or NoToken occur in the prolog
    if (type == QXmlStreamReader::Invalid || type == QXmlStreamReader::NoToken)
        return false;
 
    // If a token type gets rejected in the body, there is no recovery
    const bool result = isTokenAllowedInContext(type, currentContext);
    if (result || currentContext == XmlContext::Body)
        return result;
 
    // First non-Prolog token observed => switch context to body and check again.
    currentContext = XmlContext::Body;
    return isTokenAllowedInContext(type, currentContext);
}
 
void QXmlStreamReaderPrivate::checkToken()
{
    Q_Q(QXmlStreamReader);
 
    // The token type must be consumed, to keep track if the body has been reached.
    const XmlContext context = currentContext;
    const bool ok = isValidToken(type);
 
    // Do nothing if an error has been raised already (going along with an unexpected token)
    if (error != QXmlStreamReader::Error::NoError)
        return;
 
    if (!ok) {
        raiseError(QXmlStreamReader::UnexpectedElementError,
                   QObject::tr("Unexpected token type %1 in %2.")
                   .arg(q->tokenString(), contextString(context)));
        return;
    }
 
    if (type != QXmlStreamReader::DTD)
        return;
 
    // Raise error on multiple DTD tokens
    if (foundDTD) {
        raiseError(QXmlStreamReader::UnexpectedElementError,
                   QObject::tr("Found second DTD token in %1.").arg(contextString(context)));
    } else {
        foundDTD = true;
    }
}
 
#endif // feature xmlstreamreader
#endif // feature xmlstreamwriter
 
QT_END_NAMESPACE
 
#endif // feature xmlstream