qdom.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 <qplatformdefs.h>
#include <qdom.h>
#include "private/qxmlutils_p.h"
 
#ifndef QT_NO_DOM
 
#include "qdom_p.h"
#include "qdomhelpers_p.h"
 
#include <qatomic.h>
#include <qbuffer.h>
#include <qiodevice.h>
#if QT_CONFIG(regularexpression)
#include <qregularexpression.h>
#endif
#include <qtextstream.h>
#include <qvariant.h>
#include <qshareddata.h>
#include <qdebug.h>
#include <qxmlstream.h>
#include <private/qduplicatetracker_p.h>
#include <private/qstringiterator_p.h>
#include <qvarlengtharray.h>
 
#include <stdio.h>
#include <limits>
#include <memory>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
/*
  ### old todo comments -- I don't know if they still apply...
 
  If the document dies, remove all pointers to it from children
  which can not be deleted at this time.
 
  If a node dies and has direct children which can not be deleted,
  then remove the pointer to the parent.
 
  createElement and friends create double reference counts.
*/
 
/* ##### new TODOs:
 
  Remove empty emthods in the *Private classes
 
  Make a lot of the (mostly empty) methods in the public classes inline.
  Specially constructors assignment operators and comparison operators are candidates.
*/
 
/*
  Reference counting:
 
  Some simple rules:
  1) If an intern object returns a pointer to another intern object
     then the reference count of the returned object is not increased.
  2) If an extern object is created and gets a pointer to some intern
     object, then the extern object increases the intern objects reference count.
  3) If an extern object is deleted, then it decreases the reference count
     on its associated intern object and deletes it if nobody else hold references
     on the intern object.
*/
 
 
/*
  Helper to split a qualified name in the prefix and local name.
*/
static void qt_split_namespace(QString& prefix, QString& name, const QString& qName, bool hasURI)
{
    qsizetype i = qName.indexOf(u':');
    if (i == -1) {
        if (hasURI)
            prefix = u""_s;
        else
            prefix.clear();
        name = qName;
    } else {
        prefix = qName.left(i);
        name = qName.mid(i + 1);
    }
}
 
/**************************************************************
 *
 * Functions for verifying legal data
 *
 **************************************************************/
QDomImplementation::InvalidDataPolicy QDomImplementationPrivate::invalidDataPolicy
    = QDomImplementation::AcceptInvalidChars;
 
// [5] Name ::= (Letter | '_' | ':') (NameChar)*
 
static QString fixedXmlName(const QString &_name, bool *ok, bool namespaces = false)
{
    QString name, prefix;
    if (namespaces)
        qt_split_namespace(prefix, name, _name, true);
    else
        name = _name;
 
    if (name.isEmpty()) {
        *ok = false;
        return QString();
    }
 
    if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {
        *ok = true;
        return _name;
    }
 
    QString result;
    bool firstChar = true;
    for (int i = 0; i < name.size(); ++i) {
        QChar c = name.at(i);
        if (firstChar) {
            if (QXmlUtils::isLetter(c) || c.unicode() == '_' || c.unicode() == ':') {
                result.append(c);
                firstChar = false;
            } else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
                *ok = false;
                return QString();
            }
        } else {
            if (QXmlUtils::isNameChar(c))
                result.append(c);
            else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
                *ok = false;
                return QString();
            }
        }
    }
 
    if (result.isEmpty()) {
        *ok = false;
        return QString();
    }
 
    *ok = true;
    if (namespaces && !prefix.isEmpty())
        return prefix + u':' + result;
    return result;
}
 
// [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
// '<', '&' and "]]>" will be escaped when writing
 
static QString fixedCharData(const QString &data, bool *ok)
{
    if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {
        *ok = true;
        return data;
    }
 
    QString result;
    QStringIterator it(data);
    while (it.hasNext()) {
        const char32_t c = it.next(QChar::Null);
        if (QXmlUtils::isChar(c)) {
            result.append(QChar::fromUcs4(c));
        } else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
            *ok = false;
            return QString();
        }
    }
 
    *ok = true;
    return result;
}
 
// [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
// can't escape "--", since entities are not recognised within comments
 
static QString fixedComment(const QString &data, bool *ok)
{
    if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {
        *ok = true;
        return data;
    }
 
    QString fixedData = fixedCharData(data, ok);
    if (!*ok)
        return QString();
 
    for (;;) {
        qsizetype idx = fixedData.indexOf("--"_L1);
        if (idx == -1)
            break;
        if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
            *ok = false;
            return QString();
        }
        fixedData.remove(idx, 2);
    }
 
    *ok = true;
    return fixedData;
}
 
// [20] CData ::= (Char* - (Char* ']]>' Char*))
// can't escape "]]>", since entities are not recognised within comments
 
static QString fixedCDataSection(const QString &data, bool *ok)
{
    if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {
        *ok = true;
        return data;
    }
 
    QString fixedData = fixedCharData(data, ok);
    if (!*ok)
        return QString();
 
    for (;;) {
        qsizetype idx = fixedData.indexOf("]]>"_L1);
        if (idx == -1)
            break;
        if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
            *ok = false;
            return QString();
        }
        fixedData.remove(idx, 3);
    }
 
    *ok = true;
    return fixedData;
}
 
// [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
 
static QString fixedPIData(const QString &data, bool *ok)
{
    if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {
        *ok = true;
        return data;
    }
 
    QString fixedData = fixedCharData(data, ok);
    if (!*ok)
        return QString();
 
    for (;;) {
        qsizetype idx = fixedData.indexOf("?>"_L1);
        if (idx == -1)
            break;
        if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
            *ok = false;
            return QString();
        }
        fixedData.remove(idx, 2);
    }
 
    *ok = true;
    return fixedData;
}
 
// [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
// The correct quote will be chosen when writing
 
static QString fixedPubidLiteral(const QString &data, bool *ok)
{
    if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {
        *ok = true;
        return data;
    }
 
    QString result;
 
    if (QXmlUtils::isPublicID(data))
        result = data;
    else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
        *ok = false;
        return QString();
    }
 
    if (result.indexOf(u'\'') != -1 && result.indexOf(u'"') != -1) {
        if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
            *ok = false;
            return QString();
        } else {
            result.remove(u'\'');
        }
    }
 
    *ok = true;
    return result;
}
 
// [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
// The correct quote will be chosen when writing
 
static QString fixedSystemLiteral(const QString &data, bool *ok)
{
    if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) {
        *ok = true;
        return data;
    }
 
    QString result = data;
 
    if (result.indexOf(u'\'') != -1 && result.indexOf(u'"') != -1) {
        if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
            *ok = false;
            return QString();
        } else {
            result.remove(u'\'');
        }
    }
 
    *ok = true;
    return result;
}
 
/**************************************************************
 *
 * QDomImplementationPrivate
 *
 **************************************************************/
 
QDomImplementationPrivate* QDomImplementationPrivate::clone()
{
    return new QDomImplementationPrivate;
}
 
/**************************************************************
 *
 * QDomImplementation
 *
 **************************************************************/
 
QDomImplementation::QDomImplementation()
{
    impl = nullptr;
}
 
QDomImplementation::QDomImplementation(const QDomImplementation &x)
{
    impl = x.impl;
    if (impl)
        impl->ref.ref();
}
 
QDomImplementation::QDomImplementation(QDomImplementationPrivate *p)
{
    // We want to be co-owners, so increase the reference count
    impl = p;
    if (impl)
        impl->ref.ref();
}
 
QDomImplementation& QDomImplementation::operator=(const QDomImplementation &x)
{
    if (x.impl)
        x.impl->ref.ref();
    if (impl && !impl->ref.deref())
        delete impl;
    impl = x.impl;
    return *this;
}
 
bool QDomImplementation::operator==(const QDomImplementation &x) const
{
    return (impl == x.impl);
}
 
bool QDomImplementation::operator!=(const QDomImplementation &x) const
{
    return (impl != x.impl);
}
 
QDomImplementation::~QDomImplementation()
{
    if (impl && !impl->ref.deref())
        delete impl;
}
 
bool QDomImplementation::hasFeature(const QString& feature, const QString& version) const
{
    if (feature == "XML"_L1) {
        if (version.isEmpty() || version == "1.0"_L1)
            return true;
    }
    // ### add DOM level 2 features
    return false;
}
 
QDomDocumentType QDomImplementation::createDocumentType(const QString& qName, const QString& publicId, const QString& systemId)
{
    bool ok;
    QString fixedName = fixedXmlName(qName, &ok, true);
    if (!ok)
        return QDomDocumentType();
 
    QString fixedPublicId = fixedPubidLiteral(publicId, &ok);
    if (!ok)
        return QDomDocumentType();
 
    QString fixedSystemId = fixedSystemLiteral(systemId, &ok);
    if (!ok)
        return QDomDocumentType();
 
    QDomDocumentTypePrivate *dt = new QDomDocumentTypePrivate(nullptr);
    dt->name = fixedName;
    if (systemId.isNull()) {
        dt->publicId.clear();
        dt->systemId.clear();
    } else {
        dt->publicId = fixedPublicId;
        dt->systemId = fixedSystemId;
    }
    dt->ref.deref();
    return QDomDocumentType(dt);
}
 
QDomDocument QDomImplementation::createDocument(const QString& nsURI, const QString& qName, const QDomDocumentType& doctype)
{
    QDomDocument doc(doctype);
    QDomElement root = doc.createElementNS(nsURI, qName);
    if (root.isNull())
        return QDomDocument();
    doc.appendChild(root);
    return doc;
}
 
bool QDomImplementation::isNull()
{
    return (impl == nullptr);
}
 
QDomImplementation::InvalidDataPolicy QDomImplementation::invalidDataPolicy()
{
    return QDomImplementationPrivate::invalidDataPolicy;
}
 
void QDomImplementation::setInvalidDataPolicy(InvalidDataPolicy policy)
{
    QDomImplementationPrivate::invalidDataPolicy = policy;
}
 
/**************************************************************
 *
 * QDomNodeListPrivate
 *
 **************************************************************/
 
QDomNodeListPrivate::QDomNodeListPrivate(QDomNodePrivate *n_impl) : ref(1)
{
    node_impl = n_impl;
    if (node_impl)
        node_impl->ref.ref();
    timestamp = 0;
}
 
QDomNodeListPrivate::QDomNodeListPrivate(QDomNodePrivate *n_impl, const QString &name) :
    ref(1)
{
    node_impl = n_impl;
    if (node_impl)
        node_impl->ref.ref();
    tagname = name;
    timestamp = 0;
}
 
QDomNodeListPrivate::QDomNodeListPrivate(QDomNodePrivate *n_impl, const QString &_nsURI, const QString &localName) :
    ref(1)
{
    node_impl = n_impl;
    if (node_impl)
        node_impl->ref.ref();
    tagname = localName;
    nsURI = _nsURI;
    timestamp = 0;
}
 
QDomNodeListPrivate::~QDomNodeListPrivate()
{
    if (node_impl && !node_impl->ref.deref())
        delete node_impl;
}
 
bool QDomNodeListPrivate::operator==(const QDomNodeListPrivate &other) const
{
    return (node_impl == other.node_impl) && (tagname == other.tagname);
}
 
bool QDomNodeListPrivate::operator!=(const QDomNodeListPrivate &other) const
{
    return (node_impl != other.node_impl) || (tagname != other.tagname);
}
 
void QDomNodeListPrivate::createList()
{
    if (!node_impl)
        return;
 
    const QDomDocumentPrivate *const doc = node_impl->ownerDocument();
    if (doc && timestamp != doc->nodeListTime)
        timestamp = doc->nodeListTime;
 
    QDomNodePrivate* p = node_impl->first;
 
    list.clear();
    if (tagname.isNull()) {
        while (p) {
            list.append(p);
            p = p->next;
        }
    } else if (nsURI.isNull()) {
        while (p && p != node_impl) {
            if (p->isElement() && p->nodeName() == tagname) {
                list.append(p);
            }
            if (p->first)
                p = p->first;
            else if (p->next)
                p = p->next;
            else {
                p = p->parent();
                while (p && p != node_impl && !p->next)
                    p = p->parent();
                if (p && p != node_impl)
                    p = p->next;
            }
        }
    } else {
        while (p && p != node_impl) {
            if (p->isElement() && p->name==tagname && p->namespaceURI==nsURI) {
                list.append(p);
            }
            if (p->first)
                p = p->first;
            else if (p->next)
                p = p->next;
            else {
                p = p->parent();
                while (p && p != node_impl && !p->next)
                    p = p->parent();
                if (p && p != node_impl)
                    p = p->next;
            }
        }
    }
}
 
QDomNodePrivate* QDomNodeListPrivate::item(int index)
{
    if (!node_impl)
        return nullptr;
 
    const QDomDocumentPrivate *const doc = node_impl->ownerDocument();
    if (!doc || timestamp != doc->nodeListTime)
        createList();
 
    if (index >= list.size())
        return nullptr;
 
    return list.at(index);
}
 
int QDomNodeListPrivate::length() const
{
    if (!node_impl)
        return 0;
 
    const QDomDocumentPrivate *const doc = node_impl->ownerDocument();
    if (!doc || timestamp != doc->nodeListTime) {
        QDomNodeListPrivate *that = const_cast<QDomNodeListPrivate *>(this);
        that->createList();
    }
 
    return list.size();
}
 
/**************************************************************
 *
 * QDomNodeList
 *
 **************************************************************/
 
QDomNodeList::QDomNodeList()
    : impl(nullptr)
{
}
 
QDomNodeList::QDomNodeList(QDomNodeListPrivate* p)
    : impl(p)
{
}
 
QDomNodeList::QDomNodeList(const QDomNodeList& n)
{
    impl = n.impl;
    if (impl)
        impl->ref.ref();
}
 
QDomNodeList& QDomNodeList::operator=(const QDomNodeList &n)
{
    if (n.impl)
        n.impl->ref.ref();
    if (impl && !impl->ref.deref())
        delete impl;
    impl = n.impl;
    return *this;
}
 
bool QDomNodeList::operator==(const QDomNodeList &n) const
{
    if (impl == n.impl)
        return true;
    if (!impl || !n.impl)
        return false;
    return (*impl == *n.impl);
}
 
bool QDomNodeList::operator!=(const QDomNodeList &n) const
{
    return !operator==(n);
}
 
QDomNodeList::~QDomNodeList()
{
    if (impl && !impl->ref.deref())
        delete impl;
}
 
QDomNode QDomNodeList::item(int index) const
{
    if (!impl)
        return QDomNode();
 
    return QDomNode(impl->item(index));
}
 
int QDomNodeList::length() const
{
    if (!impl)
        return 0;
    return impl->length();
}
 
/**************************************************************
 *
 * QDomNodePrivate
 *
 **************************************************************/
 
inline void QDomNodePrivate::setOwnerDocument(QDomDocumentPrivate *doc)
{
    ownerNode = doc;
    hasParent = false;
}
 
QDomNodePrivate::QDomNodePrivate(QDomDocumentPrivate *doc, QDomNodePrivate *par) : ref(1)
{
    if (par)
        setParent(par);
    else
        setOwnerDocument(doc);
    prev = nullptr;
    next = nullptr;
    first = nullptr;
    last = nullptr;
    createdWithDom1Interface = true;
    lineNumber = -1;
    columnNumber = -1;
}
 
QDomNodePrivate::QDomNodePrivate(QDomNodePrivate *n, bool deep) : ref(1)
{
    setOwnerDocument(n->ownerDocument());
    prev = nullptr;
    next = nullptr;
    first = nullptr;
    last = nullptr;
 
    name = n->name;
    value = n->value;
    prefix = n->prefix;
    namespaceURI = n->namespaceURI;
    createdWithDom1Interface = n->createdWithDom1Interface;
    lineNumber = -1;
    columnNumber = -1;
 
    if (!deep)
        return;
 
    for (QDomNodePrivate* x = n->first; x; x = x->next)
        appendChild(x->cloneNode(true));
}
 
QDomNodePrivate::~QDomNodePrivate()
{
    QDomNodePrivate* p = first;
    QDomNodePrivate* n;
 
    while (p) {
        n = p->next;
        if (!p->ref.deref())
            delete p;
        else
            p->setNoParent();
        p = n;
    }
    first = nullptr;
    last = nullptr;
}
 
void QDomNodePrivate::clear()
{
    QDomNodePrivate* p = first;
    QDomNodePrivate* n;
 
    while (p) {
        n = p->next;
        if (!p->ref.deref())
            delete p;
        p = n;
    }
    first = nullptr;
    last = nullptr;
}
 
QDomNodePrivate* QDomNodePrivate::namedItem(const QString &n)
{
    QDomNodePrivate* p = first;
    while (p) {
        if (p->nodeName() == n)
            return p;
        p = p->next;
    }
    return nullptr;
}
 
 
QDomNodePrivate* QDomNodePrivate::insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild)
{
    // Error check
    if (!newChild)
        return nullptr;
 
    // Error check
    if (newChild == refChild)
        return nullptr;
 
    // Error check
    if (refChild && refChild->parent() != this)
        return nullptr;
 
    // "mark lists as dirty"
    QDomDocumentPrivate *const doc = ownerDocument();
    if (doc)
        doc->nodeListTime++;
 
    // Special handling for inserting a fragment. We just insert
    // all elements of the fragment instead of the fragment itself.
    if (newChild->isDocumentFragment()) {
        // Fragment is empty ?
        if (newChild->first == nullptr)
            return newChild;
 
        // New parent
        QDomNodePrivate* n = newChild->first;
        while (n)  {
            n->setParent(this);
            n = n->next;
        }
 
        // Insert at the beginning ?
        if (!refChild || refChild->prev == nullptr) {
            if (first)
                first->prev = newChild->last;
            newChild->last->next = first;
            if (!last)
                last = newChild->last;
            first = newChild->first;
        } else {
            // Insert in the middle
            newChild->last->next = refChild;
            newChild->first->prev = refChild->prev;
            refChild->prev->next = newChild->first;
            refChild->prev = newChild->last;
        }
 
        // No need to increase the reference since QDomDocumentFragment
        // does not decrease the reference.
 
        // Remove the nodes from the fragment
        newChild->first = nullptr;
        newChild->last = nullptr;
        return newChild;
    }
 
    // No more errors can occur now, so we take
    // ownership of the node.
    newChild->ref.ref();
 
    if (newChild->parent())
        newChild->parent()->removeChild(newChild);
 
    newChild->setParent(this);
 
    if (!refChild) {
        if (first)
            first->prev = newChild;
        newChild->next = first;
        if (!last)
            last = newChild;
        first = newChild;
        return newChild;
    }
 
    if (refChild->prev == nullptr) {
        if (first)
            first->prev = newChild;
        newChild->next = first;
        if (!last)
            last = newChild;
        first = newChild;
        return newChild;
    }
 
    newChild->next = refChild;
    newChild->prev = refChild->prev;
    refChild->prev->next = newChild;
    refChild->prev = newChild;
 
    return newChild;
}
 
QDomNodePrivate* QDomNodePrivate::insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild)
{
    // Error check
    if (!newChild)
        return nullptr;
 
    // Error check
    if (newChild == refChild)
        return nullptr;
 
    // Error check
    if (refChild && refChild->parent() != this)
        return nullptr;
 
    // "mark lists as dirty"
    QDomDocumentPrivate *const doc = ownerDocument();
    if (doc)
        doc->nodeListTime++;
 
    // Special handling for inserting a fragment. We just insert
    // all elements of the fragment instead of the fragment itself.
    if (newChild->isDocumentFragment()) {
        // Fragment is empty ?
        if (newChild->first == nullptr)
            return newChild;
 
        // New parent
        QDomNodePrivate* n = newChild->first;
        while (n) {
            n->setParent(this);
            n = n->next;
        }
 
        // Insert at the end
        if (!refChild || refChild->next == nullptr) {
            if (last)
                last->next = newChild->first;
            newChild->first->prev = last;
            if (!first)
                first = newChild->first;
            last = newChild->last;
        } else { // Insert in the middle
            newChild->first->prev = refChild;
            newChild->last->next = refChild->next;
            refChild->next->prev = newChild->last;
            refChild->next = newChild->first;
        }
 
        // No need to increase the reference since QDomDocumentFragment
        // does not decrease the reference.
 
        // Remove the nodes from the fragment
        newChild->first = nullptr;
        newChild->last = nullptr;
        return newChild;
    }
 
    // Release new node from its current parent
    if (newChild->parent())
        newChild->parent()->removeChild(newChild);
 
    // No more errors can occur now, so we take
    // ownership of the node
    newChild->ref.ref();
 
    newChild->setParent(this);
 
    // Insert at the end
    if (!refChild) {
        if (last)
            last->next = newChild;
        newChild->prev = last;
        if (!first)
            first = newChild;
        last = newChild;
        return newChild;
    }
 
    if (refChild->next == nullptr) {
        if (last)
            last->next = newChild;
        newChild->prev = last;
        if (!first)
            first = newChild;
        last = newChild;
        return newChild;
    }
 
    newChild->prev = refChild;
    newChild->next = refChild->next;
    refChild->next->prev = newChild;
    refChild->next = newChild;
 
    return newChild;
}
 
QDomNodePrivate* QDomNodePrivate::replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild)
{
    if (!newChild || !oldChild)
        return nullptr;
    if (oldChild->parent() != this)
        return nullptr;
    if (newChild == oldChild)
        return nullptr;
 
    // mark lists as dirty
    QDomDocumentPrivate *const doc = ownerDocument();
    if (doc)
        doc->nodeListTime++;
 
    // Special handling for inserting a fragment. We just insert
    // all elements of the fragment instead of the fragment itself.
    if (newChild->isDocumentFragment()) {
        // Fragment is empty ?
        if (newChild->first == nullptr)
            return newChild;
 
        // New parent
        QDomNodePrivate* n = newChild->first;
        while (n) {
            n->setParent(this);
            n = n->next;
        }
 
 
        if (oldChild->next)
            oldChild->next->prev = newChild->last;
        if (oldChild->prev)
            oldChild->prev->next = newChild->first;
 
        newChild->last->next = oldChild->next;
        newChild->first->prev = oldChild->prev;
 
        if (first == oldChild)
            first = newChild->first;
        if (last == oldChild)
            last = newChild->last;
 
        oldChild->setNoParent();
        oldChild->next = nullptr;
        oldChild->prev = nullptr;
 
        // No need to increase the reference since QDomDocumentFragment
        // does not decrease the reference.
 
        // Remove the nodes from the fragment
        newChild->first = nullptr;
        newChild->last = nullptr;
 
        // We are no longer interested in the old node
        oldChild->ref.deref();
 
        return oldChild;
    }
 
    // No more errors can occur now, so we take
    // ownership of the node
    newChild->ref.ref();
 
    // Release new node from its current parent
    if (newChild->parent())
        newChild->parent()->removeChild(newChild);
 
    newChild->setParent(this);
 
    if (oldChild->next)
        oldChild->next->prev = newChild;
    if (oldChild->prev)
        oldChild->prev->next = newChild;
 
    newChild->next = oldChild->next;
    newChild->prev = oldChild->prev;
 
    if (first == oldChild)
        first = newChild;
    if (last == oldChild)
        last = newChild;
 
    oldChild->setNoParent();
    oldChild->next = nullptr;
    oldChild->prev = nullptr;
 
    // We are no longer interested in the old node
    oldChild->ref.deref();
 
    return oldChild;
}
 
QDomNodePrivate* QDomNodePrivate::removeChild(QDomNodePrivate* oldChild)
{
    // Error check
    if (oldChild->parent() != this)
        return nullptr;
 
    // "mark lists as dirty"
    QDomDocumentPrivate *const doc = ownerDocument();
    if (doc)
        doc->nodeListTime++;
 
    // Perhaps oldChild was just created with "createElement" or that. In this case
    // its parent is QDomDocument but it is not part of the documents child list.
    if (oldChild->next == nullptr && oldChild->prev == nullptr && first != oldChild)
        return nullptr;
 
    if (oldChild->next)
        oldChild->next->prev = oldChild->prev;
    if (oldChild->prev)
        oldChild->prev->next = oldChild->next;
 
    if (last == oldChild)
        last = oldChild->prev;
    if (first == oldChild)
        first = oldChild->next;
 
    oldChild->setNoParent();
    oldChild->next = nullptr;
    oldChild->prev = nullptr;
 
    // We are no longer interested in the old node
    oldChild->ref.deref();
 
    return oldChild;
}
 
QDomNodePrivate* QDomNodePrivate::appendChild(QDomNodePrivate* newChild)
{
    // No reference manipulation needed. Done in insertAfter.
    return insertAfter(newChild, nullptr);
}
 
QDomDocumentPrivate* QDomNodePrivate::ownerDocument()
{
    QDomNodePrivate* p = this;
    while (p && !p->isDocument()) {
        if (!p->hasParent)
            return static_cast<QDomDocumentPrivate *>(p->ownerNode);
        p = p->parent();
    }
 
    return static_cast<QDomDocumentPrivate *>(p);
}
 
QDomNodePrivate* QDomNodePrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomNodePrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
static void qNormalizeNode(QDomNodePrivate* n)
{
    QDomNodePrivate* p = n->first;
    QDomTextPrivate* t = nullptr;
 
    while (p) {
        if (p->isText()) {
            if (t) {
                QDomNodePrivate* tmp = p->next;
                t->appendData(p->nodeValue());
                n->removeChild(p);
                p = tmp;
            } else {
                t = static_cast<QDomTextPrivate *>(p);
                p = p->next;
            }
        } else {
            p = p->next;
            t = nullptr;
        }
    }
}
void QDomNodePrivate::normalize()
{
    // ### This one has moved from QDomElementPrivate to this position. It is
    // not tested.
    qNormalizeNode(this);
}
 
void QDomNodePrivate::save(QTextStream& s, int depth, int indent) const
{
    const QDomNodePrivate* n = first;
    while (n) {
        n->save(s, depth, indent);
        n = n->next;
    }
}
 
void QDomNodePrivate::setLocation(int lineNumber, int columnNumber)
{
    this->lineNumber = lineNumber;
    this->columnNumber = columnNumber;
}
 
/**************************************************************
 *
 * QDomNode
 *
 **************************************************************/
 
#define IMPL static_cast<QDomNodePrivate *>(impl)
 
QDomNode::QDomNode()
    : impl(nullptr)
{
}
 
QDomNode::QDomNode(const QDomNode &n)
{
    impl = n.impl;
    if (impl)
        impl->ref.ref();
}
 
QDomNode::QDomNode(QDomNodePrivate *n)
{
    impl = n;
    if (impl)
        impl->ref.ref();
}
 
QDomNode& QDomNode::operator=(const QDomNode &n)
{
    if (n.impl)
        n.impl->ref.ref();
    if (impl && !impl->ref.deref())
        delete impl;
    impl = n.impl;
    return *this;
}
 
bool QDomNode::operator== (const QDomNode& n) const
{
    return (impl == n.impl);
}
 
bool QDomNode::operator!= (const QDomNode& n) const
{
    return (impl != n.impl);
}
 
QDomNode::~QDomNode()
{
    if (impl && !impl->ref.deref())
        delete impl;
}
 
QString QDomNode::nodeName() const
{
    if (!impl)
        return QString();
 
    if (!IMPL->prefix.isEmpty())
        return IMPL->prefix + u':' + IMPL->name;
    return IMPL->name;
}
 
QString QDomNode::nodeValue() const
{
    if (!impl)
        return QString();
    return IMPL->value;
}
 
void QDomNode::setNodeValue(const QString& v)
{
    if (!impl)
        return;
    IMPL->setNodeValue(v);
}
 
QDomNode::NodeType QDomNode::nodeType() const
{
    if (!impl)
        return QDomNode::BaseNode;
    return IMPL->nodeType();
}
 
QDomNode QDomNode::parentNode() const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->parent());
}
 
QDomNodeList QDomNode::childNodes() const
{
    if (!impl)
        return QDomNodeList();
    return QDomNodeList(new QDomNodeListPrivate(impl));
}
 
QDomNode QDomNode::firstChild() const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->first);
}
 
QDomNode QDomNode::lastChild() const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->last);
}
 
QDomNode QDomNode::previousSibling() const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->prev);
}
 
QDomNode QDomNode::nextSibling() const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->next);
}
 
 
// ###### don't think this is part of the DOM and
QDomNamedNodeMap QDomNode::attributes() const
{
    if (!impl || !impl->isElement())
        return QDomNamedNodeMap();
 
    return QDomNamedNodeMap(static_cast<QDomElementPrivate *>(impl)->attributes());
}
 
QDomDocument QDomNode::ownerDocument() const
{
    if (!impl)
        return QDomDocument();
    return QDomDocument(IMPL->ownerDocument());
}
 
QDomNode QDomNode::cloneNode(bool deep) const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->cloneNode(deep));
}
 
void QDomNode::normalize()
{
    if (!impl)
        return;
    IMPL->normalize();
}
 
bool QDomNode::isSupported(const QString& feature, const QString& version) const
{
    QDomImplementation i;
    return i.hasFeature(feature, version);
}
 
QString QDomNode::namespaceURI() const
{
    if (!impl)
        return QString();
    return IMPL->namespaceURI;
}
 
QString QDomNode::prefix() const
{
    if (!impl)
        return QString();
    return IMPL->prefix;
}
 
void QDomNode::setPrefix(const QString& pre)
{
    if (!impl || IMPL->prefix.isNull())
        return;
    if (isAttr() || isElement())
        IMPL->prefix = pre;
}
 
QString QDomNode::localName() const
{
    if (!impl || IMPL->createdWithDom1Interface)
        return QString();
    return IMPL->name;
}
 
bool QDomNode::hasAttributes() const
{
    if (!impl || !impl->isElement())
        return false;
    return static_cast<QDomElementPrivate *>(impl)->hasAttributes();
}
 
QDomNode QDomNode::insertBefore(const QDomNode& newChild, const QDomNode& refChild)
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->insertBefore(newChild.impl, refChild.impl));
}
 
QDomNode QDomNode::insertAfter(const QDomNode& newChild, const QDomNode& refChild)
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->insertAfter(newChild.impl, refChild.impl));
}
 
QDomNode QDomNode::replaceChild(const QDomNode& newChild, const QDomNode& oldChild)
{
    if (!impl || !newChild.impl || !oldChild.impl)
        return QDomNode();
    return QDomNode(IMPL->replaceChild(newChild.impl, oldChild.impl));
}
 
QDomNode QDomNode::removeChild(const QDomNode& oldChild)
{
    if (!impl)
        return QDomNode();
 
    if (oldChild.isNull())
        return QDomNode();
 
    return QDomNode(IMPL->removeChild(oldChild.impl));
}
 
QDomNode QDomNode::appendChild(const QDomNode& newChild)
{
    if (!impl) {
        qWarning("Calling appendChild() on a null node does nothing.");
        return QDomNode();
    }
    return QDomNode(IMPL->appendChild(newChild.impl));
}
 
bool QDomNode::hasChildNodes() const
{
    if (!impl)
        return false;
    return IMPL->first != nullptr;
}
 
bool QDomNode::isNull() const
{
    return (impl == nullptr);
}
 
void QDomNode::clear()
{
    if (impl && !impl->ref.deref())
        delete impl;
    impl = nullptr;
}
 
QDomNode QDomNode::namedItem(const QString& name) const
{
    if (!impl)
        return QDomNode();
    return QDomNode(impl->namedItem(name));
}
 
void QDomNode::save(QTextStream& stream, int indent, EncodingPolicy encodingPolicy) const
{
    if (!impl)
        return;
 
    if (isDocument())
        static_cast<const QDomDocumentPrivate *>(impl)->saveDocument(stream, indent, encodingPolicy);
    else
        IMPL->save(stream, 1, indent);
}
 
QTextStream& operator<<(QTextStream& str, const QDomNode& node)
{
    node.save(str, 1);
 
    return str;
}
 
bool QDomNode::isAttr() const
{
    if (impl)
        return impl->isAttr();
    return false;
}
 
bool QDomNode::isCDATASection() const
{
    if (impl)
        return impl->isCDATASection();
    return false;
}
 
bool QDomNode::isDocumentFragment() const
{
    if (impl)
        return impl->isDocumentFragment();
    return false;
}
 
bool QDomNode::isDocument() const
{
    if (impl)
        return impl->isDocument();
    return false;
}
 
bool QDomNode::isDocumentType() const
{
    if (impl)
        return impl->isDocumentType();
    return false;
}
 
bool QDomNode::isElement() const
{
    if (impl)
        return impl->isElement();
    return false;
}
 
bool QDomNode::isEntityReference() const
{
    if (impl)
        return impl->isEntityReference();
    return false;
}
 
bool QDomNode::isText() const
{
    if (impl)
        return impl->isText();
    return false;
}
 
bool QDomNode::isEntity() const
{
    if (impl)
        return impl->isEntity();
    return false;
}
 
bool QDomNode::isNotation() const
{
    if (impl)
        return impl->isNotation();
    return false;
}
 
bool QDomNode::isProcessingInstruction() const
{
    if (impl)
        return impl->isProcessingInstruction();
    return false;
}
 
bool QDomNode::isCharacterData() const
{
    if (impl)
        return impl->isCharacterData();
    return false;
}
 
bool QDomNode::isComment() const
{
    if (impl)
        return impl->isComment();
    return false;
}
 
#undef IMPL
 
QDomElement QDomNode::firstChildElement(const QString &tagName, const QString &namespaceURI) const
{
    for (QDomNode child = firstChild(); !child.isNull(); child = child.nextSibling()) {
        if (child.isElement() && (namespaceURI.isEmpty() || child.namespaceURI() == namespaceURI)) {
            QDomElement elt = child.toElement();
            if (tagName.isEmpty() || elt.tagName() == tagName)
                return elt;
        }
    }
    return QDomElement();
}
 
QDomElement QDomNode::lastChildElement(const QString &tagName, const QString &namespaceURI) const
{
    for (QDomNode child = lastChild(); !child.isNull(); child = child.previousSibling()) {
        if (child.isElement() && (namespaceURI.isEmpty() || child.namespaceURI() == namespaceURI)) {
            QDomElement elt = child.toElement();
            if (tagName.isEmpty() || elt.tagName() == tagName)
                return elt;
        }
    }
    return QDomElement();
}
 
QDomElement QDomNode::nextSiblingElement(const QString &tagName, const QString &namespaceURI) const
{
    for (QDomNode sib = nextSibling(); !sib.isNull(); sib = sib.nextSibling()) {
        if (sib.isElement() && (namespaceURI.isEmpty() || sib.namespaceURI() == namespaceURI)) {
            QDomElement elt = sib.toElement();
            if (tagName.isEmpty() || elt.tagName() == tagName)
                return elt;
        }
    }
    return QDomElement();
}
 
QDomElement QDomNode::previousSiblingElement(const QString &tagName, const QString &namespaceURI) const
{
    for (QDomNode sib = previousSibling(); !sib.isNull(); sib = sib.previousSibling()) {
        if (sib.isElement() && (namespaceURI.isEmpty() || sib.namespaceURI() == namespaceURI)) {
            QDomElement elt = sib.toElement();
            if (tagName.isEmpty() || elt.tagName() == tagName)
                return elt;
        }
    }
    return QDomElement();
}
 
int QDomNode::lineNumber() const
{
    return impl ? impl->lineNumber : -1;
}
 
int QDomNode::columnNumber() const
{
    return impl ? impl->columnNumber : -1;
}
 
 
/**************************************************************
 *
 * QDomNamedNodeMapPrivate
 *
 **************************************************************/
 
QDomNamedNodeMapPrivate::QDomNamedNodeMapPrivate(QDomNodePrivate* n) : ref(1)
{
    readonly = false;
    parent = n;
    appendToParent = false;
}
 
QDomNamedNodeMapPrivate::~QDomNamedNodeMapPrivate()
{
    clearMap();
}
 
QDomNamedNodeMapPrivate* QDomNamedNodeMapPrivate::clone(QDomNodePrivate* p)
{
    std::unique_ptr<QDomNamedNodeMapPrivate> m(new QDomNamedNodeMapPrivate(p));
    m->readonly = readonly;
    m->appendToParent = appendToParent;
 
    auto it = map.constBegin();
    for (; it != map.constEnd(); ++it) {
        QDomNodePrivate *new_node = it.value()->cloneNode();
        new_node->setParent(p);
        m->setNamedItem(new_node);
    }
 
    // we are no longer interested in ownership
    m->ref.deref();
    return m.release();
}
 
void QDomNamedNodeMapPrivate::clearMap()
{
    // Dereference all of our children if we took references
    if (!appendToParent) {
        auto it = map.constBegin();
        for (; it != map.constEnd(); ++it)
            if (!it.value()->ref.deref())
                delete it.value();
    }
    map.clear();
}
 
QDomNodePrivate* QDomNamedNodeMapPrivate::namedItem(const QString& name) const
{
    auto it = map.find(name);
    return it == map.end() ? nullptr : it.value();
}
 
QDomNodePrivate* QDomNamedNodeMapPrivate::namedItemNS(const QString& nsURI, const QString& localName) const
{
    auto it = map.constBegin();
    QDomNodePrivate *n;
    for (; it != map.constEnd(); ++it) {
        n = it.value();
        if (!n->prefix.isNull()) {
            // node has a namespace
            if (n->namespaceURI == nsURI && n->name == localName)
                return n;
        }
    }
    return nullptr;
}
 
QDomNodePrivate* QDomNamedNodeMapPrivate::setNamedItem(QDomNodePrivate* arg)
{
    if (readonly || !arg)
        return nullptr;
 
    if (appendToParent)
        return parent->appendChild(arg);
 
    QDomNodePrivate *n = map.value(arg->nodeName());
    // We take a reference
    arg->ref.ref();
    map.insert(arg->nodeName(), arg);
    return n;
}
 
QDomNodePrivate* QDomNamedNodeMapPrivate::setNamedItemNS(QDomNodePrivate* arg)
{
    if (readonly || !arg)
        return nullptr;
 
    if (appendToParent)
        return parent->appendChild(arg);
 
    if (!arg->prefix.isNull()) {
        // node has a namespace
        QDomNodePrivate *n = namedItemNS(arg->namespaceURI, arg->name);
        // We take a reference
        arg->ref.ref();
        map.insert(arg->nodeName(), arg);
        return n;
    } else {
        // ### check the following code if it is ok
        return setNamedItem(arg);
    }
}
 
QDomNodePrivate* QDomNamedNodeMapPrivate::removeNamedItem(const QString& name)
{
    if (readonly)
        return nullptr;
 
    QDomNodePrivate* p = namedItem(name);
    if (p == nullptr)
        return nullptr;
    if (appendToParent)
        return parent->removeChild(p);
 
    map.remove(p->nodeName());
    // We took a reference, so we have to free one here
    p->ref.deref();
    return p;
}
 
QDomNodePrivate* QDomNamedNodeMapPrivate::item(int index) const
{
    if (index >= length() || index < 0)
        return nullptr;
    return std::next(map.begin(), index).value();
}
 
int QDomNamedNodeMapPrivate::length() const
{
    return map.size();
}
 
bool QDomNamedNodeMapPrivate::contains(const QString& name) const
{
    return map.contains(name);
}
 
bool QDomNamedNodeMapPrivate::containsNS(const QString& nsURI, const QString & localName) const
{
    return namedItemNS(nsURI, localName) != nullptr;
}
 
/**************************************************************
 *
 * QDomNamedNodeMap
 *
 **************************************************************/
 
#define IMPL static_cast<QDomNamedNodeMapPrivate *>(impl)
 
QDomNamedNodeMap::QDomNamedNodeMap()
    : impl(nullptr)
{
}
 
QDomNamedNodeMap::QDomNamedNodeMap(const QDomNamedNodeMap &n)
{
    impl = n.impl;
    if (impl)
        impl->ref.ref();
}
 
QDomNamedNodeMap::QDomNamedNodeMap(QDomNamedNodeMapPrivate *n)
{
    impl = n;
    if (impl)
        impl->ref.ref();
}
 
QDomNamedNodeMap& QDomNamedNodeMap::operator=(const QDomNamedNodeMap &n)
{
    if (n.impl)
        n.impl->ref.ref();
    if (impl && !impl->ref.deref())
        delete impl;
    impl = n.impl;
    return *this;
}
 
bool QDomNamedNodeMap::operator== (const QDomNamedNodeMap& n) const
{
    return (impl == n.impl);
}
 
bool QDomNamedNodeMap::operator!= (const QDomNamedNodeMap& n) const
{
    return (impl != n.impl);
}
 
QDomNamedNodeMap::~QDomNamedNodeMap()
{
    if (impl && !impl->ref.deref())
        delete impl;
}
 
QDomNode QDomNamedNodeMap::namedItem(const QString& name) const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->namedItem(name));
}
 
QDomNode QDomNamedNodeMap::setNamedItem(const QDomNode& newNode)
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->setNamedItem(static_cast<QDomNodePrivate *>(newNode.impl)));
}
 
QDomNode QDomNamedNodeMap::removeNamedItem(const QString& name)
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->removeNamedItem(name));
}
 
QDomNode QDomNamedNodeMap::item(int index) const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->item(index));
}
 
QDomNode QDomNamedNodeMap::namedItemNS(const QString& nsURI, const QString& localName) const
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->namedItemNS(nsURI, localName));
}
 
QDomNode QDomNamedNodeMap::setNamedItemNS(const QDomNode& newNode)
{
    if (!impl)
        return QDomNode();
    return QDomNode(IMPL->setNamedItemNS(static_cast<QDomNodePrivate *>(newNode.impl)));
}
 
QDomNode QDomNamedNodeMap::removeNamedItemNS(const QString& nsURI, const QString& localName)
{
    if (!impl)
        return QDomNode();
    QDomNodePrivate *n = IMPL->namedItemNS(nsURI, localName);
    if (!n)
        return QDomNode();
    return QDomNode(IMPL->removeNamedItem(n->name));
}
 
int QDomNamedNodeMap::length() const
{
    if (!impl)
        return 0;
    return IMPL->length();
}
 
bool QDomNamedNodeMap::contains(const QString& name) const
{
    if (!impl)
        return false;
    return IMPL->contains(name);
}
 
#undef IMPL
 
/**************************************************************
 *
 * QDomDocumentTypePrivate
 *
 **************************************************************/
 
QDomDocumentTypePrivate::QDomDocumentTypePrivate(QDomDocumentPrivate* doc, QDomNodePrivate* parent)
    : QDomNodePrivate(doc, parent)
{
    init();
}
 
QDomDocumentTypePrivate::QDomDocumentTypePrivate(QDomDocumentTypePrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
    init();
    // Refill the maps with our new children
    QDomNodePrivate* p = first;
    while (p) {
        if (p->isEntity())
            // Don't use normal insert function since we would create infinite recursion
            entities->map.insert(p->nodeName(), p);
        if (p->isNotation())
            // Don't use normal insert function since we would create infinite recursion
            notations->map.insert(p->nodeName(), p);
        p = p->next;
    }
}
 
QDomDocumentTypePrivate::~QDomDocumentTypePrivate()
{
    if (!entities->ref.deref())
        delete entities;
    if (!notations->ref.deref())
        delete notations;
}
 
void QDomDocumentTypePrivate::init()
{
    entities = new QDomNamedNodeMapPrivate(this);
    QT_TRY {
        notations = new QDomNamedNodeMapPrivate(this);
        publicId.clear();
        systemId.clear();
        internalSubset.clear();
 
        entities->setAppendToParent(true);
        notations->setAppendToParent(true);
    } QT_CATCH(...) {
        delete entities;
        QT_RETHROW;
    }
}
 
QDomNodePrivate* QDomDocumentTypePrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomDocumentTypePrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
QDomNodePrivate* QDomDocumentTypePrivate::insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild)
{
    // Call the original implementation
    QDomNodePrivate* p = QDomNodePrivate::insertBefore(newChild, refChild);
    // Update the maps
    if (p && p->isEntity())
        entities->map.insert(p->nodeName(), p);
    else if (p && p->isNotation())
        notations->map.insert(p->nodeName(), p);
 
    return p;
}
 
QDomNodePrivate* QDomDocumentTypePrivate::insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild)
{
    // Call the original implementation
    QDomNodePrivate* p = QDomNodePrivate::insertAfter(newChild, refChild);
    // Update the maps
    if (p && p->isEntity())
        entities->map.insert(p->nodeName(), p);
    else if (p && p->isNotation())
        notations->map.insert(p->nodeName(), p);
 
    return p;
}
 
QDomNodePrivate* QDomDocumentTypePrivate::replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild)
{
    // Call the original implementation
    QDomNodePrivate* p = QDomNodePrivate::replaceChild(newChild, oldChild);
    // Update the maps
    if (p) {
        if (oldChild && oldChild->isEntity())
            entities->map.remove(oldChild->nodeName());
        else if (oldChild && oldChild->isNotation())
            notations->map.remove(oldChild->nodeName());
 
        if (p->isEntity())
            entities->map.insert(p->nodeName(), p);
        else if (p->isNotation())
            notations->map.insert(p->nodeName(), p);
    }
 
    return p;
}
 
QDomNodePrivate* QDomDocumentTypePrivate::removeChild(QDomNodePrivate* oldChild)
{
    // Call the original implementation
    QDomNodePrivate* p = QDomNodePrivate::removeChild( oldChild);
    // Update the maps
    if (p && p->isEntity())
        entities->map.remove(p->nodeName());
    else if (p && p->isNotation())
        notations->map.remove(p ->nodeName());
 
    return p;
}
 
QDomNodePrivate* QDomDocumentTypePrivate::appendChild(QDomNodePrivate* newChild)
{
    return insertAfter(newChild, nullptr);
}
 
static QString quotedValue(const QString &data)
{
    QChar quote = data.indexOf(u'\'') == -1 ? u'\'' : u'"';
    return quote + data + quote;
}
 
void QDomDocumentTypePrivate::save(QTextStream& s, int, int indent) const
{
    if (name.isEmpty())
        return;
 
    s << "<!DOCTYPE " << name;
 
    if (!publicId.isNull()) {
        s << " PUBLIC " << quotedValue(publicId);
        if (!systemId.isNull()) {
            s << ' ' << quotedValue(systemId);
        }
    } else if (!systemId.isNull()) {
        s << " SYSTEM " << quotedValue(systemId);
    }
 
    if (entities->length()>0 || notations->length()>0) {
        s << " [" << Qt::endl;
 
        auto it2 = notations->map.constBegin();
        for (; it2 != notations->map.constEnd(); ++it2)
            it2.value()->save(s, 0, indent);
 
        auto it = entities->map.constBegin();
        for (; it != entities->map.constEnd(); ++it)
            it.value()->save(s, 0, indent);
 
        s << ']';
    }
 
    s << '>' << Qt::endl;
}
 
/**************************************************************
 *
 * QDomDocumentType
 *
 **************************************************************/
 
#define IMPL static_cast<QDomDocumentTypePrivate *>(impl)
 
QDomDocumentType::QDomDocumentType() : QDomNode()
{
}
 
QDomDocumentType::QDomDocumentType(const QDomDocumentType& n)
    : QDomNode(n)
{
}
 
QDomDocumentType::QDomDocumentType(QDomDocumentTypePrivate* n)
    : QDomNode(n)
{
}
 
QDomDocumentType &QDomDocumentType::operator=(const QDomDocumentType &n) = default;
QString QDomDocumentType::name() const
{
    if (!impl)
        return QString();
    return IMPL->nodeName();
}
 
QDomNamedNodeMap QDomDocumentType::entities() const
{
    if (!impl)
        return QDomNamedNodeMap();
    return QDomNamedNodeMap(IMPL->entities);
}
 
QDomNamedNodeMap QDomDocumentType::notations() const
{
    if (!impl)
        return QDomNamedNodeMap();
    return QDomNamedNodeMap(IMPL->notations);
}
 
QString QDomDocumentType::publicId() const
{
    if (!impl)
        return QString();
    return IMPL->publicId;
}
 
QString QDomDocumentType::systemId() const
{
    if (!impl)
        return QString();
    return IMPL->systemId;
}
 
QString QDomDocumentType::internalSubset() const
{
    if (!impl)
        return QString();
    return IMPL->internalSubset;
}
 
/*
    Are these needed at all? The only difference when removing these
    two methods in all subclasses is that we'd get a different type
    for null nodes.
*/
 
#undef IMPL
 
/**************************************************************
 *
 * QDomDocumentFragmentPrivate
 *
 **************************************************************/
 
QDomDocumentFragmentPrivate::QDomDocumentFragmentPrivate(QDomDocumentPrivate* doc, QDomNodePrivate* parent)
    : QDomNodePrivate(doc, parent)
{
    name = u"#document-fragment"_s;
}
 
QDomDocumentFragmentPrivate::QDomDocumentFragmentPrivate(QDomNodePrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
}
 
QDomNodePrivate* QDomDocumentFragmentPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomDocumentFragmentPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
/**************************************************************
 *
 * QDomDocumentFragment
 *
 **************************************************************/
 
QDomDocumentFragment::QDomDocumentFragment()
{
}
 
QDomDocumentFragment::QDomDocumentFragment(QDomDocumentFragmentPrivate* n)
    : QDomNode(n)
{
}
 
QDomDocumentFragment::QDomDocumentFragment(const QDomDocumentFragment& x)
    : QDomNode(x)
{
}
 
QDomDocumentFragment &QDomDocumentFragment::operator=(const QDomDocumentFragment &x) = default;
 
/**************************************************************
 *
 * QDomCharacterDataPrivate
 *
 **************************************************************/
 
QDomCharacterDataPrivate::QDomCharacterDataPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p,
                                                      const QString& data)
    : QDomNodePrivate(d, p)
{
    value = data;
    name = u"#character-data"_s;
}
 
QDomCharacterDataPrivate::QDomCharacterDataPrivate(QDomCharacterDataPrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
}
 
QDomNodePrivate* QDomCharacterDataPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomCharacterDataPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
int QDomCharacterDataPrivate::dataLength() const
{
    return value.size();
}
 
QString QDomCharacterDataPrivate::substringData(unsigned long offset, unsigned long n) const
{
    return value.mid(offset, n);
}
 
void QDomCharacterDataPrivate::insertData(unsigned long offset, const QString& arg)
{
    value.insert(offset, arg);
}
 
void QDomCharacterDataPrivate::deleteData(unsigned long offset, unsigned long n)
{
    value.remove(offset, n);
}
 
void QDomCharacterDataPrivate::replaceData(unsigned long offset, unsigned long n, const QString& arg)
{
    value.replace(offset, n, arg);
}
 
void QDomCharacterDataPrivate::appendData(const QString& arg)
{
    value += arg;
}
 
/**************************************************************
 *
 * QDomCharacterData
 *
 **************************************************************/
 
#define IMPL static_cast<QDomCharacterDataPrivate *>(impl)
 
QDomCharacterData::QDomCharacterData()
{
}
 
QDomCharacterData::QDomCharacterData(const QDomCharacterData& x)
    : QDomNode(x)
{
}
 
QDomCharacterData::QDomCharacterData(QDomCharacterDataPrivate* n)
    : QDomNode(n)
{
}
 
QDomCharacterData &QDomCharacterData::operator=(const QDomCharacterData &x) = default;
 
QString QDomCharacterData::data() const
{
    if (!impl)
        return QString();
    return impl->nodeValue();
}
 
void QDomCharacterData::setData(const QString& v)
{
    if (impl)
        impl->setNodeValue(v);
}
 
int QDomCharacterData::length() const
{
    if (impl)
        return IMPL->dataLength();
    return 0;
}
 
QString QDomCharacterData::substringData(unsigned long offset, unsigned long count)
{
    if (!impl)
        return QString();
    return IMPL->substringData(offset, count);
}
 
void QDomCharacterData::appendData(const QString& arg)
{
    if (impl)
        IMPL->appendData(arg);
}
 
void QDomCharacterData::insertData(unsigned long offset, const QString& arg)
{
    if (impl)
        IMPL->insertData(offset, arg);
}
 
void QDomCharacterData::deleteData(unsigned long offset, unsigned long count)
{
    if (impl)
        IMPL->deleteData(offset, count);
}
 
void QDomCharacterData::replaceData(unsigned long offset, unsigned long count, const QString& arg)
{
    if (impl)
        IMPL->replaceData(offset, count, arg);
}
 
QDomNode::NodeType QDomCharacterData::nodeType() const
{
    if (!impl)
        return CharacterDataNode;
    return QDomNode::nodeType();
}
 
#undef IMPL
 
/**************************************************************
 *
 * QDomAttrPrivate
 *
 **************************************************************/
 
QDomAttrPrivate::QDomAttrPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& name_)
    : QDomNodePrivate(d, parent)
{
    name = name_;
    m_specified = false;
}
 
QDomAttrPrivate::QDomAttrPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p, const QString& nsURI, const QString& qName)
    : QDomNodePrivate(d, p)
{
    qt_split_namespace(prefix, name, qName, !nsURI.isNull());
    namespaceURI = nsURI;
    createdWithDom1Interface = false;
    m_specified = false;
}
 
QDomAttrPrivate::QDomAttrPrivate(QDomAttrPrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
    m_specified = n->specified();
}
 
void QDomAttrPrivate::setNodeValue(const QString& v)
{
    value = v;
    QDomTextPrivate *t = new QDomTextPrivate(nullptr, this, v);
    // keep the refcount balanced: appendChild() does a ref anyway.
    t->ref.deref();
    if (first) {
        auto removed = removeChild(first);
        if (removed && !removed->ref.loadRelaxed()) // removeChild() already deref()ed
            delete removed;
    }
    appendChild(t);
}
 
QDomNodePrivate* QDomAttrPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomAttrPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
bool QDomAttrPrivate::specified() const
{
    return m_specified;
}
 
/* \internal
  Encode & escape \a str. Yes, it makes no sense to return a QString,
  but is so for legacy reasons.
 
  Remember that content produced should be able to roundtrip with 2.11 End-of-Line Handling
  and 3.3.3 Attribute-Value Normalization.
 
  If \a performAVN is true, characters will be escaped to survive Attribute Value Normalization.
  If \a encodeEOLs is true, characters will be escaped to survive End-of-Line Handling.
*/
static QString encodeText(const QString &str,
                          const bool encodeQuotes = true,
                          const bool performAVN = false,
                          const bool encodeEOLs = false)
{
    QString retval(str);
    int len = retval.size();
    int i = 0;
 
    while (i < len) {
        const QChar ati(retval.at(i));
 
        if (ati == u'<') {
            retval.replace(i, 1, "&lt;"_L1);
            len += 3;
            i += 4;
        } else if (encodeQuotes && (ati == u'"')) {
            retval.replace(i, 1, "&quot;"_L1);
            len += 5;
            i += 6;
        } else if (ati == u'&') {
            retval.replace(i, 1, "&amp;"_L1);
            len += 4;
            i += 5;
        } else if (ati == u'>' && i >= 2 && retval[i - 1] == u']' && retval[i - 2] == u']') {
            retval.replace(i, 1, "&gt;"_L1);
            len += 3;
            i += 4;
        } else if (performAVN &&
                   (ati == QChar(0xA) ||
                    ati == QChar(0xD) ||
                    ati == QChar(0x9))) {
            const QString replacement(u"&#x"_s + QString::number(ati.unicode(), 16) + u';');
            retval.replace(i, 1, replacement);
            i += replacement.size();
            len += replacement.size() - 1;
        } else if (encodeEOLs && ati == QChar(0xD)) {
            retval.replace(i, 1, "&#xd;"_L1); // Replace a single 0xD with a ref for 0xD
            len += 4;
            i += 5;
        } else {
            ++i;
        }
    }
 
    return retval;
}
 
void QDomAttrPrivate::save(QTextStream& s, int, int) const
{
    if (namespaceURI.isNull()) {
        s << name << "=\"" << encodeText(value, true, true) << '\"';
    } else {
        s << prefix << ':' << name << "=\"" << encodeText(value, true, true) << '\"';
        /* This is a fix for 138243, as good as it gets.
         *
         * QDomElementPrivate::save() output a namespace declaration if
         * the element is in a namespace, no matter what. This function do as well, meaning
         * that we get two identical namespace declaration if we don't have the if-
         * statement below.
         *
         * This doesn't work when the parent element has the same prefix as us but
         * a different namespace. However, this can only occur by the user modifying the element,
         * and we don't do fixups by that anyway, and hence it's the user responsibility to not
         * arrive in those situations. */
        if (!ownerNode ||
           ownerNode->prefix != prefix) {
            s << " xmlns:" << prefix << "=\"" << encodeText(namespaceURI, true, true) << '\"';
        }
    }
}
 
/**************************************************************
 *
 * QDomAttr
 *
 **************************************************************/
 
#define IMPL static_cast<QDomAttrPrivate *>(impl)
 
QDomAttr::QDomAttr()
{
}
 
QDomAttr::QDomAttr(const QDomAttr& x)
    : QDomNode(x)
{
}
 
QDomAttr::QDomAttr(QDomAttrPrivate* n)
    : QDomNode(n)
{
}
 
QDomAttr &QDomAttr::operator=(const QDomAttr &x) = default;
 
QString QDomAttr::name() const
{
    if (!impl)
        return QString();
    return impl->nodeName();
}
 
bool QDomAttr::specified() const
{
    if (!impl)
        return false;
    return IMPL->specified();
}
 
QDomElement QDomAttr::ownerElement() const
{
    Q_ASSERT(impl->parent());
    if (!impl->parent()->isElement())
        return QDomElement();
    return QDomElement(static_cast<QDomElementPrivate *>(impl->parent()));
}
 
QString QDomAttr::value() const
{
    if (!impl)
        return QString();
    return impl->nodeValue();
}
 
void QDomAttr::setValue(const QString& v)
{
    if (!impl)
        return;
    impl->setNodeValue(v);
    IMPL->m_specified = true;
}
 
#undef IMPL
 
/**************************************************************
 *
 * QDomElementPrivate
 *
 **************************************************************/
 
QDomElementPrivate::QDomElementPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p,
                                          const QString& tagname)
    : QDomNodePrivate(d, p)
{
    name = tagname;
    m_attr = new QDomNamedNodeMapPrivate(this);
}
 
QDomElementPrivate::QDomElementPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p,
        const QString& nsURI, const QString& qName)
    : QDomNodePrivate(d, p)
{
    qt_split_namespace(prefix, name, qName, !nsURI.isNull());
    namespaceURI = nsURI;
    createdWithDom1Interface = false;
    m_attr = new QDomNamedNodeMapPrivate(this);
}
 
QDomElementPrivate::QDomElementPrivate(QDomElementPrivate* n, bool deep) :
    QDomNodePrivate(n, deep)
{
    m_attr = n->m_attr->clone(this);
    // Reference is down to 0, so we set it to 1 here.
    m_attr->ref.ref();
}
 
QDomElementPrivate::~QDomElementPrivate()
{
    if (!m_attr->ref.deref())
        delete m_attr;
}
 
QDomNodePrivate* QDomElementPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomElementPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
QString QDomElementPrivate::attribute(const QString& name_, const QString& defValue) const
{
    QDomNodePrivate* n = m_attr->namedItem(name_);
    if (!n)
        return defValue;
 
    return n->nodeValue();
}
 
QString QDomElementPrivate::attributeNS(const QString& nsURI, const QString& localName, const QString& defValue) const
{
    QDomNodePrivate* n = m_attr->namedItemNS(nsURI, localName);
    if (!n)
        return defValue;
 
    return n->nodeValue();
}
 
void QDomElementPrivate::setAttribute(const QString& aname, const QString& newValue)
{
    QDomNodePrivate* n = m_attr->namedItem(aname);
    if (!n) {
        n = new QDomAttrPrivate(ownerDocument(), this, aname);
        n->setNodeValue(newValue);
 
        // Referencing is done by the map, so we set the reference counter back
        // to 0 here. This is ok since we created the QDomAttrPrivate.
        n->ref.deref();
        m_attr->setNamedItem(n);
    } else {
        n->setNodeValue(newValue);
    }
}
 
void QDomElementPrivate::setAttributeNS(const QString& nsURI, const QString& qName, const QString& newValue)
{
    QString prefix, localName;
    qt_split_namespace(prefix, localName, qName, true);
    QDomNodePrivate* n = m_attr->namedItemNS(nsURI, localName);
    if (!n) {
        n = new QDomAttrPrivate(ownerDocument(), this, nsURI, qName);
        n->setNodeValue(newValue);
 
        // Referencing is done by the map, so we set the reference counter back
        // to 0 here. This is ok since we created the QDomAttrPrivate.
        n->ref.deref();
        m_attr->setNamedItem(n);
    } else {
        n->setNodeValue(newValue);
        n->prefix = prefix;
    }
}
 
void QDomElementPrivate::removeAttribute(const QString& aname)
{
    QDomNodePrivate* p = m_attr->removeNamedItem(aname);
    if (p && p->ref.loadRelaxed() == 0)
        delete p;
}
 
QDomAttrPrivate* QDomElementPrivate::attributeNode(const QString& aname)
{
    return static_cast<QDomAttrPrivate *>(m_attr->namedItem(aname));
}
 
QDomAttrPrivate* QDomElementPrivate::attributeNodeNS(const QString& nsURI, const QString& localName)
{
    return static_cast<QDomAttrPrivate *>(m_attr->namedItemNS(nsURI, localName));
}
 
QDomAttrPrivate* QDomElementPrivate::setAttributeNode(QDomAttrPrivate* newAttr)
{
    QDomNodePrivate* n = m_attr->namedItem(newAttr->nodeName());
 
    // Referencing is done by the maps
    m_attr->setNamedItem(newAttr);
 
    newAttr->setParent(this);
 
    return static_cast<QDomAttrPrivate *>(n);
}
 
QDomAttrPrivate* QDomElementPrivate::setAttributeNodeNS(QDomAttrPrivate* newAttr)
{
    QDomNodePrivate* n = nullptr;
    if (!newAttr->prefix.isNull())
        n = m_attr->namedItemNS(newAttr->namespaceURI, newAttr->name);
 
    // Referencing is done by the maps
    m_attr->setNamedItem(newAttr);
 
    return static_cast<QDomAttrPrivate *>(n);
}
 
QDomAttrPrivate* QDomElementPrivate::removeAttributeNode(QDomAttrPrivate* oldAttr)
{
    return static_cast<QDomAttrPrivate *>(m_attr->removeNamedItem(oldAttr->nodeName()));
}
 
bool QDomElementPrivate::hasAttribute(const QString& aname)
{
    return m_attr->contains(aname);
}
 
bool QDomElementPrivate::hasAttributeNS(const QString& nsURI, const QString& localName)
{
    return m_attr->containsNS(nsURI, localName);
}
 
QString QDomElementPrivate::text()
{
    QString t(u""_s);
 
    QDomNodePrivate* p = first;
    while (p) {
        if (p->isText() || p->isCDATASection())
            t += p->nodeValue();
        else if (p->isElement())
            t += static_cast<QDomElementPrivate *>(p)->text();
        p = p->next;
    }
 
    return t;
}
 
void QDomElementPrivate::save(QTextStream& s, int depth, int indent) const
{
    if (!(prev && prev->isText()))
        s << QString(indent < 1 ? 0 : depth * indent, u' ');
 
    QString qName(name);
    QString nsDecl(u""_s);
    if (!namespaceURI.isNull()) {
        if (prefix.isEmpty()) {
            nsDecl = u" xmlns"_s;
        } else {
            qName = prefix + u':' + name;
            nsDecl = u" xmlns:"_s + prefix;
        }
        nsDecl += u"=\""_s + encodeText(namespaceURI) + u'\"';
    }
    s << '<' << qName << nsDecl;
 
 
    /* Write out attributes. */
    if (!m_attr->map.isEmpty()) {
        /*
         * To ensure that we always output attributes in a consistent
         * order, sort the attributes before writing them into the
         * stream. (Note that the order may be different than the one
         * that e.g. we've read from a file, or the program order in
         * which these attributes have been populated. We just want to
         * guarantee reproducibile outputs.)
         */
        struct SavedAttribute {
            QString prefix;
            QString name;
            QString encodedValue;
        };
 
        /* Gather all the attributes to save. */
        QVarLengthArray<SavedAttribute, 8> attributesToSave;
        attributesToSave.reserve(m_attr->map.size());
 
        QDuplicateTracker<QString> outputtedPrefixes;
        for (const auto &[key, value] : std::as_const(m_attr->map).asKeyValueRange()) {
            Q_UNUSED(key); /* We extract the attribute name from the value. */
            bool mayNeedXmlNS = false;
 
            SavedAttribute attr;
            attr.name = value->name;
            attr.encodedValue = encodeText(value->value, true, true);
            if (!value->namespaceURI.isNull()) {
                attr.prefix = value->prefix;
                mayNeedXmlNS = true;
            }
 
            attributesToSave.push_back(std::move(attr));
 
            /*
             * This is a fix for 138243, as good as it gets.
             *
             * QDomElementPrivate::save() output a namespace
             * declaration if the element is in a namespace, no matter
             * what. This function do as well, meaning that we get two
             * identical namespace declaration if we don't have the if-
             * statement below.
             *
             * This doesn't work when the parent element has the same
             * prefix as us but a different namespace. However, this
             * can only occur by the user modifying the element, and we
             * don't do fixups by that anyway, and hence it's the user
             * responsibility to avoid those situations.
             */
 
            if (mayNeedXmlNS
                && ((!value->ownerNode || value->ownerNode->prefix != value->prefix)
                    && !outputtedPrefixes.hasSeen(value->prefix)))
            {
                SavedAttribute nsAttr;
                nsAttr.prefix = QStringLiteral("xmlns");
                nsAttr.name = value->prefix;
                nsAttr.encodedValue = encodeText(value->namespaceURI, true, true);
                attributesToSave.push_back(std::move(nsAttr));
            }
        }
 
        /* Sort the attributes by prefix and name. */
        const auto savedAttributeComparator = [](const SavedAttribute &lhs, const SavedAttribute &rhs)
        {
            const int cmp = QString::compare(lhs.prefix, rhs.prefix);
            return (cmp < 0) || ((cmp == 0) && (lhs.name < rhs.name));
        };
 
        std::sort(attributesToSave.begin(), attributesToSave.end(), savedAttributeComparator);
 
        /* Actually stream the sorted attributes. */
        for (const auto &attr : attributesToSave) {
            s << ' ';
            if (!attr.prefix.isEmpty())
                s << attr.prefix << ':';
            s << attr.name << "=\"" << attr.encodedValue << '\"';
        }
    }
 
    if (last) {
        // has child nodes
        if (first->isText())
            s << '>';
        else {
            s << '>';
 
            /* -1 disables new lines. */
            if (indent != -1)
                s << Qt::endl;
        }
        QDomNodePrivate::save(s, depth + 1, indent); if (!last->isText())
            s << QString(indent < 1 ? 0 : depth * indent, u' ');
 
        s << "</" << qName << '>';
    } else {
        s << "/>";
    }
    if (!(next && next->isText())) {
        /* -1 disables new lines. */
        if (indent != -1)
            s << Qt::endl;
    }
}
 
/**************************************************************
 *
 * QDomElement
 *
 **************************************************************/
 
#define IMPL static_cast<QDomElementPrivate *>(impl)
 
QDomElement::QDomElement()
    : QDomNode()
{
}
 
QDomElement::QDomElement(const QDomElement& x)
    : QDomNode(x)
{
}
 
QDomElement::QDomElement(QDomElementPrivate* n)
    : QDomNode(n)
{
}
 
QDomElement &QDomElement::operator=(const QDomElement &x) = default;
 
void QDomElement::setTagName(const QString& name)
{
    if (impl)
        impl->name = name;
}
 
QString QDomElement::tagName() const
{
    if (!impl)
        return QString();
    return impl->nodeName();
}
 
 
QDomNamedNodeMap QDomElement::attributes() const
{
    if (!impl)
        return QDomNamedNodeMap();
    return QDomNamedNodeMap(IMPL->attributes());
}
 
QString QDomElement::attribute(const QString& name, const QString& defValue) const
{
    if (!impl)
        return defValue;
    return IMPL->attribute(name, defValue);
}
 
void QDomElement::setAttribute(const QString& name, const QString& value)
{
    if (!impl)
        return;
    IMPL->setAttribute(name, value);
}
 
void QDomElement::setAttribute(const QString& name, qlonglong value)
{
    if (!impl)
        return;
    QString x;
    x.setNum(value);
    IMPL->setAttribute(name, x);
}
 
void QDomElement::setAttribute(const QString& name, qulonglong value)
{
    if (!impl)
        return;
    QString x;
    x.setNum(value);
    IMPL->setAttribute(name, x);
}
 
void QDomElement::setAttribute(const QString& name, float value)
{
    if (!impl)
        return;
    QString x;
    x.setNum(value, 'g', 8);
    IMPL->setAttribute(name, x);
}
 
void QDomElement::setAttribute(const QString& name, double value)
{
    if (!impl)
        return;
    QString x;
    x.setNum(value, 'g', 17);
    IMPL->setAttribute(name, x);
}
 
void QDomElement::removeAttribute(const QString& name)
{
    if (!impl)
        return;
    IMPL->removeAttribute(name);
}
 
QDomAttr QDomElement::attributeNode(const QString& name)
{
    if (!impl)
        return QDomAttr();
    return QDomAttr(IMPL->attributeNode(name));
}
 
QDomAttr QDomElement::setAttributeNode(const QDomAttr& newAttr)
{
    if (!impl)
        return QDomAttr();
    return QDomAttr(IMPL->setAttributeNode(static_cast<QDomAttrPrivate *>(newAttr.impl)));
}
 
QDomAttr QDomElement::removeAttributeNode(const QDomAttr& oldAttr)
{
    if (!impl)
        return QDomAttr(); // ### should this return oldAttr?
    return QDomAttr(IMPL->removeAttributeNode(static_cast<QDomAttrPrivate *>(oldAttr.impl)));
}
 
QDomNodeList QDomElement::elementsByTagName(const QString& tagname) const
{
    return QDomNodeList(new QDomNodeListPrivate(impl, tagname));
}
 
bool QDomElement::hasAttribute(const QString& name) const
{
    if (!impl)
        return false;
    return IMPL->hasAttribute(name);
}
 
QString QDomElement::attributeNS(const QString& nsURI, const QString& localName, const QString& defValue) const
{
    if (!impl)
        return defValue;
    return IMPL->attributeNS(nsURI, localName, defValue);
}
 
void QDomElement::setAttributeNS(const QString& nsURI, const QString& qName, const QString& value)
{
    if (!impl)
        return;
    IMPL->setAttributeNS(nsURI, qName, value);
}
 
void QDomElement::setAttributeNS(const QString& nsURI, const QString& qName, qlonglong value)
{
    if (!impl)
        return;
    QString x;
    x.setNum(value);
    IMPL->setAttributeNS(nsURI, qName, x);
}
 
void QDomElement::setAttributeNS(const QString& nsURI, const QString& qName, qulonglong value)
{
    if (!impl)
        return;
    QString x;
    x.setNum(value);
    IMPL->setAttributeNS(nsURI, qName, x);
}
 
void QDomElement::setAttributeNS(const QString& nsURI, const QString& qName, double value)
{
    if (!impl)
        return;
    QString x;
    x.setNum(value, 'g', 17);
    IMPL->setAttributeNS(nsURI, qName, x);
}
 
void QDomElement::removeAttributeNS(const QString& nsURI, const QString& localName)
{
    if (!impl)
        return;
    QDomNodePrivate *n = IMPL->attributeNodeNS(nsURI, localName);
    if (!n)
        return;
    IMPL->removeAttribute(n->nodeName());
}
 
QDomAttr QDomElement::attributeNodeNS(const QString& nsURI, const QString& localName)
{
    if (!impl)
        return QDomAttr();
    return QDomAttr(IMPL->attributeNodeNS(nsURI, localName));
}
 
QDomAttr QDomElement::setAttributeNodeNS(const QDomAttr& newAttr)
{
    if (!impl)
        return QDomAttr();
    return QDomAttr(IMPL->setAttributeNodeNS(static_cast<QDomAttrPrivate *>(newAttr.impl)));
}
 
QDomNodeList QDomElement::elementsByTagNameNS(const QString& nsURI, const QString& localName) const
{
    return QDomNodeList(new QDomNodeListPrivate(impl, nsURI, localName));
}
 
bool QDomElement::hasAttributeNS(const QString& nsURI, const QString& localName) const
{
    if (!impl)
        return false;
    return IMPL->hasAttributeNS(nsURI, localName);
}
 
QString QDomElement::text() const
{
    if (!impl)
        return QString();
    return IMPL->text();
}
 
#undef IMPL
 
/**************************************************************
 *
 * QDomTextPrivate
 *
 **************************************************************/
 
QDomTextPrivate::QDomTextPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& val)
    : QDomCharacterDataPrivate(d, parent, val)
{
    name = u"#text"_s;
}
 
QDomTextPrivate::QDomTextPrivate(QDomTextPrivate* n, bool deep)
    : QDomCharacterDataPrivate(n, deep)
{
}
 
QDomNodePrivate* QDomTextPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomTextPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
QDomTextPrivate* QDomTextPrivate::splitText(int offset)
{
    if (!parent()) {
        qWarning("QDomText::splitText  The node has no parent. So I cannot split");
        return nullptr;
    }
 
    QDomTextPrivate* t = new QDomTextPrivate(ownerDocument(), nullptr, value.mid(offset));
    value.truncate(offset);
 
    parent()->insertAfter(t, this);
 
    return t;
}
 
void QDomTextPrivate::save(QTextStream& s, int, int) const
{
    QDomTextPrivate *that = const_cast<QDomTextPrivate*>(this);
    s << encodeText(value, !(that->parent() && that->parent()->isElement()), false, true);
}
 
/**************************************************************
 *
 * QDomText
 *
 **************************************************************/
 
#define IMPL static_cast<QDomTextPrivate *>(impl)
 
QDomText::QDomText()
    : QDomCharacterData()
{
}
 
QDomText::QDomText(const QDomText& x)
    : QDomCharacterData(x)
{
}
 
QDomText::QDomText(QDomTextPrivate* n)
    : QDomCharacterData(n)
{
}
 
QDomText &QDomText::operator=(const QDomText &x) = default;
 
QDomText QDomText::splitText(int offset)
{
    if (!impl)
        return QDomText();
    return QDomText(IMPL->splitText(offset));
}
 
#undef IMPL
 
/**************************************************************
 *
 * QDomCommentPrivate
 *
 **************************************************************/
 
QDomCommentPrivate::QDomCommentPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& val)
    : QDomCharacterDataPrivate(d, parent, val)
{
    name = u"#comment"_s;
}
 
QDomCommentPrivate::QDomCommentPrivate(QDomCommentPrivate* n, bool deep)
    : QDomCharacterDataPrivate(n, deep)
{
}
 
 
QDomNodePrivate* QDomCommentPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomCommentPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
void QDomCommentPrivate::save(QTextStream& s, int depth, int indent) const
{
    /* We don't output whitespace if we would pollute a text node. */
    if (!(prev && prev->isText()))
        s << QString(indent < 1 ? 0 : depth * indent, u' ');
 
    s << "<!--" << value;
    if (value.endsWith(u'-'))
        s << ' '; // Ensures that XML comment doesn't end with --->
    s << "-->";
 
    if (!(next && next->isText()))
        s << Qt::endl;
}
 
/**************************************************************
 *
 * QDomComment
 *
 **************************************************************/
 
QDomComment::QDomComment()
    : QDomCharacterData()
{
}
 
QDomComment::QDomComment(const QDomComment& x)
    : QDomCharacterData(x)
{
}
 
QDomComment::QDomComment(QDomCommentPrivate* n)
    : QDomCharacterData(n)
{
}
 
QDomComment &QDomComment::operator=(const QDomComment &x) = default;
 
/**************************************************************
 *
 * QDomCDATASectionPrivate
 *
 **************************************************************/
 
QDomCDATASectionPrivate::QDomCDATASectionPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent,
                                                    const QString& val)
    : QDomTextPrivate(d, parent, val)
{
    name = u"#cdata-section"_s;
}
 
QDomCDATASectionPrivate::QDomCDATASectionPrivate(QDomCDATASectionPrivate* n, bool deep)
    : QDomTextPrivate(n, deep)
{
}
 
QDomNodePrivate* QDomCDATASectionPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomCDATASectionPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
void QDomCDATASectionPrivate::save(QTextStream& s, int, int) const
{
    // ### How do we escape "]]>" ?
    // "]]>" is not allowed; so there should be none in value anyway
    s << "<![CDATA[" << value << "]]>";
}
 
/**************************************************************
 *
 * QDomCDATASection
 *
 **************************************************************/
 
QDomCDATASection::QDomCDATASection()
    : QDomText()
{
}
 
QDomCDATASection::QDomCDATASection(const QDomCDATASection& x)
    : QDomText(x)
{
}
 
QDomCDATASection::QDomCDATASection(QDomCDATASectionPrivate* n)
    : QDomText(n)
{
}
 
QDomCDATASection &QDomCDATASection::operator=(const QDomCDATASection &x) = default;
 
/**************************************************************
 *
 * QDomNotationPrivate
 *
 **************************************************************/
 
QDomNotationPrivate::QDomNotationPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent,
                                            const QString& aname,
                                            const QString& pub, const QString& sys)
    : QDomNodePrivate(d, parent)
{
    name = aname;
    m_pub = pub;
    m_sys = sys;
}
 
QDomNotationPrivate::QDomNotationPrivate(QDomNotationPrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
    m_sys = n->m_sys;
    m_pub = n->m_pub;
}
 
QDomNodePrivate* QDomNotationPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomNotationPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
void QDomNotationPrivate::save(QTextStream& s, int, int) const
{
    s << "<!NOTATION " << name << ' ';
    if (!m_pub.isNull())  {
        s << "PUBLIC " << quotedValue(m_pub);
        if (!m_sys.isNull())
            s << ' ' << quotedValue(m_sys);
    }  else {
        s << "SYSTEM " << quotedValue(m_sys);
    }
    s << '>' << Qt::endl;
}
 
/**************************************************************
 *
 * QDomNotation
 *
 **************************************************************/
 
#define IMPL static_cast<QDomNotationPrivate *>(impl)
 
QDomNotation::QDomNotation()
    : QDomNode()
{
}
 
QDomNotation::QDomNotation(const QDomNotation& x)
    : QDomNode(x)
{
}
 
QDomNotation::QDomNotation(QDomNotationPrivate* n)
    : QDomNode(n)
{
}
 
QDomNotation &QDomNotation::operator=(const QDomNotation &x) = default;
 
QString QDomNotation::publicId() const
{
    if (!impl)
        return QString();
    return IMPL->m_pub;
}
 
QString QDomNotation::systemId() const
{
    if (!impl)
        return QString();
    return IMPL->m_sys;
}
 
#undef IMPL
 
/**************************************************************
 *
 * QDomEntityPrivate
 *
 **************************************************************/
 
QDomEntityPrivate::QDomEntityPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent,
                                        const QString& aname,
                                        const QString& pub, const QString& sys, const QString& notation)
    : QDomNodePrivate(d, parent)
{
    name = aname;
    m_pub = pub;
    m_sys = sys;
    m_notationName = notation;
}
 
QDomEntityPrivate::QDomEntityPrivate(QDomEntityPrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
    m_sys = n->m_sys;
    m_pub = n->m_pub;
    m_notationName = n->m_notationName;
}
 
QDomNodePrivate* QDomEntityPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomEntityPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
/*
  Encode an entity value upon saving.
*/
static QByteArray encodeEntity(const QByteArray& str)
{
    QByteArray tmp(str);
    int len = tmp.size();
    int i = 0;
    const char* d = tmp.constData();
    while (i < len) {
        if (d[i] == '%'){
            tmp.replace(i, 1, "&#60;");
            d = tmp.constData();
            len += 4;
            i += 5;
        }
        else if (d[i] == '"') {
            tmp.replace(i, 1, "&#34;");
            d = tmp.constData();
            len += 4;
            i += 5;
        } else if (d[i] == '&' && i + 1 < len && d[i+1] == '#') {
            // Don't encode &lt; or &quot; or &custom;.
            // Only encode character references
            tmp.replace(i, 1, "&#38;");
            d = tmp.constData();
            len += 4;
            i += 5;
        } else {
            ++i;
        }
    }
 
    return tmp;
}
 
void QDomEntityPrivate::save(QTextStream& s, int, int) const
{
    QString _name = name;
    if (_name.startsWith(u'%'))
        _name = u"% "_s + _name.mid(1);
 
    if (m_sys.isNull() && m_pub.isNull()) {
        s << "<!ENTITY " << _name << " \"" << encodeEntity(value.toUtf8()) << "\">" << Qt::endl;
    } else {
        s << "<!ENTITY " << _name << ' ';
        if (m_pub.isNull()) {
            s << "SYSTEM " << quotedValue(m_sys);
        } else {
            s << "PUBLIC " << quotedValue(m_pub) << ' ' << quotedValue(m_sys);
        }
        if (! m_notationName.isNull()) {
            s << " NDATA " << m_notationName;
        }
        s << '>' << Qt::endl;
    }
}
 
/**************************************************************
 *
 * QDomEntity
 *
 **************************************************************/
 
#define IMPL static_cast<QDomEntityPrivate *>(impl)
 
QDomEntity::QDomEntity()
    : QDomNode()
{
}
 
 
QDomEntity::QDomEntity(const QDomEntity& x)
    : QDomNode(x)
{
}
 
QDomEntity::QDomEntity(QDomEntityPrivate* n)
    : QDomNode(n)
{
}
 
QDomEntity &QDomEntity::operator=(const QDomEntity &x) = default;
 
QString QDomEntity::publicId() const
{
    if (!impl)
        return QString();
    return IMPL->m_pub;
}
 
QString QDomEntity::systemId() const
{
    if (!impl)
        return QString();
    return IMPL->m_sys;
}
 
QString QDomEntity::notationName() const
{
    if (!impl)
        return QString();
    return IMPL->m_notationName;
}
 
#undef IMPL
 
/**************************************************************
 *
 * QDomEntityReferencePrivate
 *
 **************************************************************/
 
QDomEntityReferencePrivate::QDomEntityReferencePrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& aname)
    : QDomNodePrivate(d, parent)
{
    name = aname;
}
 
QDomEntityReferencePrivate::QDomEntityReferencePrivate(QDomNodePrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
}
 
QDomNodePrivate* QDomEntityReferencePrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomEntityReferencePrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
void QDomEntityReferencePrivate::save(QTextStream& s, int, int) const
{
    s << '&' << name << ';';
}
 
/**************************************************************
 *
 * QDomEntityReference
 *
 **************************************************************/
 
QDomEntityReference::QDomEntityReference()
    : QDomNode()
{
}
 
QDomEntityReference::QDomEntityReference(const QDomEntityReference& x)
    : QDomNode(x)
{
}
 
QDomEntityReference::QDomEntityReference(QDomEntityReferencePrivate* n)
    : QDomNode(n)
{
}
 
QDomEntityReference &QDomEntityReference::operator=(const QDomEntityReference &x) = default;
 
/**************************************************************
 *
 * QDomProcessingInstructionPrivate
 *
 **************************************************************/
 
QDomProcessingInstructionPrivate::QDomProcessingInstructionPrivate(QDomDocumentPrivate* d,
        QDomNodePrivate* parent, const QString& target, const QString& data)
    : QDomNodePrivate(d, parent)
{
    name = target;
    value = data;
}
 
QDomProcessingInstructionPrivate::QDomProcessingInstructionPrivate(QDomProcessingInstructionPrivate* n, bool deep)
    : QDomNodePrivate(n, deep)
{
}
 
 
QDomNodePrivate* QDomProcessingInstructionPrivate::cloneNode(bool deep)
{
    QDomNodePrivate* p = new QDomProcessingInstructionPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
void QDomProcessingInstructionPrivate::save(QTextStream& s, int, int) const
{
    s << "<?" << name << ' ' << value << "?>" << Qt::endl;
}
 
/**************************************************************
 *
 * QDomProcessingInstruction
 *
 **************************************************************/
 
QDomProcessingInstruction::QDomProcessingInstruction()
    : QDomNode()
{
}
 
QDomProcessingInstruction::QDomProcessingInstruction(const QDomProcessingInstruction& x)
    : QDomNode(x)
{
}
 
QDomProcessingInstruction::QDomProcessingInstruction(QDomProcessingInstructionPrivate* n)
    : QDomNode(n)
{
}
 
QDomProcessingInstruction &
QDomProcessingInstruction::operator=(const QDomProcessingInstruction &x) = default;
 
QString QDomProcessingInstruction::target() const
{
    if (!impl)
        return QString();
    return impl->nodeName();
}
 
QString QDomProcessingInstruction::data() const
{
    if (!impl)
        return QString();
    return impl->nodeValue();
}
 
void QDomProcessingInstruction::setData(const QString& d)
{
    if (!impl)
        return;
    impl->setNodeValue(d);
}
 
/**************************************************************
 *
 * QDomDocumentPrivate
 *
 **************************************************************/
 
QDomDocumentPrivate::QDomDocumentPrivate()
    : QDomNodePrivate(nullptr),
      impl(new QDomImplementationPrivate),
      nodeListTime(1)
{
    type = new QDomDocumentTypePrivate(this, this);
    type->ref.deref();
 
    name = u"#document"_s;
}
 
QDomDocumentPrivate::QDomDocumentPrivate(const QString& aname)
    : QDomNodePrivate(nullptr),
      impl(new QDomImplementationPrivate),
      nodeListTime(1)
{
    type = new QDomDocumentTypePrivate(this, this);
    type->ref.deref();
    type->name = aname;
 
    name = u"#document"_s;
}
 
QDomDocumentPrivate::QDomDocumentPrivate(QDomDocumentTypePrivate* dt)
    : QDomNodePrivate(nullptr),
      impl(new QDomImplementationPrivate),
      nodeListTime(1)
{
    if (dt != nullptr) {
        type = dt;
    } else {
        type = new QDomDocumentTypePrivate(this, this);
        type->ref.deref();
    }
 
    name = u"#document"_s;
}
 
QDomDocumentPrivate::QDomDocumentPrivate(QDomDocumentPrivate* n, bool deep)
    : QDomNodePrivate(n, deep),
      impl(n->impl->clone()),
      nodeListTime(1)
{
    type = static_cast<QDomDocumentTypePrivate*>(n->type->cloneNode());
    type->setParent(this);
}
 
QDomDocumentPrivate::~QDomDocumentPrivate()
{
}
 
void QDomDocumentPrivate::clear()
{
    impl.reset();
    type.reset();
    QDomNodePrivate::clear();
}
 
QDomDocument::ParseResult QDomDocumentPrivate::setContent(QXmlStreamReader *reader,
                                                          QDomDocument::ParseOptions options)
{
    clear();
    impl = new QDomImplementationPrivate;
    type = new QDomDocumentTypePrivate(this, this);
    type->ref.deref();
 
    if (!reader) {
        const auto error = u"Failed to set content, XML reader is not initialized"_s;
        qWarning("%s", qPrintable(error));
        return { error };
    }
 
    QDomParser domParser(this, reader, options);
 
    if (!domParser.parse())
        return domParser.result();
    return {};
}
 
QDomNodePrivate* QDomDocumentPrivate::cloneNode(bool deep)
{
    QDomNodePrivate *p = new QDomDocumentPrivate(this, deep);
    // We are not interested in this node
    p->ref.deref();
    return p;
}
 
QDomElementPrivate* QDomDocumentPrivate::documentElement()
{
    QDomNodePrivate *p = first;
    while (p && !p->isElement())
        p = p->next;
 
    return static_cast<QDomElementPrivate *>(p);
}
 
QDomElementPrivate* QDomDocumentPrivate::createElement(const QString &tagName)
{
    bool ok;
    QString fixedName = fixedXmlName(tagName, &ok);
    if (!ok)
        return nullptr;
 
    QDomElementPrivate *e = new QDomElementPrivate(this, nullptr, fixedName);
    e->ref.deref();
    return e;
}
 
QDomElementPrivate* QDomDocumentPrivate::createElementNS(const QString &nsURI, const QString &qName)
{
    bool ok;
    QString fixedName = fixedXmlName(qName, &ok, true);
    if (!ok)
        return nullptr;
 
    QDomElementPrivate *e = new QDomElementPrivate(this, nullptr, nsURI, fixedName);
    e->ref.deref();
    return e;
}
 
QDomDocumentFragmentPrivate* QDomDocumentPrivate::createDocumentFragment()
{
    QDomDocumentFragmentPrivate *f = new QDomDocumentFragmentPrivate(this, nullptr);
    f->ref.deref();
    return f;
}
 
QDomTextPrivate* QDomDocumentPrivate::createTextNode(const QString &data)
{
    bool ok;
    QString fixedData = fixedCharData(data, &ok);
    if (!ok)
        return nullptr;
 
    QDomTextPrivate *t = new QDomTextPrivate(this, nullptr, fixedData);
    t->ref.deref();
    return t;
}
 
QDomCommentPrivate* QDomDocumentPrivate::createComment(const QString &data)
{
    bool ok;
    QString fixedData = fixedComment(data, &ok);
    if (!ok)
        return nullptr;
 
    QDomCommentPrivate *c = new QDomCommentPrivate(this, nullptr, fixedData);
    c->ref.deref();
    return c;
}
 
QDomCDATASectionPrivate* QDomDocumentPrivate::createCDATASection(const QString &data)
{
    bool ok;
    QString fixedData = fixedCDataSection(data, &ok);
    if (!ok)
        return nullptr;
 
    QDomCDATASectionPrivate *c = new QDomCDATASectionPrivate(this, nullptr, fixedData);
    c->ref.deref();
    return c;
}
 
QDomProcessingInstructionPrivate* QDomDocumentPrivate::createProcessingInstruction(const QString &target,
                                                                                   const QString &data)
{
    bool ok;
    QString fixedData = fixedPIData(data, &ok);
    if (!ok)
        return nullptr;
    // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
    QString fixedTarget = fixedXmlName(target, &ok);
    if (!ok)
        return nullptr;
 
    QDomProcessingInstructionPrivate *p = new QDomProcessingInstructionPrivate(this, nullptr, fixedTarget, fixedData);
    p->ref.deref();
    return p;
}
QDomAttrPrivate* QDomDocumentPrivate::createAttribute(const QString &aname)
{
    bool ok;
    QString fixedName = fixedXmlName(aname, &ok);
    if (!ok)
        return nullptr;
 
    QDomAttrPrivate *a = new QDomAttrPrivate(this, nullptr, fixedName);
    a->ref.deref();
    return a;
}
 
QDomAttrPrivate* QDomDocumentPrivate::createAttributeNS(const QString &nsURI, const QString &qName)
{
    bool ok;
    QString fixedName = fixedXmlName(qName, &ok, true);
    if (!ok)
        return nullptr;
 
    QDomAttrPrivate *a = new QDomAttrPrivate(this, nullptr, nsURI, fixedName);
    a->ref.deref();
    return a;
}
 
QDomEntityReferencePrivate* QDomDocumentPrivate::createEntityReference(const QString &aname)
{
    bool ok;
    QString fixedName = fixedXmlName(aname, &ok);
    if (!ok)
        return nullptr;
 
    QDomEntityReferencePrivate *e = new QDomEntityReferencePrivate(this, nullptr, fixedName);
    e->ref.deref();
    return e;
}
 
QDomNodePrivate* QDomDocumentPrivate::importNode(QDomNodePrivate *importedNode, bool deep)
{
    QDomNodePrivate *node = nullptr;
    switch (importedNode->nodeType()) {
        case QDomNode::AttributeNode:
            node = new QDomAttrPrivate(static_cast<QDomAttrPrivate *>(importedNode), true);
            break;
        case QDomNode::DocumentFragmentNode:
            node = new QDomDocumentFragmentPrivate(
                    static_cast<QDomDocumentFragmentPrivate *>(importedNode), deep);
            break;
        case QDomNode::ElementNode:
            node = new QDomElementPrivate(static_cast<QDomElementPrivate *>(importedNode), deep);
            break;
        case QDomNode::EntityNode:
            node = new QDomEntityPrivate(static_cast<QDomEntityPrivate *>(importedNode), deep);
            break;
        case QDomNode::EntityReferenceNode:
            node = new QDomEntityReferencePrivate(
                    static_cast<QDomEntityReferencePrivate *>(importedNode), false);
            break;
        case QDomNode::NotationNode:
            node = new QDomNotationPrivate(static_cast<QDomNotationPrivate *>(importedNode), deep);
            break;
        case QDomNode::ProcessingInstructionNode:
            node = new QDomProcessingInstructionPrivate(
                    static_cast<QDomProcessingInstructionPrivate *>(importedNode), deep);
            break;
        case QDomNode::TextNode:
            node = new QDomTextPrivate(static_cast<QDomTextPrivate *>(importedNode), deep);
            break;
        case QDomNode::CDATASectionNode:
            node = new QDomCDATASectionPrivate(static_cast<QDomCDATASectionPrivate *>(importedNode),
                                               deep);
            break;
        case QDomNode::CommentNode:
            node = new QDomCommentPrivate(static_cast<QDomCommentPrivate *>(importedNode), deep);
            break;
        default:
            break;
    }
    if (node) {
        node->setOwnerDocument(this);
        // The QDomNode constructor increases the refcount, so deref first to
        // keep refcount balanced.
        node->ref.deref();
    }
    return node;
}
 
void QDomDocumentPrivate::saveDocument(QTextStream& s, const int indent, QDomNode::EncodingPolicy encUsed) const
{
    const QDomNodePrivate* n = first;
 
    if (encUsed == QDomNode::EncodingFromDocument) {
#if QT_CONFIG(regularexpression)
        const QDomNodePrivate* n = first;
 
        if (n && n->isProcessingInstruction() && n->nodeName() == "xml"_L1) {
            // we have an XML declaration
            QString data = n->nodeValue();
            QRegularExpression encoding(QString::fromLatin1("encoding\\s*=\\s*((\"([^\"]*)\")|('([^']*)'))"));
            auto match = encoding.match(data);
            QString enc = match.captured(3);
            if (enc.isEmpty())
                enc = match.captured(5);
            if (!enc.isEmpty()) {
                auto encoding = QStringConverter::encodingForName(enc.toUtf8().constData());
                if (!encoding)
                    qWarning() << "QDomDocument::save(): Unsupported encoding" << enc << "specified.";
                else
                    s.setEncoding(encoding.value());
            }
        }
#endif
        bool doc = false;
 
        while (n) {
            if (!doc && !(n->isProcessingInstruction() && n->nodeName() == "xml"_L1)) {
                // save doctype after XML declaration
                type->save(s, 0, indent);
                doc = true;
            }
            n->save(s, 0, indent);
            n = n->next;
        }
    }
    else {
 
        // Write out the XML declaration.
        const QByteArray codecName = QStringConverter::nameForEncoding(s.encoding());
 
        s << "<?xml version=\"1.0\" encoding=\""
          << codecName
          << "\"?>\n";
 
        //  Skip the first processing instruction by name "xml", if any such exists.
        const QDomNodePrivate* startNode = n;
 
        // First, we try to find the PI and sets the startNode to the one appearing after it.
        while (n) {
            if (n->isProcessingInstruction() && n->nodeName() == "xml"_L1) {
                startNode = n->next;
                break;
            }
            else
                n = n->next;
        }
 
        // Now we serialize all the nodes after the faked XML declaration(the PI).
        while(startNode) {
            startNode->save(s, 0, indent);
            startNode = startNode->next;
        }
    }
}
 
/**************************************************************
 *
 * QDomDocument
 *
 **************************************************************/
 
#define IMPL static_cast<QDomDocumentPrivate *>(impl)
 
QDomDocument::QDomDocument()
{
    impl = nullptr;
}
 
QDomDocument::QDomDocument(const QString& name)
{
    // We take over ownership
    impl = new QDomDocumentPrivate(name);
}
 
QDomDocument::QDomDocument(const QDomDocumentType& doctype)
{
    impl = new QDomDocumentPrivate(static_cast<QDomDocumentTypePrivate *>(doctype.impl));
}
 
QDomDocument::QDomDocument(const QDomDocument& x)
    : QDomNode(x)
{
}
 
QDomDocument::QDomDocument(QDomDocumentPrivate* x)
    : QDomNode(x)
{
}
 
QDomDocument &QDomDocument::operator=(const QDomDocument &x) = default;
 
QDomDocument::~QDomDocument()
{
}
 
#if QT_DEPRECATED_SINCE(6, 8)
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
bool QDomDocument::setContent(const QString& text, bool namespaceProcessing,
                              QString *errorMsg, int *errorLine, int *errorColumn)
{
    QXmlStreamReader reader(text);
    reader.setNamespaceProcessing(namespaceProcessing);
    return setContent(&reader, namespaceProcessing, errorMsg, errorLine, errorColumn);
}
 
 
 
bool QDomDocument::setContent(const QByteArray &data, bool namespaceProcessing,
                              QString *errorMsg, int *errorLine, int *errorColumn)
{
    QXmlStreamReader reader(data);
    reader.setNamespaceProcessing(namespaceProcessing);
    return setContent(&reader, namespaceProcessing, errorMsg, errorLine, errorColumn);
}
 
static inline QDomDocument::ParseOptions toParseOptions(bool namespaceProcessing)
{
    return namespaceProcessing ? QDomDocument::ParseOption::UseNamespaceProcessing
                               : QDomDocument::ParseOption::Default;
}
 
static inline void unpackParseResult(const QDomDocument::ParseResult &parseResult,
                                     QString *errorMsg, int *errorLine, int *errorColumn)
{
    if (!parseResult) {
        if (errorMsg)
            *errorMsg = parseResult.errorMessage;
        if (errorLine)
            *errorLine = static_cast<int>(parseResult.errorLine);
        if (errorColumn)
            *errorColumn = static_cast<int>(parseResult.errorLine);
    }
}
 
bool QDomDocument::setContent(QIODevice* dev, bool namespaceProcessing,
                              QString *errorMsg, int *errorLine, int *errorColumn)
{
    ParseResult result = setContent(dev, toParseOptions(namespaceProcessing));
    unpackParseResult(result, errorMsg, errorLine, errorColumn);
    return bool(result);
}
 
bool QDomDocument::setContent(const QString& text, QString *errorMsg, int *errorLine, int *errorColumn)
{
    return setContent(text, false, errorMsg, errorLine, errorColumn);
}
 
bool QDomDocument::setContent(const QByteArray& buffer, QString *errorMsg, int *errorLine, int *errorColumn )
{
    return setContent(buffer, false, errorMsg, errorLine, errorColumn);
}
 
bool QDomDocument::setContent(QIODevice* dev, QString *errorMsg, int *errorLine, int *errorColumn )
{
    return setContent(dev, false, errorMsg, errorLine, errorColumn);
}
 
bool QDomDocument::setContent(QXmlStreamReader *reader, bool namespaceProcessing,
                              QString *errorMsg, int *errorLine, int *errorColumn)
{
    ParseResult result = setContent(reader, toParseOptions(namespaceProcessing));
    unpackParseResult(result, errorMsg, errorLine, errorColumn);
    return bool(result);
}
QT_WARNING_POP
#endif // QT_DEPRECATED_SINCE(6, 8)
 
QDomDocument::ParseResult QDomDocument::setContentImpl(const QByteArray &data, ParseOptions options)
{
    QXmlStreamReader reader(data);
    reader.setNamespaceProcessing(options.testFlag(ParseOption::UseNamespaceProcessing));
    return setContent(&reader, options);
}
 
QDomDocument::ParseResult QDomDocument::setContent(QAnyStringView data, ParseOptions options)
{
    QXmlStreamReader reader(data);
    reader.setNamespaceProcessing(options.testFlag(ParseOption::UseNamespaceProcessing));
    return setContent(&reader, options);
}
 
QDomDocument::ParseResult QDomDocument::setContent(QIODevice *device, ParseOptions options)
{
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
    if (!device->isOpen()) {
        qWarning("QDomDocument called with unopened QIODevice. "
                 "This will not be supported in future Qt versions.");
        if (!device->open(QIODevice::ReadOnly)) {
            const auto error = u"QDomDocument::setContent: Failed to open device."_s;
            qWarning("%s", qPrintable(error));
            return { error };
        }
    }
#endif
 
    QXmlStreamReader reader(device);
    reader.setNamespaceProcessing(options.testFlag(ParseOption::UseNamespaceProcessing));
    return setContent(&reader, options);
}
 
QDomDocument::ParseResult QDomDocument::setContent(QXmlStreamReader *reader, ParseOptions options)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return IMPL->setContent(reader, options);
}
 
QString QDomDocument::toString(int indent) const
{
    QString str;
    QTextStream s(&str, QIODevice::WriteOnly);
    save(s, indent);
    return str;
}
 
QByteArray QDomDocument::toByteArray(int indent) const
{
    // ### if there is an encoding specified in the xml declaration, this
    // encoding declaration should be changed to utf8
    return toString(indent).toUtf8();
}
 
 
QDomDocumentType QDomDocument::doctype() const
{
    if (!impl)
        return QDomDocumentType();
    return QDomDocumentType(IMPL->doctype());
}
 
QDomImplementation QDomDocument::implementation() const
{
    if (!impl)
        return QDomImplementation();
    return QDomImplementation(IMPL->implementation());
}
 
QDomElement QDomDocument::documentElement() const
{
    if (!impl)
        return QDomElement();
    return QDomElement(IMPL->documentElement());
}
 
QDomElement QDomDocument::createElement(const QString& tagName)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomElement(IMPL->createElement(tagName));
}
 
QDomDocumentFragment QDomDocument::createDocumentFragment()
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomDocumentFragment(IMPL->createDocumentFragment());
}
 
QDomText QDomDocument::createTextNode(const QString& value)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomText(IMPL->createTextNode(value));
}
 
QDomComment QDomDocument::createComment(const QString& value)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomComment(IMPL->createComment(value));
}
 
QDomCDATASection QDomDocument::createCDATASection(const QString& value)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomCDATASection(IMPL->createCDATASection(value));
}
 
QDomProcessingInstruction QDomDocument::createProcessingInstruction(const QString& target,
                                                                    const QString& data)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomProcessingInstruction(IMPL->createProcessingInstruction(target, data));
}
 
 
QDomAttr QDomDocument::createAttribute(const QString& name)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomAttr(IMPL->createAttribute(name));
}
 
QDomEntityReference QDomDocument::createEntityReference(const QString& name)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomEntityReference(IMPL->createEntityReference(name));
}
 
QDomNodeList QDomDocument::elementsByTagName(const QString& tagname) const
{
    return QDomNodeList(new QDomNodeListPrivate(impl, tagname));
}
 
QDomNode QDomDocument::importNode(const QDomNode& importedNode, bool deep)
{
    if (importedNode.isNull())
        return QDomNode();
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomNode(IMPL->importNode(importedNode.impl, deep));
}
 
QDomElement QDomDocument::createElementNS(const QString& nsURI, const QString& qName)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomElement(IMPL->createElementNS(nsURI, qName));
}
 
QDomAttr QDomDocument::createAttributeNS(const QString& nsURI, const QString& qName)
{
    if (!impl)
        impl = new QDomDocumentPrivate();
    return QDomAttr(IMPL->createAttributeNS(nsURI, qName));
}
 
QDomNodeList QDomDocument::elementsByTagNameNS(const QString& nsURI, const QString& localName)
{
    return QDomNodeList(new QDomNodeListPrivate(impl, nsURI, localName));
}
 
QDomElement QDomDocument::elementById(const QString& /*elementId*/)
{
    qWarning("elementById() is not implemented and will always return a null node.");
    return QDomElement();
}
 
#undef IMPL
 
/**************************************************************
 *
 * Node casting functions
 *
 **************************************************************/
 
QDomAttr QDomNode::toAttr() const
{
    if (impl && impl->isAttr())
        return QDomAttr(static_cast<QDomAttrPrivate *>(impl));
    return QDomAttr();
}
 
QDomCDATASection QDomNode::toCDATASection() const
{
    if (impl && impl->isCDATASection())
        return QDomCDATASection(static_cast<QDomCDATASectionPrivate *>(impl));
    return QDomCDATASection();
}
 
QDomDocumentFragment QDomNode::toDocumentFragment() const
{
    if (impl && impl->isDocumentFragment())
        return QDomDocumentFragment(static_cast<QDomDocumentFragmentPrivate *>(impl));
    return QDomDocumentFragment();
}
 
QDomDocument QDomNode::toDocument() const
{
    if (impl && impl->isDocument())
        return QDomDocument(static_cast<QDomDocumentPrivate *>(impl));
    return QDomDocument();
}
 
QDomDocumentType QDomNode::toDocumentType() const
{
    if (impl && impl->isDocumentType())
        return QDomDocumentType(static_cast<QDomDocumentTypePrivate *>(impl));
    return QDomDocumentType();
}
 
QDomElement QDomNode::toElement() const
{
    if (impl && impl->isElement())
        return QDomElement(static_cast<QDomElementPrivate *>(impl));
    return QDomElement();
}
 
QDomEntityReference QDomNode::toEntityReference() const
{
    if (impl && impl->isEntityReference())
        return QDomEntityReference(static_cast<QDomEntityReferencePrivate *>(impl));
    return QDomEntityReference();
}
 
QDomText QDomNode::toText() const
{
    if (impl && impl->isText())
        return QDomText(static_cast<QDomTextPrivate *>(impl));
    return QDomText();
}
 
QDomEntity QDomNode::toEntity() const
{
    if (impl && impl->isEntity())
        return QDomEntity(static_cast<QDomEntityPrivate *>(impl));
    return QDomEntity();
}
 
QDomNotation QDomNode::toNotation() const
{
    if (impl && impl->isNotation())
        return QDomNotation(static_cast<QDomNotationPrivate *>(impl));
    return QDomNotation();
}
 
QDomProcessingInstruction QDomNode::toProcessingInstruction() const
{
    if (impl && impl->isProcessingInstruction())
        return QDomProcessingInstruction(static_cast<QDomProcessingInstructionPrivate *>(impl));
    return QDomProcessingInstruction();
}
 
QDomCharacterData QDomNode::toCharacterData() const
{
    if (impl && impl->isCharacterData())
        return QDomCharacterData(static_cast<QDomCharacterDataPrivate *>(impl));
    return QDomCharacterData();
}
 
QDomComment QDomNode::toComment() const
{
    if (impl && impl->isComment())
        return QDomComment(static_cast<QDomCommentPrivate *>(impl));
    return QDomComment();
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_DOM