summaryrefslogtreecommitdiffstats
path: root/src/xml
diff options
context:
space:
mode:
authorLars Knoll <lars.knoll@nokia.com>2009-03-23 09:18:55 (GMT)
committerSimon Hausmann <simon.hausmann@nokia.com>2009-03-23 09:18:55 (GMT)
commite5fcad302d86d316390c6b0f62759a067313e8a9 (patch)
treec2afbf6f1066b6ce261f14341cf6d310e5595bc1 /src/xml
downloadQt-e5fcad302d86d316390c6b0f62759a067313e8a9.zip
Qt-e5fcad302d86d316390c6b0f62759a067313e8a9.tar.gz
Qt-e5fcad302d86d316390c6b0f62759a067313e8a9.tar.bz2
Long live Qt 4.5!
Diffstat (limited to 'src/xml')
-rw-r--r--src/xml/dom/dom.pri2
-rw-r--r--src/xml/dom/qdom.cpp7563
-rw-r--r--src/xml/dom/qdom.h681
-rw-r--r--src/xml/sax/qxml.cpp8114
-rw-r--r--src/xml/sax/qxml.h425
-rw-r--r--src/xml/sax/sax.pri2
-rw-r--r--src/xml/stream/qxmlstream.h73
-rw-r--r--src/xml/stream/stream.pri9
-rw-r--r--src/xml/xml.pro20
9 files changed, 16889 insertions, 0 deletions
diff --git a/src/xml/dom/dom.pri b/src/xml/dom/dom.pri
new file mode 100644
index 0000000..d86071e
--- /dev/null
+++ b/src/xml/dom/dom.pri
@@ -0,0 +1,2 @@
+HEADERS += $$PWD/qdom.h
+SOURCES += $$PWD/qdom.cpp
diff --git a/src/xml/dom/qdom.cpp b/src/xml/dom/qdom.cpp
new file mode 100644
index 0000000..550abc9
--- /dev/null
+++ b/src/xml/dom/qdom.cpp
@@ -0,0 +1,7563 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qplatformdefs.h>
+#include <qdom.h>
+#include "private/qxmlutils_p.h"
+
+#ifndef QT_NO_DOM
+
+#include <qatomic.h>
+#include <qbuffer.h>
+#include <qhash.h>
+#include <qiodevice.h>
+#include <qlist.h>
+#include <qregexp.h>
+#include <qtextcodec.h>
+#include <qtextstream.h>
+#include <qxml.h>
+#include <qvariant.h>
+#include <qmap.h>
+#include <qdebug.h>
+#include <stdio.h>
+
+QT_BEGIN_NAMESPACE
+
+/*
+ ### 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 emtpy 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.
+
+ The virtual isXxx functions in *Private can probably be replaced by inline methods checking the nodeType().
+*/
+
+/*
+ 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)
+{
+ int i = qName.indexOf(QLatin1Char(':'));
+ if (i == -1) {
+ if (hasURI)
+ prefix = QLatin1String("");
+ else
+ prefix.clear();
+ name = qName;
+ } else {
+ prefix = qName.left(i);
+ name = qName.mid(i + 1);
+ }
+}
+
+/**************************************************************
+ *
+ * Private class declerations
+ *
+ **************************************************************/
+
+class QDomImplementationPrivate
+{
+public:
+ QDomImplementationPrivate() { ref = 1; }
+ QDomImplementationPrivate* clone();
+ QAtomicInt ref;
+ static QDomImplementation::InvalidDataPolicy invalidDataPolicy;
+};
+
+class QDomNodePrivate
+{
+public:
+ QDomNodePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0);
+ QDomNodePrivate(QDomNodePrivate* n, bool deep);
+ virtual ~QDomNodePrivate();
+
+ QString nodeName() const { return name; }
+ QString nodeValue() const { return value; }
+ virtual void setNodeValue(const QString& v) { value = v; }
+
+ QDomDocumentPrivate* ownerDocument();
+ void setOwnerDocument(QDomDocumentPrivate* doc);
+
+ virtual QDomNodePrivate* insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild);
+ virtual QDomNodePrivate* insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild);
+ virtual QDomNodePrivate* replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild);
+ virtual QDomNodePrivate* removeChild(QDomNodePrivate* oldChild);
+ virtual QDomNodePrivate* appendChild(QDomNodePrivate* newChild);
+
+ QDomNodePrivate* namedItem(const QString& name);
+
+ virtual QDomNodePrivate* cloneNode(bool deep = true);
+ virtual void normalize();
+ virtual void clear();
+
+ inline QDomNodePrivate* parent() const { return hasParent ? ownerNode : 0; }
+ inline void setParent(QDomNodePrivate *p) { ownerNode = p; hasParent = true; }
+
+ void setNoParent() {
+ ownerNode = hasParent ? (QDomNodePrivate*)ownerDocument() : 0;
+ hasParent = false;
+ }
+
+ // Dynamic cast
+ virtual bool isAttr() const { return false; }
+ virtual bool isCDATASection() const { return false; }
+ virtual bool isDocumentFragment() const { return false; }
+ virtual bool isDocument() const { return false; }
+ virtual bool isDocumentType() const { return false; }
+ virtual bool isElement() const { return false; }
+ virtual bool isEntityReference() const { return false; }
+ virtual bool isText() const { return false; }
+ virtual bool isEntity() const { return false; }
+ virtual bool isNotation() const { return false; }
+ virtual bool isProcessingInstruction() const { return false; }
+ virtual bool isCharacterData() const { return false; }
+ virtual bool isComment() const { return false; }
+
+ virtual QDomNode::NodeType nodeType() const { return QDomNode::BaseNode; }
+
+ virtual void save(QTextStream&, int, int) const;
+
+ void setLocation(int lineNumber, int columnNumber);
+
+ // Variables
+ QAtomicInt ref;
+ QDomNodePrivate* prev;
+ QDomNodePrivate* next;
+ QDomNodePrivate* ownerNode; // either the node's parent or the node's owner document
+ QDomNodePrivate* first;
+ QDomNodePrivate* last;
+
+ QString name; // this is the local name if prefix != null
+ QString value;
+ QString prefix; // set this only for ElementNode and AttributeNode
+ QString namespaceURI; // set this only for ElementNode and AttributeNode
+ bool createdWithDom1Interface : 1;
+ bool hasParent : 1;
+
+ int lineNumber;
+ int columnNumber;
+};
+
+class QDomNodeListPrivate
+{
+public:
+ QDomNodeListPrivate(QDomNodePrivate*);
+ QDomNodeListPrivate(QDomNodePrivate*, const QString& );
+ QDomNodeListPrivate(QDomNodePrivate*, const QString&, const QString& );
+ ~QDomNodeListPrivate();
+
+ bool operator== (const QDomNodeListPrivate&) const;
+ bool operator!= (const QDomNodeListPrivate&) const;
+
+ void createList();
+ QDomNodePrivate* item(int index);
+ uint length() const;
+
+ QAtomicInt ref;
+ /*
+ This list contains the children of this node.
+ */
+ QDomNodePrivate* node_impl;
+ QString tagname;
+ QString nsURI;
+ QList<QDomNodePrivate*> list;
+ long timestamp;
+};
+
+class QDomNamedNodeMapPrivate
+{
+public:
+ QDomNamedNodeMapPrivate(QDomNodePrivate*);
+ ~QDomNamedNodeMapPrivate();
+
+ QDomNodePrivate* namedItem(const QString& name) const;
+ QDomNodePrivate* namedItemNS(const QString& nsURI, const QString& localName) const;
+ QDomNodePrivate* setNamedItem(QDomNodePrivate* arg);
+ QDomNodePrivate* setNamedItemNS(QDomNodePrivate* arg);
+ QDomNodePrivate* removeNamedItem(const QString& name);
+ QDomNodePrivate* item(int index) const;
+ uint length() const;
+ bool contains(const QString& name) const;
+ bool containsNS(const QString& nsURI, const QString & localName) const;
+
+ /**
+ * Remove all children from the map.
+ */
+ void clearMap();
+ bool isReadOnly() { return readonly; }
+ void setReadOnly(bool r) { readonly = r; }
+ bool isAppendToParent() { return appendToParent; }
+ /**
+ * If true, then the node will redirect insert/remove calls
+ * to its parent by calling QDomNodePrivate::appendChild or removeChild.
+ * In addition the map wont increase or decrease the reference count
+ * of the nodes it contains.
+ *
+ * By default this value is false and the map will handle reference counting
+ * by itself.
+ */
+ void setAppendToParent(bool b) { appendToParent = b; }
+
+ /**
+ * Creates a copy of the map. It is a deep copy
+ * that means that all children are cloned.
+ */
+ QDomNamedNodeMapPrivate* clone(QDomNodePrivate* parent);
+
+ // Variables
+ QAtomicInt ref;
+ QHash<QString, QDomNodePrivate *> map;
+ QDomNodePrivate* parent;
+ bool readonly;
+ bool appendToParent;
+};
+
+class QDomDocumentTypePrivate : public QDomNodePrivate
+{
+public:
+ QDomDocumentTypePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0);
+ QDomDocumentTypePrivate(QDomDocumentTypePrivate* n, bool deep);
+ ~QDomDocumentTypePrivate();
+ void init();
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ QDomNodePrivate* insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild);
+ QDomNodePrivate* insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild);
+ QDomNodePrivate* replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild);
+ QDomNodePrivate* removeChild(QDomNodePrivate* oldChild);
+ QDomNodePrivate* appendChild(QDomNodePrivate* newChild);
+
+ virtual bool isDocumentType() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::DocumentTypeNode; }
+
+ void save(QTextStream& s, int, int) const;
+
+ // Variables
+ QDomNamedNodeMapPrivate* entities;
+ QDomNamedNodeMapPrivate* notations;
+ QString publicId;
+ QString systemId;
+ QString internalSubset;
+};
+
+class QDomDocumentFragmentPrivate : public QDomNodePrivate
+{
+public:
+ QDomDocumentFragmentPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0);
+ QDomDocumentFragmentPrivate(QDomNodePrivate* n, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ virtual QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isDocumentFragment() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::DocumentFragmentNode; }
+};
+
+class QDomCharacterDataPrivate : public QDomNodePrivate
+{
+public:
+ QDomCharacterDataPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& data);
+ QDomCharacterDataPrivate(QDomCharacterDataPrivate* n, bool deep);
+
+ uint dataLength() const;
+ QString substringData(unsigned long offset, unsigned long count) const;
+ void appendData(const QString& arg);
+ void insertData(unsigned long offset, const QString& arg);
+ void deleteData(unsigned long offset, unsigned long count);
+ void replaceData(unsigned long offset, unsigned long count, const QString& arg);
+
+ // Reimplemented from QDomNodePrivate
+ virtual bool isCharacterData() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::CharacterDataNode; }
+ QDomNodePrivate* cloneNode(bool deep = true);
+};
+
+class QDomTextPrivate : public QDomCharacterDataPrivate
+{
+public:
+ QDomTextPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& val);
+ QDomTextPrivate(QDomTextPrivate* n, bool deep);
+
+ QDomTextPrivate* splitText(int offset);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isText() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::TextNode; }
+ virtual void save(QTextStream& s, int, int) const;
+};
+
+class QDomAttrPrivate : public QDomNodePrivate
+{
+public:
+ QDomAttrPrivate(QDomDocumentPrivate*, QDomNodePrivate*, const QString& name);
+ QDomAttrPrivate(QDomDocumentPrivate*, QDomNodePrivate*, const QString& nsURI, const QString& qName);
+ QDomAttrPrivate(QDomAttrPrivate* n, bool deep);
+
+ bool specified() const;
+
+ // Reimplemented from QDomNodePrivate
+ void setNodeValue(const QString& v);
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isAttr() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::AttributeNode; }
+ virtual void save(QTextStream& s, int, int) const;
+
+ // Variables
+ bool m_specified;
+};
+
+class QDomElementPrivate : public QDomNodePrivate
+{
+public:
+ QDomElementPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name);
+ QDomElementPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& nsURI, const QString& qName);
+ QDomElementPrivate(QDomElementPrivate* n, bool deep);
+ ~QDomElementPrivate();
+
+ QString attribute(const QString& name, const QString& defValue) const;
+ QString attributeNS(const QString& nsURI, const QString& localName, const QString& defValue) const;
+ void setAttribute(const QString& name, const QString& value);
+ void setAttributeNS(const QString& nsURI, const QString& qName, const QString& newValue);
+ void removeAttribute(const QString& name);
+ QDomAttrPrivate* attributeNode(const QString& name);
+ QDomAttrPrivate* attributeNodeNS(const QString& nsURI, const QString& localName);
+ QDomAttrPrivate* setAttributeNode(QDomAttrPrivate* newAttr);
+ QDomAttrPrivate* setAttributeNodeNS(QDomAttrPrivate* newAttr);
+ QDomAttrPrivate* removeAttributeNode(QDomAttrPrivate* oldAttr);
+ bool hasAttribute(const QString& name);
+ bool hasAttributeNS(const QString& nsURI, const QString& localName);
+
+ QString text();
+
+ // Reimplemented from QDomNodePrivate
+ QDomNamedNodeMapPrivate* attributes() { return m_attr; }
+ bool hasAttributes() { return (m_attr->length() > 0); }
+ virtual bool isElement() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::ElementNode; }
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual void save(QTextStream& s, int, int) const;
+
+ // Variables
+ QDomNamedNodeMapPrivate* m_attr;
+};
+
+
+class QDomCommentPrivate : public QDomCharacterDataPrivate
+{
+public:
+ QDomCommentPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& val);
+ QDomCommentPrivate(QDomCommentPrivate* n, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isComment() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::CommentNode; }
+ virtual void save(QTextStream& s, int, int) const;
+};
+
+class QDomCDATASectionPrivate : public QDomTextPrivate
+{
+public:
+ QDomCDATASectionPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& val);
+ QDomCDATASectionPrivate(QDomCDATASectionPrivate* n, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isCDATASection() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::CDATASectionNode; }
+ virtual void save(QTextStream& s, int, int) const;
+};
+
+class QDomNotationPrivate : public QDomNodePrivate
+{
+public:
+ QDomNotationPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name,
+ const QString& pub, const QString& sys);
+ QDomNotationPrivate(QDomNotationPrivate* n, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isNotation() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::NotationNode; }
+ virtual void save(QTextStream& s, int, int) const;
+
+ // Variables
+ QString m_sys;
+ QString m_pub;
+};
+
+class QDomEntityPrivate : public QDomNodePrivate
+{
+public:
+ QDomEntityPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name,
+ const QString& pub, const QString& sys, const QString& notation);
+ QDomEntityPrivate(QDomEntityPrivate* n, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isEntity() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::EntityNode; }
+ virtual void save(QTextStream& s, int, int) const;
+
+ // Variables
+ QString m_sys;
+ QString m_pub;
+ QString m_notationName;
+};
+
+class QDomEntityReferencePrivate : public QDomNodePrivate
+{
+public:
+ QDomEntityReferencePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& name);
+ QDomEntityReferencePrivate(QDomNodePrivate* n, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ bool isEntityReference() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::EntityReferenceNode; }
+ virtual void save(QTextStream& s, int, int) const;
+};
+
+class QDomProcessingInstructionPrivate : public QDomNodePrivate
+{
+public:
+ QDomProcessingInstructionPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& target,
+ const QString& data);
+ QDomProcessingInstructionPrivate(QDomProcessingInstructionPrivate* n, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ virtual bool isProcessingInstruction() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::ProcessingInstructionNode; }
+ virtual void save(QTextStream& s, int, int) const;
+};
+
+class QDomDocumentPrivate : public QDomNodePrivate
+{
+public:
+ QDomDocumentPrivate();
+ QDomDocumentPrivate(const QString& name);
+ QDomDocumentPrivate(QDomDocumentTypePrivate* dt);
+ QDomDocumentPrivate(QDomDocumentPrivate* n, bool deep);
+ ~QDomDocumentPrivate();
+
+ bool setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn);
+ bool setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg, int *errorLine, int *errorColumn);
+
+ // Attributes
+ QDomDocumentTypePrivate* doctype() { return type; };
+ QDomImplementationPrivate* implementation() { return impl; };
+ QDomElementPrivate* documentElement();
+
+ // Factories
+ QDomElementPrivate* createElement(const QString& tagName);
+ QDomElementPrivate* createElementNS(const QString& nsURI, const QString& qName);
+ QDomDocumentFragmentPrivate* createDocumentFragment();
+ QDomTextPrivate* createTextNode(const QString& data);
+ QDomCommentPrivate* createComment(const QString& data);
+ QDomCDATASectionPrivate* createCDATASection(const QString& data);
+ QDomProcessingInstructionPrivate* createProcessingInstruction(const QString& target, const QString& data);
+ QDomAttrPrivate* createAttribute(const QString& name);
+ QDomAttrPrivate* createAttributeNS(const QString& nsURI, const QString& qName);
+ QDomEntityReferencePrivate* createEntityReference(const QString& name);
+
+ QDomNodePrivate* importNode(const QDomNodePrivate* importedNode, bool deep);
+
+ // Reimplemented from QDomNodePrivate
+ QDomNodePrivate* cloneNode(bool deep = true);
+ bool isDocument() const { return true; }
+ QDomNode::NodeType nodeType() const { return QDomNode::DocumentNode; }
+ void clear();
+
+ // Variables
+ QDomImplementationPrivate* impl;
+ QDomDocumentTypePrivate* type;
+
+ void saveDocument(QTextStream& stream, const int indent, QDomNode::EncodingPolicy encUsed) const;
+
+ /* \internal
+ Counter for the QDomNodeListPrivate timestamps.
+
+ This is a cache optimization, that might in some cases be effective. The
+ dilemma is that QDomNode::childNodes() returns a list, but the
+ implementation stores the children in a linked list. Hence, in order to
+ get the children out through childNodes(), a list must be populated each
+ time, which is O(N).
+
+ DOM has the requirement of node references being live, see DOM Core
+ Level 3, 1.1.1 The DOM Structure Model, which means that changes to the
+ underlying documents must be reflected in node lists.
+
+ This mechanism, nodeListTime, is a caching optimization that reduces the
+ amount of times the node list is rebuilt, by only doing so when the
+ document actually changes. However, a change to anywhere in any document
+ invalidate all lists, since no dependency tracking is done.
+
+ It functions by that all modifying functions(insertBefore() and so on)
+ increment the count; each QDomNodeListPrivate copies nodeListTime on
+ construction, and compares its own value to nodeListTime in order to
+ determine whether it needs to rebuild.
+
+ This is reentrant. The nodeListTime may overflow, but that's ok since we
+ check for equalness, not whether nodeListTime is smaller than the list's
+ stored timestamp.
+ */
+ long nodeListTime;
+};
+
+/**************************************************************
+ *
+ * QDomHandler
+ *
+ **************************************************************/
+
+class QDomHandler : public QXmlDefaultHandler
+{
+public:
+ QDomHandler(QDomDocumentPrivate* d, bool namespaceProcessing);
+ ~QDomHandler();
+
+ // content handler
+ bool endDocument();
+ bool startElement(const QString& nsURI, const QString& localName, const QString& qName, const QXmlAttributes& atts);
+ bool endElement(const QString& nsURI, const QString& localName, const QString& qName);
+ bool characters(const QString& ch);
+ bool processingInstruction(const QString& target, const QString& data);
+ bool skippedEntity(const QString& name);
+
+ // error handler
+ bool fatalError(const QXmlParseException& exception);
+
+ // lexical handler
+ bool startCDATA();
+ bool endCDATA();
+ bool startEntity(const QString &);
+ bool endEntity(const QString &);
+ bool startDTD(const QString& name, const QString& publicId, const QString& systemId);
+ bool comment(const QString& ch);
+
+ // decl handler
+ bool externalEntityDecl(const QString &name, const QString &publicId, const QString &systemId) ;
+
+ // DTD handler
+ bool notationDecl(const QString & name, const QString & publicId, const QString & systemId);
+ bool unparsedEntityDecl(const QString &name, const QString &publicId, const QString &systemId, const QString &notationName) ;
+
+ void setDocumentLocator(QXmlLocator *locator);
+
+ QString errorMsg;
+ int errorLine;
+ int errorColumn;
+
+private:
+ QDomDocumentPrivate *doc;
+ QDomNodePrivate *node;
+ QString entityName;
+ bool cdata;
+ bool nsProcessing;
+ QXmlLocator *locator;
+};
+
+/**************************************************************
+ *
+ * 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 + QLatin1Char(':') + 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;
+ for (int i = 0; i < data.size(); ++i) {
+ QChar c = data.at(i);
+ if (QXmlUtils::isChar(c)) {
+ result.append(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 (;;) {
+ int idx = fixedData.indexOf(QLatin1String("--"));
+ 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 (;;) {
+ int idx = fixedData.indexOf(QLatin1String("]]>"));
+ 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 (;;) {
+ int idx = fixedData.indexOf(QLatin1String("?>"));
+ 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(QLatin1Char('\'')) != -1
+ && result.indexOf(QLatin1Char('"')) != -1) {
+ if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
+ *ok = false;
+ return QString();
+ } else {
+ result.remove(QLatin1Char('\''));
+ }
+ }
+
+ *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(QLatin1Char('\'')) != -1
+ && result.indexOf(QLatin1Char('"')) != -1) {
+ if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) {
+ *ok = false;
+ return QString();
+ } else {
+ result.remove(QLatin1Char('\''));
+ }
+ }
+
+ *ok = true;
+ return result;
+}
+
+/**************************************************************
+ *
+ * QDomImplementationPrivate
+ *
+ **************************************************************/
+
+QDomImplementationPrivate* QDomImplementationPrivate::clone()
+{
+ QDomImplementationPrivate* p = new QDomImplementationPrivate;
+ // We are not interested in this node
+ p->ref.deref();
+ return p;
+}
+
+/**************************************************************
+ *
+ * QDomImplementation
+ *
+ **************************************************************/
+
+/*!
+ \class QDomImplementation
+ \reentrant
+ \brief The QDomImplementation class provides information about the
+ features of the DOM implementation.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ This class describes the features that are supported by the DOM
+ implementation. Currently the XML subset of DOM Level 1 and DOM
+ Level 2 Core are supported.
+
+ Normally you will use the function QDomDocument::implementation()
+ to get the implementation object.
+
+ You can create a new document type with createDocumentType() and a
+ new document with createDocument().
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. For a more
+ general introduction of the DOM implementation see the QDomDocument
+ documentation.
+
+ The QDom classes have a few issues of nonconformance with the XML
+ specifications that cannot be fixed in Qt 4 without breaking backward
+ compatibility. The QtXmlPatterns module and the QXmlStreamReader and
+ QXmlStreamWriter classes have a higher degree of a conformance.
+
+ \sa hasFeature()
+*/
+
+/*!
+ Constructs a QDomImplementation object.
+*/
+QDomImplementation::QDomImplementation()
+{
+ impl = 0;
+}
+
+/*!
+ Constructs a copy of \a x.
+*/
+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();
+}
+
+/*!
+ Assigns \a x to this DOM implementation.
+*/
+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;
+}
+
+/*!
+ Returns true if \a x and this DOM implementation object were
+ created from the same QDomDocument; otherwise returns false.
+*/
+bool QDomImplementation::operator==(const QDomImplementation &x) const
+{
+ return (impl == x.impl);
+}
+
+/*!
+ Returns true if \a x and this DOM implementation object were
+ created from different QDomDocuments; otherwise returns false.
+*/
+bool QDomImplementation::operator!=(const QDomImplementation &x) const
+{
+ return (impl != x.impl);
+}
+
+/*!
+ Destroys the object and frees its resources.
+*/
+QDomImplementation::~QDomImplementation()
+{
+ if (impl && !impl->ref.deref())
+ delete impl;
+}
+
+/*!
+ The function returns true if QDom implements the requested \a
+ version of a \a feature; otherwise returns false.
+
+ The currently supported features and their versions:
+ \table
+ \header \i Feature \i Version
+ \row \i XML \i 1.0
+ \endtable
+*/
+bool QDomImplementation::hasFeature(const QString& feature, const QString& version) const
+{
+ if (feature == QLatin1String("XML")) {
+ if (version.isEmpty() || version == QLatin1String("1.0")) {
+ return true;
+ }
+ }
+ // ### add DOM level 2 features
+ return false;
+}
+
+/*!
+ Creates a document type node for the name \a qName.
+
+ \a publicId specifies the public identifier of the external
+ subset. If you specify an empty string (QString()) as the \a
+ publicId, this means that the document type has no public
+ identifier.
+
+ \a systemId specifies the system identifier of the external
+ subset. If you specify an empty string as the \a systemId, this
+ means that the document type has no system identifier.
+
+ Since you cannot have a public identifier without a system
+ identifier, the public identifier is set to an empty string if
+ there is no system identifier.
+
+ DOM level 2 does not support any other document type declaration
+ features.
+
+ The only way you can use a document type that was created this
+ way, is in combination with the createDocument() function to
+ create a QDomDocument with this document type.
+
+ In the DOM specification, this is the only way to create a non-null
+ document. For historical reasons, Qt also allows to create the
+ document using the default empty constructor. The resulting document
+ is null, but becomes non-null when a factory function, for example
+ QDomDocument::createElement(), is called. The document also becomes
+ non-null when setContent() is called.
+
+ \sa createDocument()
+*/
+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(0);
+ 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);
+}
+
+/*!
+ Creates a DOM document with the document type \a doctype. This
+ function also adds a root element node with the qualified name \a
+ qName and the namespace URI \a nsURI.
+*/
+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;
+}
+
+/*!
+ Returns false if the object was created by
+ QDomDocument::implementation(); otherwise returns true.
+*/
+bool QDomImplementation::isNull()
+{
+ return (impl == 0);
+}
+
+/*!
+ \enum QDomImplementation::InvalidDataPolicy
+
+ This enum specifies what should be done when a factory function
+ in QDomDocument is called with invalid data.
+ \value AcceptInvalidChars The data should be stored in the DOM object
+ anyway. In this case the resulting XML document might not be well-formed.
+ This is the default value and QDom's behavior in Qt < 4.1.
+ \value DropInvalidChars The invalid characters should be removed from
+ the data.
+ \value ReturnNullNode The factory function should return a null node.
+
+ \sa setInvalidDataPolicy() invalidDataPolicy()
+*/
+
+/*!
+ \enum QDomNode::EncodingPolicy
+ \since 4.3
+
+ This enum specifies how QDomNode::save() determines what encoding to use
+ when serializing.
+
+ \value EncodingFromDocument The encoding is fetched from the document.
+ \value EncodingFromTextStream The encoding is fetched from the QTextStream.
+
+ See also the overload of the save() function that takes an EncodingPolicy.
+*/
+
+/*!
+ \since 4.1
+ \nonreentrant
+
+ Returns the invalid data policy, which specifies what should be done when
+ a factory function in QDomDocument is passed invalid data.
+
+ \sa setInvalidDataPolicy() InvalidDataPolicy
+*/
+
+QDomImplementation::InvalidDataPolicy QDomImplementation::invalidDataPolicy()
+{
+ return QDomImplementationPrivate::invalidDataPolicy;
+}
+
+/*!
+ \since 4.1
+ \nonreentrant
+
+ Sets the invalid data policy, which specifies what should be done when
+ a factory function in QDomDocument is passed invalid data.
+
+ The \a policy is set for all instances of QDomDocument which already
+ exist and which will be created in the future.
+
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 0
+
+ \sa invalidDataPolicy() 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 0;
+
+ const QDomDocumentPrivate *const doc = node_impl->ownerDocument();
+ if (!doc || timestamp != doc->nodeListTime)
+ createList();
+
+ if (index >= list.size())
+ return 0;
+
+ return list.at(index);
+}
+
+uint 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.count();
+}
+
+/**************************************************************
+ *
+ * QDomNodeList
+ *
+ **************************************************************/
+
+/*!
+ \class QDomNodeList
+ \reentrant
+ \brief The QDomNodeList class is a list of QDomNode objects.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ Lists can be obtained by QDomDocument::elementsByTagName() and
+ QDomNode::childNodes(). The Document Object Model (DOM) requires
+ these lists to be "live": whenever you change the underlying
+ document, the contents of the list will get updated.
+
+ You can get a particular node from the list with item(). The
+ number of items in the list is returned by length().
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+
+ \sa QDomNode::childNodes() QDomDocument::elementsByTagName()
+*/
+
+/*!
+ Creates an empty node list.
+*/
+QDomNodeList::QDomNodeList()
+{
+ impl = 0;
+}
+
+QDomNodeList::QDomNodeList(QDomNodeListPrivate* p)
+{
+ impl = p;
+}
+
+/*!
+ Constructs a copy of \a n.
+*/
+QDomNodeList::QDomNodeList(const QDomNodeList& n)
+{
+ impl = n.impl;
+ if (impl)
+ impl->ref.ref();
+}
+
+/*!
+ Assigns \a n to this node list.
+*/
+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;
+}
+
+/*!
+ Returns true if the node list \a n and this node list are equal;
+ otherwise returns false.
+*/
+bool QDomNodeList::operator==(const QDomNodeList &n) const
+{
+ if (impl == n.impl)
+ return true;
+ if (!impl || !n.impl)
+ return false;
+ return (*impl == *n.impl);
+}
+
+/*!
+ Returns true the node list \a n and this node list are not equal;
+ otherwise returns false.
+*/
+bool QDomNodeList::operator!=(const QDomNodeList &n) const
+{
+ return !operator==(n);
+}
+
+/*!
+ Destroys the object and frees its resources.
+*/
+QDomNodeList::~QDomNodeList()
+{
+ if (impl && !impl->ref.deref())
+ delete impl;
+}
+
+/*!
+ Returns the node at position \a index.
+
+ If \a index is negative or if \a index >= length() then a null
+ node is returned (i.e. a node for which QDomNode::isNull() returns
+ true).
+
+ \sa length()
+*/
+QDomNode QDomNodeList::item(int index) const
+{
+ if (!impl)
+ return QDomNode();
+
+ return QDomNode(impl->item(index));
+}
+
+/*!
+ Returns the number of nodes in the list.
+*/
+uint QDomNodeList::length() const
+{
+ if (!impl)
+ return 0;
+ return impl->length();
+}
+
+/*!
+ \fn bool QDomNodeList::isEmpty() const
+
+ Returns true if the list contains no items; otherwise returns false.
+ This function is provided for Qt API consistency.
+*/
+
+/*!
+ \fn int QDomNodeList::count() const
+
+ This function is provided for Qt API consistency. It is equivalent to length().
+*/
+
+/*!
+ \fn int QDomNodeList::size() const
+
+ This function is provided for Qt API consistency. It is equivalent to length().
+*/
+
+/*!
+ \fn QDomNode QDomNodeList::at(int index) const
+
+ This function is provided for Qt API consistency. It is equivalent
+ to item().
+
+ If \a index is negative or if \a index >= length() then a null
+ node is returned (i.e. a node for which QDomNode::isNull() returns
+ true).
+*/
+
+/**************************************************************
+ *
+ * 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 = 0;
+ next = 0;
+ first = 0;
+ last = 0;
+ createdWithDom1Interface = true;
+ lineNumber = -1;
+ columnNumber = -1;
+}
+
+QDomNodePrivate::QDomNodePrivate(QDomNodePrivate *n, bool deep)
+{
+ ref = 1;
+ setOwnerDocument(n->ownerDocument());
+ prev = 0;
+ next = 0;
+ first = 0;
+ last = 0;
+
+ 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 = 0;
+ last = 0;
+}
+
+void QDomNodePrivate::clear()
+{
+ QDomNodePrivate* p = first;
+ QDomNodePrivate* n;
+
+ while (p) {
+ n = p->next;
+ if (!p->ref.deref())
+ delete p;
+ p = n;
+ }
+ first = 0;
+ last = 0;
+}
+
+QDomNodePrivate* QDomNodePrivate::namedItem(const QString &n)
+{
+ QDomNodePrivate* p = first;
+ while (p) {
+ if (p->nodeName() == n)
+ return p;
+ p = p->next;
+ }
+ return 0;
+}
+
+
+QDomNodePrivate* QDomNodePrivate::insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild)
+{
+ // Error check
+ if (!newChild)
+ return 0;
+
+ // Error check
+ if (newChild == refChild)
+ return 0;
+
+ // Error check
+ if (refChild && refChild->parent() != this)
+ return 0;
+
+ // "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 == 0)
+ return newChild;
+
+ // New parent
+ QDomNodePrivate* n = newChild->first;
+ while (n) {
+ n->setParent(this);
+ n = n->next;
+ }
+
+ // Insert at the beginning ?
+ if (!refChild || refChild->prev == 0) {
+ 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 = 0;
+ newChild->last = 0;
+ 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 == 0) {
+ 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 0;
+
+ // Error check
+ if (newChild == refChild)
+ return 0;
+
+ // Error check
+ if (refChild && refChild->parent() != this)
+ return 0;
+
+ // "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 == 0)
+ return newChild;
+
+ // New parent
+ QDomNodePrivate* n = newChild->first;
+ while (n) {
+ n->setParent(this);
+ n = n->next;
+ }
+
+ // Insert at the end
+ if (!refChild || refChild->next == 0) {
+ 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 = 0;
+ newChild->last = 0;
+ 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 == 0) {
+ 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 0;
+ if (oldChild->parent() != this)
+ return 0;
+ if (newChild == oldChild)
+ return 0;
+
+ // 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 == 0)
+ 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 = 0;
+ oldChild->prev = 0;
+
+ // No need to increase the reference since QDomDocumentFragment
+ // does not decrease the reference.
+
+ // Remove the nodes from the fragment
+ newChild->first = 0;
+ newChild->last = 0;
+
+ // We are no longer interested in the old node
+ if (oldChild)
+ 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 = 0;
+ oldChild->prev = 0;
+
+ // We are no longer interested in the old node
+ if (oldChild)
+ oldChild->ref.deref();
+
+ return oldChild;
+}
+
+QDomNodePrivate* QDomNodePrivate::removeChild(QDomNodePrivate* oldChild)
+{
+ // Error check
+ if (oldChild->parent() != this)
+ return 0;
+
+ // "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 == 0 && oldChild->prev == 0 && first != oldChild)
+ return 0;
+
+ 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 = 0;
+ oldChild->prev = 0;
+
+ // We are no longer interested in the old node
+ if (oldChild)
+ oldChild->ref.deref();
+
+ return oldChild;
+}
+
+QDomNodePrivate* QDomNodePrivate::appendChild(QDomNodePrivate* newChild)
+{
+ // No reference manipulation needed. Done in insertAfter.
+ return insertAfter(newChild, 0);
+}
+
+QDomDocumentPrivate* QDomNodePrivate::ownerDocument()
+{
+ QDomNodePrivate* p = this;
+ while (p && !p->isDocument()) {
+ if (!p->hasParent)
+ return (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 = 0;
+
+ while (p) {
+ if (p->isText()) {
+ if (t) {
+ QDomNodePrivate* tmp = p->next;
+ t->appendData(p->nodeValue());
+ n->removeChild(p);
+ p = tmp;
+ } else {
+ t = (QDomTextPrivate*)p;
+ p = p->next;
+ }
+ } else {
+ p = p->next;
+ t = 0;
+ }
+ }
+}
+void QDomNodePrivate::normalize()
+{
+ // ### This one has moved from QDomElementPrivate to this position. It is
+ // not tested.
+ qNormalizeNode(this);
+}
+
+/*! \internal
+ \a depth is used for indentation, it seems.
+ */
+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 ((QDomNodePrivate*)impl)
+
+/*!
+ \class QDomNode
+ \reentrant
+ \brief The QDomNode class is the base class for all the nodes in a DOM tree.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+ \mainclass
+
+ Many functions in the DOM return a QDomNode.
+
+ You can find out the type of a node using isAttr(),
+ isCDATASection(), isDocumentFragment(), isDocument(),
+ isDocumentType(), isElement(), isEntityReference(), isText(),
+ isEntity(), isNotation(), isProcessingInstruction(),
+ isCharacterData() and isComment().
+
+ A QDomNode can be converted into one of its subclasses using
+ toAttr(), toCDATASection(), toDocumentFragment(), toDocument(),
+ toDocumentType(), toElement(), toEntityReference(), toText(),
+ toEntity(), toNotation(), toProcessingInstruction(),
+ toCharacterData() or toComment(). You can convert a node to a null
+ node with clear().
+
+ Copies of the QDomNode class share their data using explicit
+ sharing. This means that modifying one node will change all
+ copies. This is especially useful in combination with functions
+ which return a QDomNode, e.g. firstChild(). You can make an
+ independent (deep) copy of the node with cloneNode().
+
+ A QDomNode can be null, much like a null pointer. Creating a copy
+ of a null node results in another null node. It is not
+ possible to modify a null node, but it is possible to assign another,
+ possibly non-null node to it. In this case, the copy of the null node
+ will remain null. You can check if a QDomNode is null by calling isNull().
+ The empty constructor of a QDomNode (or any of the derived classes) creates
+ a null node.
+
+ Nodes are inserted with insertBefore(), insertAfter() or
+ appendChild(). You can replace one node with another using
+ replaceChild() and remove a node with removeChild().
+
+ To traverse nodes use firstChild() to get a node's first child (if
+ any), and nextSibling() to traverse. QDomNode also provides
+ lastChild(), previousSibling() and parentNode(). To find the first
+ child node with a particular node name use namedItem().
+
+ To find out if a node has children use hasChildNodes() and to get
+ a list of all of a node's children use childNodes().
+
+ The node's name and value (the meaning of which varies depending
+ on its type) is returned by nodeName() and nodeValue()
+ respectively. The node's type is returned by nodeType(). The
+ node's value can be set with setNodeValue().
+
+ The document to which the node belongs is returned by
+ ownerDocument().
+
+ Adjacent QDomText nodes can be merged into a single node with
+ normalize().
+
+ \l QDomElement nodes have attributes which can be retrieved with
+ attributes().
+
+ QDomElement and QDomAttr nodes can have namespaces which can be
+ retrieved with namespaceURI(). Their local name is retrieved with
+ localName(), and their prefix with prefix(). The prefix can be set
+ with setPrefix().
+
+ You can write the XML representation of the node to a text stream
+ with save().
+
+ The following example looks for the first element in an XML document and
+ prints the names of all the elements that are its direct children.
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 1
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+/*!
+ Constructs a \link isNull() null\endlink node.
+*/
+QDomNode::QDomNode()
+{
+ impl = 0;
+}
+
+/*!
+ Constructs a copy of \a n.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomNode::QDomNode(const QDomNode &n)
+{
+ impl = n.impl;
+ if (impl)
+ impl->ref.ref();
+}
+
+/*! \internal
+ Constructs a new node for the data \a n.
+*/
+QDomNode::QDomNode(QDomNodePrivate *n)
+{
+ impl = n;
+ if (impl)
+ impl->ref.ref();
+}
+
+/*!
+ Assigns a copy of \a n to this DOM node.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+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;
+}
+
+/*!
+ Returns true if \a n and this DOM node are equal; otherwise
+ returns false.
+
+ Any instance of QDomNode acts as a reference to an underlying data
+ structure in QDomDocument. The test for equality checks if the two
+ references point to the same underlying node. For example:
+
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 2
+
+ The two nodes (QDomElement is a QDomNode subclass) both refer to
+ the document's root element, and \c {element1 == element2} will
+ return true. On the other hand:
+
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 3
+
+ Even though both nodes are empty elements carrying the same name,
+ \c {element3 == element4} will return false because they refer to
+ two different nodes in the underlying data structure.
+*/
+bool QDomNode::operator== (const QDomNode& n) const
+{
+ return (impl == n.impl);
+}
+
+/*!
+ Returns true if \a n and this DOM node are not equal; otherwise
+ returns false.
+*/
+bool QDomNode::operator!= (const QDomNode& n) const
+{
+ return (impl != n.impl);
+}
+
+/*!
+ Destroys the object and frees its resources.
+*/
+QDomNode::~QDomNode()
+{
+ if (impl && !impl->ref.deref())
+ delete impl;
+}
+
+/*!
+ Returns the name of the node.
+
+ The meaning of the name depends on the subclass:
+
+ \table
+ \header \i Name \i Meaning
+ \row \i QDomAttr \i The name of the attribute
+ \row \i QDomCDATASection \i The string "#cdata-section"
+ \row \i QDomComment \i The string "#comment"
+ \row \i QDomDocument \i The string "#document"
+ \row \i QDomDocumentFragment \i The string "#document-fragment"
+ \row \i QDomDocumentType \i The name of the document type
+ \row \i QDomElement \i The tag name
+ \row \i QDomEntity \i The name of the entity
+ \row \i QDomEntityReference \i The name of the referenced entity
+ \row \i QDomNotation \i The name of the notation
+ \row \i QDomProcessingInstruction \i The target of the processing instruction
+ \row \i QDomText \i The string "#text"
+ \endtable
+
+ \bold{Note:} This function does not take the presence of namespaces into account
+ when processing the names of element and attribute nodes. As a result, the
+ returned name can contain any namespace prefix that may be present.
+ To obtain the node name of an element or attribute, use localName(); to
+ obtain the namespace prefix, use namespaceURI().
+
+ \sa nodeValue()
+*/
+QString QDomNode::nodeName() const
+{
+ if (!impl)
+ return QString();
+
+ if (!IMPL->prefix.isEmpty())
+ return IMPL->prefix + QLatin1Char(':') + IMPL->name;
+ return IMPL->name;
+}
+
+/*!
+ Returns the value of the node.
+
+ The meaning of the value depends on the subclass:
+ \table
+ \header \i Name \i Meaning
+ \row \i QDomAttr \i The attribute value
+ \row \i QDomCDATASection \i The content of the CDATA section
+ \row \i QDomComment \i The comment
+ \row \i QDomProcessingInstruction \i The data of the processing instruction
+ \row \i QDomText \i The text
+ \endtable
+
+ All the other subclasses do not have a node value and will return
+ an empty string.
+
+ \sa setNodeValue() nodeName()
+*/
+QString QDomNode::nodeValue() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->value;
+}
+
+/*!
+ Sets the node's value to \a v.
+
+ \sa nodeValue()
+*/
+void QDomNode::setNodeValue(const QString& v)
+{
+ if (!impl)
+ return;
+ IMPL->setNodeValue(v);
+}
+
+/*!
+ \enum QDomNode::NodeType
+
+ This enum defines the type of the node:
+ \value ElementNode
+ \value AttributeNode
+ \value TextNode
+ \value CDATASectionNode
+ \value EntityReferenceNode
+ \value EntityNode
+ \value ProcessingInstructionNode
+ \value CommentNode
+ \value DocumentNode
+ \value DocumentTypeNode
+ \value DocumentFragmentNode
+ \value NotationNode
+ \value BaseNode A QDomNode object, i.e. not a QDomNode subclass.
+ \value CharacterDataNode
+*/
+
+/*!
+ Returns the type of the node.
+
+ \sa toAttr(), toCDATASection(), toDocumentFragment(),
+ toDocument() toDocumentType(), toElement(), toEntityReference(),
+ toText(), toEntity() toNotation(), toProcessingInstruction(),
+ toCharacterData(), toComment()
+*/
+QDomNode::NodeType QDomNode::nodeType() const
+{
+ if (!impl)
+ return QDomNode::BaseNode;
+ return IMPL->nodeType();
+}
+
+/*!
+ Returns the parent node. If this node has no parent, a null node
+ is returned (i.e. a node for which isNull() returns true).
+*/
+QDomNode QDomNode::parentNode() const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->parent());
+}
+
+/*!
+ Returns a list of all direct child nodes.
+
+ Most often you will call this function on a QDomElement object.
+
+ For example, if the XML document looks like this:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 4
+ Then the list of child nodes for the "body"-element will contain
+ the node created by the &lt;h1&gt; tag and the node created by the
+ &lt;p&gt; tag.
+
+ The nodes in the list are not copied; so changing the nodes in the
+ list will also change the children of this node.
+
+ \sa firstChild() lastChild()
+*/
+QDomNodeList QDomNode::childNodes() const
+{
+ if (!impl)
+ return QDomNodeList();
+ return QDomNodeList(new QDomNodeListPrivate(impl));
+}
+
+/*!
+ Returns the first child of the node. If there is no child node, a
+ \link isNull() null node\endlink is returned. Changing the
+ returned node will also change the node in the document tree.
+
+ \sa lastChild() childNodes()
+*/
+QDomNode QDomNode::firstChild() const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->first);
+}
+
+/*!
+ Returns the last child of the node. If there is no child node, a
+ \link isNull() null node\endlink is returned. Changing the
+ returned node will also change the node in the document tree.
+
+ \sa firstChild() childNodes()
+*/
+QDomNode QDomNode::lastChild() const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->last);
+}
+
+/*!
+ Returns the previous sibling in the document tree. Changing the
+ returned node will also change the node in the document tree.
+
+ For example, if you have XML like this:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 5
+ and this QDomNode represents the &lt;p&gt; tag, previousSibling()
+ will return the node representing the &lt;h1&gt; tag.
+
+ \sa nextSibling()
+*/
+QDomNode QDomNode::previousSibling() const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->prev);
+}
+
+/*!
+ Returns the next sibling in the document tree. Changing the
+ returned node will also change the node in the document tree.
+
+ If you have XML like this:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 6
+ and this QDomNode represents the <p> tag, nextSibling() will
+ return the node representing the <h2> tag.
+
+ \sa previousSibling()
+*/
+QDomNode QDomNode::nextSibling() const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->next);
+}
+
+
+// ###### don't think this is part of the DOM and
+/*!
+ Returns a named node map of all attributes. Attributes are only
+ provided for \l{QDomElement}s.
+
+ Changing the attributes in the map will also change the attributes
+ of this QDomNode.
+*/
+QDomNamedNodeMap QDomNode::attributes() const
+{
+ if (!impl || !impl->isElement())
+ return QDomNamedNodeMap();
+
+ return QDomNamedNodeMap(static_cast<QDomElementPrivate *>(impl)->attributes());
+}
+
+/*!
+ Returns the document to which this node belongs.
+*/
+QDomDocument QDomNode::ownerDocument() const
+{
+ if (!impl)
+ return QDomDocument();
+ return QDomDocument(IMPL->ownerDocument());
+}
+
+/*!
+ Creates a deep (not shallow) copy of the QDomNode.
+
+ If \a deep is true, then the cloning is done recursively which
+ means that all the node's children are deep copied too. If \a deep
+ is false only the node itself is copied and the copy will have no
+ child nodes.
+*/
+QDomNode QDomNode::cloneNode(bool deep) const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->cloneNode(deep));
+}
+
+/*!
+ Calling normalize() on an element converts all its children into a
+ standard form. This means that adjacent QDomText objects will be
+ merged into a single text object (QDomCDATASection nodes are not
+ merged).
+*/
+void QDomNode::normalize()
+{
+ if (!impl)
+ return;
+ IMPL->normalize();
+}
+
+/*!
+ Returns true if the DOM implementation implements the feature \a
+ feature and this feature is supported by this node in the version
+ \a version; otherwise returns false.
+
+ \sa QDomImplementation::hasFeature()
+*/
+bool QDomNode::isSupported(const QString& feature, const QString& version) const
+{
+ QDomImplementation i;
+ return i.hasFeature(feature, version);
+}
+
+/*!
+ Returns the namespace URI of this node or an empty string if the
+ node has no namespace URI.
+
+ Only nodes of type \link QDomNode::NodeType ElementNode\endlink or
+ \link QDomNode::NodeType AttributeNode\endlink can have
+ namespaces. A namespace URI must be specified at creation time and
+ cannot be changed later.
+
+ \sa prefix() localName() QDomDocument::createElementNS()
+ QDomDocument::createAttributeNS()
+*/
+QString QDomNode::namespaceURI() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->namespaceURI;
+}
+
+/*!
+ Returns the namespace prefix of the node or an empty string if the
+ node has no namespace prefix.
+
+ Only nodes of type \link QDomNode::NodeType ElementNode\endlink or
+ \link QDomNode::NodeType AttributeNode\endlink can have
+ namespaces. A namespace prefix must be specified at creation time.
+ If a node was created with a namespace prefix, you can change it
+ later with setPrefix().
+
+ If you create an element or attribute with
+ QDomDocument::createElement() or QDomDocument::createAttribute(),
+ the prefix will be an empty string. If you use
+ QDomDocument::createElementNS() or
+ QDomDocument::createAttributeNS() instead, the prefix will not be
+ an empty string; but it might be an empty string if the name does
+ not have a prefix.
+
+ \sa setPrefix() localName() namespaceURI()
+ QDomDocument::createElementNS() QDomDocument::createAttributeNS()
+*/
+QString QDomNode::prefix() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->prefix;
+}
+
+/*!
+ If the node has a namespace prefix, this function changes the
+ namespace prefix of the node to \a pre. Otherwise this function
+ does nothing.
+
+ Only nodes of type \link QDomNode::NodeType ElementNode\endlink or
+ \link QDomNode::NodeType AttributeNode\endlink can have
+ namespaces. A namespace prefix must have be specified at creation
+ time; it is not possible to add a namespace prefix afterwards.
+
+ \sa prefix() localName() namespaceURI()
+ QDomDocument::createElementNS() QDomDocument::createAttributeNS()
+*/
+void QDomNode::setPrefix(const QString& pre)
+{
+ if (!impl || IMPL->prefix.isNull())
+ return;
+ if (isAttr() || isElement())
+ IMPL->prefix = pre;
+}
+
+/*!
+ If the node uses namespaces, this function returns the local name
+ of the node; otherwise it returns an empty string.
+
+ Only nodes of type \link QDomNode::NodeType ElementNode\endlink or
+ \link QDomNode::NodeType AttributeNode\endlink can have
+ namespaces. A namespace must have been specified at creation time;
+ it is not possible to add a namespace afterwards.
+
+ \sa prefix() namespaceURI() QDomDocument::createElementNS()
+ QDomDocument::createAttributeNS()
+*/
+QString QDomNode::localName() const
+{
+ if (!impl || IMPL->createdWithDom1Interface)
+ return QString();
+ return IMPL->name;
+}
+
+/*!
+ Returns true if the node has attributes; otherwise returns false.
+
+ \sa attributes()
+*/
+bool QDomNode::hasAttributes() const
+{
+ if (!impl || !impl->isElement())
+ return false;
+ return static_cast<QDomElementPrivate *>(impl)->hasAttributes();
+}
+
+/*!
+ Inserts the node \a newChild before the child node \a refChild.
+ \a refChild must be a direct child of this node. If \a refChild is
+ \link isNull() null\endlink then \a newChild is inserted as the
+ node's first child.
+
+ If \a newChild is the child of another node, it is reparented to
+ this node. If \a newChild is a child of this node, then its
+ position in the list of children is changed.
+
+ If \a newChild is a QDomDocumentFragment, then the children of the
+ fragment are removed from the fragment and inserted before \a
+ refChild.
+
+ Returns a new reference to \a newChild on success or a \link
+ isNull() null node\endlink on failure.
+
+ The DOM specification disallow inserting attribute nodes, but due
+ to historical reasons QDom accept them nevertheless.
+
+ \sa insertAfter() replaceChild() removeChild() appendChild()
+*/
+QDomNode QDomNode::insertBefore(const QDomNode& newChild, const QDomNode& refChild)
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->insertBefore(newChild.impl, refChild.impl));
+}
+
+/*!
+ Inserts the node \a newChild after the child node \a refChild. \a
+ refChild must be a direct child of this node. If \a refChild is
+ \link isNull() null\endlink then \a newChild is appended as this
+ node's last child.
+
+ If \a newChild is the child of another node, it is reparented to
+ this node. If \a newChild is a child of this node, then its
+ position in the list of children is changed.
+
+ If \a newChild is a QDomDocumentFragment, then the children of the
+ fragment are removed from the fragment and inserted after \a
+ refChild.
+
+ Returns a new reference to \a newChild on success or a \link
+ isNull() null node\endlink on failure.
+
+ The DOM specification disallow inserting attribute nodes, but due
+ to historical reasons QDom accept them nevertheless.
+
+ \sa insertBefore() replaceChild() removeChild() appendChild()
+*/
+QDomNode QDomNode::insertAfter(const QDomNode& newChild, const QDomNode& refChild)
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->insertAfter(newChild.impl, refChild.impl));
+}
+
+/*!
+ Replaces \a oldChild with \a newChild. \a oldChild must be a
+ direct child of this node.
+
+ If \a newChild is the child of another node, it is reparented to
+ this node. If \a newChild is a child of this node, then its
+ position in the list of children is changed.
+
+ If \a newChild is a QDomDocumentFragment, then \a oldChild is
+ replaced by all of the children of the fragment.
+
+ Returns a new reference to \a oldChild on success or a \link
+ isNull() null node\endlink an failure.
+
+ \sa insertBefore() insertAfter() removeChild() appendChild()
+*/
+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));
+}
+
+/*!
+ Removes \a oldChild from the list of children. \a oldChild must be
+ a direct child of this node.
+
+ Returns a new reference to \a oldChild on success or a \link
+ isNull() null node\endlink on failure.
+
+ \sa insertBefore() insertAfter() replaceChild() appendChild()
+*/
+QDomNode QDomNode::removeChild(const QDomNode& oldChild)
+{
+ if (!impl)
+ return QDomNode();
+
+ if (oldChild.isNull())
+ return QDomNode();
+
+ return QDomNode(IMPL->removeChild(oldChild.impl));
+}
+
+/*!
+ Appends \a newChild as the node's last child.
+
+ If \a newChild is the child of another node, it is reparented to
+ this node. If \a newChild is a child of this node, then its
+ position in the list of children is changed.
+
+ If \a newChild is a QDomDocumentFragment, then the children of the
+ fragment are removed from the fragment and appended.
+
+ If \a newChild is a QDomElement and this node is a QDomDocument that
+ already has an element node as a child, \a newChild is not added as
+ a child and a null node is returned.
+
+ Calling this function on a null node(created, for example, with the
+ default constructor) does nothing.
+
+ The DOM specification disallow inserting attribute nodes, but due
+ to historical reasons QDom accept them nevertheless.
+
+ \sa insertBefore() insertAfter() replaceChild() removeChild()
+*/
+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));
+}
+
+/*!
+ Returns true if the node has one or more children; otherwise
+ returns false.
+*/
+bool QDomNode::hasChildNodes() const
+{
+ if (!impl)
+ return false;
+ return IMPL->first != 0;
+}
+
+/*!
+ Returns true if this node is null (i.e. if it has no type or
+ contents); otherwise returns false.
+*/
+bool QDomNode::isNull() const
+{
+ return (impl == 0);
+}
+
+/*!
+ Converts the node into a null node; if it was not a null node
+ before, its type and contents are deleted.
+
+ \sa isNull()
+*/
+void QDomNode::clear()
+{
+ if (impl && !impl->ref.deref())
+ delete impl;
+ impl = 0;
+}
+
+/*!
+ Returns the first direct child node for which nodeName() equals \a
+ name.
+
+ If no such direct child exists, a \link isNull() null node\endlink
+ is returned.
+
+ \sa nodeName()
+*/
+QDomNode QDomNode::namedItem(const QString& name) const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(impl->namedItem(name));
+}
+
+/*!
+ Writes the XML representation of the node and all its children to
+ the stream \a str. This function uses \a indent as the amount of
+ space to indent the node.
+
+ If this node is a document node, the encoding of text stream \a str's encoding is
+ set by treating a processing instruction by name "xml" as an XML declaration, if such a one exists,
+ and otherwise defaults to UTF-8. XML declarations are not processing instructions, but this
+ behavior exists for historical reasons. If this node is not a document node,
+ the text stream's encoding is used.
+
+ If the document contains invalid XML characters or characters that cannot be
+ encoded in the given encoding, the result and behavior is undefined.
+
+*/
+void QDomNode::save(QTextStream& str, int indent) const
+{
+ save(str, indent, QDomNode::EncodingFromDocument);
+}
+
+/*!
+ If \a encodingPolicy is QDomNode::EncodingFromDocument, this function behaves as save(QTextStream &str, int indent).
+
+ If \a encodingPolicy is EncodingFromTextStream and this node is a document node, this
+ function behaves as save(QTextStream &str, int indent) with the exception that the encoding
+ specified in the text stream \a str is used.
+
+ If the document contains invalid XML characters or characters that cannot be
+ encoded in the given encoding, the result and behavior is undefined.
+
+ \since 4.2
+ */
+void QDomNode::save(QTextStream& str, int indent, EncodingPolicy encodingPolicy) const
+{
+ if (!impl)
+ return;
+
+ if(isDocument())
+ static_cast<const QDomDocumentPrivate *>(impl)->saveDocument(str, indent, encodingPolicy);
+ else
+ IMPL->save(str, 1, indent);
+}
+
+/*!
+ \relates QDomNode
+
+ Writes the XML representation of the node \a node and all its
+ children to the stream \a str.
+*/
+QTextStream& operator<<(QTextStream& str, const QDomNode& node)
+{
+ node.save(str, 1);
+
+ return str;
+}
+
+/*!
+ Returns true if the node is an attribute; otherwise returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomAttribute; you can get the QDomAttribute with
+ toAttribute().
+
+ \sa toAttr()
+*/
+bool QDomNode::isAttr() const
+{
+ if(impl)
+ return impl->isAttr();
+ return false;
+}
+
+/*!
+ Returns true if the node is a CDATA section; otherwise returns
+ false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomCDATASection; you can get the QDomCDATASection with
+ toCDATASection().
+
+ \sa toCDATASection()
+*/
+bool QDomNode::isCDATASection() const
+{
+ if(impl)
+ return impl->isCDATASection();
+ return false;
+}
+
+/*!
+ Returns true if the node is a document fragment; otherwise returns
+ false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomDocumentFragment; you can get the QDomDocumentFragment
+ with toDocumentFragment().
+
+ \sa toDocumentFragment()
+*/
+bool QDomNode::isDocumentFragment() const
+{
+ if(impl)
+ return impl->isDocumentFragment();
+ return false;
+}
+
+/*!
+ Returns true if the node is a document; otherwise returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomDocument; you can get the QDomDocument with toDocument().
+
+ \sa toDocument()
+*/
+bool QDomNode::isDocument() const
+{
+ if(impl)
+ return impl->isDocument();
+ return false;
+}
+
+/*!
+ Returns true if the node is a document type; otherwise returns
+ false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomDocumentType; you can get the QDomDocumentType with
+ toDocumentType().
+
+ \sa toDocumentType()
+*/
+bool QDomNode::isDocumentType() const
+{
+ if(impl)
+ return impl->isDocumentType();
+ return false;
+}
+
+/*!
+ Returns true if the node is an element; otherwise returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomElement; you can get the QDomElement with toElement().
+
+ \sa toElement()
+*/
+bool QDomNode::isElement() const
+{
+ if(impl)
+ return impl->isElement();
+ return false;
+}
+
+/*!
+ Returns true if the node is an entity reference; otherwise returns
+ false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomEntityReference; you can get the QDomEntityReference with
+ toEntityReference().
+
+ \sa toEntityReference()
+*/
+bool QDomNode::isEntityReference() const
+{
+ if(impl)
+ return impl->isEntityReference();
+ return false;
+}
+
+/*!
+ Returns true if the node is a text node; otherwise returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomText; you can get the QDomText with toText().
+
+ \sa toText()
+*/
+bool QDomNode::isText() const
+{
+ if(impl)
+ return impl->isText();
+ return false;
+}
+
+/*!
+ Returns true if the node is an entity; otherwise returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomEntity; you can get the QDomEntity with toEntity().
+
+ \sa toEntity()
+*/
+bool QDomNode::isEntity() const
+{
+ if(impl)
+ return impl->isEntity();
+ return false;
+}
+
+/*!
+ Returns true if the node is a notation; otherwise returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomNotation; you can get the QDomNotation with toNotation().
+
+ \sa toNotation()
+*/
+bool QDomNode::isNotation() const
+{
+ if(impl)
+ return impl->isNotation();
+ return false;
+}
+
+/*!
+ Returns true if the node is a processing instruction; otherwise
+ returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomProcessingInstruction; you can get the
+ QProcessingInstruction with toProcessingInstruction().
+
+ \sa toProcessingInstruction()
+*/
+bool QDomNode::isProcessingInstruction() const
+{
+ if(impl)
+ return impl->isProcessingInstruction();
+ return false;
+}
+
+/*!
+ Returns true if the node is a character data node; otherwise
+ returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomCharacterData; you can get the QDomCharacterData with
+ toCharacterData().
+
+ \sa toCharacterData()
+*/
+bool QDomNode::isCharacterData() const
+{
+ if (impl)
+ return impl->isCharacterData();
+ return false;
+}
+
+/*!
+ Returns true if the node is a comment; otherwise returns false.
+
+ If this function returns true, it does not imply that this object
+ is a QDomComment; you can get the QDomComment with toComment().
+
+ \sa toComment()
+*/
+bool QDomNode::isComment() const
+{
+ if (impl)
+ return impl->isComment();
+ return false;
+}
+
+#undef IMPL
+
+/*!
+ Returns the first child element with tag name \a tagName if tagName is non-empty;
+ otherwise returns the first child element. Returns a null element if no
+ such child exists.
+
+ \sa lastChildElement() previousSiblingElement() nextSiblingElement()
+*/
+
+QDomElement QDomNode::firstChildElement(const QString &tagName) const
+{
+ for (QDomNode child = firstChild(); !child.isNull(); child = child.nextSibling()) {
+ if (child.isElement()) {
+ QDomElement elt = child.toElement();
+ if (tagName.isEmpty() || elt.tagName() == tagName)
+ return elt;
+ }
+ }
+ return QDomElement();
+}
+
+/*!
+ Returns the last child element with tag name \a tagName if tagName is non-empty;
+ otherwise returns the first child element. Returns a null element if no
+ such child exists.
+
+ \sa firstChildElement() previousSiblingElement() nextSiblingElement()
+*/
+
+QDomElement QDomNode::lastChildElement(const QString &tagName) const
+{
+ for (QDomNode child = lastChild(); !child.isNull(); child = child.previousSibling()) {
+ if (child.isElement()) {
+ QDomElement elt = child.toElement();
+ if (tagName.isEmpty() || elt.tagName() == tagName)
+ return elt;
+ }
+ }
+ return QDomElement();
+}
+
+/*!
+ Returns the next sibilng element with tag name \a tagName if \a tagName
+ is non-empty; otherwise returns any next sibling element.
+ Returns a null element if no such sibling exists.
+
+ \sa firstChildElement() previousSiblingElement() lastChildElement()
+*/
+
+QDomElement QDomNode::nextSiblingElement(const QString &tagName) const
+{
+ for (QDomNode sib = nextSibling(); !sib.isNull(); sib = sib.nextSibling()) {
+ if (sib.isElement()) {
+ QDomElement elt = sib.toElement();
+ if (tagName.isEmpty() || elt.tagName() == tagName)
+ return elt;
+ }
+ }
+ return QDomElement();
+}
+
+/*!
+ Returns the previous sibilng element with tag name \a tagName if \a tagName
+ is non-empty; otherwise returns any previous sibling element.
+ Returns a null element if no such sibling exists.
+
+ \sa firstChildElement(), nextSiblingElement(), lastChildElement()
+*/
+
+QDomElement QDomNode::previousSiblingElement(const QString &tagName) const
+{
+ for (QDomNode sib = previousSibling(); !sib.isNull(); sib = sib.previousSibling()) {
+ if (sib.isElement()) {
+ QDomElement elt = sib.toElement();
+ if (tagName.isEmpty() || elt.tagName() == tagName)
+ return elt;
+ }
+ }
+ return QDomElement();
+}
+
+/*!
+ \since 4.1
+
+ For nodes created by QDomDocument::setContent(), this function
+ returns the line number in the XML document where the node was parsed.
+ Otherwise, -1 is returned.
+
+ \sa columnNumber(), QDomDocument::setContent()
+*/
+int QDomNode::lineNumber() const
+{
+ return impl ? impl->lineNumber : -1;
+}
+
+/*!
+ \since 4.1
+
+ For nodes created by QDomDocument::setContent(), this function
+ returns the column number in the XML document where the node was parsed.
+ Otherwise, -1 is returned.
+
+ \sa lineNumber(), QDomDocument::setContent()
+*/
+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)
+{
+ QDomNamedNodeMapPrivate* m = new QDomNamedNodeMapPrivate(p);
+ m->readonly = readonly;
+ m->appendToParent = appendToParent;
+
+ QHash<QString, QDomNodePrivate*>::const_iterator it = map.constBegin();
+ for (; it != map.constEnd(); ++it) {
+ QDomNodePrivate *new_node = (*it)->cloneNode();
+ new_node->setParent(p);
+ m->setNamedItem(new_node);
+ }
+
+ // we are no longer interested in ownership
+ m->ref.deref();
+ return m;
+}
+
+void QDomNamedNodeMapPrivate::clearMap()
+{
+ // Dereference all of our children if we took references
+ if (!appendToParent) {
+ QHash<QString, QDomNodePrivate *>::const_iterator it = map.constBegin();
+ for (; it != map.constEnd(); ++it)
+ if (!(*it)->ref.deref())
+ delete *it;
+ }
+ map.clear();
+}
+
+QDomNodePrivate* QDomNamedNodeMapPrivate::namedItem(const QString& name) const
+{
+ QDomNodePrivate* p = map[name];
+ return p;
+}
+
+QDomNodePrivate* QDomNamedNodeMapPrivate::namedItemNS(const QString& nsURI, const QString& localName) const
+{
+ QHash<QString, QDomNodePrivate *>::const_iterator it = map.constBegin();
+ QDomNodePrivate *n;
+ for (; it != map.constEnd(); ++it) {
+ n = *it;
+ if (!n->prefix.isNull()) {
+ // node has a namespace
+ if (n->namespaceURI == nsURI && n->name == localName)
+ return n;
+ }
+ }
+ return 0;
+}
+
+QDomNodePrivate* QDomNamedNodeMapPrivate::setNamedItem(QDomNodePrivate* arg)
+{
+ if (readonly || !arg)
+ return 0;
+
+ if (appendToParent)
+ return parent->appendChild(arg);
+
+ QDomNodePrivate *n = map.value(arg->nodeName());
+ // We take a reference
+ arg->ref.ref();
+ map.insertMulti(arg->nodeName(), arg);
+ return n;
+}
+
+QDomNodePrivate* QDomNamedNodeMapPrivate::setNamedItemNS(QDomNodePrivate* arg)
+{
+ if (readonly || !arg)
+ return 0;
+
+ 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.insertMulti(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 0;
+
+ QDomNodePrivate* p = namedItem(name);
+ if (p == 0)
+ return 0;
+ 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 ((uint)index >= length())
+ return 0;
+ return *(map.constBegin() + index);
+}
+
+// ### Qt 5: convert all length/size() functions in QDom to use int instead of uint.
+uint QDomNamedNodeMapPrivate::length() const
+{
+ return map.count();
+}
+
+bool QDomNamedNodeMapPrivate::contains(const QString& name) const
+{
+ return map.value(name) != 0;
+}
+
+bool QDomNamedNodeMapPrivate::containsNS(const QString& nsURI, const QString & localName) const
+{
+ return namedItemNS(nsURI, localName) != 0;
+}
+
+/**************************************************************
+ *
+ * QDomNamedNodeMap
+ *
+ **************************************************************/
+
+#define IMPL ((QDomNamedNodeMapPrivate*)impl)
+
+/*!
+ \class QDomNamedNodeMap
+ \reentrant
+ \brief The QDomNamedNodeMap class contains a collection of nodes
+ that can be accessed by name.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ Note that QDomNamedNodeMap does not inherit from QDomNodeList.
+ QDomNamedNodeMaps do not provide any specific node ordering.
+ Although nodes in a QDomNamedNodeMap may be accessed by an ordinal
+ index, this is simply to allow a convenient enumeration of the
+ contents of a QDomNamedNodeMap, and does not imply that the DOM
+ specifies an ordering of the nodes.
+
+ The QDomNamedNodeMap is used in three places:
+ \list 1
+ \i QDomDocumentType::entities() returns a map of all entities
+ described in the DTD.
+ \i QDomDocumentType::notations() returns a map of all notations
+ described in the DTD.
+ \i QDomNode::attributes() returns a map of all attributes of an
+ element.
+ \endlist
+
+ Items in the map are identified by the name which QDomNode::name()
+ returns. Nodes are retrieved using namedItem(), namedItemNS() or
+ item(). New nodes are inserted with setNamedItem() or
+ setNamedItemNS() and removed with removeNamedItem() or
+ removeNamedItemNS(). Use contains() to see if an item with the
+ given name is in the named node map. The number of items is
+ returned by length().
+
+ Terminology: in this class we use "item" and "node"
+ interchangeably.
+*/
+
+/*!
+ Constructs an empty named node map.
+*/
+QDomNamedNodeMap::QDomNamedNodeMap()
+{
+ impl = 0;
+}
+
+/*!
+ Constructs a copy of \a n.
+*/
+QDomNamedNodeMap::QDomNamedNodeMap(const QDomNamedNodeMap &n)
+{
+ impl = n.impl;
+ if (impl)
+ impl->ref.ref();
+}
+
+QDomNamedNodeMap::QDomNamedNodeMap(QDomNamedNodeMapPrivate *n)
+{
+ impl = n;
+ if (impl)
+ impl->ref.ref();
+}
+
+/*!
+ Assigns \a n to this named node map.
+*/
+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;
+}
+
+/*!
+ Returns true if \a n and this named node map are equal; otherwise
+ returns false.
+*/
+bool QDomNamedNodeMap::operator== (const QDomNamedNodeMap& n) const
+{
+ return (impl == n.impl);
+}
+
+/*!
+ Returns true if \a n and this named node map are not equal;
+ otherwise returns false.
+*/
+bool QDomNamedNodeMap::operator!= (const QDomNamedNodeMap& n) const
+{
+ return (impl != n.impl);
+}
+
+/*!
+ Destroys the object and frees its resources.
+*/
+QDomNamedNodeMap::~QDomNamedNodeMap()
+{
+ if (impl && !impl->ref.deref())
+ delete impl;
+}
+
+/*!
+ Returns the node called \a name.
+
+ If the named node map does not contain such a node, a \link
+ QDomNode::isNull() null node\endlink is returned. A node's name is
+ the name returned by QDomNode::nodeName().
+
+ \sa setNamedItem() namedItemNS()
+*/
+QDomNode QDomNamedNodeMap::namedItem(const QString& name) const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->namedItem(name));
+}
+
+/*!
+ Inserts the node \a newNode into the named node map. The name used
+ by the map is the node name of \a newNode as returned by
+ QDomNode::nodeName().
+
+ If the new node replaces an existing node, i.e. the map contains a
+ node with the same name, the replaced node is returned.
+
+ \sa namedItem() removeNamedItem() setNamedItemNS()
+*/
+QDomNode QDomNamedNodeMap::setNamedItem(const QDomNode& newNode)
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->setNamedItem((QDomNodePrivate*)newNode.impl));
+}
+
+/*!
+ Removes the node called \a name from the map.
+
+ The function returns the removed node or a \link
+ QDomNode::isNull() null node\endlink if the map did not contain a
+ node called \a name.
+
+ \sa setNamedItem() namedItem() removeNamedItemNS()
+*/
+QDomNode QDomNamedNodeMap::removeNamedItem(const QString& name)
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->removeNamedItem(name));
+}
+
+/*!
+ Retrieves the node at position \a index.
+
+ This can be used to iterate over the map. Note that the nodes in
+ the map are ordered arbitrarily.
+
+ \sa length()
+*/
+QDomNode QDomNamedNodeMap::item(int index) const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->item(index));
+}
+
+/*!
+ Returns the node associated with the local name \a localName and
+ the namespace URI \a nsURI.
+
+ If the map does not contain such a node, a \link
+ QDomNode::isNull() null node\endlink is returned.
+
+ \sa setNamedItemNS() namedItem()
+*/
+QDomNode QDomNamedNodeMap::namedItemNS(const QString& nsURI, const QString& localName) const
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->namedItemNS(nsURI, localName));
+}
+
+/*!
+ Inserts the node \a newNode in the map. If a node with the same
+ namespace URI and the same local name already exists in the map,
+ it is replaced by \a newNode. If the new node replaces an existing
+ node, the replaced node is returned.
+
+ \sa namedItemNS() removeNamedItemNS() setNamedItem()
+*/
+QDomNode QDomNamedNodeMap::setNamedItemNS(const QDomNode& newNode)
+{
+ if (!impl)
+ return QDomNode();
+ return QDomNode(IMPL->setNamedItemNS((QDomNodePrivate*)newNode.impl));
+}
+
+/*!
+ Removes the node with the local name \a localName and the
+ namespace URI \a nsURI from the map.
+
+ The function returns the removed node or a \link
+ QDomNode::isNull() null node\endlink if the map did not contain a
+ node with the local name \a localName and the namespace URI \a
+ nsURI.
+
+ \sa setNamedItemNS() namedItemNS() removeNamedItem()
+*/
+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));
+}
+
+/*!
+ Returns the number of nodes in the map.
+
+ \sa item()
+*/
+uint QDomNamedNodeMap::length() const
+{
+ if (!impl)
+ return 0;
+ return IMPL->length();
+}
+
+/*!
+ \fn bool QDomNamedNodeMap::isEmpty() const
+
+ Returns true if the map is empty; otherwise returns false. This function is
+ provided for Qt API consistency.
+*/
+
+/*!
+ \fn int QDomNamedNodeMap::count() const
+
+ This function is provided for Qt API consistency. It is equivalent to length().
+*/
+
+/*!
+ \fn int QDomNamedNodeMap::size() const
+
+ This function is provided for Qt API consistency. It is equivalent to length().
+*/
+
+/*!
+ Returns true if the map contains a node called \a name; otherwise
+ returns false.
+
+ \bold{Note:} This function does not take the presence of namespaces into account.
+ Use namedItemNS() to test whether the map contains a node with a specific namespace
+ URI and name.
+*/
+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())
+ // Dont use normal insert function since we would create infinite recursion
+ entities->map.insertMulti(p->nodeName(), p);
+ if (p->isNotation())
+ // Dont use normal insert function since we would create infinite recursion
+ notations->map.insertMulti(p->nodeName(), p);
+ }
+}
+
+QDomDocumentTypePrivate::~QDomDocumentTypePrivate()
+{
+ if (!entities->ref.deref())
+ delete entities;
+ if (!notations->ref.deref())
+ delete notations;
+}
+
+void QDomDocumentTypePrivate::init()
+{
+ entities = new QDomNamedNodeMapPrivate(this);
+ notations = new QDomNamedNodeMapPrivate(this);
+ publicId.clear();
+ systemId.clear();
+ internalSubset.clear();
+
+ entities->setAppendToParent(true);
+ notations->setAppendToParent(true);
+}
+
+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 origianl implementation
+ QDomNodePrivate* p = QDomNodePrivate::insertBefore(newChild, refChild);
+ // Update the maps
+ if (p && p->isEntity())
+ entities->map.insertMulti(p->nodeName(), p);
+ else if (p && p->isNotation())
+ notations->map.insertMulti(p->nodeName(), p);
+
+ return p;
+}
+
+QDomNodePrivate* QDomDocumentTypePrivate::insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild)
+{
+ // Call the origianl implementation
+ QDomNodePrivate* p = QDomNodePrivate::insertAfter(newChild, refChild);
+ // Update the maps
+ if (p && p->isEntity())
+ entities->map.insertMulti(p->nodeName(), p);
+ else if (p && p->isNotation())
+ notations->map.insertMulti(p->nodeName(), p);
+
+ return p;
+}
+
+QDomNodePrivate* QDomDocumentTypePrivate::replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild)
+{
+ // Call the origianl 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.insertMulti(p->nodeName(), p);
+ else if (p->isNotation())
+ notations->map.insertMulti(p->nodeName(), p);
+ }
+
+ return p;
+}
+
+QDomNodePrivate* QDomDocumentTypePrivate::removeChild(QDomNodePrivate* oldChild)
+{
+ // Call the origianl 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, 0);
+}
+
+static QString quotedValue(const QString &data)
+{
+ QChar quote = data.indexOf(QLatin1Char('\'')) == -1
+ ? QLatin1Char('\'')
+ : QLatin1Char('"');
+ 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 << " [" << endl;
+
+ QHash<QString, QDomNodePrivate *>::const_iterator it2 = notations->map.constBegin();
+ for (; it2 != notations->map.constEnd(); ++it2)
+ (*it2)->save(s, 0, indent);
+
+ QHash<QString, QDomNodePrivate *>::const_iterator it = entities->map.constBegin();
+ for (; it != entities->map.constEnd(); ++it)
+ (*it)->save(s, 0, indent);
+
+ s << ']';
+ }
+
+ s << '>' << endl;
+}
+
+/**************************************************************
+ *
+ * QDomDocumentType
+ *
+ **************************************************************/
+
+#define IMPL ((QDomDocumentTypePrivate*)impl)
+
+/*!
+ \class QDomDocumentType
+ \reentrant
+ \brief The QDomDocumentType class is the representation of the DTD
+ in the document tree.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ The QDomDocumentType class allows read-only access to some of the
+ data structures in the DTD: it can return a map of all entities()
+ and notations(). In addition the function name() returns the name
+ of the document type as specified in the &lt;!DOCTYPE name&gt;
+ tag. This class also provides the publicId(), systemId() and
+ internalSubset() functions.
+
+ \sa QDomDocument
+*/
+
+/*!
+ Creates an empty QDomDocumentType object.
+*/
+QDomDocumentType::QDomDocumentType() : QDomNode()
+{
+}
+
+/*!
+ Constructs a copy of \a n.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomDocumentType::QDomDocumentType(const QDomDocumentType& n)
+ : QDomNode(n)
+{
+}
+
+QDomDocumentType::QDomDocumentType(QDomDocumentTypePrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a n to this document type.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomDocumentType& QDomDocumentType::operator= (const QDomDocumentType& n)
+{
+ return (QDomDocumentType&) QDomNode::operator=(n);
+}
+
+/*!
+ Returns the name of the document type as specified in the
+ &lt;!DOCTYPE name&gt; tag.
+
+ \sa nodeName()
+*/
+QString QDomDocumentType::name() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->nodeName();
+}
+
+/*!
+ Returns a map of all entities described in the DTD.
+*/
+QDomNamedNodeMap QDomDocumentType::entities() const
+{
+ if (!impl)
+ return QDomNamedNodeMap();
+ return QDomNamedNodeMap(IMPL->entities);
+}
+
+/*!
+ Returns a map of all notations described in the DTD.
+*/
+QDomNamedNodeMap QDomDocumentType::notations() const
+{
+ if (!impl)
+ return QDomNamedNodeMap();
+ return QDomNamedNodeMap(IMPL->notations);
+}
+
+/*!
+ Returns the public identifier of the external DTD subset or
+ an empty string if there is no public identifier.
+
+ \sa systemId() internalSubset() QDomImplementation::createDocumentType()
+*/
+QString QDomDocumentType::publicId() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->publicId;
+}
+
+/*!
+ Returns the system identifier of the external DTD subset or
+ an empty string if there is no system identifier.
+
+ \sa publicId() internalSubset() QDomImplementation::createDocumentType()
+*/
+QString QDomDocumentType::systemId() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->systemId;
+}
+
+/*!
+ Returns the internal subset of the document type or an empty
+ string if there is no internal subset.
+
+ \sa publicId() 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.
+*/
+
+/*!
+ \fn QDomNode::NodeType QDomDocumentType::nodeType() const
+
+ Returns \c DocumentTypeNode.
+
+ \sa isDocumentType() QDomNode::toDocumentType()
+*/
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomDocumentFragmentPrivate
+ *
+ **************************************************************/
+
+QDomDocumentFragmentPrivate::QDomDocumentFragmentPrivate(QDomDocumentPrivate* doc, QDomNodePrivate* parent)
+ : QDomNodePrivate(doc, parent)
+{
+ name = QLatin1String("#document-fragment");
+}
+
+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
+ *
+ **************************************************************/
+
+/*!
+ \class QDomDocumentFragment
+ \reentrant
+ \brief The QDomDocumentFragment class is a tree of QDomNodes which is not usually a complete QDomDocument.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ If you want to do complex tree operations it is useful to have a
+ lightweight class to store nodes and their relations.
+ QDomDocumentFragment stores a subtree of a document which does not
+ necessarily represent a well-formed XML document.
+
+ QDomDocumentFragment is also useful if you want to group several
+ nodes in a list and insert them all together as children of some
+ node. In these cases QDomDocumentFragment can be used as a
+ temporary container for this list of children.
+
+ The most important feature of QDomDocumentFragment is that it is
+ treated in a special way by QDomNode::insertAfter(),
+ QDomNode::insertBefore(), QDomNode::replaceChild() and
+ QDomNode::appendChild(): instead of inserting the fragment itself, all
+ the fragment's children are inserted.
+*/
+
+/*!
+ Constructs an empty document fragment.
+*/
+QDomDocumentFragment::QDomDocumentFragment()
+{
+}
+
+QDomDocumentFragment::QDomDocumentFragment(QDomDocumentFragmentPrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomDocumentFragment::QDomDocumentFragment(const QDomDocumentFragment& x)
+ : QDomNode(x)
+{
+}
+
+/*!
+ Assigns \a x to this DOM document fragment.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomDocumentFragment& QDomDocumentFragment::operator= (const QDomDocumentFragment& x)
+{
+ return (QDomDocumentFragment&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomDocumentFragment::nodeType() const
+
+ Returns \c DocumentFragment.
+
+ \sa isDocumentFragment() QDomNode::toDocumentFragment()
+*/
+
+/**************************************************************
+ *
+ * QDomCharacterDataPrivate
+ *
+ **************************************************************/
+
+QDomCharacterDataPrivate::QDomCharacterDataPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p,
+ const QString& data)
+ : QDomNodePrivate(d, p)
+{
+ value = data;
+ name = QLatin1String("#character-data");
+}
+
+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;
+}
+
+uint QDomCharacterDataPrivate::dataLength() const
+{
+ return value.length();
+}
+
+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 ((QDomCharacterDataPrivate*)impl)
+
+/*!
+ \class QDomCharacterData
+ \reentrant
+ \brief The QDomCharacterData class represents a generic string in the DOM.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ Character data as used in XML specifies a generic data string.
+ More specialized versions of this class are QDomText, QDomComment
+ and QDomCDATASection.
+
+ The data string is set with setData() and retrieved with data().
+ You can retrieve a portion of the data string using
+ substringData(). Extra data can be appended with appendData(), or
+ inserted with insertData(). Portions of the data string can be
+ deleted with deleteData() or replaced with replaceData(). The
+ length of the data string is returned by length().
+
+ The node type of the node containing this character data is
+ returned by nodeType().
+
+ \sa QDomText QDomComment QDomCDATASection
+*/
+
+/*!
+ Constructs an empty character data object.
+*/
+QDomCharacterData::QDomCharacterData()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomCharacterData::QDomCharacterData(const QDomCharacterData& x)
+ : QDomNode(x)
+{
+}
+
+QDomCharacterData::QDomCharacterData(QDomCharacterDataPrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a x to this character data.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomCharacterData& QDomCharacterData::operator= (const QDomCharacterData& x)
+{
+ return (QDomCharacterData&) QDomNode::operator=(x);
+}
+
+/*!
+ Returns the string stored in this object.
+
+ If the node is a \link isNull() null node\endlink, it will return
+ an empty string.
+*/
+QString QDomCharacterData::data() const
+{
+ if (!impl)
+ return QString();
+ return impl->nodeValue();
+}
+
+/*!
+ Sets this object's string to \a v.
+*/
+void QDomCharacterData::setData(const QString& v)
+{
+ if (impl)
+ impl->setNodeValue(v);
+}
+
+/*!
+ Returns the length of the stored string.
+*/
+uint QDomCharacterData::length() const
+{
+ if (impl)
+ return IMPL->dataLength();
+ return 0;
+}
+
+/*!
+ Returns the substring of length \a count from position \a offset.
+*/
+QString QDomCharacterData::substringData(unsigned long offset, unsigned long count)
+{
+ if (!impl)
+ return QString();
+ return IMPL->substringData(offset, count);
+}
+
+/*!
+ Appends the string \a arg to the stored string.
+*/
+void QDomCharacterData::appendData(const QString& arg)
+{
+ if (impl)
+ IMPL->appendData(arg);
+}
+
+/*!
+ Inserts the string \a arg into the stored string at position \a offset.
+*/
+void QDomCharacterData::insertData(unsigned long offset, const QString& arg)
+{
+ if (impl)
+ IMPL->insertData(offset, arg);
+}
+
+/*!
+ Deletes a substring of length \a count from position \a offset.
+*/
+void QDomCharacterData::deleteData(unsigned long offset, unsigned long count)
+{
+ if (impl)
+ IMPL->deleteData(offset, count);
+}
+
+/*!
+ Replaces the substring of length \a count starting at position \a
+ offset with the string \a arg.
+*/
+void QDomCharacterData::replaceData(unsigned long offset, unsigned long count, const QString& arg)
+{
+ if (impl)
+ IMPL->replaceData(offset, count, arg);
+}
+
+/*!
+ Returns the type of node this object refers to (i.e. \c TextNode,
+ \c CDATASectionNode, \c CommentNode or \c CharacterDataNode). For
+ a \link isNull() null node\endlink, returns \c CharacterDataNode.
+*/
+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(0, this, v);
+ // keep the refcount balanced: appendChild() does a ref anyway.
+ t->ref.deref();
+ if (first) {
+ delete removeChild(first);
+ }
+ 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,
+ QTextStream &s,
+ const bool encodeQuotes = true,
+ const bool performAVN = false,
+ const bool encodeEOLs = false)
+{
+#ifdef QT_NO_TEXTCODEC
+ Q_UNUSED(s);
+#else
+ const QTextCodec *const codec = s.codec();
+ Q_ASSERT(codec);
+#endif
+ QString retval(str);
+ int len = retval.length();
+ int i = 0;
+
+ while (i < len) {
+ const QChar ati(retval.at(i));
+
+ if (ati == QLatin1Char('<')) {
+ retval.replace(i, 1, QLatin1String("&lt;"));
+ len += 3;
+ i += 4;
+ } else if (encodeQuotes && (ati == QLatin1Char('"'))) {
+ retval.replace(i, 1, QLatin1String("&quot;"));
+ len += 5;
+ i += 6;
+ } else if (ati == QLatin1Char('&')) {
+ retval.replace(i, 1, QLatin1String("&amp;"));
+ len += 4;
+ i += 5;
+ } else if (ati == QLatin1Char('>') && i >= 2 && retval[i - 1] == QLatin1Char(']') && retval[i - 2] == QLatin1Char(']')) {
+ retval.replace(i, 1, QLatin1String("&gt;"));
+ len += 3;
+ i += 4;
+ } else if (performAVN &&
+ (ati == QChar(0xA) ||
+ ati == QChar(0xD) ||
+ ati == QChar(0x9))) {
+ const QString replacement(QLatin1String("&#x") + QString::number(ati.unicode(), 16) + QLatin1Char(';'));
+ retval.replace(i, 1, replacement);
+ i += replacement.length();
+ len += replacement.length() - 1;
+ } else if (encodeEOLs && ati == QChar(0xD)) {
+ retval.replace(i, 1, QLatin1String("&#xd;")); // Replace a single 0xD with a ref for 0xD
+ len += 4;
+ i += 5;
+ } else {
+#ifndef QT_NO_TEXTCODEC
+ if(codec->canEncode(ati))
+ ++i;
+ else
+#endif
+ {
+ // We have to use a character reference to get it through.
+ const ushort codepoint(ati.unicode());
+ const QString replacement(QLatin1String("&#x") + QString::number(codepoint, 16) + QLatin1Char(';'));
+ retval.replace(i, 1, replacement);
+ i += replacement.length();
+ len += replacement.length() - 1;
+ }
+ }
+ }
+
+ return retval;
+}
+
+void QDomAttrPrivate::save(QTextStream& s, int, int) const
+{
+ if (namespaceURI.isNull()) {
+ s << name << "=\"" << encodeText(value, s, true, true) << '\"';
+ } else {
+ s << prefix << ':' << name << "=\"" << encodeText(value, s, 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, s, true, true) << '\"';
+ }
+ }
+}
+
+/**************************************************************
+ *
+ * QDomAttr
+ *
+ **************************************************************/
+
+#define IMPL ((QDomAttrPrivate*)impl)
+
+/*!
+ \class QDomAttr
+ \reentrant
+ \brief The QDomAttr class represents one attribute of a QDomElement.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ For example, the following piece of XML produces an element with
+ no children, but two attributes:
+
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 7
+
+ You can access the attributes of an element with code like this:
+
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 8
+
+ This example also shows that changing an attribute received from
+ an element changes the attribute of the element. If you do not
+ want to change the value of the element's attribute you must
+ use cloneNode() to get an independent copy of the attribute.
+
+ QDomAttr can return the name() and value() of an attribute. An
+ attribute's value is set with setValue(). If specified() returns
+ true the value was set with setValue(). The node this
+ attribute is attached to (if any) is returned by ownerElement().
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+
+/*!
+ Constructs an empty attribute.
+*/
+QDomAttr::QDomAttr()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomAttr::QDomAttr(const QDomAttr& x)
+ : QDomNode(x)
+{
+}
+
+QDomAttr::QDomAttr(QDomAttrPrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a x to this DOM attribute.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomAttr& QDomAttr::operator= (const QDomAttr& x)
+{
+ return (QDomAttr&) QDomNode::operator=(x);
+}
+
+/*!
+ Returns the attribute's name.
+*/
+QString QDomAttr::name() const
+{
+ if (!impl)
+ return QString();
+ return impl->nodeName();
+}
+
+/*!
+ Returns true if the attribute has been set by the user with setValue().
+ Returns false if the value hasn't been specified or set.
+
+ \sa setValue()
+*/
+bool QDomAttr::specified() const
+{
+ if (!impl)
+ return false;
+ return IMPL->specified();
+}
+
+/*!
+ Returns the element node this attribute is attached to or a \link
+ QDomNode::isNull() null node\endlink if this attribute is not
+ attached to any element.
+*/
+QDomElement QDomAttr::ownerElement() const
+{
+ Q_ASSERT(impl->parent());
+ if (!impl || !impl->parent()->isElement())
+ return QDomElement();
+ return QDomElement((QDomElementPrivate*)(impl->parent()));
+}
+
+/*!
+ Returns the value of the attribute or an empty string if the
+ attribute has not been specified.
+
+ \sa specified() setValue()
+*/
+QString QDomAttr::value() const
+{
+ if (!impl)
+ return QString();
+ return impl->nodeValue();
+}
+
+/*!
+ Sets the attribute's value to \a v.
+
+ \sa value()
+*/
+void QDomAttr::setValue(const QString& v)
+{
+ if (!impl)
+ return;
+ impl->setNodeValue(v);
+ IMPL->m_specified = true;
+}
+
+/*!
+ \fn QDomNode::NodeType QDomAttr::nodeType() const
+
+ Returns \link QDomNode::NodeType AttributeNode\endlink.
+*/
+
+#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 == 0)
+ delete p;
+}
+
+QDomAttrPrivate* QDomElementPrivate::attributeNode(const QString& aname)
+{
+ return (QDomAttrPrivate*)m_attr->namedItem(aname);
+}
+
+QDomAttrPrivate* QDomElementPrivate::attributeNodeNS(const QString& nsURI, const QString& localName)
+{
+ return (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 (QDomAttrPrivate*)n;
+}
+
+QDomAttrPrivate* QDomElementPrivate::setAttributeNodeNS(QDomAttrPrivate* newAttr)
+{
+ QDomNodePrivate* n = 0;
+ if (!newAttr->prefix.isNull())
+ n = m_attr->namedItemNS(newAttr->namespaceURI, newAttr->name);
+
+ // Referencing is done by the maps
+ m_attr->setNamedItem(newAttr);
+
+ return (QDomAttrPrivate*)n;
+}
+
+QDomAttrPrivate* QDomElementPrivate::removeAttributeNode(QDomAttrPrivate* oldAttr)
+{
+ return (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(QLatin1String(""));
+
+ QDomNodePrivate* p = first;
+ while (p) {
+ if (p->isText() || p->isCDATASection())
+ t += p->nodeValue();
+ else if (p->isElement())
+ t += ((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, QLatin1Char(' '));
+
+ QString qName(name);
+ QString nsDecl(QLatin1String(""));
+ if (!namespaceURI.isNull()) {
+ /** ### Qt 5:
+ *
+ * If we still have QDom, optimize this so that we only declare namespaces that are not
+ * yet declared. We loose default namespace mappings, so maybe we should rather store
+ * the information that we get from startPrefixMapping()/endPrefixMapping() and use them.
+ * Modifications becomes more complex then, however.
+ *
+ * We cannot do this during the Qt 4 series because it would require too invasive changes, and
+ * hence possibly behavioral changes.
+ */
+ if (prefix.isEmpty()) {
+ nsDecl = QLatin1String(" xmlns");
+ } else {
+ qName = prefix + QLatin1Char(':') + name;
+ nsDecl = QLatin1String(" xmlns:") + prefix;
+ }
+ nsDecl += QLatin1String("=\"") + encodeText(namespaceURI, s) + QLatin1String("\"");
+ }
+ s << '<' << qName << nsDecl;
+
+ QSet<QString> outputtedPrefixes;
+
+ /* Write out attributes. */
+ if (!m_attr->map.isEmpty()) {
+ s << ' ';
+ QHash<QString, QDomNodePrivate *>::const_iterator it = m_attr->map.constBegin();
+ for (; it != m_attr->map.constEnd(); ++it) {
+ if (it.value()->namespaceURI.isNull()) {
+ s << it.value()->name << "=\"" << encodeText(it.value()->value, s, true, true) << '\"';
+ } else {
+ s << it.value()->prefix << ':' << it.value()->name << "=\"" << encodeText(it.value()->value, s, 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((!it.value()->ownerNode ||
+ it.value()->ownerNode->prefix != it.value()->prefix) &&
+ !outputtedPrefixes.contains(it.value()->prefix)) {
+ s << " xmlns:" << it.value()->prefix << "=\"" << encodeText(it.value()->namespaceURI, s, true, true) << '\"';
+ outputtedPrefixes.insert(it.value()->prefix);
+ }
+ }
+ s << ' ';
+ }
+ }
+
+ if (last) {
+ // has child nodes
+ if (first->isText())
+ s << '>';
+ else {
+ s << '>';
+
+ /* -1 disables new lines. */
+ if (indent != -1)
+ s << endl;
+ }
+ QDomNodePrivate::save(s, depth + 1, indent); if (!last->isText())
+ s << QString(indent < 1 ? 0 : depth * indent, QLatin1Char(' '));
+
+ s << "</" << qName << '>';
+ } else {
+ s << "/>";
+ }
+ if (!(next && next->isText())) {
+ /* -1 disables new lines. */
+ if (indent != -1)
+ s << endl;
+ }
+}
+
+/**************************************************************
+ *
+ * QDomElement
+ *
+ **************************************************************/
+
+#define IMPL ((QDomElementPrivate*)impl)
+
+/*!
+ \class QDomElement
+ \reentrant
+ \brief The QDomElement class represents one element in the DOM tree.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ Elements have a tagName() and zero or more attributes associated
+ with them. The tag name can be changed with setTagName().
+
+ Element attributes are represented by QDomAttr objects that can
+ be queried using the attribute() and attributeNode() functions.
+ You can set attributes with the setAttribute() and
+ setAttributeNode() functions. Attributes can be removed with
+ removeAttribute(). There are namespace-aware equivalents to these
+ functions, i.e. setAttributeNS(), setAttributeNodeNS() and
+ removeAttributeNS().
+
+ If you want to access the text of a node use text(), e.g.
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 9
+ The text() function operates recursively to find the text (since
+ not all elements contain text). If you want to find all the text
+ in all of a node's children, iterate over the children looking for
+ QDomText nodes, e.g.
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 10
+ Note that we attempt to convert each node to a text node and use
+ text() rather than using firstChild().toText().data() or
+ n.toText().data() directly on the node, because the node may not
+ be a text element.
+
+ You can get a list of all the decendents of an element which have
+ a specified tag name with elementsByTagName() or
+ elementsByTagNameNS().
+
+ To browse the elements of a dom document use firstChildElement(), lastChildElement(),
+ nextSiblingElement() and previousSiblingElement(). For example, to iterate over all
+ child elements called "entry" in a root element called "database", you can use:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 11
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+/*!
+ Constructs an empty element. Use the QDomDocument::createElement()
+ function to construct elements with content.
+*/
+QDomElement::QDomElement()
+ : QDomNode()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomElement::QDomElement(const QDomElement& x)
+ : QDomNode(x)
+{
+}
+
+QDomElement::QDomElement(QDomElementPrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a x to this DOM element.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomElement& QDomElement::operator= (const QDomElement& x)
+{
+ return (QDomElement&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomElement::nodeType() const
+
+ Returns \c ElementNode.
+*/
+
+/*!
+ Sets this element's tag name to \a name.
+
+ \sa tagName()
+*/
+void QDomElement::setTagName(const QString& name)
+{
+ if (impl)
+ impl->name = name;
+}
+
+/*!
+ Returns the tag name of this element. For an XML element like this:
+
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 12
+
+ the tagname would return "img".
+
+ \sa setTagName()
+*/
+QString QDomElement::tagName() const
+{
+ if (!impl)
+ return QString();
+ return impl->nodeName();
+}
+
+
+/*!
+ Returns a QDomNamedNodeMap containing all this element's attributes.
+
+ \sa attribute() setAttribute() attributeNode() setAttributeNode()
+*/
+QDomNamedNodeMap QDomElement::attributes() const
+{
+ if (!impl)
+ return QDomNamedNodeMap();
+ return QDomNamedNodeMap(IMPL->attributes());
+}
+
+/*!
+ Returns the attribute called \a name. If the attribute does not
+ exist \a defValue is returned.
+
+ \sa setAttribute() attributeNode() setAttributeNode() attributeNS()
+*/
+QString QDomElement::attribute(const QString& name, const QString& defValue) const
+{
+ if (!impl)
+ return defValue;
+ return IMPL->attribute(name, defValue);
+}
+
+/*!
+ Adds an attribute called \a name with value \a value. If an
+ attribute with the same name exists, its value is replaced by \a
+ value.
+
+ \sa attribute() setAttributeNode() setAttributeNS()
+*/
+void QDomElement::setAttribute(const QString& name, const QString& value)
+{
+ if (!impl)
+ return;
+ IMPL->setAttribute(name, value);
+}
+
+/*!
+ \fn void QDomElement::setAttribute(const QString& name, int value)
+
+ \overload
+ The number is formatted according to the current locale.
+*/
+
+/*!
+ \fn void QDomElement::setAttribute(const QString& name, uint value)
+
+ \overload
+ The number is formatted according to the current locale.
+*/
+
+/*!
+ \overload
+
+ The number is formatted according to the current locale.
+*/
+void QDomElement::setAttribute(const QString& name, qlonglong value)
+{
+ if (!impl)
+ return;
+ QString x;
+ x.setNum(value);
+ IMPL->setAttribute(name, x);
+}
+
+/*!
+ \overload
+
+ The number is formatted according to the current locale.
+*/
+void QDomElement::setAttribute(const QString& name, qulonglong value)
+{
+ if (!impl)
+ return;
+ QString x;
+ x.setNum(value);
+ IMPL->setAttribute(name, x);
+}
+
+/*!
+ \overload
+
+ The number is formatted according to the current locale.
+*/
+void QDomElement::setAttribute(const QString& name, float value)
+{
+ if (!impl)
+ return;
+ QString x;
+ x.setNum(value);
+ IMPL->setAttribute(name, x);
+}
+
+/*!
+ \overload
+
+ The number is formatted according to the current locale.
+*/
+void QDomElement::setAttribute(const QString& name, double value)
+{
+ if (!impl)
+ return;
+ QString x;
+ char buf[256];
+ int count = qsnprintf(buf, sizeof(buf), "%.16g", value);
+ if (count > 0)
+ x = QString::fromLatin1(buf, count);
+ else
+ x.setNum(value); // Fallback
+ IMPL->setAttribute(name, x);
+}
+
+/*!
+ Removes the attribute called name \a name from this element.
+
+ \sa setAttribute() attribute() removeAttributeNS()
+*/
+void QDomElement::removeAttribute(const QString& name)
+{
+ if (!impl)
+ return;
+ IMPL->removeAttribute(name);
+}
+
+/*!
+ Returns the QDomAttr object that corresponds to the attribute
+ called \a name. If no such attribute exists a \link
+ QDomNode::isNull() null attribute\endlink is returned.
+
+ \sa setAttributeNode() attribute() setAttribute() attributeNodeNS()
+*/
+QDomAttr QDomElement::attributeNode(const QString& name)
+{
+ if (!impl)
+ return QDomAttr();
+ return QDomAttr(IMPL->attributeNode(name));
+}
+
+/*!
+ Adds the attribute \a newAttr to this element.
+
+ If the element has another attribute that has the same name as \a
+ newAttr, this function replaces that attribute and returns it;
+ otherwise the function returns a \link QDomNode::isNull() null
+ attribute\endlink.
+
+ \sa attributeNode() setAttribute() setAttributeNodeNS()
+*/
+QDomAttr QDomElement::setAttributeNode(const QDomAttr& newAttr)
+{
+ if (!impl)
+ return QDomAttr();
+ return QDomAttr(IMPL->setAttributeNode(((QDomAttrPrivate*)newAttr.impl)));
+}
+
+/*!
+ Removes the attribute \a oldAttr from the element and returns it.
+
+ \sa attributeNode() setAttributeNode()
+*/
+QDomAttr QDomElement::removeAttributeNode(const QDomAttr& oldAttr)
+{
+ if (!impl)
+ return QDomAttr(); // ### should this return oldAttr?
+ return QDomAttr(IMPL->removeAttributeNode(((QDomAttrPrivate*)oldAttr.impl)));
+}
+
+/*!
+ Returns a QDomNodeList containing all descendants of this element
+ named \a tagname encountered during a preorder traversal of the
+ element subtree with this element as its root. The order of the
+ elements in the returned list is the order they are encountered
+ during the preorder traversal.
+
+ \sa elementsByTagNameNS() QDomDocument::elementsByTagName()
+*/
+QDomNodeList QDomElement::elementsByTagName(const QString& tagname) const
+{
+ return QDomNodeList(new QDomNodeListPrivate(impl, tagname));
+}
+
+/*!
+ Returns true if this element has an attribute called \a name;
+ otherwise returns false.
+
+ \bold{Note:} This function does not take the presence of namespaces
+ into account. As a result, the specified name will be tested
+ against fully-qualified attribute names that include any namespace
+ prefixes that may be present.
+
+ Use hasAttributeNS() to explicitly test for attributes with specific
+ namespaces and names.
+*/
+bool QDomElement::hasAttribute(const QString& name) const
+{
+ if (!impl)
+ return false;
+ return IMPL->hasAttribute(name);
+}
+
+/*!
+ Returns the attribute with the local name \a localName and the
+ namespace URI \a nsURI. If the attribute does not exist \a
+ defValue is returned.
+
+ \sa setAttributeNS() attributeNodeNS() setAttributeNodeNS() attribute()
+*/
+QString QDomElement::attributeNS(const QString nsURI, const QString& localName, const QString& defValue) const
+{
+ if (!impl)
+ return defValue;
+ return IMPL->attributeNS(nsURI, localName, defValue);
+}
+
+/*!
+ Adds an attribute with the qualified name \a qName and the
+ namespace URI \a nsURI with the value \a value. If an attribute
+ with the same local name and namespace URI exists, its prefix is
+ replaced by the prefix of \a qName and its value is repaced by \a
+ value.
+
+ Although \a qName is the qualified name, the local name is used to
+ decide if an existing attribute's value should be replaced.
+
+ \sa attributeNS() setAttributeNodeNS() setAttribute()
+*/
+void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, const QString& value)
+{
+ if (!impl)
+ return;
+ IMPL->setAttributeNS(nsURI, qName, value);
+}
+
+/*!
+ \fn void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, int value)
+
+ \overload
+*/
+
+/*!
+ \fn void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, uint value)
+
+ \overload
+*/
+
+/*!
+ \overload
+*/
+void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, qlonglong value)
+{
+ if (!impl)
+ return;
+ QString x;
+ x.setNum(value);
+ IMPL->setAttributeNS(nsURI, qName, x);
+}
+
+/*!
+ \overload
+*/
+void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, qulonglong value)
+{
+ if (!impl)
+ return;
+ QString x;
+ x.setNum(value);
+ IMPL->setAttributeNS(nsURI, qName, x);
+}
+
+/*!
+ \overload
+*/
+void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, double value)
+{
+ if (!impl)
+ return;
+ QString x;
+ x.setNum(value);
+ IMPL->setAttributeNS(nsURI, qName, x);
+}
+
+/*!
+ Removes the attribute with the local name \a localName and the
+ namespace URI \a nsURI from this element.
+
+ \sa setAttributeNS() attributeNS() removeAttribute()
+*/
+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());
+}
+
+/*!
+ Returns the QDomAttr object that corresponds to the attribute
+ with the local name \a localName and the namespace URI \a nsURI.
+ If no such attribute exists a \l{QDomNode::isNull()}{null
+ attribute} is returned.
+
+ \sa setAttributeNode() attribute() setAttribute()
+*/
+QDomAttr QDomElement::attributeNodeNS(const QString& nsURI, const QString& localName)
+{
+ if (!impl)
+ return QDomAttr();
+ return QDomAttr(IMPL->attributeNodeNS(nsURI, localName));
+}
+
+/*!
+ Adds the attribute \a newAttr to this element.
+
+ If the element has another attribute that has the same local name
+ and namespace URI as \a newAttr, this function replaces that
+ attribute and returns it; otherwise the function returns a \link
+ QDomNode::isNull() null attribute\endlink.
+
+ \sa attributeNodeNS() setAttributeNS() setAttributeNode()
+*/
+QDomAttr QDomElement::setAttributeNodeNS(const QDomAttr& newAttr)
+{
+ if (!impl)
+ return QDomAttr();
+ return QDomAttr(IMPL->setAttributeNodeNS(((QDomAttrPrivate*)newAttr.impl)));
+}
+
+/*!
+ Returns a QDomNodeList containing all descendants of this element
+ with local name \a localName and namespace URI \a nsURI encountered
+ during a preorder traversal of the element subtree with this element
+ as its root. The order of the elements in the returned list is the
+ order they are encountered during the preorder traversal.
+
+ \sa elementsByTagName() QDomDocument::elementsByTagNameNS()
+*/
+QDomNodeList QDomElement::elementsByTagNameNS(const QString& nsURI, const QString& localName) const
+{
+ return QDomNodeList(new QDomNodeListPrivate(impl, nsURI, localName));
+}
+
+/*!
+ Returns true if this element has an attribute with the local name
+ \a localName and the namespace URI \a nsURI; otherwise returns
+ false.
+*/
+bool QDomElement::hasAttributeNS(const QString& nsURI, const QString& localName) const
+{
+ if (!impl)
+ return false;
+ return IMPL->hasAttributeNS(nsURI, localName);
+}
+
+/*!
+ Returns the element's text or an empty string.
+
+ Example:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 13
+
+ The function text() of the QDomElement for the \c{<h1>} tag,
+ will return the following text:
+
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 14
+
+ Comments are ignored by this function. It only evaluates QDomText
+ and QDomCDATASection objects.
+*/
+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 = QLatin1String("#text");
+}
+
+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 can not split");
+ return 0;
+ }
+
+ QDomTextPrivate* t = new QDomTextPrivate(ownerDocument(), 0, 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, s, !(that->parent() && that->parent()->isElement()), false, true);
+}
+
+/**************************************************************
+ *
+ * QDomText
+ *
+ **************************************************************/
+
+#define IMPL ((QDomTextPrivate*)impl)
+
+/*!
+ \class QDomText
+ \reentrant
+ \brief The QDomText class represents text data in the parsed XML document.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ You can split the text in a QDomText object over two QDomText
+ objecs with splitText().
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+/*!
+ Constructs an empty QDomText object.
+
+ To construct a QDomText with content, use QDomDocument::createTextNode().
+*/
+QDomText::QDomText()
+ : QDomCharacterData()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomText::QDomText(const QDomText& x)
+ : QDomCharacterData(x)
+{
+}
+
+QDomText::QDomText(QDomTextPrivate* n)
+ : QDomCharacterData(n)
+{
+}
+
+/*!
+ Assigns \a x to this DOM text.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomText& QDomText::operator= (const QDomText& x)
+{
+ return (QDomText&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomText::nodeType() const
+
+ Returns \c TextNode.
+*/
+
+/*!
+ Splits this DOM text object into two QDomText objects. This object
+ keeps its first \a offset characters and the second (newly
+ created) object is inserted into the document tree after this
+ object with the remaining characters.
+
+ The function returns the newly created object.
+
+ \sa QDomNode::normalize()
+*/
+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 = QLatin1String("#comment");
+}
+
+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, QLatin1Char(' '));
+
+ s << "<!--" << value;
+ if (value.endsWith(QLatin1Char('-')))
+ s << ' '; // Ensures that XML comment doesn't end with --->
+ s << "-->";
+
+ if (!(next && next->isText()))
+ s << endl;
+}
+
+/**************************************************************
+ *
+ * QDomComment
+ *
+ **************************************************************/
+
+/*!
+ \class QDomComment
+ \reentrant
+ \brief The QDomComment class represents an XML comment.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ A comment in the parsed XML such as this:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 15
+ is represented by QDomComment objects in the parsed Dom tree.
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+/*!
+ Constructs an empty comment. To construct a comment with content,
+ use the QDomDocument::createComment() function.
+*/
+QDomComment::QDomComment()
+ : QDomCharacterData()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomComment::QDomComment(const QDomComment& x)
+ : QDomCharacterData(x)
+{
+}
+
+QDomComment::QDomComment(QDomCommentPrivate* n)
+ : QDomCharacterData(n)
+{
+}
+
+/*!
+ Assigns \a x to this DOM comment.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomComment& QDomComment::operator= (const QDomComment& x)
+{
+ return (QDomComment&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomComment::nodeType() const
+
+ Returns \c CommentNode.
+*/
+
+/**************************************************************
+ *
+ * QDomCDATASectionPrivate
+ *
+ **************************************************************/
+
+QDomCDATASectionPrivate::QDomCDATASectionPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent,
+ const QString& val)
+ : QDomTextPrivate(d, parent, val)
+{
+ name = QLatin1String("#cdata-section");
+}
+
+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
+ *
+ **************************************************************/
+
+/*!
+ \class QDomCDATASection
+ \reentrant
+ \brief The QDomCDATASection class represents an XML CDATA section.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ CDATA sections are used to escape blocks of text containing
+ characters that would otherwise be regarded as markup. The only
+ delimiter that is recognized in a CDATA section is the "]]&gt;"
+ string that terminates the CDATA section. CDATA sections cannot be
+ nested. Their primary purpose is for including material such as
+ XML fragments, without needing to escape all the delimiters.
+
+ Adjacent QDomCDATASection nodes are not merged by the
+ QDomNode::normalize() function.
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+/*!
+ Constructs an empty CDATA section. To create a CDATA section with
+ content, use the QDomDocument::createCDATASection() function.
+*/
+QDomCDATASection::QDomCDATASection()
+ : QDomText()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomCDATASection::QDomCDATASection(const QDomCDATASection& x)
+ : QDomText(x)
+{
+}
+
+QDomCDATASection::QDomCDATASection(QDomCDATASectionPrivate* n)
+ : QDomText(n)
+{
+}
+
+/*!
+ Assigns \a x to this CDATA section.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomCDATASection& QDomCDATASection::operator= (const QDomCDATASection& x)
+{
+ return (QDomCDATASection&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomCDATASection::nodeType() const
+
+ Returns \c CDATASection.
+*/
+
+/**************************************************************
+ *
+ * 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 << '>' << endl;
+}
+
+/**************************************************************
+ *
+ * QDomNotation
+ *
+ **************************************************************/
+
+#define IMPL ((QDomNotationPrivate*)impl)
+
+/*!
+ \class QDomNotation
+ \reentrant
+ \brief The QDomNotation class represents an XML notation.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ A notation either declares, by name, the format of an unparsed
+ entity (see section 4.7 of the XML 1.0 specification), or is used
+ for formal declaration of processing instruction targets (see
+ section 2.6 of the XML 1.0 specification).
+
+ DOM does not support editing notation nodes; they are therefore
+ read-only.
+
+ A notation node does not have any parent.
+
+ You can retrieve the publicId() and systemId() from a notation
+ node.
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+
+/*!
+ Constructor.
+*/
+QDomNotation::QDomNotation()
+ : QDomNode()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomNotation::QDomNotation(const QDomNotation& x)
+ : QDomNode(x)
+{
+}
+
+QDomNotation::QDomNotation(QDomNotationPrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a x to this DOM notation.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomNotation& QDomNotation::operator= (const QDomNotation& x)
+{
+ return (QDomNotation&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomNotation::nodeType() const
+
+ Returns \c NotationNode.
+*/
+
+/*!
+ Returns the public identifier of this notation.
+*/
+QString QDomNotation::publicId() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->m_pub;
+}
+
+/*!
+ Returns the system identifier of this notation.
+*/
+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);
+ uint len = tmp.size();
+ uint i = 0;
+ const char* d = tmp.data();
+ while (i < len) {
+ if (d[i] == '%'){
+ tmp.replace(i, 1, "&#60;");
+ d = tmp;
+ len += 4;
+ i += 5;
+ }
+ else if (d[i] == '"') {
+ tmp.replace(i, 1, "&#34;");
+ d = tmp;
+ len += 4;
+ i += 5;
+ } else if (d[i] == '&' && i + 1 < len && d[i+1] == '#') {
+ // Dont encode &lt; or &quot; or &custom;.
+ // Only encode character references
+ tmp.replace(i, 1, "&#38;");
+ d = tmp;
+ len += 4;
+ i += 5;
+ } else {
+ ++i;
+ }
+ }
+
+ return tmp;
+}
+
+void QDomEntityPrivate::save(QTextStream& s, int, int) const
+{
+ QString _name = name;
+ if (_name.startsWith(QLatin1Char('%')))
+ _name = QLatin1String("% ") + _name.mid(1);
+
+ if (m_sys.isNull() && m_pub.isNull()) {
+ s << "<!ENTITY " << _name << " \"" << encodeEntity(value.toUtf8()) << "\">" << 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 << '>' << endl;
+ }
+}
+
+/**************************************************************
+ *
+ * QDomEntity
+ *
+ **************************************************************/
+
+#define IMPL ((QDomEntityPrivate*)impl)
+
+/*!
+ \class QDomEntity
+ \reentrant
+ \brief The QDomEntity class represents an XML entity.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ This class represents an entity in an XML document, either parsed
+ or unparsed. Note that this models the entity itself not the
+ entity declaration.
+
+ DOM does not support editing entity nodes; if a user wants to make
+ changes to the contents of an entity, every related
+ QDomEntityReference node must be replaced in the DOM tree by a
+ clone of the entity's contents, and then the desired changes must
+ be made to each of the clones instead. All the descendants of an
+ entity node are read-only.
+
+ An entity node does not have any parent.
+
+ You can access the entity's publicId(), systemId() and
+ notationName() when available.
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+
+/*!
+ Constructs an empty entity.
+*/
+QDomEntity::QDomEntity()
+ : QDomNode()
+{
+}
+
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomEntity::QDomEntity(const QDomEntity& x)
+ : QDomNode(x)
+{
+}
+
+QDomEntity::QDomEntity(QDomEntityPrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a x to this DOM entity.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomEntity& QDomEntity::operator= (const QDomEntity& x)
+{
+ return (QDomEntity&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomEntity::nodeType() const
+
+ Returns \c EntityNode.
+*/
+
+/*!
+ Returns the public identifier associated with this entity. If the
+ public identifier was not specified an empty string is returned.
+*/
+QString QDomEntity::publicId() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->m_pub;
+}
+
+/*!
+ Returns the system identifier associated with this entity. If the
+ system identifier was not specified an empty string is returned.
+*/
+QString QDomEntity::systemId() const
+{
+ if (!impl)
+ return QString();
+ return IMPL->m_sys;
+}
+
+/*!
+ For unparsed entities this function returns the name of the
+ notation for the entity. For parsed entities this function returns
+ an empty string.
+*/
+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
+ *
+ **************************************************************/
+
+/*!
+ \class QDomEntityReference
+ \reentrant
+ \brief The QDomEntityReference class represents an XML entity reference.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ A QDomEntityReference object may be inserted into the DOM tree
+ when an entity reference is in the source document, or when the
+ user wishes to insert an entity reference.
+
+ Note that character references and references to predefined
+ entities are expanded by the XML processor so that characters are
+ represented by their Unicode equivalent rather than by an entity
+ reference.
+
+ Moreover, the XML processor may completely expand references to
+ entities while building the DOM tree, instead of providing
+ QDomEntityReference objects.
+
+ If it does provide such objects, then for a given entity reference
+ node, it may be that there is no entity node representing the
+ referenced entity; but if such an entity exists, then the child
+ list of the entity reference node is the same as that of the
+ entity node. As with the entity node, all descendants of the
+ entity reference are read-only.
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+/*!
+ Constructs an empty entity reference. Use
+ QDomDocument::createEntityReference() to create a entity reference
+ with content.
+*/
+QDomEntityReference::QDomEntityReference()
+ : QDomNode()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomEntityReference::QDomEntityReference(const QDomEntityReference& x)
+ : QDomNode(x)
+{
+}
+
+QDomEntityReference::QDomEntityReference(QDomEntityReferencePrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a x to this entity reference.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomEntityReference& QDomEntityReference::operator= (const QDomEntityReference& x)
+{
+ return (QDomEntityReference&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomEntityReference::nodeType() const
+
+ Returns \c EntityReference.
+*/
+
+/**************************************************************
+ *
+ * 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 << "?>" << endl;
+}
+
+/**************************************************************
+ *
+ * QDomProcessingInstruction
+ *
+ **************************************************************/
+
+/*!
+ \class QDomProcessingInstruction
+ \reentrant
+ \brief The QDomProcessingInstruction class represents an XML processing
+ instruction.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ Processing instructions are used in XML to keep processor-specific
+ information in the text of the document.
+
+ The XML declaration that appears at the top of an XML document,
+ typically \tt{<?xml version='1.0' encoding='UTF-8'?>}, is treated by QDom as a
+ processing instruction. This is unfortunate, since the XML declaration is
+ not a processing instruction; among other differences, it cannot be
+ inserted into a document anywhere but on the first line.
+
+ Do not use this function to create an xml declaration, since although it
+ has the same syntax as a processing instruction, it isn't, and might not
+ be treated by QDom as such.
+
+ The content of the processing instruction is retrieved with data()
+ and set with setData(). The processing instruction's target is
+ retrieved with target().
+
+ For further information about the Document Object Model see
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}.
+ For a more general introduction of the DOM implementation see the
+ QDomDocument documentation.
+*/
+
+/*!
+ Constructs an empty processing instruction. Use
+ QDomDocument::createProcessingInstruction() to create a processing
+ instruction with content.
+*/
+QDomProcessingInstruction::QDomProcessingInstruction()
+ : QDomNode()
+{
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomProcessingInstruction::QDomProcessingInstruction(const QDomProcessingInstruction& x)
+ : QDomNode(x)
+{
+}
+
+QDomProcessingInstruction::QDomProcessingInstruction(QDomProcessingInstructionPrivate* n)
+ : QDomNode(n)
+{
+}
+
+/*!
+ Assigns \a x to this processing instruction.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomProcessingInstruction& QDomProcessingInstruction::operator= (const QDomProcessingInstruction& x)
+{
+ return (QDomProcessingInstruction&) QDomNode::operator=(x);
+}
+
+/*!
+ \fn QDomNode::NodeType QDomProcessingInstruction::nodeType() const
+
+ Returns \c ProcessingInstructionNode.
+*/
+
+/*!
+ Returns the target of this processing instruction.
+
+ \sa data()
+*/
+QString QDomProcessingInstruction::target() const
+{
+ if (!impl)
+ return QString();
+ return impl->nodeName();
+}
+
+/*!
+ Returns the content of this processing instruction.
+
+ \sa setData() target()
+*/
+QString QDomProcessingInstruction::data() const
+{
+ if (!impl)
+ return QString();
+ return impl->nodeValue();
+}
+
+/*!
+ Sets the data contained in the processing instruction to \a d.
+
+ \sa data()
+*/
+void QDomProcessingInstruction::setData(const QString& d)
+{
+ if (!impl)
+ return;
+ impl->setNodeValue(d);
+}
+
+/**************************************************************
+ *
+ * QDomDocumentPrivate
+ *
+ **************************************************************/
+
+QDomDocumentPrivate::QDomDocumentPrivate()
+ : QDomNodePrivate(0),
+ nodeListTime(1)
+{
+ impl = new QDomImplementationPrivate;
+ type = new QDomDocumentTypePrivate(this, this);
+
+ name = QLatin1String("#document");
+}
+
+QDomDocumentPrivate::QDomDocumentPrivate(const QString& aname)
+ : QDomNodePrivate(0),
+ nodeListTime(1)
+{
+ impl = new QDomImplementationPrivate;
+ type = new QDomDocumentTypePrivate(this, this);
+ type->name = aname;
+
+ name = QLatin1String("#document");
+}
+
+QDomDocumentPrivate::QDomDocumentPrivate(QDomDocumentTypePrivate* dt)
+ : QDomNodePrivate(0),
+ nodeListTime(1)
+{
+ impl = new QDomImplementationPrivate;
+ if (dt != 0) {
+ type = dt;
+ type->ref.ref();
+ } else {
+ type = new QDomDocumentTypePrivate(this, this);
+ }
+
+ name = QLatin1String("#document");
+}
+
+QDomDocumentPrivate::QDomDocumentPrivate(QDomDocumentPrivate* n, bool deep)
+ : QDomNodePrivate(n, deep),
+ nodeListTime(1)
+{
+ impl = n->impl->clone();
+ // Reference count is down to 0, so we set it to 1 here.
+ impl->ref.ref();
+ type = (QDomDocumentTypePrivate*)n->type->cloneNode();
+ type->setParent(this);
+ // Reference count is down to 0, so we set it to 1 here.
+ type->ref.ref();
+}
+
+QDomDocumentPrivate::~QDomDocumentPrivate()
+{
+ if (!impl->ref.deref())
+ delete impl;
+ if (!type->ref.deref())
+ delete type;
+}
+
+void QDomDocumentPrivate::clear()
+{
+ if (!impl->ref.deref())
+ delete impl;
+ if (!type->ref.deref())
+ delete type;
+ impl = 0;
+ type = 0;
+ QDomNodePrivate::clear();
+}
+
+static void initializeReader(QXmlSimpleReader &reader, bool namespaceProcessing)
+{
+ reader.setFeature(QLatin1String("http://xml.org/sax/features/namespaces"), namespaceProcessing);
+ reader.setFeature(QLatin1String("http://xml.org/sax/features/namespace-prefixes"), !namespaceProcessing);
+ reader.setFeature(QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData"), false); // Shouldn't change in Qt 4
+}
+
+bool QDomDocumentPrivate::setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn)
+{
+ QXmlSimpleReader reader;
+ initializeReader(reader, namespaceProcessing);
+ return setContent(source, &reader, errorMsg, errorLine, errorColumn);
+}
+
+bool QDomDocumentPrivate::setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg, int *errorLine, int *errorColumn)
+{
+ clear();
+ impl = new QDomImplementationPrivate;
+ type = new QDomDocumentTypePrivate(this, this);
+
+ bool namespaceProcessing = reader->feature(QLatin1String("http://xml.org/sax/features/namespaces"))
+ && !reader->feature(QLatin1String("http://xml.org/sax/features/namespace-prefixes"));
+
+ QDomHandler hnd(this, namespaceProcessing);
+ reader->setContentHandler(&hnd);
+ reader->setErrorHandler(&hnd);
+ reader->setLexicalHandler(&hnd);
+ reader->setDeclHandler(&hnd);
+ reader->setDTDHandler(&hnd);
+
+ if (!reader->parse(source)) {
+ if (errorMsg)
+ *errorMsg = hnd.errorMsg;
+ if (errorLine)
+ *errorLine = hnd.errorLine;
+ if (errorColumn)
+ *errorColumn = hnd.errorColumn;
+ return false;
+ }
+
+ return true;
+}
+
+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 0;
+
+ QDomElementPrivate *e = new QDomElementPrivate(this, 0, 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 0;
+
+ QDomElementPrivate *e = new QDomElementPrivate(this, 0, nsURI, fixedName);
+ e->ref.deref();
+ return e;
+}
+
+QDomDocumentFragmentPrivate* QDomDocumentPrivate::createDocumentFragment()
+{
+ QDomDocumentFragmentPrivate *f = new QDomDocumentFragmentPrivate(this, (QDomNodePrivate*)0);
+ f->ref.deref();
+ return f;
+}
+
+QDomTextPrivate* QDomDocumentPrivate::createTextNode(const QString &data)
+{
+ bool ok;
+ QString fixedData = fixedCharData(data, &ok);
+ if (!ok)
+ return 0;
+
+ QDomTextPrivate *t = new QDomTextPrivate(this, 0, fixedData);
+ t->ref.deref();
+ return t;
+}
+
+QDomCommentPrivate* QDomDocumentPrivate::createComment(const QString &data)
+{
+ bool ok;
+ QString fixedData = fixedComment(data, &ok);
+ if (!ok)
+ return 0;
+
+ QDomCommentPrivate *c = new QDomCommentPrivate(this, 0, fixedData);
+ c->ref.deref();
+ return c;
+}
+
+QDomCDATASectionPrivate* QDomDocumentPrivate::createCDATASection(const QString &data)
+{
+ bool ok;
+ QString fixedData = fixedCDataSection(data, &ok);
+ if (!ok)
+ return 0;
+
+ QDomCDATASectionPrivate *c = new QDomCDATASectionPrivate(this, 0, 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 0;
+ // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
+ QString fixedTarget = fixedXmlName(target, &ok);
+ if (!ok)
+ return 0;
+
+ QDomProcessingInstructionPrivate *p = new QDomProcessingInstructionPrivate(this, 0, fixedTarget, fixedData);
+ p->ref.deref();
+ return p;
+}
+QDomAttrPrivate* QDomDocumentPrivate::createAttribute(const QString &aname)
+{
+ bool ok;
+ QString fixedName = fixedXmlName(aname, &ok);
+ if (!ok)
+ return 0;
+
+ QDomAttrPrivate *a = new QDomAttrPrivate(this, 0, 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 0;
+
+ QDomAttrPrivate *a = new QDomAttrPrivate(this, 0, nsURI, fixedName);
+ a->ref.deref();
+ return a;
+}
+
+QDomEntityReferencePrivate* QDomDocumentPrivate::createEntityReference(const QString &aname)
+{
+ bool ok;
+ QString fixedName = fixedXmlName(aname, &ok);
+ if (!ok)
+ return 0;
+
+ QDomEntityReferencePrivate *e = new QDomEntityReferencePrivate(this, 0, fixedName);
+ e->ref.deref();
+ return e;
+}
+
+QDomNodePrivate* QDomDocumentPrivate::importNode(const QDomNodePrivate *importedNode, bool deep)
+{
+ QDomNodePrivate *node = 0;
+ switch (importedNode->nodeType()) {
+ case QDomNode::AttributeNode:
+ node = new QDomAttrPrivate((QDomAttrPrivate*)importedNode, true);
+ break;
+ case QDomNode::DocumentFragmentNode:
+ node = new QDomDocumentFragmentPrivate((QDomDocumentFragmentPrivate*)importedNode, deep);
+ break;
+ case QDomNode::ElementNode:
+ node = new QDomElementPrivate((QDomElementPrivate*)importedNode, deep);
+ break;
+ case QDomNode::EntityNode:
+ node = new QDomEntityPrivate((QDomEntityPrivate*)importedNode, deep);
+ break;
+ case QDomNode::EntityReferenceNode:
+ node = new QDomEntityReferencePrivate((QDomEntityReferencePrivate*)importedNode, false);
+ break;
+ case QDomNode::NotationNode:
+ node = new QDomNotationPrivate((QDomNotationPrivate*)importedNode, deep);
+ break;
+ case QDomNode::ProcessingInstructionNode:
+ node = new QDomProcessingInstructionPrivate((QDomProcessingInstructionPrivate*)importedNode, deep);
+ break;
+ case QDomNode::TextNode:
+ node = new QDomTextPrivate((QDomTextPrivate*)importedNode, deep);
+ break;
+ case QDomNode::CDATASectionNode:
+ node = new QDomCDATASectionPrivate((QDomCDATASectionPrivate*)importedNode, deep);
+ break;
+ case QDomNode::CommentNode:
+ node = new QDomCommentPrivate((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) {
+#ifndef QT_NO_TEXTCODEC
+ const QDomNodePrivate* n = first;
+
+ if (n && n->isProcessingInstruction() && n->nodeName() == QLatin1String("xml")) {
+ // we have an XML declaration
+ QString data = n->nodeValue();
+ QRegExp encoding(QString::fromLatin1("encoding\\s*=\\s*((\"([^\"]*)\")|('([^']*)'))"));
+ encoding.indexIn(data);
+ QString enc = encoding.cap(3);
+ if (enc.isEmpty()) {
+ enc = encoding.cap(5);
+ }
+ if (enc.isEmpty())
+ s.setCodec(QTextCodec::codecForName("UTF-8"));
+ else
+ s.setCodec(QTextCodec::codecForName(enc.toLatin1().data()));
+ } else {
+ s.setCodec(QTextCodec::codecForName("UTF-8"));
+ }
+#endif
+ bool doc = false;
+
+ while (n) {
+ if (!doc && !(n->isProcessingInstruction() && n->nodeName() == QLatin1String("xml"))) {
+ // 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.
+#ifdef QT_NO_TEXTCODEC
+ const QLatin1String codecName("iso-8859-1");
+#else
+ const QTextCodec *const codec = s.codec();
+ Q_ASSERT_X(codec, "QDomNode::save()", "A codec must be specified in the text stream.");
+ const QByteArray codecName = codec->name();
+#endif
+
+ 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() == QLatin1String("xml")) {
+ 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 ((QDomDocumentPrivate*)impl)
+
+/*!
+ \class QDomDocument
+ \reentrant
+ \brief The QDomDocument class represents an XML document.
+
+ \inmodule QtXml
+ \mainclass
+ \ingroup xml-tools
+
+ The QDomDocument class represents the entire XML document.
+ Conceptually, it is the root of the document tree, and provides
+ the primary access to the document's data.
+
+ Since elements, text nodes, comments, processing instructions,
+ etc., cannot exist outside the context of a document, the document
+ class also contains the factory functions needed to create these
+ objects. The node objects created have an ownerDocument() function
+ which associates them with the document within whose context they
+ were created. The DOM classes that will be used most often are
+ QDomNode, QDomDocument, QDomElement and QDomText.
+
+ The parsed XML is represented internally by a tree of objects that
+ can be accessed using the various QDom classes. All QDom classes
+ only \e reference objects in the internal tree. The internal
+ objects in the DOM tree will get deleted once the last QDom
+ object referencing them and the QDomDocument itself are deleted.
+
+ Creation of elements, text nodes, etc. is done using the various
+ factory functions provided in this class. Using the default
+ constructors of the QDom classes will only result in empty
+ objects that cannot be manipulated or inserted into the Document.
+
+ The QDomDocument class has several functions for creating document
+ data, for example, createElement(), createTextNode(),
+ createComment(), createCDATASection(),
+ createProcessingInstruction(), createAttribute() and
+ createEntityReference(). Some of these functions have versions
+ that support namespaces, i.e. createElementNS() and
+ createAttributeNS(). The createDocumentFragment() function is used
+ to hold parts of the document; this is useful for manipulating for
+ complex documents.
+
+ The entire content of the document is set with setContent(). This
+ function parses the string it is passed as an XML document and
+ creates the DOM tree that represents the document. The root
+ element is available using documentElement(). The textual
+ representation of the document can be obtained using toString().
+
+ It is possible to insert a node from another document into the
+ document using importNode().
+
+ You can obtain a list of all the elements that have a particular
+ tag with elementsByTagName() or with elementsByTagNameNS().
+
+ The QDom classes are typically used as follows:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 16
+
+ Once \c doc and \c elem go out of scope, the whole internal tree
+ representing the XML document is deleted.
+
+ To create a document using DOM use code like this:
+ \snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 17
+
+ For further information about the Document Object Model see
+ the Document Object Model (DOM)
+ \l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and
+ \l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}
+ Specifications.
+
+ \sa {DOM Bookmarks Example}, {Simple DOM Model Example}
+*/
+
+
+/*!
+ Constructs an empty document.
+*/
+QDomDocument::QDomDocument()
+{
+ impl = 0;
+}
+
+/*!
+ Creates a document and sets the name of the document type to \a
+ name.
+*/
+QDomDocument::QDomDocument(const QString& name)
+{
+ // We take over ownership
+ impl = new QDomDocumentPrivate(name);
+}
+
+/*!
+ Creates a document with the document type \a doctype.
+
+ \sa QDomImplementation::createDocumentType()
+*/
+QDomDocument::QDomDocument(const QDomDocumentType& doctype)
+{
+ impl = new QDomDocumentPrivate((QDomDocumentTypePrivate*)(doctype.impl));
+}
+
+/*!
+ Constructs a copy of \a x.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomDocument::QDomDocument(const QDomDocument& x)
+ : QDomNode(x)
+{
+}
+
+QDomDocument::QDomDocument(QDomDocumentPrivate* x)
+ : QDomNode(x)
+{
+}
+
+/*!
+ Assigns \a x to this DOM document.
+
+ The data of the copy is shared (shallow copy): modifying one node
+ will also change the other. If you want to make a deep copy, use
+ cloneNode().
+*/
+QDomDocument& QDomDocument::operator= (const QDomDocument& x)
+{
+ return (QDomDocument&) QDomNode::operator=(x);
+}
+
+/*!
+ Destroys the object and frees its resources.
+*/
+QDomDocument::~QDomDocument()
+{
+}
+
+/*!
+ \overload
+
+ This function reads the XML document from the string \a text, returning
+ true if the content was successfully parsed; otherwise returns false.
+ Since \a text is already a Unicode string, no encoding detection
+ is done.
+*/
+bool QDomDocument::setContent(const QString& text, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ QXmlInputSource source;
+ source.setData(text);
+ return IMPL->setContent(&source, namespaceProcessing, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ \nonreentrant
+
+ This function parses the XML document from the byte array \a
+ data and sets it as the content of the document. It tries to
+ detect the encoding of the document as required by the XML
+ specification.
+
+ If \a namespaceProcessing is true, the parser recognizes
+ namespaces in the XML file and sets the prefix name, local name
+ and namespace URI to appropriate values. If \a namespaceProcessing
+ is false, the parser does no namespace processing when it reads
+ the XML file.
+
+ If a parse error occurs, this function returns false and the error
+ message is placed in \c{*}\a{errorMsg}, the line number in
+ \c{*}\a{errorLine} and the column number in \c{*}\a{errorColumn}
+ (unless the associated pointer is set to 0); otherwise this
+ function returns true. The various error messages are described in
+ the QXmlParseException class documentation. Note that, if you
+ want to display these error messages to your application's users,
+ they will be displayed in English unless they are explicitly
+ translated.
+
+ If \a namespaceProcessing is true, the function QDomNode::prefix()
+ returns a string for all elements and attributes. It returns an
+ empty string if the element or attribute has no prefix.
+
+ Text nodes consisting only of whitespace are stripped and won't
+ appear in the QDomDocument. If this behavior is not desired,
+ one can use the setContent() overload that allows a QXmlReader to be
+ supplied.
+
+ If \a namespaceProcessing is false, the functions
+ QDomNode::prefix(), QDomNode::localName() and
+ QDomNode::namespaceURI() return an empty string.
+
+ Entity references are handled as follows:
+ \list
+ \o References to internal general entities and character entities occurring in the
+ content are included. The result is a QDomText node with the references replaced
+ by their corresponding entity values.
+ \o References to parameter entities occurring in the internal subset are included.
+ The result is a QDomDocumentType node which contains entity and notation declarations
+ with the references replaced by their corresponding entity values.
+ \o Any general parsed entity reference which is not defined in the internal subset and
+ which occurs in the content is represented as a QDomEntityReference node.
+ \o Any parsed entity reference which is not defined in the internal subset and which
+ occurs outside of the content is replaced with an empty string.
+ \o Any unparsed entity reference is replaced with an empty string.
+ \endlist
+
+ \sa QDomNode::namespaceURI() QDomNode::localName()
+ QDomNode::prefix() QString::isNull() QString::isEmpty()
+*/
+bool QDomDocument::setContent(const QByteArray &data, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ QBuffer buf;
+ buf.setData(data);
+ QXmlInputSource source(&buf);
+ return IMPL->setContent(&source, namespaceProcessing, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ \overload
+
+ This function reads the XML document from the IO device \a dev, returning
+ true if the content was successfully parsed; otherwise returns false.
+*/
+bool QDomDocument::setContent(QIODevice* dev, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ QXmlInputSource source(dev);
+ return IMPL->setContent(&source, namespaceProcessing, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ \overload
+ \since 4.5
+
+ This function reads the XML document from the QXmlInputSource \a source,
+ returning true if the content was successfully parsed; otherwise returns false.
+
+*/
+bool QDomDocument::setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn )
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ QXmlSimpleReader reader;
+ initializeReader(reader, namespaceProcessing);
+ return IMPL->setContent(source, &reader, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ \overload
+
+ This function reads the XML document from the string \a text, returning
+ true if the content was successfully parsed; otherwise returns false.
+ Since \a text is already a Unicode string, no encoding detection
+ is performed.
+
+ No namespace processing is performed either.
+*/
+bool QDomDocument::setContent(const QString& text, QString *errorMsg, int *errorLine, int *errorColumn)
+{
+ return setContent(text, false, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ \overload
+
+ This function reads the XML document from the byte array \a buffer,
+ returning true if the content was successfully parsed; otherwise returns
+ false.
+
+ No namespace processing is performed.
+*/
+bool QDomDocument::setContent(const QByteArray& buffer, QString *errorMsg, int *errorLine, int *errorColumn )
+{
+ return setContent(buffer, false, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ \overload
+
+ This function reads the XML document from the IO device \a dev, returning
+ true if the content was successfully parsed; otherwise returns false.
+
+ No namespace processing is performed.
+*/
+bool QDomDocument::setContent(QIODevice* dev, QString *errorMsg, int *errorLine, int *errorColumn )
+{
+ return setContent(dev, false, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ \overload
+
+ This function reads the XML document from the QXmlInputSource \a source and
+ parses it with the QXmlReader \a reader, returning true if the content was
+ successfully parsed; otherwise returns false.
+
+ This function doesn't change the features of the \a reader. If you want to
+ use certain features for parsing you can use this function to set up the
+ reader appropriately.
+
+ \sa QXmlSimpleReader
+*/
+bool QDomDocument::setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg, int *errorLine, int *errorColumn )
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return IMPL->setContent(source, reader, errorMsg, errorLine, errorColumn);
+}
+
+/*!
+ Converts the parsed document back to its textual representation.
+
+ This function uses \a indent as the amount of space to indent
+ subelements.
+
+ If \a indent is -1, no whitespace at all is added.
+*/
+QString QDomDocument::toString(int indent) const
+{
+ QString str;
+ QTextStream s(&str, QIODevice::WriteOnly);
+ save(s, indent);
+ return str;
+}
+
+/*!
+ Converts the parsed document back to its textual representation
+ and returns a QByteArray containing the data encoded as UTF-8.
+
+ This function uses \a indent as the amount of space to indent
+ subelements.
+
+ \sa toString()
+*/
+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();
+}
+
+
+/*!
+ Returns the document type of this document.
+*/
+QDomDocumentType QDomDocument::doctype() const
+{
+ if (!impl)
+ return QDomDocumentType();
+ return QDomDocumentType(IMPL->doctype());
+}
+
+/*!
+ Returns a QDomImplementation object.
+*/
+QDomImplementation QDomDocument::implementation() const
+{
+ if (!impl)
+ return QDomImplementation();
+ return QDomImplementation(IMPL->implementation());
+}
+
+/*!
+ Returns the root element of the document.
+*/
+QDomElement QDomDocument::documentElement() const
+{
+ if (!impl)
+ return QDomElement();
+ return QDomElement(IMPL->documentElement());
+}
+
+/*!
+ Creates a new element called \a tagName that can be inserted into
+ the DOM tree, e.g. using QDomNode::appendChild().
+
+ If \a tagName is not a valid XML name, the behavior of this function is governed
+ by QDomImplementation::InvalidDataPolicy.
+
+ \sa createElementNS() QDomNode::appendChild() QDomNode::insertBefore()
+ QDomNode::insertAfter()
+*/
+QDomElement QDomDocument::createElement(const QString& tagName)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomElement(IMPL->createElement(tagName));
+}
+
+/*!
+ Creates a new document fragment, that can be used to hold parts of
+ the document, e.g. when doing complex manipulations of the
+ document tree.
+*/
+QDomDocumentFragment QDomDocument::createDocumentFragment()
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomDocumentFragment(IMPL->createDocumentFragment());
+}
+
+/*!
+ Creates a text node for the string \a value that can be inserted
+ into the document tree, e.g. using QDomNode::appendChild().
+
+ If \a value contains characters which cannot be stored as character
+ data of an XML document (even in the form of character references), the
+ behavior of this function is governed by QDomImplementation::InvalidDataPolicy.
+
+ \sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter()
+*/
+QDomText QDomDocument::createTextNode(const QString& value)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomText(IMPL->createTextNode(value));
+}
+
+/*!
+ Creates a new comment for the string \a value that can be inserted
+ into the document, e.g. using QDomNode::appendChild().
+
+ If \a value contains characters which cannot be stored in an XML comment,
+ the behavior of this function is governed by QDomImplementation::InvalidDataPolicy.
+
+ \sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter()
+*/
+QDomComment QDomDocument::createComment(const QString& value)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomComment(IMPL->createComment(value));
+}
+
+/*!
+ Creates a new CDATA section for the string \a value that can be
+ inserted into the document, e.g. using QDomNode::appendChild().
+
+ If \a value contains characters which cannot be stored in a CDATA section,
+ the behavior of this function is governed by
+ QDomImplementation::InvalidDataPolicy.
+
+ \sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter()
+*/
+QDomCDATASection QDomDocument::createCDATASection(const QString& value)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomCDATASection(IMPL->createCDATASection(value));
+}
+
+/*!
+ Creates a new processing instruction that can be inserted into the
+ document, e.g. using QDomNode::appendChild(). This function sets
+ the target for the processing instruction to \a target and the
+ data to \a data.
+
+ If \a target is not a valid XML name, or data if contains characters which cannot
+ appear in a processing instruction, the behavior of this function is governed by
+ QDomImplementation::InvalidDataPolicy.
+
+ \sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter()
+*/
+QDomProcessingInstruction QDomDocument::createProcessingInstruction(const QString& target,
+ const QString& data)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomProcessingInstruction(IMPL->createProcessingInstruction(target, data));
+}
+
+
+/*!
+ Creates a new attribute called \a name that can be inserted into
+ an element, e.g. using QDomElement::setAttributeNode().
+
+ If \a name is not a valid XML name, the behavior of this function is governed by
+ QDomImplementation::InvalidDataPolicy.
+
+ \sa createAttributeNS()
+*/
+QDomAttr QDomDocument::createAttribute(const QString& name)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomAttr(IMPL->createAttribute(name));
+}
+
+/*!
+ Creates a new entity reference called \a name that can be inserted
+ into the document, e.g. using QDomNode::appendChild().
+
+ If \a name is not a valid XML name, the behavior of this function is governed by
+ QDomImplementation::InvalidDataPolicy.
+
+ \sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter()
+*/
+QDomEntityReference QDomDocument::createEntityReference(const QString& name)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomEntityReference(IMPL->createEntityReference(name));
+}
+
+/*!
+ Returns a QDomNodeList, that contains all the elements in the
+ document with the name \a tagname. The order of the node list is
+ the order they are encountered in a preorder traversal of the
+ element tree.
+
+ \sa elementsByTagNameNS() QDomElement::elementsByTagName()
+*/
+QDomNodeList QDomDocument::elementsByTagName(const QString& tagname) const
+{
+ return QDomNodeList(new QDomNodeListPrivate(impl, tagname));
+}
+
+/*!
+ Imports the node \a importedNode from another document to this
+ document. \a importedNode remains in the original document; this
+ function creates a copy that can be used within this document.
+
+ This function returns the imported node that belongs to this
+ document. The returned node has no parent. It is not possible to
+ import QDomDocument and QDomDocumentType nodes. In those cases
+ this function returns a \link QDomNode::isNull() null node\endlink.
+
+ If \a deep is true, this function imports not only the node \a
+ importedNode but its whole subtree; if it is false, only the \a
+ importedNode is imported. The argument \a deep has no effect on
+ QDomAttr and QDomEntityReference nodes, since the descendants of
+ QDomAttr nodes are always imported and those of
+ QDomEntityReference nodes are never imported.
+
+ The behavior of this function is slightly different depending on
+ the node types:
+ \table
+ \header \i Node Type \i Behavior
+ \row \i QDomAttr
+ \i The owner element is set to 0 and the specified flag is
+ set to true in the generated attribute. The whole subtree
+ of \a importedNode is always imported for attribute nodes:
+ \a deep has no effect.
+ \row \i QDomDocument
+ \i Document nodes cannot be imported.
+ \row \i QDomDocumentFragment
+ \i If \a deep is true, this function imports the whole
+ document fragment; otherwise it only generates an empty
+ document fragment.
+ \row \i QDomDocumentType
+ \i Document type nodes cannot be imported.
+ \row \i QDomElement
+ \i Attributes for which QDomAttr::specified() is true are
+ also imported, other attributes are not imported. If \a
+ deep is true, this function also imports the subtree of \a
+ importedNode; otherwise it imports only the element node
+ (and some attributes, see above).
+ \row \i QDomEntity
+ \i Entity nodes can be imported, but at the moment there is
+ no way to use them since the document type is read-only in
+ DOM level 2.
+ \row \i QDomEntityReference
+ \i Descendants of entity reference nodes are never imported:
+ \a deep has no effect.
+ \row \i QDomNotation
+ \i Notation nodes can be imported, but at the moment there is
+ no way to use them since the document type is read-only in
+ DOM level 2.
+ \row \i QDomProcessingInstruction
+ \i The target and value of the processing instruction is
+ copied to the new node.
+ \row \i QDomText
+ \i The text is copied to the new node.
+ \row \i QDomCDATASection
+ \i The text is copied to the new node.
+ \row \i QDomComment
+ \i The text is copied to the new node.
+ \endtable
+
+ \sa QDomElement::setAttribute() QDomNode::insertBefore()
+ QDomNode::insertAfter() QDomNode::replaceChild() QDomNode::removeChild()
+ QDomNode::appendChild()
+*/
+QDomNode QDomDocument::importNode(const QDomNode& importedNode, bool deep)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomNode(IMPL->importNode(importedNode.impl, deep));
+}
+
+/*!
+ Creates a new element with namespace support that can be inserted
+ into the DOM tree. The name of the element is \a qName and the
+ namespace URI is \a nsURI. This function also sets
+ QDomNode::prefix() and QDomNode::localName() to appropriate values
+ (depending on \a qName).
+
+ If \a qName is an empty string, returns a null element regardless of
+ whether the invalid data policy is set.
+
+ \sa createElement()
+*/
+QDomElement QDomDocument::createElementNS(const QString& nsURI, const QString& qName)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomElement(IMPL->createElementNS(nsURI, qName));
+}
+
+/*!
+ Creates a new attribute with namespace support that can be
+ inserted into an element. The name of the attribute is \a qName
+ and the namespace URI is \a nsURI. This function also sets
+ QDomNode::prefix() and QDomNode::localName() to appropriate values
+ (depending on \a qName).
+
+ If \a qName is not a valid XML name, the behavior of this function is governed by
+ QDomImplementation::InvalidDataPolicy.
+
+ \sa createAttribute()
+*/
+QDomAttr QDomDocument::createAttributeNS(const QString& nsURI, const QString& qName)
+{
+ if (!impl)
+ impl = new QDomDocumentPrivate();
+ return QDomAttr(IMPL->createAttributeNS(nsURI, qName));
+}
+
+/*!
+ Returns a QDomNodeList that contains all the elements in the
+ document with the local name \a localName and a namespace URI of
+ \a nsURI. The order of the node list is the order they are
+ encountered in a preorder traversal of the element tree.
+
+ \sa elementsByTagName() QDomElement::elementsByTagNameNS()
+*/
+QDomNodeList QDomDocument::elementsByTagNameNS(const QString& nsURI, const QString& localName)
+{
+ return QDomNodeList(new QDomNodeListPrivate(impl, nsURI, localName));
+}
+
+/*!
+ Returns the element whose ID is equal to \a elementId. If no
+ element with the ID was found, this function returns a \link
+ QDomNode::isNull() null element\endlink.
+
+ Since the QDomClasses do not know which attributes are element
+ IDs, this function returns always a \link QDomNode::isNull() null
+ element\endlink. This may change in a future version.
+*/
+QDomElement QDomDocument::elementById(const QString& /*elementId*/)
+{
+ qWarning("elementById() is not implemented and will always return a null node.");
+ return QDomElement();
+}
+
+/*!
+ \fn QDomNode::NodeType QDomDocument::nodeType() const
+
+ Returns \c DocumentNode.
+*/
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * Node casting functions
+ *
+ **************************************************************/
+
+/*!
+ Converts a QDomNode into a QDomAttr. If the node is not an
+ attribute, the returned object will be \link QDomNode::isNull()
+ null\endlink.
+
+ \sa isAttr()
+*/
+QDomAttr QDomNode::toAttr() const
+{
+ if (impl && impl->isAttr())
+ return QDomAttr(((QDomAttrPrivate*)impl));
+ return QDomAttr();
+}
+
+/*!
+ Converts a QDomNode into a QDomCDATASection. If the node is not a
+ CDATA section, the returned object will be \link
+ QDomNode::isNull() null\endlink.
+
+ \sa isCDATASection()
+*/
+QDomCDATASection QDomNode::toCDATASection() const
+{
+ if (impl && impl->isCDATASection())
+ return QDomCDATASection(((QDomCDATASectionPrivate*)impl));
+ return QDomCDATASection();
+}
+
+/*!
+ Converts a QDomNode into a QDomDocumentFragment. If the node is
+ not a document fragment the returned object will be \link
+ QDomNode::isNull() null\endlink.
+
+ \sa isDocumentFragment()
+*/
+QDomDocumentFragment QDomNode::toDocumentFragment() const
+{
+ if (impl && impl->isDocumentFragment())
+ return QDomDocumentFragment(((QDomDocumentFragmentPrivate*)impl));
+ return QDomDocumentFragment();
+}
+
+/*!
+ Converts a QDomNode into a QDomDocument. If the node is not a
+ document the returned object will be \link QDomNode::isNull()
+ null\endlink.
+
+ \sa isDocument()
+*/
+QDomDocument QDomNode::toDocument() const
+{
+ if (impl && impl->isDocument())
+ return QDomDocument(((QDomDocumentPrivate*)impl));
+ return QDomDocument();
+}
+
+/*!
+ Converts a QDomNode into a QDomDocumentType. If the node is not a
+ document type the returned object will be \link QDomNode::isNull()
+ null\endlink.
+
+ \sa isDocumentType()
+*/
+QDomDocumentType QDomNode::toDocumentType() const
+{
+ if (impl && impl->isDocumentType())
+ return QDomDocumentType(((QDomDocumentTypePrivate*)impl));
+ return QDomDocumentType();
+}
+
+/*!
+ Converts a QDomNode into a QDomElement. If the node is not an
+ element the returned object will be \link QDomNode::isNull()
+ null\endlink.
+
+ \sa isElement()
+*/
+QDomElement QDomNode::toElement() const
+{
+ if (impl && impl->isElement())
+ return QDomElement(((QDomElementPrivate*)impl));
+ return QDomElement();
+}
+
+/*!
+ Converts a QDomNode into a QDomEntityReference. If the node is not
+ an entity reference, the returned object will be \link
+ QDomNode::isNull() null\endlink.
+
+ \sa isEntityReference()
+*/
+QDomEntityReference QDomNode::toEntityReference() const
+{
+ if (impl && impl->isEntityReference())
+ return QDomEntityReference(((QDomEntityReferencePrivate*)impl));
+ return QDomEntityReference();
+}
+
+/*!
+ Converts a QDomNode into a QDomText. If the node is not a text,
+ the returned object will be \link QDomNode::isNull() null\endlink.
+
+ \sa isText()
+*/
+QDomText QDomNode::toText() const
+{
+ if (impl && impl->isText())
+ return QDomText(((QDomTextPrivate*)impl));
+ return QDomText();
+}
+
+/*!
+ Converts a QDomNode into a QDomEntity. If the node is not an
+ entity the returned object will be \link QDomNode::isNull()
+ null\endlink.
+
+ \sa isEntity()
+*/
+QDomEntity QDomNode::toEntity() const
+{
+ if (impl && impl->isEntity())
+ return QDomEntity(((QDomEntityPrivate*)impl));
+ return QDomEntity();
+}
+
+/*!
+ Converts a QDomNode into a QDomNotation. If the node is not a
+ notation the returned object will be \link QDomNode::isNull()
+ null\endlink.
+
+ \sa isNotation()
+*/
+QDomNotation QDomNode::toNotation() const
+{
+ if (impl && impl->isNotation())
+ return QDomNotation(((QDomNotationPrivate*)impl));
+ return QDomNotation();
+}
+
+/*!
+ Converts a QDomNode into a QDomProcessingInstruction. If the node
+ is not a processing instruction the returned object will be \link
+ QDomNode::isNull() null\endlink.
+
+ \sa isProcessingInstruction()
+*/
+QDomProcessingInstruction QDomNode::toProcessingInstruction() const
+{
+ if (impl && impl->isProcessingInstruction())
+ return QDomProcessingInstruction(((QDomProcessingInstructionPrivate*)impl));
+ return QDomProcessingInstruction();
+}
+
+/*!
+ Converts a QDomNode into a QDomCharacterData. If the node is not a
+ character data node the returned object will be \link
+ QDomNode::isNull() null\endlink.
+
+ \sa isCharacterData()
+*/
+QDomCharacterData QDomNode::toCharacterData() const
+{
+ if (impl && impl->isCharacterData())
+ return QDomCharacterData(((QDomCharacterDataPrivate*)impl));
+ return QDomCharacterData();
+}
+
+/*!
+ Converts a QDomNode into a QDomComment. If the node is not a
+ comment the returned object will be \link QDomNode::isNull()
+ null\endlink.
+
+ \sa isComment()
+*/
+QDomComment QDomNode::toComment() const
+{
+ if (impl && impl->isComment())
+ return QDomComment(((QDomCommentPrivate*)impl));
+ return QDomComment();
+}
+
+/**************************************************************
+ *
+ * QDomHandler
+ *
+ **************************************************************/
+
+QDomHandler::QDomHandler(QDomDocumentPrivate* adoc, bool namespaceProcessing)
+{
+ doc = adoc;
+ node = doc;
+ cdata = false;
+ nsProcessing = namespaceProcessing;
+}
+
+QDomHandler::~QDomHandler()
+{
+}
+
+bool QDomHandler::endDocument()
+{
+ // ### is this really necessary? (rms)
+ if (node != doc)
+ return false;
+ return true;
+}
+
+bool QDomHandler::startDTD(const QString& name, const QString& publicId, const QString& systemId)
+{
+ doc->doctype()->name = name;
+ doc->doctype()->publicId = publicId;
+ doc->doctype()->systemId = systemId;
+ return true;
+}
+
+bool QDomHandler::startElement(const QString& nsURI, const QString&, const QString& qName, const QXmlAttributes& atts)
+{
+ // tag name
+ QDomNodePrivate* n;
+ if (nsProcessing) {
+ n = doc->createElementNS(nsURI, qName);
+ } else {
+ n = doc->createElement(qName);
+ }
+ n->setLocation(locator->lineNumber(), locator->columnNumber());
+
+ node->appendChild(n);
+ node = n;
+
+ // attributes
+ for (int i=0; i<atts.length(); i++)
+ {
+ if (nsProcessing) {
+ ((QDomElementPrivate*)node)->setAttributeNS(atts.uri(i), atts.qName(i), atts.value(i));
+ } else {
+ ((QDomElementPrivate*)node)->setAttribute(atts.qName(i), atts.value(i));
+ }
+ }
+
+ return true;
+}
+
+bool QDomHandler::endElement(const QString&, const QString&, const QString&)
+{
+ if (node == doc)
+ return false;
+ node = node->parent();
+
+ return true;
+}
+
+bool QDomHandler::characters(const QString& ch)
+{
+ // No text as child of some document
+ if (node == doc)
+ return false;
+
+ QDomNodePrivate *n;
+ if (cdata) {
+ n = doc->createCDATASection(ch);
+ } else if (!entityName.isEmpty()) {
+ QDomEntityPrivate* e = new QDomEntityPrivate(doc, 0, entityName,
+ QString(), QString(), QString());
+ e->value = ch;
+ doc->doctype()->appendChild(e);
+ n = doc->createEntityReference(entityName);
+ } else {
+ n = doc->createTextNode(ch);
+ }
+ n->setLocation(locator->lineNumber(), locator->columnNumber());
+ node->appendChild(n);
+
+ return true;
+}
+
+bool QDomHandler::processingInstruction(const QString& target, const QString& data)
+{
+ QDomNodePrivate *n;
+ n = doc->createProcessingInstruction(target, data);
+ if (n) {
+ n->setLocation(locator->lineNumber(), locator->columnNumber());
+ node->appendChild(n);
+ return true;
+ }
+ else
+ return false;
+}
+
+extern bool qt_xml_skipped_entity_in_content;
+bool QDomHandler::skippedEntity(const QString& name)
+{
+ // we can only handle inserting entity references into content
+ if (!qt_xml_skipped_entity_in_content)
+ return true;
+
+ QDomNodePrivate *n = doc->createEntityReference(name);
+ n->setLocation(locator->lineNumber(), locator->columnNumber());
+ node->appendChild(n);
+ return true;
+}
+
+bool QDomHandler::fatalError(const QXmlParseException& exception)
+{
+ errorMsg = exception.message();
+ errorLine = exception.lineNumber();
+ errorColumn = exception.columnNumber();
+ return QXmlDefaultHandler::fatalError(exception);
+}
+
+bool QDomHandler::startCDATA()
+{
+ cdata = true;
+ return true;
+}
+
+bool QDomHandler::endCDATA()
+{
+ cdata = false;
+ return true;
+}
+
+bool QDomHandler::startEntity(const QString &name)
+{
+ entityName = name;
+ return true;
+}
+
+bool QDomHandler::endEntity(const QString &)
+{
+ entityName.clear();
+ return true;
+}
+
+bool QDomHandler::comment(const QString& ch)
+{
+ QDomNodePrivate *n;
+ n = doc->createComment(ch);
+ n->setLocation(locator->lineNumber(), locator->columnNumber());
+ node->appendChild(n);
+ return true;
+}
+
+bool QDomHandler::unparsedEntityDecl(const QString &name, const QString &publicId, const QString &systemId, const QString &notationName)
+{
+ QDomEntityPrivate* e = new QDomEntityPrivate(doc, 0, name,
+ publicId, systemId, notationName);
+ doc->doctype()->appendChild(e);
+ return true;
+}
+
+bool QDomHandler::externalEntityDecl(const QString &name, const QString &publicId, const QString &systemId)
+{
+ return unparsedEntityDecl(name, publicId, systemId, QString());
+}
+
+bool QDomHandler::notationDecl(const QString & name, const QString & publicId, const QString & systemId)
+{
+ QDomNotationPrivate* n = new QDomNotationPrivate(doc, 0, name, publicId, systemId);
+ doc->doctype()->appendChild(n);
+ return true;
+}
+
+void QDomHandler::setDocumentLocator(QXmlLocator *locator)
+{
+ this->locator = locator;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_DOM
diff --git a/src/xml/dom/qdom.h b/src/xml/dom/qdom.h
new file mode 100644
index 0000000..f72361f
--- /dev/null
+++ b/src/xml/dom/qdom.h
@@ -0,0 +1,681 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDOM_H
+#define QDOM_H
+
+#include <QtCore/qstring.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Xml)
+
+#ifndef QT_NO_DOM
+
+class QIODevice;
+class QTextStream;
+
+class QXmlInputSource;
+class QXmlReader;
+
+class QDomDocumentPrivate;
+class QDomDocumentTypePrivate;
+class QDomDocumentFragmentPrivate;
+class QDomNodePrivate;
+class QDomNodeListPrivate;
+class QDomImplementationPrivate;
+class QDomElementPrivate;
+class QDomNotationPrivate;
+class QDomEntityPrivate;
+class QDomEntityReferencePrivate;
+class QDomProcessingInstructionPrivate;
+class QDomAttrPrivate;
+class QDomCharacterDataPrivate;
+class QDomTextPrivate;
+class QDomCommentPrivate;
+class QDomCDATASectionPrivate;
+class QDomNamedNodeMapPrivate;
+class QDomImplementationPrivate;
+
+class QDomNodeList;
+class QDomElement;
+class QDomText;
+class QDomComment;
+class QDomCDATASection;
+class QDomProcessingInstruction;
+class QDomAttr;
+class QDomEntityReference;
+class QDomDocument;
+class QDomNamedNodeMap;
+class QDomDocument;
+class QDomDocumentFragment;
+class QDomDocumentType;
+class QDomImplementation;
+class QDomNode;
+class QDomEntity;
+class QDomNotation;
+class QDomCharacterData;
+
+class Q_XML_EXPORT QDomImplementation
+{
+public:
+ QDomImplementation();
+ QDomImplementation(const QDomImplementation&);
+ ~QDomImplementation();
+ QDomImplementation& operator= (const QDomImplementation&);
+ bool operator== (const QDomImplementation&) const;
+ bool operator!= (const QDomImplementation&) const;
+
+ // functions
+ bool hasFeature(const QString& feature, const QString& version) const;
+ QDomDocumentType createDocumentType(const QString& qName, const QString& publicId, const QString& systemId);
+ QDomDocument createDocument(const QString& nsURI, const QString& qName, const QDomDocumentType& doctype);
+
+ enum InvalidDataPolicy { AcceptInvalidChars = 0, DropInvalidChars, ReturnNullNode };
+ static InvalidDataPolicy invalidDataPolicy();
+ static void setInvalidDataPolicy(InvalidDataPolicy policy);
+
+ // Qt extension
+ bool isNull();
+
+private:
+ QDomImplementationPrivate* impl;
+ QDomImplementation(QDomImplementationPrivate*);
+
+ friend class QDomDocument;
+};
+
+class Q_XML_EXPORT QDomNode
+{
+public:
+ enum NodeType {
+ ElementNode = 1,
+ AttributeNode = 2,
+ TextNode = 3,
+ CDATASectionNode = 4,
+ EntityReferenceNode = 5,
+ EntityNode = 6,
+ ProcessingInstructionNode = 7,
+ CommentNode = 8,
+ DocumentNode = 9,
+ DocumentTypeNode = 10,
+ DocumentFragmentNode = 11,
+ NotationNode = 12,
+ BaseNode = 21,// this is not in the standard
+ CharacterDataNode = 22 // this is not in the standard
+ };
+
+ enum EncodingPolicy
+ {
+ EncodingFromDocument = 1,
+ EncodingFromTextStream = 2
+ };
+
+ QDomNode();
+ QDomNode(const QDomNode&);
+ QDomNode& operator= (const QDomNode&);
+ bool operator== (const QDomNode&) const;
+ bool operator!= (const QDomNode&) const;
+ ~QDomNode();
+
+ // DOM functions
+ QDomNode insertBefore(const QDomNode& newChild, const QDomNode& refChild);
+ QDomNode insertAfter(const QDomNode& newChild, const QDomNode& refChild);
+ QDomNode replaceChild(const QDomNode& newChild, const QDomNode& oldChild);
+ QDomNode removeChild(const QDomNode& oldChild);
+ QDomNode appendChild(const QDomNode& newChild);
+ bool hasChildNodes() const;
+ QDomNode cloneNode(bool deep = true) const;
+ void normalize();
+ bool isSupported(const QString& feature, const QString& version) const;
+
+ // DOM read-only attributes
+ QString nodeName() const;
+ NodeType nodeType() const;
+ QDomNode parentNode() const;
+ QDomNodeList childNodes() const;
+ QDomNode firstChild() const;
+ QDomNode lastChild() const;
+ QDomNode previousSibling() const;
+ QDomNode nextSibling() const;
+ QDomNamedNodeMap attributes() const;
+ QDomDocument ownerDocument() const;
+ QString namespaceURI() const;
+ QString localName() const;
+ bool hasAttributes() const;
+
+ // DOM attributes
+ QString nodeValue() const;
+ void setNodeValue(const QString&);
+ QString prefix() const;
+ void setPrefix(const QString& pre);
+
+ // Qt extensions
+ bool isAttr() const;
+ bool isCDATASection() const;
+ bool isDocumentFragment() const;
+ bool isDocument() const;
+ bool isDocumentType() const;
+ bool isElement() const;
+ bool isEntityReference() const;
+ bool isText() const;
+ bool isEntity() const;
+ bool isNotation() const;
+ bool isProcessingInstruction() const;
+ bool isCharacterData() const;
+ bool isComment() const;
+
+ /**
+ * Shortcut to avoid dealing with QDomNodeList
+ * all the time.
+ */
+ QDomNode namedItem(const QString& name) const;
+
+ bool isNull() const;
+ void clear();
+
+ QDomAttr toAttr() const;
+ QDomCDATASection toCDATASection() const;
+ QDomDocumentFragment toDocumentFragment() const;
+ QDomDocument toDocument() const;
+ QDomDocumentType toDocumentType() const;
+ QDomElement toElement() const;
+ QDomEntityReference toEntityReference() const;
+ QDomText toText() const;
+ QDomEntity toEntity() const;
+ QDomNotation toNotation() const;
+ QDomProcessingInstruction toProcessingInstruction() const;
+ QDomCharacterData toCharacterData() const;
+ QDomComment toComment() const;
+
+ void save(QTextStream&, int) const;
+ void save(QTextStream&, int, EncodingPolicy) const; // ### Qt 5: Merge overload(if we at all keep this)
+
+ QDomElement firstChildElement(const QString &tagName = QString()) const;
+ QDomElement lastChildElement(const QString &tagName = QString()) const;
+ QDomElement previousSiblingElement(const QString &tagName = QString()) const;
+ QDomElement nextSiblingElement(const QString &taName = QString()) const;
+
+ int lineNumber() const;
+ int columnNumber() const;
+
+protected:
+ QDomNodePrivate* impl;
+ QDomNode(QDomNodePrivate*);
+
+private:
+ friend class QDomDocument;
+ friend class QDomDocumentType;
+ friend class QDomNodeList;
+ friend class QDomNamedNodeMap;
+};
+
+class Q_XML_EXPORT QDomNodeList
+{
+public:
+ QDomNodeList();
+ QDomNodeList(const QDomNodeList&);
+ QDomNodeList& operator= (const QDomNodeList&);
+ bool operator== (const QDomNodeList&) const;
+ bool operator!= (const QDomNodeList&) const;
+ ~QDomNodeList();
+
+ // DOM functions
+ QDomNode item(int index) const;
+ inline QDomNode at(int index) const { return item(index); } // Qt API consistency
+
+ // DOM read only attributes
+ uint length() const;
+ inline int count() const { return length(); } // Qt API consitancy
+ inline int size() const { return length(); } // Qt API consistency
+ inline bool isEmpty() const { return length() == 0; } // Qt API consistency
+
+private:
+ QDomNodeListPrivate* impl;
+ QDomNodeList(QDomNodeListPrivate*);
+
+ friend class QDomNode;
+ friend class QDomElement;
+ friend class QDomDocument;
+};
+
+class Q_XML_EXPORT QDomDocumentType : public QDomNode
+{
+public:
+ QDomDocumentType();
+ QDomDocumentType(const QDomDocumentType& x);
+ QDomDocumentType& operator= (const QDomDocumentType&);
+
+ // DOM read only attributes
+ QString name() const;
+ QDomNamedNodeMap entities() const;
+ QDomNamedNodeMap notations() const;
+ QString publicId() const;
+ QString systemId() const;
+ QString internalSubset() const;
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return DocumentTypeNode; }
+
+private:
+ QDomDocumentType(QDomDocumentTypePrivate*);
+
+ friend class QDomImplementation;
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomDocument : public QDomNode
+{
+public:
+ QDomDocument();
+ explicit QDomDocument(const QString& name);
+ explicit QDomDocument(const QDomDocumentType& doctype);
+ QDomDocument(const QDomDocument& x);
+ QDomDocument& operator= (const QDomDocument&);
+ ~QDomDocument();
+
+ // DOM functions
+ QDomElement createElement(const QString& tagName);
+ QDomDocumentFragment createDocumentFragment();
+ QDomText createTextNode(const QString& data);
+ QDomComment createComment(const QString& data);
+ QDomCDATASection createCDATASection(const QString& data);
+ QDomProcessingInstruction createProcessingInstruction(const QString& target, const QString& data);
+ QDomAttr createAttribute(const QString& name);
+ QDomEntityReference createEntityReference(const QString& name);
+ QDomNodeList elementsByTagName(const QString& tagname) const;
+ QDomNode importNode(const QDomNode& importedNode, bool deep);
+ QDomElement createElementNS(const QString& nsURI, const QString& qName);
+ QDomAttr createAttributeNS(const QString& nsURI, const QString& qName);
+ QDomNodeList elementsByTagNameNS(const QString& nsURI, const QString& localName);
+ QDomElement elementById(const QString& elementId);
+
+ // DOM read only attributes
+ QDomDocumentType doctype() const;
+ QDomImplementation implementation() const;
+ QDomElement documentElement() const;
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return DocumentNode; }
+
+ // Qt extensions
+ bool setContent(const QByteArray& text, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+ bool setContent(const QString& text, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+ bool setContent(QIODevice* dev, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+ bool setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+ bool setContent(const QByteArray& text, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+ bool setContent(const QString& text, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+ bool setContent(QIODevice* dev, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+ bool setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0 );
+
+ // Qt extensions
+ QString toString(int = 1) const;
+ QByteArray toByteArray(int = 1) const;
+
+private:
+ QDomDocument(QDomDocumentPrivate*);
+
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomNamedNodeMap
+{
+public:
+ QDomNamedNodeMap();
+ QDomNamedNodeMap(const QDomNamedNodeMap&);
+ QDomNamedNodeMap& operator= (const QDomNamedNodeMap&);
+ bool operator== (const QDomNamedNodeMap&) const;
+ bool operator!= (const QDomNamedNodeMap&) const;
+ ~QDomNamedNodeMap();
+
+ // DOM functions
+ QDomNode namedItem(const QString& name) const;
+ QDomNode setNamedItem(const QDomNode& newNode);
+ QDomNode removeNamedItem(const QString& name);
+ QDomNode item(int index) const;
+ QDomNode namedItemNS(const QString& nsURI, const QString& localName) const;
+ QDomNode setNamedItemNS(const QDomNode& newNode);
+ QDomNode removeNamedItemNS(const QString& nsURI, const QString& localName);
+
+ // DOM read only attributes
+ uint length() const;
+ int count() const { return length(); } // Qt API consitancy
+ inline int size() const { return length(); } // Qt API consistency
+ inline bool isEmpty() const { return length() == 0; } // Qt API consistency
+
+ // Qt extension
+ bool contains(const QString& name) const;
+
+private:
+ QDomNamedNodeMapPrivate* impl;
+ QDomNamedNodeMap(QDomNamedNodeMapPrivate*);
+
+ friend class QDomNode;
+ friend class QDomDocumentType;
+ friend class QDomElement;
+};
+
+class Q_XML_EXPORT QDomDocumentFragment : public QDomNode
+{
+public:
+ QDomDocumentFragment();
+ QDomDocumentFragment(const QDomDocumentFragment& x);
+ QDomDocumentFragment& operator= (const QDomDocumentFragment&);
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return DocumentFragmentNode; }
+
+private:
+ QDomDocumentFragment(QDomDocumentFragmentPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomCharacterData : public QDomNode
+{
+public:
+ QDomCharacterData();
+ QDomCharacterData(const QDomCharacterData& x);
+ QDomCharacterData& operator= (const QDomCharacterData&);
+
+ // DOM functions
+ QString substringData(unsigned long offset, unsigned long count);
+ void appendData(const QString& arg);
+ void insertData(unsigned long offset, const QString& arg);
+ void deleteData(unsigned long offset, unsigned long count);
+ void replaceData(unsigned long offset, unsigned long count, const QString& arg);
+
+ // DOM read only attributes
+ uint length() const;
+
+ // DOM attributes
+ QString data() const;
+ void setData(const QString&);
+
+ // Overridden from QDomNode
+ QDomNode::NodeType nodeType() const;
+
+private:
+ QDomCharacterData(QDomCharacterDataPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomText;
+ friend class QDomComment;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomAttr : public QDomNode
+{
+public:
+ QDomAttr();
+ QDomAttr(const QDomAttr& x);
+ QDomAttr& operator= (const QDomAttr&);
+
+ // DOM read only attributes
+ QString name() const;
+ bool specified() const;
+ QDomElement ownerElement() const;
+
+ // DOM attributes
+ QString value() const;
+ void setValue(const QString&);
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return AttributeNode; }
+
+private:
+ QDomAttr(QDomAttrPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomElement;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomElement : public QDomNode
+{
+public:
+ QDomElement();
+ QDomElement(const QDomElement& x);
+ QDomElement& operator= (const QDomElement&);
+
+ // DOM functions
+ QString attribute(const QString& name, const QString& defValue = QString() ) const;
+ void setAttribute(const QString& name, const QString& value);
+ void setAttribute(const QString& name, qlonglong value);
+ void setAttribute(const QString& name, qulonglong value);
+ inline void setAttribute(const QString& name, int value)
+ { setAttribute(name, qlonglong(value)); }
+ inline void setAttribute(const QString& name, uint value)
+ { setAttribute(name, qulonglong(value)); }
+ void setAttribute(const QString& name, float value);
+ void setAttribute(const QString& name, double value);
+ void removeAttribute(const QString& name);
+ QDomAttr attributeNode(const QString& name);
+ QDomAttr setAttributeNode(const QDomAttr& newAttr);
+ QDomAttr removeAttributeNode(const QDomAttr& oldAttr);
+ QDomNodeList elementsByTagName(const QString& tagname) const;
+ bool hasAttribute(const QString& name) const;
+
+ QString attributeNS(const QString nsURI, const QString& localName, const QString& defValue = QString()) const;
+ void setAttributeNS(const QString nsURI, const QString& qName, const QString& value);
+ inline void setAttributeNS(const QString nsURI, const QString& qName, int value)
+ { setAttributeNS(nsURI, qName, qlonglong(value)); }
+ inline void setAttributeNS(const QString nsURI, const QString& qName, uint value)
+ { setAttributeNS(nsURI, qName, qulonglong(value)); }
+ void setAttributeNS(const QString nsURI, const QString& qName, qlonglong value);
+ void setAttributeNS(const QString nsURI, const QString& qName, qulonglong value);
+ void setAttributeNS(const QString nsURI, const QString& qName, double value);
+ void removeAttributeNS(const QString& nsURI, const QString& localName);
+ QDomAttr attributeNodeNS(const QString& nsURI, const QString& localName);
+ QDomAttr setAttributeNodeNS(const QDomAttr& newAttr);
+ QDomNodeList elementsByTagNameNS(const QString& nsURI, const QString& localName) const;
+ bool hasAttributeNS(const QString& nsURI, const QString& localName) const;
+
+ // DOM read only attributes
+ QString tagName() const;
+ void setTagName(const QString& name); // Qt extension
+
+ // Overridden from QDomNode
+ QDomNamedNodeMap attributes() const;
+ inline QDomNode::NodeType nodeType() const { return ElementNode; }
+
+ QString text() const;
+
+private:
+ QDomElement(QDomElementPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomNode;
+ friend class QDomAttr;
+};
+
+class Q_XML_EXPORT QDomText : public QDomCharacterData
+{
+public:
+ QDomText();
+ QDomText(const QDomText& x);
+ QDomText& operator= (const QDomText&);
+
+ // DOM functions
+ QDomText splitText(int offset);
+
+ // Overridden from QDomCharacterData
+ inline QDomNode::NodeType nodeType() const { return TextNode; }
+
+private:
+ QDomText(QDomTextPrivate*);
+
+ friend class QDomCDATASection;
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomComment : public QDomCharacterData
+{
+public:
+ QDomComment();
+ QDomComment(const QDomComment& x);
+ QDomComment& operator= (const QDomComment&);
+
+ // Overridden from QDomCharacterData
+ inline QDomNode::NodeType nodeType() const { return CommentNode; }
+
+private:
+ QDomComment(QDomCommentPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomCDATASection : public QDomText
+{
+public:
+ QDomCDATASection();
+ QDomCDATASection(const QDomCDATASection& x);
+ QDomCDATASection& operator= (const QDomCDATASection&);
+
+ // Overridden from QDomText
+ inline QDomNode::NodeType nodeType() const { return CDATASectionNode; }
+
+private:
+ QDomCDATASection(QDomCDATASectionPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomNotation : public QDomNode
+{
+public:
+ QDomNotation();
+ QDomNotation(const QDomNotation& x);
+ QDomNotation& operator= (const QDomNotation&);
+
+ // DOM read only attributes
+ QString publicId() const;
+ QString systemId() const;
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return NotationNode; }
+
+private:
+ QDomNotation(QDomNotationPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomEntity : public QDomNode
+{
+public:
+ QDomEntity();
+ QDomEntity(const QDomEntity& x);
+ QDomEntity& operator= (const QDomEntity&);
+
+ // DOM read only attributes
+ QString publicId() const;
+ QString systemId() const;
+ QString notationName() const;
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return EntityNode; }
+
+private:
+ QDomEntity(QDomEntityPrivate*);
+
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomEntityReference : public QDomNode
+{
+public:
+ QDomEntityReference();
+ QDomEntityReference(const QDomEntityReference& x);
+ QDomEntityReference& operator= (const QDomEntityReference&);
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return EntityReferenceNode; }
+
+private:
+ QDomEntityReference(QDomEntityReferencePrivate*);
+
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+class Q_XML_EXPORT QDomProcessingInstruction : public QDomNode
+{
+public:
+ QDomProcessingInstruction();
+ QDomProcessingInstruction(const QDomProcessingInstruction& x);
+ QDomProcessingInstruction& operator= (const QDomProcessingInstruction&);
+
+ // DOM read only attributes
+ QString target() const;
+
+ // DOM attributes
+ QString data() const;
+ void setData(const QString& d);
+
+ // Overridden from QDomNode
+ inline QDomNode::NodeType nodeType() const { return ProcessingInstructionNode; }
+
+private:
+ QDomProcessingInstruction(QDomProcessingInstructionPrivate*);
+
+ friend class QDomDocument;
+ friend class QDomNode;
+};
+
+
+Q_XML_EXPORT QTextStream& operator<<(QTextStream&, const QDomNode&);
+
+#endif // QT_NO_DOM
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDOM_H
diff --git a/src/xml/sax/qxml.cpp b/src/xml/sax/qxml.cpp
new file mode 100644
index 0000000..c78d4ba
--- /dev/null
+++ b/src/xml/sax/qxml.cpp
@@ -0,0 +1,8114 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qxml.h"
+#include "qtextcodec.h"
+#include "qbuffer.h"
+#include "qregexp.h"
+#include "qmap.h"
+#include "qstack.h"
+#include <qdebug.h>
+
+
+#ifdef Q_CC_BOR // borland 6 finds bogus warnings when building this file in uic3
+# pragma warn -8080
+#endif
+
+//#define QT_QXML_DEBUG
+
+// Error strings for the XML reader
+#define XMLERR_OK QT_TRANSLATE_NOOP("QXml", "no error occurred")
+#define XMLERR_ERRORBYCONSUMER QT_TRANSLATE_NOOP("QXml", "error triggered by consumer")
+#define XMLERR_UNEXPECTEDEOF QT_TRANSLATE_NOOP("QXml", "unexpected end of file")
+#define XMLERR_MORETHANONEDOCTYPE QT_TRANSLATE_NOOP("QXml", "more than one document type definition")
+#define XMLERR_ERRORPARSINGELEMENT QT_TRANSLATE_NOOP("QXml", "error occurred while parsing element")
+#define XMLERR_TAGMISMATCH QT_TRANSLATE_NOOP("QXml", "tag mismatch")
+#define XMLERR_ERRORPARSINGCONTENT QT_TRANSLATE_NOOP("QXml", "error occurred while parsing content")
+#define XMLERR_UNEXPECTEDCHARACTER QT_TRANSLATE_NOOP("QXml", "unexpected character")
+#define XMLERR_INVALIDNAMEFORPI QT_TRANSLATE_NOOP("QXml", "invalid name for processing instruction")
+#define XMLERR_VERSIONEXPECTED QT_TRANSLATE_NOOP("QXml", "version expected while reading the XML declaration")
+#define XMLERR_WRONGVALUEFORSDECL QT_TRANSLATE_NOOP("QXml", "wrong value for standalone declaration")
+#define XMLERR_EDECLORSDDECLEXPECTED QT_TRANSLATE_NOOP("QXml", "encoding declaration or standalone declaration expected while reading the XML declaration")
+#define XMLERR_SDDECLEXPECTED QT_TRANSLATE_NOOP("QXml", "standalone declaration expected while reading the XML declaration")
+#define XMLERR_ERRORPARSINGDOCTYPE QT_TRANSLATE_NOOP("QXml", "error occurred while parsing document type definition")
+#define XMLERR_LETTEREXPECTED QT_TRANSLATE_NOOP("QXml", "letter is expected")
+#define XMLERR_ERRORPARSINGCOMMENT QT_TRANSLATE_NOOP("QXml", "error occurred while parsing comment")
+#define XMLERR_ERRORPARSINGREFERENCE QT_TRANSLATE_NOOP("QXml", "error occurred while parsing reference")
+#define XMLERR_INTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP("QXml", "internal general entity reference not allowed in DTD")
+#define XMLERR_EXTERNALGENERALENTITYINAV QT_TRANSLATE_NOOP("QXml", "external parsed general entity reference not allowed in attribute value")
+#define XMLERR_EXTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP("QXml", "external parsed general entity reference not allowed in DTD")
+#define XMLERR_UNPARSEDENTITYREFERENCE QT_TRANSLATE_NOOP("QXml", "unparsed entity reference in wrong context")
+#define XMLERR_RECURSIVEENTITIES QT_TRANSLATE_NOOP("QXml", "recursive entities")
+#define XMLERR_ERRORINTEXTDECL QT_TRANSLATE_NOOP("QXml", "error in the text declaration of an external entity")
+
+QT_BEGIN_NAMESPACE
+
+// the constants for the lookup table
+static const signed char cltWS = 0; // white space
+static const signed char cltPer = 1; // %
+static const signed char cltAmp = 2; // &
+static const signed char cltGt = 3; // >
+static const signed char cltLt = 4; // <
+static const signed char cltSlash = 5; // /
+static const signed char cltQm = 6; // ?
+static const signed char cltEm = 7; // !
+static const signed char cltDash = 8; // -
+static const signed char cltCB = 9; // ]
+static const signed char cltOB = 10; // [
+static const signed char cltEq = 11; // =
+static const signed char cltDq = 12; // "
+static const signed char cltSq = 13; // '
+static const signed char cltUnknown = 14;
+
+// Hack for letting QDom know where the skipped entity occurred
+// ### Qt5: the use of this variable means the code isn't reentrant.
+bool qt_xml_skipped_entity_in_content;
+
+// character lookup table
+static const signed char charLookupTable[256]={
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x00 - 0x07
+ cltUnknown, // 0x08
+ cltWS, // 0x09 \t
+ cltWS, // 0x0A \n
+ cltUnknown, // 0x0B
+ cltUnknown, // 0x0C
+ cltWS, // 0x0D \r
+ cltUnknown, // 0x0E
+ cltUnknown, // 0x0F
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x17 - 0x16
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x18 - 0x1F
+ cltWS, // 0x20 Space
+ cltEm, // 0x21 !
+ cltDq, // 0x22 "
+ cltUnknown, // 0x23
+ cltUnknown, // 0x24
+ cltPer, // 0x25 %
+ cltAmp, // 0x26 &
+ cltSq, // 0x27 '
+ cltUnknown, // 0x28
+ cltUnknown, // 0x29
+ cltUnknown, // 0x2A
+ cltUnknown, // 0x2B
+ cltUnknown, // 0x2C
+ cltDash, // 0x2D -
+ cltUnknown, // 0x2E
+ cltSlash, // 0x2F /
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x30 - 0x37
+ cltUnknown, // 0x38
+ cltUnknown, // 0x39
+ cltUnknown, // 0x3A
+ cltUnknown, // 0x3B
+ cltLt, // 0x3C <
+ cltEq, // 0x3D =
+ cltGt, // 0x3E >
+ cltQm, // 0x3F ?
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x40 - 0x47
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x48 - 0x4F
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x50 - 0x57
+ cltUnknown, // 0x58
+ cltUnknown, // 0x59
+ cltUnknown, // 0x5A
+ cltOB, // 0x5B [
+ cltUnknown, // 0x5C
+ cltCB, // 0x5D]
+ cltUnknown, // 0x5E
+ cltUnknown, // 0x5F
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x60 - 0x67
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x68 - 0x6F
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x70 - 0x77
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x78 - 0x7F
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x80 - 0x87
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x88 - 0x8F
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x90 - 0x97
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x98 - 0x9F
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA0 - 0xA7
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA8 - 0xAF
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB0 - 0xB7
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB8 - 0xBF
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC0 - 0xC7
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC8 - 0xCF
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD0 - 0xD7
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD8 - 0xDF
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE0 - 0xE7
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE8 - 0xEF
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xF0 - 0xF7
+ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown // 0xF8 - 0xFF
+};
+
+//
+// local helper functions
+//
+
+/*
+ This function strips the TextDecl [77] ("<?xml ...?>") from the string \a
+ str. The stripped version is stored in \a str. If this function finds an
+ invalid TextDecl, it returns false, otherwise true.
+
+ This function is used for external entities since those can include an
+ TextDecl that must be stripped before inserting the entity.
+*/
+static bool stripTextDecl(QString& str)
+{
+ QString textDeclStart(QLatin1String("<?xml"));
+ if (str.startsWith(textDeclStart)) {
+ QRegExp textDecl(QString::fromLatin1(
+ "^<\\?xml\\s+"
+ "(version\\s*=\\s*((['\"])[-a-zA-Z0-9_.:]+\\3))?"
+ "\\s*"
+ "(encoding\\s*=\\s*((['\"])[A-Za-z][-a-zA-Z0-9_.]*\\6))?"
+ "\\s*\\?>"
+ ));
+ QString strTmp = str.replace(textDecl, QLatin1String(""));
+ if (strTmp.length() != str.length())
+ return false; // external entity has wrong TextDecl
+ str = strTmp;
+ }
+ return true;
+}
+
+
+class QXmlAttributesPrivate
+{
+};
+
+/* \class QXmlInputSourcePrivate
+ \internal
+
+ There's a slight misdesign in this class that can
+ be worth to keep in mind: the `str' member is
+ a buffer which QXmlInputSource::next() returns from,
+ and which is populated from the input device or input
+ stream. However, when the input is a QString(the user called
+ QXmlInputSource::setData()), `str' has two roles: it's the
+ buffer, but also the source. This /seems/ to be no problem
+ because in the case of having no device or stream, the QString
+ is read in one go.
+ */
+class QXmlInputSourcePrivate
+{
+public:
+ QIODevice *inputDevice;
+ QTextStream *inputStream;
+
+ QString str;
+ const QChar *unicode;
+ int pos;
+ int length;
+ bool nextReturnedEndOfData;
+#ifndef QT_NO_TEXTCODEC
+ QTextDecoder *encMapper;
+#endif
+
+ QByteArray encodingDeclBytes;
+ QString encodingDeclChars;
+ bool lookingForEncodingDecl;
+};
+class QXmlParseExceptionPrivate
+{
+public:
+ QString msg;
+ int column;
+ int line;
+ QString pub;
+ QString sys;
+
+};
+
+class QXmlLocatorPrivate
+{
+};
+
+class QXmlDefaultHandlerPrivate
+{
+};
+
+class QXmlSimpleReaderPrivate
+{
+private:
+ // functions
+ QXmlSimpleReaderPrivate();
+ ~QXmlSimpleReaderPrivate();
+ void initIncrementalParsing();
+
+ // used to determine if elements are correctly nested
+ QStack<QString> tags;
+
+ // used by parseReference() and parsePEReference()
+ enum EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD };
+
+ // used for entity declarations
+ struct ExternParameterEntity
+ {
+ ExternParameterEntity() {}
+ ExternParameterEntity(const QString &p, const QString &s)
+ : publicId(p), systemId(s) {}
+ QString publicId;
+ QString systemId;
+
+ Q_DUMMY_COMPARISON_OPERATOR(ExternParameterEntity)
+ };
+ struct ExternEntity
+ {
+ ExternEntity() {}
+ ExternEntity(const QString &p, const QString &s, const QString &n)
+ : publicId(p), systemId(s), notation(n) {}
+ QString publicId;
+ QString systemId;
+ QString notation;
+ Q_DUMMY_COMPARISON_OPERATOR(ExternEntity)
+ };
+ QMap<QString,ExternParameterEntity> externParameterEntities;
+ QMap<QString,QString> parameterEntities;
+ QMap<QString,ExternEntity> externEntities;
+ QMap<QString,QString> entities;
+
+ // used for parsing of entity references
+ struct XmlRef {
+ XmlRef(const QString &_name = QString(), const QString &_value = QString())
+ : name(_name), value(_value), index(0) {}
+ bool isEmpty() const { return index == value.length(); }
+ QChar next() { return value.at(index++); }
+ QString name;
+ QString value;
+ int index;
+ };
+ QStack<XmlRef> xmlRefStack;
+
+ // used for standalone declaration
+ enum Standalone { Yes, No, Unknown };
+
+ QString doctype; // only used for the doctype
+ QString xmlVersion; // only used to store the version information
+ QString encoding; // only used to store the encoding
+ Standalone standalone; // used to store the value of the standalone declaration
+
+ QString publicId; // used by parseExternalID() to store the public ID
+ QString systemId; // used by parseExternalID() to store the system ID
+
+ // Since publicId/systemId is used as temporary variables by parseExternalID(), it
+ // might overwrite the PUBLIC/SYSTEM for the document we're parsing. In effect, we would
+ // possibly send off an QXmlParseException that has the PUBLIC/SYSTEM of a entity declaration
+ // instead of those of the current document.
+ // Hence we have these two variables for storing the document's data.
+ QString thisPublicId;
+ QString thisSystemId;
+
+ QString attDeclEName; // use by parseAttlistDecl()
+ QString attDeclAName; // use by parseAttlistDecl()
+
+ // flags for some features support
+ bool useNamespaces;
+ bool useNamespacePrefixes;
+ bool reportWhitespaceCharData;
+ bool reportEntities;
+
+ // used to build the attribute list
+ QXmlAttributes attList;
+
+ // used in QXmlSimpleReader::parseContent() to decide whether character
+ // data was read
+ bool contentCharDataRead;
+
+ // helper classes
+ QXmlLocator *locator;
+ QXmlNamespaceSupport namespaceSupport;
+
+ // error string
+ QString error;
+
+ // arguments for parse functions (this is needed to allow incremental
+ // parsing)
+ bool parsePI_xmldecl;
+ bool parseName_useRef;
+ bool parseReference_charDataRead;
+ EntityRecognitionContext parseReference_context;
+ bool parseExternalID_allowPublicID;
+ EntityRecognitionContext parsePEReference_context;
+ QString parseString_s;
+
+ // for incremental parsing
+ struct ParseState {
+ typedef bool (QXmlSimpleReaderPrivate::*ParseFunction)();
+ ParseFunction function;
+ int state;
+ };
+ QStack<ParseState> *parseStack;
+
+ // used in parseProlog()
+ bool xmldecl_possible;
+ bool doctype_read;
+
+ // used in parseDoctype()
+ bool startDTDwasReported;
+
+ // used in parseString()
+ signed char Done;
+
+
+ // variables
+ QXmlContentHandler *contentHnd;
+ QXmlErrorHandler *errorHnd;
+ QXmlDTDHandler *dtdHnd;
+ QXmlEntityResolver *entityRes;
+ QXmlLexicalHandler *lexicalHnd;
+ QXmlDeclHandler *declHnd;
+
+ QXmlInputSource *inputSource;
+
+ QChar c; // the character at reading position
+ int lineNr; // number of line
+ int columnNr; // position in line
+
+ QChar nameArray[256]; // only used for names
+ QString nameValue; // only used for names
+ int nameArrayPos;
+ int nameValueLen;
+ QChar refArray[256]; // only used for references
+ QString refValue; // only used for references
+ int refArrayPos;
+ int refValueLen;
+ QChar stringArray[256]; // used for any other strings that are parsed
+ QString stringValue; // used for any other strings that are parsed
+ int stringArrayPos;
+ int stringValueLen;
+ QString emptyStr;
+
+ const QString &string();
+ void stringClear();
+ void stringAddC(QChar);
+ inline void stringAddC() { stringAddC(c); }
+ const QString &name();
+ void nameClear();
+ void nameAddC(QChar);
+ inline void nameAddC() { nameAddC(c); }
+ const QString &ref();
+ void refClear();
+ void refAddC(QChar);
+ inline void refAddC() { refAddC(c); }
+
+ // private functions
+ bool eat_ws();
+ bool next_eat_ws();
+
+ void QT_FASTCALL next();
+ bool atEnd();
+
+ void init(const QXmlInputSource* i);
+ void initData();
+
+ bool entityExist(const QString&) const;
+
+ bool parseBeginOrContinue(int state, bool incremental);
+
+ bool parseProlog();
+ bool parseElement();
+ bool processElementEmptyTag();
+ bool processElementETagBegin2();
+ bool processElementAttribute();
+ bool parseMisc();
+ bool parseContent();
+
+ bool parsePI();
+ bool parseDoctype();
+ bool parseComment();
+
+ bool parseName();
+ bool parseNmtoken();
+ bool parseAttribute();
+ bool parseReference();
+ bool processReference();
+
+ bool parseExternalID();
+ bool parsePEReference();
+ bool parseMarkupdecl();
+ bool parseAttlistDecl();
+ bool parseAttType();
+ bool parseAttValue();
+ bool parseElementDecl();
+ bool parseNotationDecl();
+ bool parseChoiceSeq();
+ bool parseEntityDecl();
+ bool parseEntityValue();
+
+ bool parseString();
+
+ bool insertXmlRef(const QString&, const QString&, bool);
+
+ bool reportEndEntities();
+ void reportParseError(const QString& error);
+
+ typedef bool (QXmlSimpleReaderPrivate::*ParseFunction) ();
+ void unexpectedEof(ParseFunction where, int state);
+ void parseFailed(ParseFunction where, int state);
+ void pushParseState(ParseFunction function, int state);
+
+ Q_DECLARE_PUBLIC(QXmlSimpleReader)
+ QXmlSimpleReader *q_ptr;
+
+ friend class QXmlSimpleReaderLocator;
+};
+
+/*!
+ \class QXmlParseException
+ \reentrant
+ \brief The QXmlParseException class is used to report errors with
+ the QXmlErrorHandler interface.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ The XML subsystem constructs an instance of this class when it
+ detects an error. You can retrieve the place where the error
+ occurred using systemId(), publicId(), lineNumber() and
+ columnNumber(), along with the error message(). The possible error
+ messages are:
+
+
+ \list
+ \o "no error occurred"
+ \o "error triggered by consumer"
+ \o "unexpected end of file"
+ \o "more than one document type definition"
+ \o "error occurred while parsing element"
+ \o "tag mismatch"
+ \o "error occurred while parsing content"
+ \o "unexpected character"
+ \o "invalid name for processing instruction"
+ \o "version expected while reading the XML declaration"
+ \o "wrong value for standalone declaration"
+ \o "encoding declaration or standalone declaration expected while reading the XML declaration"
+ \o "standalone declaration expected while reading the XML declaration"
+ \o "error occurred while parsing document type definition"
+ \o "letter is expected"
+ \o "error occurred while parsing comment"
+ \o "error occurred while parsing reference"
+ \o "internal general entity reference not allowed in DTD"
+ \o "external parsed general entity reference not allowed in attribute value"
+ \o "external parsed general entity reference not allowed in DTD"
+ \o "unparsed entity reference n wrong context"
+ \o "recursive entities"
+ \o "error in the text declaration of an external entity"
+ \endlist
+
+ Note that, if you want to display these error messages to your
+ application's users, they will be displayed in English unless
+ they are explicitly translated.
+
+ \sa QXmlErrorHandler, QXmlReader
+*/
+
+/*!
+ Constructs a parse exception with the error string \a name for
+ column \a c and line \a l for the public identifier \a p and the
+ system identifier \a s.
+*/
+
+QXmlParseException::QXmlParseException(const QString& name, int c, int l,
+ const QString& p, const QString& s)
+{
+ d = new QXmlParseExceptionPrivate;
+ d->msg = name;
+ d->column = c;
+ d->line = l;
+ d->pub = p;
+ d->sys = s;
+}
+
+/*!
+ Destroys the QXmlParseException.
+*/
+QXmlParseException::~QXmlParseException()
+{
+ delete d;
+}
+
+/*!
+ Returns the error message.
+*/
+QString QXmlParseException::message() const
+{
+ return d->msg;
+}
+/*!
+ Returns the column number where the error occurred.
+*/
+int QXmlParseException::columnNumber() const
+{
+ return d->column;
+}
+/*!
+ Returns the line number where the error occurred.
+*/
+int QXmlParseException::lineNumber() const
+{
+ return d->line;
+}
+/*!
+ Returns the public identifier where the error occurred.
+*/
+QString QXmlParseException::publicId() const
+{
+ return d->pub;
+}
+/*!
+ Returns the system identifier where the error occurred.
+*/
+QString QXmlParseException::systemId() const
+{
+ return d->sys;
+}
+
+
+/*!
+ \class QXmlLocator
+ \reentrant
+ \brief The QXmlLocator class provides the XML handler classes with
+ information about the parsing position within a file.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ The reader reports a QXmlLocator to the content handler before it
+ starts to parse the document. This is done with the
+ QXmlContentHandler::setDocumentLocator() function. The handler
+ classes can now use this locator to get the position (lineNumber()
+ and columnNumber()) that the reader has reached.
+*/
+
+/*!
+ Constructor.
+*/
+QXmlLocator::QXmlLocator()
+{
+}
+
+/*!
+ Destructor.
+*/
+QXmlLocator::~QXmlLocator()
+{
+}
+
+/*!
+ \fn int QXmlLocator::columnNumber() const
+
+ Returns the column number (starting at 1) or -1 if there is no
+ column number available.
+*/
+
+/*!
+ \fn int QXmlLocator::lineNumber() const
+
+ Returns the line number (starting at 1) or -1 if there is no line
+ number available.
+*/
+
+class QXmlSimpleReaderLocator : public QXmlLocator
+{
+public:
+ QXmlSimpleReaderLocator(QXmlSimpleReader* parent)
+ {
+ reader = parent;
+ }
+ ~QXmlSimpleReaderLocator()
+ {
+ }
+
+ int columnNumber() const
+ {
+ return (reader->d_ptr->columnNr == -1 ? -1 : reader->d_ptr->columnNr + 1);
+ }
+ int lineNumber() const
+ {
+ return (reader->d_ptr->lineNr == -1 ? -1 : reader->d_ptr->lineNr + 1);
+ }
+// QString getPublicId()
+// QString getSystemId()
+
+private:
+ QXmlSimpleReader *reader;
+};
+
+/*********************************************
+ *
+ * QXmlNamespaceSupport
+ *
+ *********************************************/
+
+typedef QMap<QString, QString> NamespaceMap;
+
+class QXmlNamespaceSupportPrivate
+{
+public:
+ QXmlNamespaceSupportPrivate()
+ {
+ ns.insert(QLatin1String("xml"), QLatin1String("http://www.w3.org/XML/1998/namespace")); // the XML namespace
+ }
+
+ ~QXmlNamespaceSupportPrivate()
+ {
+ }
+
+ QStack<NamespaceMap> nsStack;
+ NamespaceMap ns;
+};
+
+/*!
+ \class QXmlNamespaceSupport
+ \since 4.4
+ \reentrant
+ \brief The QXmlNamespaceSupport class is a helper class for XML
+ readers which want to include namespace support.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ You can set the prefix for the current namespace with setPrefix(),
+ and get the list of current prefixes (or those for a given URI)
+ with prefixes(). The namespace URI is available from uri(). Use
+ pushContext() to start a new namespace context, and popContext()
+ to return to the previous namespace context. Use splitName() or
+ processName() to split a name into its prefix and local name.
+
+ \sa {Namespace Support via Features}
+*/
+
+/*!
+ Constructs a QXmlNamespaceSupport.
+*/
+QXmlNamespaceSupport::QXmlNamespaceSupport()
+{
+ d = new QXmlNamespaceSupportPrivate;
+}
+
+/*!
+ Destroys a QXmlNamespaceSupport.
+*/
+QXmlNamespaceSupport::~QXmlNamespaceSupport()
+{
+ delete d;
+}
+
+/*!
+ This function declares a prefix \a pre in the current namespace
+ context to be the namespace URI \a uri. The prefix remains in
+ force until this context is popped, unless it is shadowed in a
+ descendant context.
+
+ Note that there is an asymmetry in this library. prefix() does not
+ return the default "" prefix, even if you have declared one; to
+ check for a default prefix, you must look it up explicitly using
+ uri(). This asymmetry exists to make it easier to look up prefixes
+ for attribute names, where the default prefix is not allowed.
+*/
+void QXmlNamespaceSupport::setPrefix(const QString& pre, const QString& uri)
+{
+ if(pre.isNull()) {
+ d->ns.insert(QLatin1String(""), uri);
+ } else {
+ d->ns.insert(pre, uri);
+ }
+}
+
+/*!
+ Returns one of the prefixes mapped to the namespace URI \a uri.
+
+ If more than one prefix is currently mapped to the same URI, this
+ function makes an arbitrary selection; if you want all of the
+ prefixes, use prefixes() instead.
+
+ Note: to check for a default prefix, use the uri() function with
+ an argument of "".
+*/
+QString QXmlNamespaceSupport::prefix(const QString& uri) const
+{
+ NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+ while ((itc=it) != d->ns.constEnd()) {
+ ++it;
+ if (*itc == uri && !itc.key().isEmpty())
+ return itc.key();
+ }
+ return QLatin1String("");
+}
+
+/*!
+ Looks up the prefix \a prefix in the current context and returns
+ the currently-mapped namespace URI. Use the empty string ("") for
+ the default namespace.
+*/
+QString QXmlNamespaceSupport::uri(const QString& prefix) const
+{
+ return d->ns[prefix];
+}
+
+/*!
+ Splits the name \a qname at the ':' and returns the prefix in \a
+ prefix and the local name in \a localname.
+
+ \sa processName()
+*/
+void QXmlNamespaceSupport::splitName(const QString& qname, QString& prefix,
+ QString& localname) const
+{
+ int pos = qname.indexOf(QLatin1Char(':'));
+ if (pos == -1)
+ pos = qname.size();
+
+ prefix = qname.left(pos);
+ localname = qname.mid(pos+1);
+}
+
+/*!
+ Processes a raw XML 1.0 name in the current context by removing
+ the prefix and looking it up among the prefixes currently
+ declared.
+
+ \a qname is the raw XML 1.0 name to be processed. \a isAttribute
+ is true if the name is an attribute name.
+
+ This function stores the namespace URI in \a nsuri (which will be
+ set to an empty string if the raw name has an undeclared prefix),
+ and stores the local name (without prefix) in \a localname (which
+ will be set to an empty string if no namespace is in use).
+
+ Note that attribute names are processed differently than element
+ names: an unprefixed element name gets the default namespace (if
+ any), while an unprefixed attribute name does not.
+*/
+void QXmlNamespaceSupport::processName(const QString& qname,
+ bool isAttribute,
+ QString& nsuri, QString& localname) const
+{
+ int len = qname.size();
+ const QChar *data = qname.constData();
+ for (int pos = 0; pos < len; ++pos) {
+ if (data[pos] == QLatin1Char(':')) {
+ nsuri = uri(qname.left(pos));
+ localname = qname.mid(pos + 1);
+ return;
+ }
+ }
+
+ // there was no ':'
+ nsuri.clear();
+ // attributes don't take default namespace
+ if (!isAttribute && !d->ns.isEmpty()) {
+ /*
+ We want to access d->ns.value(""), but as an optimization
+ we use the fact that "" compares less than any other
+ string, so it's either first in the map or not there.
+ */
+ NamespaceMap::const_iterator first = d->ns.constBegin();
+ if (first.key().isEmpty())
+ nsuri = first.value(); // get default namespace
+ }
+ localname = qname;
+}
+
+/*!
+ Returns a list of all the prefixes currently declared.
+
+ If there is a default prefix, this function does not return it in
+ the list; check for the default prefix using uri() with an
+ argument of "".
+*/
+QStringList QXmlNamespaceSupport::prefixes() const
+{
+ QStringList list;
+
+ NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+ while ((itc=it) != d->ns.constEnd()) {
+ ++it;
+ if (!itc.key().isEmpty())
+ list.append(itc.key());
+ }
+ return list;
+}
+
+/*!
+ \overload
+
+ Returns a list of all prefixes currently declared for the
+ namespace URI \a uri.
+
+ The "xml:" prefix is included. If you only want one prefix that is
+ mapped to the namespace URI, and you don't care which one you get,
+ use the prefix() function instead.
+
+ Note: The empty (default) prefix is never included in this list;
+ to check for the presence of a default namespace, call uri() with
+ "" as the argument.
+*/
+QStringList QXmlNamespaceSupport::prefixes(const QString& uri) const
+{
+ QStringList list;
+
+ NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+ while ((itc=it) != d->ns.constEnd()) {
+ ++it;
+ if (*itc == uri && !itc.key().isEmpty())
+ list.append(itc.key());
+ }
+ return list;
+}
+
+/*!
+ Starts a new namespace context.
+
+ Normally, you should push a new context at the beginning of each
+ XML element: the new context automatically inherits the
+ declarations of its parent context, and it also keeps track of
+ which declarations were made within this context.
+
+ \sa popContext()
+*/
+void QXmlNamespaceSupport::pushContext()
+{
+ d->nsStack.push(d->ns);
+}
+
+/*!
+ Reverts to the previous namespace context.
+
+ Normally, you should pop the context at the end of each XML
+ element. After popping the context, all namespace prefix mappings
+ that were previously in force are restored.
+
+ \sa pushContext()
+*/
+void QXmlNamespaceSupport::popContext()
+{
+ d->ns.clear();
+ if(!d->nsStack.isEmpty())
+ d->ns = d->nsStack.pop();
+}
+
+/*!
+ Resets this namespace support object ready for reuse.
+*/
+void QXmlNamespaceSupport::reset()
+{
+ delete d;
+ d = new QXmlNamespaceSupportPrivate;
+}
+
+
+
+/*********************************************
+ *
+ * QXmlAttributes
+ *
+ *********************************************/
+
+/*!
+ \class QXmlAttributes
+ \reentrant
+ \brief The QXmlAttributes class provides XML attributes.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ If attributes are reported by QXmlContentHandler::startElement()
+ this class is used to pass the attribute values.
+
+ Use index() to locate the position of an attribute in the list,
+ count() to retrieve the number of attributes, and clear() to
+ remove the attributes. New attributes can be added with append().
+ Use type() to get an attribute's type and value() to get its
+ value. The attribute's name is available from localName() or
+ qName(), and its namespace URI from uri().
+
+*/
+
+/*!
+ \fn QXmlAttributes::QXmlAttributes()
+
+ Constructs an empty attribute list.
+*/
+
+/*!
+ \fn QXmlAttributes::~QXmlAttributes()
+
+ Destroys the attributes object.
+*/
+
+/*!
+ Looks up the index of an attribute by the qualified name \a qName.
+
+ Returns the index of the attribute or -1 if it wasn't found.
+
+ \sa {Namespace Support via Features}
+*/
+int QXmlAttributes::index(const QString& qName) const
+{
+ for (int i = 0; i < attList.size(); ++i) {
+ if (attList.at(i).qname == qName)
+ return i;
+ }
+ return -1;
+}
+
+/*! \overload
+ */
+int QXmlAttributes::index(const QLatin1String& qName) const
+{
+ for (int i = 0; i < attList.size(); ++i) {
+ if (attList.at(i).qname == qName)
+ return i;
+ }
+ return -1;
+}
+
+/*!
+ \overload
+
+ Looks up the index of an attribute by a namespace name.
+
+ \a uri specifies the namespace URI, or an empty string if the name
+ has no namespace URI. \a localPart specifies the attribute's local
+ name.
+
+ Returns the index of the attribute, or -1 if it wasn't found.
+
+ \sa {Namespace Support via Features}
+*/
+int QXmlAttributes::index(const QString& uri, const QString& localPart) const
+{
+ for (int i = 0; i < attList.size(); ++i) {
+ const Attribute &att = attList.at(i);
+ if (att.uri == uri && att.localname == localPart)
+ return i;
+ }
+ return -1;
+}
+
+/*!
+ Returns the number of attributes in the list.
+
+ \sa count()
+*/
+int QXmlAttributes::length() const
+{
+ return attList.count();
+}
+
+/*!
+ \fn int QXmlAttributes::count() const
+
+ Returns the number of attributes in the list. This function is
+ equivalent to length().
+*/
+
+/*!
+ Looks up an attribute's local name for the attribute at position
+ \a index. If no namespace processing is done, the local name is
+ an empty string.
+
+ \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::localName(int index) const
+{
+ return attList.at(index).localname;
+}
+
+/*!
+ Looks up an attribute's XML 1.0 qualified name for the attribute
+ at position \a index.
+
+ \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::qName(int index) const
+{
+ return attList.at(index).qname;
+}
+
+/*!
+ Looks up an attribute's namespace URI for the attribute at
+ position \a index. If no namespace processing is done or if the
+ attribute has no namespace, the namespace URI is an empty string.
+
+ \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::uri(int index) const
+{
+ return attList.at(index).uri;
+}
+
+/*!
+ Looks up an attribute's type for the attribute at position \a
+ index.
+
+ Currently only "CDATA" is returned.
+*/
+QString QXmlAttributes::type(int) const
+{
+ return QLatin1String("CDATA");
+}
+
+/*!
+ \overload
+
+ Looks up an attribute's type for the qualified name \a qName.
+
+ Currently only "CDATA" is returned.
+*/
+QString QXmlAttributes::type(const QString&) const
+{
+ return QLatin1String("CDATA");
+}
+
+/*!
+ \overload
+
+ Looks up an attribute's type by namespace name.
+
+ \a uri specifies the namespace URI and \a localName specifies the
+ local name. If the name has no namespace URI, use an empty string
+ for \a uri.
+
+ Currently only "CDATA" is returned.
+*/
+QString QXmlAttributes::type(const QString&, const QString&) const
+{
+ return QLatin1String("CDATA");
+}
+
+/*!
+ Returns an attribute's value for the attribute at position \a
+ index. The index must be a valid position
+ (i.e., 0 <= \a index < count()).
+*/
+QString QXmlAttributes::value(int index) const
+{
+ return attList.at(index).value;
+}
+
+/*!
+ \overload
+
+ Returns an attribute's value for the qualified name \a qName, or an
+ empty string if no attribute exists for the name given.
+
+ \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::value(const QString& qName) const
+{
+ int i = index(qName);
+ if (i == -1)
+ return QString();
+ return attList.at(i).value;
+}
+
+/*!
+ \overload
+
+ Returns an attribute's value for the qualified name \a qName, or an
+ empty string if no attribute exists for the name given.
+
+ \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::value(const QLatin1String& qName) const
+{
+ int i = index(qName);
+ if (i == -1)
+ return QString();
+ return attList.at(i).value;
+}
+
+/*!
+ \overload
+
+ Returns an attribute's value by namespace name.
+
+ \a uri specifies the namespace URI, or an empty string if the name
+ has no namespace URI. \a localName specifies the attribute's local
+ name.
+*/
+QString QXmlAttributes::value(const QString& uri, const QString& localName) const
+{
+ int i = index(uri, localName);
+ if (i == -1)
+ return QString();
+ return attList.at(i).value;
+}
+
+/*!
+ Clears the list of attributes.
+
+ \sa append()
+*/
+void QXmlAttributes::clear()
+{
+ attList.clear();
+}
+
+/*!
+ Appends a new attribute entry to the list of attributes. The
+ qualified name of the attribute is \a qName, the namespace URI is
+ \a uri and the local name is \a localPart. The value of the
+ attribute is \a value.
+
+ \sa qName() uri() localName() value()
+*/
+void QXmlAttributes::append(const QString &qName, const QString &uri, const QString &localPart, const QString &value)
+{
+ Attribute att;
+ att.qname = qName;
+ att.uri = uri;
+ att.localname = localPart;
+ att.value = value;
+
+ attList.append(att);
+}
+
+
+/*********************************************
+ *
+ * QXmlInputSource
+ *
+ *********************************************/
+
+/*!
+ \class QXmlInputSource
+ \reentrant
+ \brief The QXmlInputSource class provides the input data for the
+ QXmlReader subclasses.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ All subclasses of QXmlReader read the input XML document from this
+ class.
+
+ This class recognizes the encoding of the data by reading the
+ encoding declaration in the XML file if it finds one, and reading
+ the data using the corresponding encoding. If it does not find an
+ encoding declaration, then it assumes that the data is either in
+ UTF-8 or UTF-16, depending on whether it can find a byte-order
+ mark.
+
+ There are two ways to populate the input source with data: you can
+ construct it with a QIODevice* so that the input source reads the
+ data from that device. Or you can set the data explicitly with one
+ of the setData() functions.
+
+ Usually you either construct a QXmlInputSource that works on a
+ QIODevice* or you construct an empty QXmlInputSource and set the
+ data with setData(). There are only rare occasions where you would
+ want to mix both methods.
+
+ The QXmlReader subclasses use the next() function to read the
+ input character by character. If you want to start from the
+ beginning again, use reset().
+
+ The functions data() and fetchData() are useful if you want to do
+ something with the data other than parsing, e.g. displaying the
+ raw XML file. The benefit of using the QXmlInputClass in such
+ cases is that it tries to use the correct encoding.
+
+ \sa QXmlReader QXmlSimpleReader
+*/
+
+// the following two are guaranteed not to be a character
+const ushort QXmlInputSource::EndOfData = 0xfffe;
+const ushort QXmlInputSource::EndOfDocument = 0xffff;
+
+/*
+ Common part of the constructors.
+*/
+void QXmlInputSource::init()
+{
+ d = new QXmlInputSourcePrivate;
+
+ d->inputDevice = 0;
+ d->inputStream = 0;
+
+ setData(QString());
+#ifndef QT_NO_TEXTCODEC
+ d->encMapper = 0;
+#endif
+ d->nextReturnedEndOfData = true; // first call to next() will call fetchData()
+
+ d->encodingDeclBytes.clear();
+ d->encodingDeclChars.clear();
+ d->lookingForEncodingDecl = true;
+}
+
+/*!
+ Constructs an input source which contains no data.
+
+ \sa setData()
+*/
+QXmlInputSource::QXmlInputSource()
+{
+ init();
+}
+
+/*!
+ Constructs an input source and gets the data from device \a dev.
+ If \a dev is not open, it is opened in read-only mode. If \a dev
+ is 0 or it is not possible to read from the device, the input
+ source will contain no data.
+
+ \sa setData() fetchData() QIODevice
+*/
+QXmlInputSource::QXmlInputSource(QIODevice *dev)
+{
+ init();
+ d->inputDevice = dev;
+ d->inputDevice->setTextModeEnabled(false);
+}
+
+#ifdef QT3_SUPPORT
+/*!
+ Use the QXmlInputSource(QIODevice *) constructor instead, with
+ the device used by \a stream.
+
+ \sa QTextStream::device()
+*/
+QXmlInputSource::QXmlInputSource(QTextStream& stream)
+{
+ init();
+ d->inputStream = &stream;
+}
+
+/*!
+ Use QXmlInputSource(&\a file) instead.
+*/
+QXmlInputSource::QXmlInputSource(QFile& file)
+{
+ init();
+ d->inputDevice = &file;
+}
+#endif
+
+/*!
+ Destructor.
+*/
+QXmlInputSource::~QXmlInputSource()
+{
+ // ### Qt 5: close the input device. See task 153111
+#ifndef QT_NO_TEXTCODEC
+ delete d->encMapper;
+#endif
+ delete d;
+}
+
+/*!
+Returns the next character of the input source. If this function
+reaches the end of available data, it returns
+QXmlInputSource::EndOfData. If you call next() after that, it
+tries to fetch more data by calling fetchData(). If the
+fetchData() call results in new data, this function returns the
+first character of that data; otherwise it returns
+QXmlInputSource::EndOfDocument.
+
+Readers, such as QXmlSimpleReader, will assume that the end of
+the XML document has been reached if the this function returns
+QXmlInputSource::EndOfDocument, and will check that the
+supplied input is well-formed. Therefore, when reimplementing
+this function, it is important to ensure that this behavior is
+duplicated.
+
+\sa reset() fetchData() QXmlSimpleReader::parse() QXmlSimpleReader::parseContinue()
+*/
+QChar QXmlInputSource::next()
+{
+ if (d->pos >= d->length) {
+ if (d->nextReturnedEndOfData) {
+ d->nextReturnedEndOfData = false;
+ fetchData();
+ if (d->pos >= d->length) {
+ return EndOfDocument;
+ }
+ return next();
+ }
+ d->nextReturnedEndOfData = true;
+ return EndOfData;
+ }
+
+ // QXmlInputSource has no way to signal encoding errors. The best we can do
+ // is return EndOfDocument. We do *not* return EndOfData, because the reader
+ // will then just call this function again to get the next char.
+ QChar c = d->unicode[d->pos++];
+ if (c.unicode() == EndOfData)
+ c = EndOfDocument;
+ return c;
+}
+
+/*!
+ This function sets the position used by next() to the beginning of
+ the data returned by data(). This is useful if you want to use the
+ input source for more than one parse.
+
+ \note In the case that the underlying data source is a QIODevice,
+ the current position in the device is not automatically set to the
+ start of input. Call QIODevice::seek(0) on the device to do this.
+
+ \sa next()
+*/
+void QXmlInputSource::reset()
+{
+ d->nextReturnedEndOfData = false;
+ d->pos = 0;
+}
+
+/*!
+ Returns the data the input source contains or an empty string if the
+ input source does not contain any data.
+
+ \sa setData() QXmlInputSource() fetchData()
+*/
+QString QXmlInputSource::data() const
+{
+ if (d->nextReturnedEndOfData) {
+ QXmlInputSource *that = const_cast<QXmlInputSource*>(this);
+ that->d->nextReturnedEndOfData = false;
+ that->fetchData();
+ }
+ return d->str;
+}
+
+/*!
+ Sets the data of the input source to \a dat.
+
+ If the input source already contains data, this function deletes
+ that data first.
+
+ \sa data()
+*/
+void QXmlInputSource::setData(const QString& dat)
+{
+ d->str = dat;
+ d->unicode = dat.unicode();
+ d->pos = 0;
+ d->length = d->str.length();
+ d->nextReturnedEndOfData = false;
+}
+
+/*!
+ \overload
+
+ The data \a dat is passed through the correct text-codec, before
+ it is set.
+*/
+void QXmlInputSource::setData(const QByteArray& dat)
+{
+ setData(fromRawData(dat));
+}
+
+/*!
+ This function reads more data from the device that was set during
+ construction. If the input source already contained data, this
+ function deletes that data first.
+
+ This object contains no data after a call to this function if the
+ object was constructed without a device to read data from or if
+ this function was not able to get more data from the device.
+
+ There are two occasions where a fetch is done implicitly by
+ another function call: during construction (so that the object
+ starts out with some initial data where available), and during a
+ call to next() (if the data had run out).
+
+ You don't normally need to use this function if you use next().
+
+ \sa data() next() QXmlInputSource()
+*/
+
+void QXmlInputSource::fetchData()
+{
+ enum
+ {
+ BufferSize = 1024
+ };
+
+ QByteArray rawData;
+
+ if (d->inputDevice || d->inputStream) {
+ QIODevice *device = d->inputDevice ? d->inputDevice : d->inputStream->device();
+
+ if (!device) {
+ if (d->inputStream && d->inputStream->string()) {
+ QString *s = d->inputStream->string();
+ rawData = QByteArray((const char *) s->constData(), s->size() * sizeof(QChar));
+ }
+ } else if (device->isOpen() || device->open(QIODevice::ReadOnly)) {
+ rawData.resize(BufferSize);
+ qint64 size = device->read(rawData.data(), BufferSize);
+
+ if (size != -1) {
+ // We don't want to give fromRawData() less than four bytes if we can avoid it.
+ while (size < 4) {
+ if (!device->waitForReadyRead(-1))
+ break;
+ int ret = device->read(rawData.data() + size, BufferSize - size);
+ if (ret <= 0)
+ break;
+ size += ret;
+ }
+ }
+
+ rawData.resize(qMax(qint64(0), size));
+ }
+
+ /* We do this inside the "if (d->inputDevice ..." scope
+ * because if we're not using a stream or device, that is,
+ * the user set a QString manually, we don't want to set
+ * d->str. */
+ setData(fromRawData(rawData));
+ }
+}
+
+#ifndef QT_NO_TEXTCODEC
+static QString extractEncodingDecl(const QString &text, bool *needMoreText)
+{
+ *needMoreText = false;
+
+ int l = text.length();
+ QString snip = QString::fromLatin1("<?xml").left(l);
+ if (l > 0 && !text.startsWith(snip))
+ return QString();
+
+ int endPos = text.indexOf(QLatin1Char('>'));
+ if (endPos == -1) {
+ *needMoreText = l < 255; // we won't look forever
+ return QString();
+ }
+
+ int pos = text.indexOf(QLatin1String("encoding"));
+ if (pos == -1 || pos >= endPos)
+ return QString();
+
+ while (pos < endPos) {
+ ushort uc = text.at(pos).unicode();
+ if (uc == '\'' || uc == '"')
+ break;
+ ++pos;
+ }
+
+ if (pos == endPos)
+ return QString();
+
+ QString encoding;
+ ++pos;
+ while (pos < endPos) {
+ ushort uc = text.at(pos).unicode();
+ if (uc == '\'' || uc == '"')
+ break;
+ encoding.append(uc);
+ ++pos;
+ }
+
+ return encoding;
+}
+#endif // QT_NO_TEXTCODEC
+
+/*!
+ This function reads the XML file from \a data and tries to
+ recognize the encoding. It converts the raw data \a data into a
+ QString and returns it. It tries its best to get the correct
+ encoding for the XML file.
+
+ If \a beginning is true, this function assumes that the data
+ starts at the beginning of a new XML document and looks for an
+ encoding declaration. If \a beginning is false, it converts the
+ raw data using the encoding determined from prior calls.
+*/
+QString QXmlInputSource::fromRawData(const QByteArray &data, bool beginning)
+{
+#ifdef QT_NO_TEXTCODEC
+ Q_UNUSED(beginning);
+ return QString::fromAscii(data.constData(), data.size());
+#else
+ if (data.size() == 0)
+ return QString();
+ if (beginning) {
+ delete d->encMapper;
+ d->encMapper = 0;
+ }
+
+ int mib = 106; // UTF-8
+
+ // This is the initial UTF codec we will read the encoding declaration with
+ if (d->encMapper == 0) {
+ d->encodingDeclBytes.clear();
+ d->encodingDeclChars.clear();
+ d->lookingForEncodingDecl = true;
+
+ // look for byte order mark and read the first 5 characters
+ if (data.size() >= 4) {
+ uchar ch1 = data.at(0);
+ uchar ch2 = data.at(1);
+ uchar ch3 = data.at(2);
+ uchar ch4 = data.at(3);
+
+ if ((ch1 == 0 && ch2 == 0 && ch3 == 0xfe && ch4 == 0xff) ||
+ (ch1 == 0xff && ch2 == 0xfe && ch3 == 0 && ch4 == 0))
+ mib = 1017; // UTF-32 with byte order mark
+ else if (ch1 == 0x3c && ch2 == 0x00 && ch3 == 0x00 && ch4 == 0x00)
+ mib = 1019; // UTF-32LE
+ else if (ch1 == 0x00 && ch2 == 0x00 && ch3 == 0x00 && ch4 == 0x3c)
+ mib = 1018; // UTF-32BE
+ }
+ if (mib == 106 && data.size() >= 2) {
+ uchar ch1 = data.at(0);
+ uchar ch2 = data.at(1);
+
+ if ((ch1 == 0xfe && ch2 == 0xff) || (ch1 == 0xff && ch2 == 0xfe))
+ mib = 1015; // UTF-16 with byte order mark
+ else if (ch1 == 0x3c && ch2 == 0x00)
+ mib = 1014; // UTF-16LE
+ else if (ch1 == 0x00 && ch2 == 0x3c)
+ mib = 1013; // UTF-16BE
+ }
+
+ QTextCodec *codec = QTextCodec::codecForMib(mib);
+ Q_ASSERT(codec);
+
+ d->encMapper = codec->makeDecoder();
+ }
+
+ QString input = d->encMapper->toUnicode(data, data.size());
+
+ if (d->lookingForEncodingDecl) {
+ d->encodingDeclChars += input;
+
+ bool needMoreText;
+ QString encoding = extractEncodingDecl(d->encodingDeclChars, &needMoreText);
+
+ if (!encoding.isEmpty()) {
+ if (QTextCodec *codec = QTextCodec::codecForName(encoding.toLatin1())) {
+ /* If the encoding is the same, we don't have to do toUnicode() all over again. */
+ if(codec->mibEnum() != mib) {
+ delete d->encMapper;
+ d->encMapper = codec->makeDecoder();
+
+ /* The variable input can potentially be large, so we deallocate
+ * it before calling toUnicode() in order to avoid having two
+ * large QStrings in memory simultaneously. */
+ input.clear();
+
+ // prime the decoder with the data so far
+ d->encMapper->toUnicode(d->encodingDeclBytes, d->encodingDeclBytes.size());
+ // now feed it the new data
+ input = d->encMapper->toUnicode(data, data.size());
+ }
+ }
+ }
+
+ d->encodingDeclBytes += data;
+ d->lookingForEncodingDecl = needMoreText;
+ }
+
+ return input;
+#endif
+}
+
+
+/*********************************************
+ *
+ * QXmlDefaultHandler
+ *
+ *********************************************/
+
+/*!
+ \class QXmlContentHandler
+ \reentrant
+ \brief The QXmlContentHandler class provides an interface to
+ report the logical content of XML data.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ If the application needs to be informed of basic parsing events,
+ it can implement this interface and activate it using
+ QXmlReader::setContentHandler(). The reader can then report basic
+ document-related events like the start and end of elements and
+ character data through this interface.
+
+ The order of events in this interface is very important, and
+ mirrors the order of information in the document itself. For
+ example, all of an element's content (character data, processing
+ instructions, and sub-elements) appears, in order, between the
+ startElement() event and the corresponding endElement() event.
+
+ The class QXmlDefaultHandler provides a default implementation for
+ this interface; subclassing from the QXmlDefaultHandler class is
+ very convenient if you only want to be informed of some parsing
+ events.
+
+ The startDocument() function is called at the start of the
+ document, and endDocument() is called at the end. Before parsing
+ begins setDocumentLocator() is called. For each element
+ startElement() is called, with endElement() being called at the
+ end of each element. The characters() function is called with
+ chunks of character data; ignorableWhitespace() is called with
+ chunks of whitespace and processingInstruction() is called with
+ processing instructions. If an entity is skipped skippedEntity()
+ is called. At the beginning of prefix-URI scopes
+ startPrefixMapping() is called.
+
+ \sa QXmlDTDHandler, QXmlDeclHandler, QXmlEntityResolver, QXmlErrorHandler,
+ QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+ \fn QXmlContentHandler::~QXmlContentHandler()
+
+ Destroys the content handler.
+*/
+
+/*!
+ \fn void QXmlContentHandler::setDocumentLocator(QXmlLocator* locator)
+
+ The reader calls this function before it starts parsing the
+ document. The argument \a locator is a pointer to a QXmlLocator
+ which allows the application to get the parsing position within
+ the document.
+
+ Do not destroy the \a locator; it is destroyed when the reader is
+ destroyed. (Do not use the \a locator after the reader is
+ destroyed).
+*/
+
+/*!
+ \fn bool QXmlContentHandler::startDocument()
+
+ The reader calls this function when it starts parsing the
+ document. The reader calls this function just once, after the call
+ to setDocumentLocator(), and before any other functions in this
+ class or in the QXmlDTDHandler class are called.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa endDocument()
+*/
+
+/*!
+ \fn bool QXmlContentHandler::endDocument()
+
+ The reader calls this function after it has finished parsing. It
+ is called just once, and is the last handler function called. It
+ is called after the reader has read all input or has abandoned
+ parsing because of a fatal error.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa startDocument()
+*/
+
+/*!
+ \fn bool QXmlContentHandler::startPrefixMapping(const QString& prefix, const QString& uri)
+
+ The reader calls this function to signal the begin of a prefix-URI
+ namespace mapping scope. This information is not necessary for
+ normal namespace processing since the reader automatically
+ replaces prefixes for element and attribute names.
+
+ Note that startPrefixMapping() and endPrefixMapping() calls are
+ not guaranteed to be properly nested relative to each other: all
+ startPrefixMapping() events occur before the corresponding
+ startElement() event, and all endPrefixMapping() events occur
+ after the corresponding endElement() event, but their order is not
+ otherwise guaranteed.
+
+ The argument \a prefix is the namespace prefix being declared and
+ the argument \a uri is the namespace URI the prefix is mapped to.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa endPrefixMapping(), {Namespace Support via Features}
+*/
+
+/*!
+ \fn bool QXmlContentHandler::endPrefixMapping(const QString& prefix)
+
+ The reader calls this function to signal the end of a prefix
+ mapping for the prefix \a prefix.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa startPrefixMapping(), {Namespace Support via Features}
+*/
+
+/*!
+ \fn bool QXmlContentHandler::startElement(const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts)
+
+ The reader calls this function when it has parsed a start element
+ tag.
+
+ There is a corresponding endElement() call when the corresponding
+ end element tag is read. The startElement() and endElement() calls
+ are always nested correctly. Empty element tags (e.g. \c{<x/>})
+ cause a startElement() call to be immediately followed by an
+ endElement() call.
+
+ The attribute list provided only contains attributes with explicit
+ values. The attribute list contains attributes used for namespace
+ declaration (i.e. attributes starting with xmlns) only if the
+ namespace-prefix property of the reader is true.
+
+ The argument \a namespaceURI is the namespace URI, or
+ an empty string if the element has no namespace URI or if no
+ namespace processing is done. \a localName is the local name
+ (without prefix), or an empty string if no namespace processing is
+ done, \a qName is the qualified name (with prefix) and \a atts are
+ the attributes attached to the element. If there are no
+ attributes, \a atts is an empty attributes object.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa endElement(), {Namespace Support via Features}
+*/
+
+/*!
+ \fn bool QXmlContentHandler::endElement(const QString& namespaceURI, const QString& localName, const QString& qName)
+
+ The reader calls this function when it has parsed an end element
+ tag with the qualified name \a qName, the local name \a localName
+ and the namespace URI \a namespaceURI.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa startElement(), {Namespace Support via Features}
+*/
+
+/*!
+ \fn bool QXmlContentHandler::characters(const QString& ch)
+
+ The reader calls this function when it has parsed a chunk of
+ character data (either normal character data or character data
+ inside a CDATA section; if you need to distinguish between those
+ two types you must use QXmlLexicalHandler::startCDATA() and
+ QXmlLexicalHandler::endCDATA()). The character data is reported in
+ \a ch.
+
+ Some readers report whitespace in element content using the
+ ignorableWhitespace() function rather than using this one.
+
+ A reader may report the character data of an element in more than
+ one chunk; e.g. a reader might want to report "a\<b" in three
+ characters() events ("a ", "\<" and " b").
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn bool QXmlContentHandler::ignorableWhitespace(const QString& ch)
+
+ Some readers may use this function to report each chunk of
+ whitespace in element content. The whitespace is reported in \a ch.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn bool QXmlContentHandler::processingInstruction(const QString& target, const QString& data)
+
+ The reader calls this function when it has parsed a processing
+ instruction.
+
+ \a target is the target name of the processing instruction and \a
+ data is the data in the processing instruction.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn bool QXmlContentHandler::skippedEntity(const QString& name)
+
+ Some readers may skip entities if they have not seen the
+ declarations (e.g. because they are in an external DTD). If they
+ do so they report that they skipped the entity called \a name by
+ calling this function.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn QString QXmlContentHandler::errorString() const
+
+ The reader calls this function to get an error string, e.g. if any
+ of the handler functions returns false.
+*/
+
+
+/*!
+ \class QXmlErrorHandler
+ \reentrant
+ \brief The QXmlErrorHandler class provides an interface to report
+ errors in XML data.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ If you want your application to report errors to the user or to
+ perform customized error handling, you should subclass this class.
+
+ You can set the error handler with QXmlReader::setErrorHandler().
+
+ Errors can be reported using warning(), error() and fatalError(),
+ with the error text being reported with errorString().
+
+ \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver,
+ QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+ \fn QXmlErrorHandler::~QXmlErrorHandler()
+
+ Destroys the error handler.
+*/
+
+/*!
+ \fn bool QXmlErrorHandler::warning(const QXmlParseException& exception)
+
+ A reader might use this function to report a warning. Warnings are
+ conditions that are not errors or fatal errors as defined by the
+ XML 1.0 specification. Details of the warning are stored in \a
+ exception.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn bool QXmlErrorHandler::error(const QXmlParseException& exception)
+
+ A reader might use this function to report a recoverable error. A
+ recoverable error corresponds to the definiton of "error" in
+ section 1.2 of the XML 1.0 specification. Details of the error are
+ stored in \a exception.
+
+ The reader must continue to provide normal parsing events after
+ invoking this function.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+\fn bool QXmlErrorHandler::fatalError(const QXmlParseException& exception)
+
+A reader must use this function to report a non-recoverable error.
+Details of the error are stored in \a exception.
+
+If this function returns true the reader might try to go on
+parsing and reporting further errors, but no regular parsing
+events are reported.
+*/
+
+/*!
+ \fn QString QXmlErrorHandler::errorString() const
+
+ The reader calls this function to get an error string if any of
+ the handler functions returns false.
+*/
+
+
+/*!
+ \class QXmlDTDHandler
+ \reentrant
+ \brief The QXmlDTDHandler class provides an interface to report
+ DTD content of XML data.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ If an application needs information about notations and unparsed
+ entities, it can implement this interface and register an instance
+ with QXmlReader::setDTDHandler().
+
+ Note that this interface includes only those DTD events that the
+ XML recommendation requires processors to report, i.e. notation
+ and unparsed entity declarations using notationDecl() and
+ unparsedEntityDecl() respectively.
+
+ \sa QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver, QXmlErrorHandler,
+ QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+ \fn QXmlDTDHandler::~QXmlDTDHandler()
+
+ Destroys the DTD handler.
+*/
+
+/*!
+ \fn bool QXmlDTDHandler::notationDecl(const QString& name, const QString& publicId, const QString& systemId)
+
+ The reader calls this function when it has parsed a notation
+ declaration.
+
+ The argument \a name is the notation name, \a publicId is the
+ notation's public identifier and \a systemId is the notation's
+ system identifier.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn bool QXmlDTDHandler::unparsedEntityDecl(const QString& name, const QString& publicId, const QString& systemId, const QString& notationName)
+
+ The reader calls this function when it finds an unparsed entity
+ declaration.
+
+ The argument \a name is the unparsed entity's name, \a publicId is
+ the entity's public identifier, \a systemId is the entity's system
+ identifier and \a notationName is the name of the associated
+ notation.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn QString QXmlDTDHandler::errorString() const
+
+ The reader calls this function to get an error string if any of
+ the handler functions returns false.
+*/
+
+
+/*!
+ \class QXmlEntityResolver
+ \reentrant
+ \brief The QXmlEntityResolver class provides an interface to
+ resolve external entities contained in XML data.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ If an application needs to implement customized handling for
+ external entities, it must implement this interface, i.e.
+ resolveEntity(), and register it with
+ QXmlReader::setEntityResolver().
+
+ \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlErrorHandler,
+ QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+ \fn QXmlEntityResolver::~QXmlEntityResolver()
+
+ Destroys the entity resolver.
+*/
+
+/*!
+ \fn bool QXmlEntityResolver::resolveEntity(const QString& publicId, const QString& systemId, QXmlInputSource*& ret)
+
+ The reader calls this function before it opens any external
+ entity, except the top-level document entity. The application may
+ request the reader to resolve the entity itself (\a ret is 0) or
+ to use an entirely different input source (\a ret points to the
+ input source).
+
+ The reader deletes the input source \a ret when it no longer needs
+ it, so you should allocate it on the heap with \c new.
+
+ The argument \a publicId is the public identifier of the external
+ entity, \a systemId is the system identifier of the external
+ entity and \a ret is the return value of this function. If \a ret
+ is 0 the reader should resolve the entity itself, if it is
+ non-zero it must point to an input source which the reader uses
+ instead.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn QString QXmlEntityResolver::errorString() const
+
+ The reader calls this function to get an error string if any of
+ the handler functions returns false.
+*/
+
+
+/*!
+ \class QXmlLexicalHandler
+ \reentrant
+ \brief The QXmlLexicalHandler class provides an interface to
+ report the lexical content of XML data.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ The events in the lexical handler apply to the entire document,
+ not just to the document element, and all lexical handler events
+ appear between the content handler's startDocument and endDocument
+ events.
+
+ You can set the lexical handler with
+ QXmlReader::setLexicalHandler().
+
+ This interface's design is based on the the SAX2 extension
+ LexicalHandler.
+
+ The interface provides the startDTD(), endDTD(), startEntity(),
+ endEntity(), startCDATA(), endCDATA() and comment() functions.
+
+ \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver,
+ QXmlErrorHandler, {Introduction to SAX2}
+*/
+
+/*!
+ \fn QXmlLexicalHandler::~QXmlLexicalHandler()
+
+ Destroys the lexical handler.
+*/
+
+/*!
+ \fn bool QXmlLexicalHandler::startDTD(const QString& name, const QString& publicId, const QString& systemId)
+
+ The reader calls this function to report the start of a DTD
+ declaration, if any. It reports the name of the document type in
+ \a name, the public identifier in \a publicId and the system
+ identifier in \a systemId.
+
+ If the public identifier is missing, \a publicId is set to
+ an empty string. If the system identifier is missing, \a systemId is
+ set to an empty string. Note that it is not valid XML to have a
+ public identifier but no system identifier; in such cases a parse
+ error will occur.
+
+ All declarations reported through QXmlDTDHandler or
+ QXmlDeclHandler appear between the startDTD() and endDTD() calls.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa endDTD()
+*/
+
+/*!
+ \fn bool QXmlLexicalHandler::endDTD()
+
+ The reader calls this function to report the end of a DTD
+ declaration, if any.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa startDTD()
+*/
+
+/*!
+ \fn bool QXmlLexicalHandler::startEntity(const QString& name)
+
+ The reader calls this function to report the start of an entity
+ called \a name.
+
+ Note that if the entity is unknown, the reader reports it through
+ QXmlContentHandler::skippedEntity() and not through this
+ function.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa endEntity(), QXmlSimpleReader::setFeature()
+*/
+
+/*!
+ \fn bool QXmlLexicalHandler::endEntity(const QString& name)
+
+ The reader calls this function to report the end of an entity
+ called \a name.
+
+ For every startEntity() call, there is a corresponding endEntity()
+ call. The calls to startEntity() and endEntity() are properly
+ nested.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa startEntity(), QXmlContentHandler::skippedEntity(), QXmlSimpleReader::setFeature()
+*/
+
+/*!
+ \fn bool QXmlLexicalHandler::startCDATA()
+
+ The reader calls this function to report the start of a CDATA
+ section. The content of the CDATA section is reported through the
+ QXmlContentHandler::characters() function. This function is
+ intended only to report the boundary.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+
+ \sa endCDATA()
+*/
+
+/*!
+ \fn bool QXmlLexicalHandler::endCDATA()
+
+ The reader calls this function to report the end of a CDATA
+ section.
+
+ If this function returns false the reader stops parsing and reports
+ an error. The reader uses the function errorString() to get the error
+ message.
+
+ \sa startCDATA(), QXmlContentHandler::characters()
+*/
+
+/*!
+ \fn bool QXmlLexicalHandler::comment(const QString& ch)
+
+ The reader calls this function to report an XML comment anywhere
+ in the document. It reports the text of the comment in \a ch.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn QString QXmlLexicalHandler::errorString() const
+
+ The reader calls this function to get an error string if any of
+ the handler functions returns false.
+*/
+
+
+/*!
+ \class QXmlDeclHandler
+ \reentrant
+ \brief The QXmlDeclHandler class provides an interface to report declaration
+ content of XML data.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ You can set the declaration handler with
+ QXmlReader::setDeclHandler().
+
+ This interface is based on the SAX2 extension DeclHandler.
+
+ The interface provides attributeDecl(), internalEntityDecl() and
+ externalEntityDecl() functions.
+
+ \sa QXmlDTDHandler, QXmlContentHandler, QXmlEntityResolver, QXmlErrorHandler,
+ QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+ \fn QXmlDeclHandler::~QXmlDeclHandler()
+
+ Destroys the declaration handler.
+*/
+
+/*!
+ \fn bool QXmlDeclHandler::attributeDecl(const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value)
+
+ The reader calls this function to report an attribute type
+ declaration. Only the effective (first) declaration for an
+ attribute is reported.
+
+ The reader passes the name of the associated element in \a eName
+ and the name of the attribute in \a aName. It passes a string that
+ represents the attribute type in \a type and a string that
+ represents the attribute default in \a valueDefault. This string
+ is one of "#IMPLIED", "#REQUIRED", "#FIXED" or an empty string (if
+ none of the others applies). The reader passes the attribute's
+ default value in \a value. If no default value is specified in the
+ XML file, \a value is an empty string.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn bool QXmlDeclHandler::internalEntityDecl(const QString& name, const QString& value)
+
+ The reader calls this function to report an internal entity
+ declaration. Only the effective (first) declaration is reported.
+
+ The reader passes the name of the entity in \a name and the value
+ of the entity in \a value.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn bool QXmlDeclHandler::externalEntityDecl(const QString& name, const QString& publicId, const QString& systemId)
+
+ The reader calls this function to report a parsed external entity
+ declaration. Only the effective (first) declaration for each
+ entity is reported.
+
+ The reader passes the name of the entity in \a name, the public
+ identifier in \a publicId and the system identifier in \a
+ systemId. If there is no public identifier specified, it passes
+ an empty string in \a publicId.
+
+ If this function returns false the reader stops parsing and
+ reports an error. The reader uses the function errorString() to
+ get the error message.
+*/
+
+/*!
+ \fn QString QXmlDeclHandler::errorString() const
+
+ The reader calls this function to get an error string if any of
+ the handler functions returns false.
+*/
+
+
+/*!
+ \class QXmlDefaultHandler
+ \reentrant
+ \brief The QXmlDefaultHandler class provides a default implementation of all
+ the XML handler classes.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ This class gathers together the features of
+ the specialized handler classes, making it a convenient
+ starting point when implementing custom handlers for
+ subclasses of QXmlReader, particularly QXmlSimpleReader.
+ The virtual functions from each of the base classes are
+ reimplemented in this class, providing sensible default behavior
+ for many common cases. By subclassing this class, and
+ overriding these functions, you can concentrate
+ on implementing the parts of the handler relevant to your
+ application.
+
+ The XML reader must be told which handler to use for different
+ kinds of events during parsing. This means that, although
+ QXmlDefaultHandler provides default implementations of functions
+ inherited from all its base classes, we can still use specialized
+ handlers for particular kinds of events.
+
+ For example, QXmlDefaultHandler subclasses both
+ QXmlContentHandler and QXmlErrorHandler, so by subclassing
+ it we can use the same handler for both of the following
+ reader functions:
+
+ \snippet doc/src/snippets/xml/rsslisting/rsslisting.cpp 0
+
+ Since the reader will inform the handler of parsing errors, it is
+ necessary to reimplement QXmlErrorHandler::fatalError() if, for
+ example, we want to stop parsing when such an error occurs:
+
+ \snippet doc/src/snippets/xml/rsslisting/handler.cpp 0
+
+ The above function returns false, which tells the reader to stop
+ parsing. To continue to use the same reader,
+ it is necessary to create a new handler instance, and set up the
+ reader to use it in the manner described above.
+
+ It is useful to examine some of the functions inherited by
+ QXmlDefaultHandler, and consider why they might be
+ reimplemented in a custom handler.
+ Custom handlers will typically reimplement
+ QXmlContentHandler::startDocument() to prepare the handler for
+ new content. Document elements and the text within them can be
+ processed by reimplementing QXmlContentHandler::startElement(),
+ QXmlContentHandler::endElement(), and
+ QXmlContentHandler::characters().
+ You may want to reimplement QXmlContentHandler::endDocument()
+ to perform some finalization or validation on the content once the
+ document has been read completely.
+
+ \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver,
+ QXmlErrorHandler, QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+ \fn QXmlDefaultHandler::QXmlDefaultHandler()
+
+ Constructs a handler for use with subclasses of QXmlReader.
+*/
+/*!
+ \fn QXmlDefaultHandler::~QXmlDefaultHandler()
+
+ Destroys the handler.
+*/
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+void QXmlDefaultHandler::setDocumentLocator(QXmlLocator*)
+{
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::startDocument()
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::endDocument()
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::startPrefixMapping(const QString&, const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::endPrefixMapping(const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::startElement(const QString&, const QString&,
+ const QString&, const QXmlAttributes&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::endElement(const QString&, const QString&,
+ const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::characters(const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::ignorableWhitespace(const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::processingInstruction(const QString&,
+ const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::skippedEntity(const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::warning(const QXmlParseException&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::error(const QXmlParseException&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::fatalError(const QXmlParseException&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::notationDecl(const QString&, const QString&,
+ const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::unparsedEntityDecl(const QString&, const QString&,
+ const QString&, const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Sets \a ret to 0, so that the reader uses the system identifier
+ provided in the XML document.
+*/
+bool QXmlDefaultHandler::resolveEntity(const QString&, const QString&,
+ QXmlInputSource*& ret)
+{
+ ret = 0;
+ return true;
+}
+
+/*!
+ \reimp
+
+ Returns the default error string.
+*/
+QString QXmlDefaultHandler::errorString() const
+{
+ return QString::fromLatin1(XMLERR_ERRORBYCONSUMER);
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::startDTD(const QString&, const QString&, const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::endDTD()
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::startEntity(const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::endEntity(const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::startCDATA()
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::endCDATA()
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::comment(const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::attributeDecl(const QString&, const QString&, const QString&, const QString&, const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::internalEntityDecl(const QString&, const QString&)
+{
+ return true;
+}
+
+/*!
+ \reimp
+
+ Does nothing.
+*/
+bool QXmlDefaultHandler::externalEntityDecl(const QString&, const QString&, const QString&)
+{
+ return true;
+}
+
+
+/*********************************************
+ *
+ * QXmlSimpleReaderPrivate
+ *
+ *********************************************/
+
+inline bool QXmlSimpleReaderPrivate::atEnd()
+{
+ return (c.unicode()|0x0001) == 0xffff;
+}
+
+inline void QXmlSimpleReaderPrivate::stringClear()
+{
+ stringValueLen = 0; stringArrayPos = 0;
+}
+inline void QXmlSimpleReaderPrivate::nameClear()
+{
+ nameValueLen = 0; nameArrayPos = 0;
+}
+
+inline void QXmlSimpleReaderPrivate::refClear()
+{
+ refValueLen = 0; refArrayPos = 0;
+}
+
+QXmlSimpleReaderPrivate::QXmlSimpleReaderPrivate()
+{
+ parseStack = 0;
+}
+
+QXmlSimpleReaderPrivate::~QXmlSimpleReaderPrivate()
+{
+ delete parseStack;
+}
+
+void QXmlSimpleReaderPrivate::initIncrementalParsing()
+{
+ delete parseStack;
+ parseStack = new QStack<ParseState>;
+}
+
+/*********************************************
+ *
+ * QXmlSimpleReader
+ *
+ *********************************************/
+
+/*!
+ \class QXmlReader
+ \reentrant
+ \brief The QXmlReader class provides an interface for XML readers (i.e.
+ parsers).
+
+ \inmodule QtXml
+ \ingroup xml-tools
+
+ This abstract class provides an interface for all of Qt's XML
+ readers. Currently there is only one implementation of a reader
+ included in Qt's XML module: QXmlSimpleReader. In future releases
+ there might be more readers with different properties available
+ (e.g. a validating parser).
+
+ The design of the XML classes follows the \link
+ http://www.saxproject.org/ SAX2 Java interface\endlink, with
+ the names adapted to fit Qt naming conventions. It should be very
+ easy for anybody who has worked with SAX2 to get started with the
+ Qt XML classes.
+
+ All readers use the class QXmlInputSource to read the input
+ document. Since you are normally interested in particular content
+ in the XML document, the reader reports the content through
+ special handler classes (QXmlDTDHandler, QXmlDeclHandler,
+ QXmlContentHandler, QXmlEntityResolver, QXmlErrorHandler and
+ QXmlLexicalHandler), which you must subclass, if you want to
+ process the contents.
+
+ Since the handler classes only describe interfaces you must
+ implement all the functions. We provide the QXmlDefaultHandler
+ class to make this easier: it implements a default behavior (do
+ nothing) for all functions, so you can subclass it and just
+ implement the functions you are interested in.
+
+ Features and properties of the reader can be set with setFeature()
+ and setProperty() respectively. You can set the reader to use your
+ own subclasses with setEntityResolver(), setDTDHandler(),
+ setContentHandler(), setErrorHandler(), setLexicalHandler() and
+ setDeclHandler(). The parse itself is started with a call to
+ parse().
+
+ \sa QXmlSimpleReader
+*/
+
+/*!
+ \fn QXmlReader::~QXmlReader()
+
+ Destroys the reader.
+*/
+
+/*!
+ \fn bool QXmlReader::feature(const QString& name, bool *ok) const
+
+ If the reader has the feature called \a name, the feature's value
+ is returned. If no such feature exists the return value is
+ undefined.
+
+ If \a ok is not 0: \c{*}\a{ok} is set to true if the reader has the
+ feature called \a name; otherwise \c{*}\a{ok} is set to false.
+
+ \sa setFeature(), hasFeature()
+*/
+
+/*!
+ \fn void QXmlReader::setFeature(const QString& name, bool value)
+
+ Sets the feature called \a name to the given \a value. If the
+ reader doesn't have the feature nothing happens.
+
+ \sa feature(), hasFeature()
+*/
+
+/*!
+ \fn bool QXmlReader::hasFeature(const QString& name) const
+
+ Returns \c true if the reader has the feature called \a name;
+ otherwise returns false.
+
+ \sa feature(), setFeature()
+*/
+
+/*!
+ \fn void* QXmlReader::property(const QString& name, bool *ok) const
+
+ If the reader has the property \a name, this function returns the
+ value of the property; otherwise the return value is undefined.
+
+ If \a ok is not 0: if the reader has the \a name property
+ \c{*}\a{ok} is set to true; otherwise \c{*}\a{ok} is set to false.
+
+ \sa setProperty(), hasProperty()
+*/
+
+/*!
+ \fn void QXmlReader::setProperty(const QString& name, void* value)
+
+ Sets the property \a name to \a value. If the reader doesn't have
+ the property nothing happens.
+
+ \sa property(), hasProperty()
+*/
+
+/*!
+ \fn bool QXmlReader::hasProperty(const QString& name) const
+
+ Returns true if the reader has the property \a name; otherwise
+ returns false.
+
+ \sa property(), setProperty()
+*/
+
+/*!
+ \fn void QXmlReader::setEntityResolver(QXmlEntityResolver* handler)
+
+ Sets the entity resolver to \a handler.
+
+ \sa entityResolver()
+*/
+
+/*!
+ \fn QXmlEntityResolver* QXmlReader::entityResolver() const
+
+ Returns the entity resolver or 0 if none was set.
+
+ \sa setEntityResolver()
+*/
+
+/*!
+ \fn void QXmlReader::setDTDHandler(QXmlDTDHandler* handler)
+
+ Sets the DTD handler to \a handler.
+
+ \sa DTDHandler()
+*/
+
+/*!
+ \fn QXmlDTDHandler* QXmlReader::DTDHandler() const
+
+ Returns the DTD handler or 0 if none was set.
+
+ \sa setDTDHandler()
+*/
+
+/*!
+ \fn void QXmlReader::setContentHandler(QXmlContentHandler* handler)
+
+ Sets the content handler to \a handler.
+
+ \sa contentHandler()
+*/
+
+/*!
+ \fn QXmlContentHandler* QXmlReader::contentHandler() const
+
+ Returns the content handler or 0 if none was set.
+
+ \sa setContentHandler()
+*/
+
+/*!
+ \fn void QXmlReader::setErrorHandler(QXmlErrorHandler* handler)
+
+ Sets the error handler to \a handler. Clears the error handler if
+ \a handler is 0.
+
+ \sa errorHandler()
+*/
+
+/*!
+ \fn QXmlErrorHandler* QXmlReader::errorHandler() const
+
+ Returns the error handler or 0 if none is set.
+
+ \sa setErrorHandler()
+*/
+
+/*!
+ \fn void QXmlReader::setLexicalHandler(QXmlLexicalHandler* handler)
+
+ Sets the lexical handler to \a handler.
+
+ \sa lexicalHandler()
+*/
+
+/*!
+ \fn QXmlLexicalHandler* QXmlReader::lexicalHandler() const
+
+ Returns the lexical handler or 0 if none was set.
+
+ \sa setLexicalHandler()
+*/
+
+/*!
+ \fn void QXmlReader::setDeclHandler(QXmlDeclHandler* handler)
+
+ Sets the declaration handler to \a handler.
+
+ \sa declHandler()
+*/
+
+/*!
+ \fn QXmlDeclHandler* QXmlReader::declHandler() const
+
+ Returns the declaration handler or 0 if none was set.
+
+ \sa setDeclHandler()
+*/
+
+/*!
+ \fn bool QXmlReader::parse(const QXmlInputSource &input)
+
+ \obsolete
+
+ Parses the given \a input.
+*/
+
+/*!
+ \fn bool QXmlReader::parse(const QXmlInputSource *input)
+
+ Reads an XML document from \a input and parses it. Returns true if
+ the parsing was successful; otherwise returns false.
+*/
+
+
+/*!
+ \class QXmlSimpleReader
+ \nonreentrant
+ \brief The QXmlSimpleReader class provides an implementation of a
+ simple XML parser.
+
+ \inmodule QtXml
+ \ingroup xml-tools
+ \mainclass
+
+ This XML reader is suitable for a wide range of applications. It
+ is able to parse well-formed XML and can report the namespaces of
+ elements to a content handler; however, it does not parse any
+ external entities. For historical reasons, Attribute Value
+ Normalization and End-of-Line Handling as described in the XML 1.0
+ specification is not performed.
+
+ The easiest pattern of use for this class is to create a reader
+ instance, define an input source, specify the handlers to be used
+ by the reader, and parse the data.
+
+ For example, we could use a QFile to supply the input. Here, we
+ create a reader, and define an input source to be used by the
+ reader:
+
+ \snippet doc/src/snippets/xml/simpleparse/main.cpp 0
+
+ A handler lets us perform actions when the reader encounters
+ certain types of content, or if errors in the input are found. The
+ reader must be told which handler to use for each type of
+ event. For many common applications, we can create a custom
+ handler by subclassing QXmlDefaultHandler, and use this to handle
+ both error and content events:
+
+ \snippet doc/src/snippets/xml/simpleparse/main.cpp 1
+
+ If you don't set at least the content and error handlers, the
+ parser will fall back on its default behavior---and will do
+ nothing.
+
+ The most convenient way to handle the input is to read it in a
+ single pass using the parse() function with an argument that
+ specifies the input source:
+
+ \snippet doc/src/snippets/xml/simpleparse/main.cpp 2
+
+ If you can't parse the entire input in one go (for example, it is
+ huge, or is being delivered over a network connection), data can
+ be fed to the parser in pieces. This is achieved by telling
+ parse() to work incrementally, and making subsequent calls to the
+ parseContinue() function, until all the data has been processed.
+
+ A common way to perform incremental parsing is to connect the
+ \c readyRead() signal of the input source to a slot, and handle the
+ incoming data there. For example, the following code shows how a
+ parser for \l{http://web.resource.org/rss/1.0/}{RSS feeds} can be
+ used to incrementally parse data that it receives from a QHttp
+ object:
+
+ \snippet doc/src/snippets/xml/rsslisting/rsslisting.cpp 1
+
+ Aspects of the parsing behavior can be adapted using setFeature()
+ and setProperty(). For example, the following code could be used
+ to enable reporting of namespace prefixes to the content handler:
+
+ QXmlSimpleReader is not reentrant. If you want to use the class
+ in threaded code, lock the code using QXmlSimpleReader with a
+ locking mechanism, such as a QMutex.
+
+ \snippet doc/src/snippets/code/src_xml_sax_qxml.cpp 0
+*/
+
+static inline bool is_S(QChar ch)
+{
+ ushort uc = ch.unicode();
+ return (uc == ' ' || uc == '\t' || uc == '\n' || uc == '\r');
+}
+
+enum NameChar { NameBeginning, NameNotBeginning, NotName };
+
+static const char Begi = (char)NameBeginning;
+static const char NtBg = (char)NameNotBeginning;
+static const char NotN = (char)NotName;
+
+static const char nameCharTable[128] =
+{
+// 0x00
+ NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+ NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+// 0x10
+ NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+ NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+// 0x20 (0x2D is '-', 0x2E is '.')
+ NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+ NotN, NotN, NotN, NotN, NotN, NtBg, NtBg, NotN,
+// 0x30 (0x30..0x39 are '0'..'9', 0x3A is ':')
+ NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg,
+ NtBg, NtBg, Begi, NotN, NotN, NotN, NotN, NotN,
+// 0x40 (0x41..0x5A are 'A'..'Z')
+ NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+ Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+// 0x50 (0x5F is '_')
+ Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+ Begi, Begi, Begi, NotN, NotN, NotN, NotN, Begi,
+// 0x60 (0x61..0x7A are 'a'..'z')
+ NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+ Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+// 0x70
+ Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+ Begi, Begi, Begi, NotN, NotN, NotN, NotN, NotN
+};
+
+static inline NameChar fastDetermineNameChar(QChar ch)
+{
+ ushort uc = ch.unicode();
+ if (!(uc & ~0x7f)) // uc < 128
+ return (NameChar)nameCharTable[uc];
+
+ QChar::Category cat = ch.category();
+ // ### some these categories might be slightly wrong
+ if ((cat >= QChar::Letter_Uppercase && cat <= QChar::Letter_Other)
+ || cat == QChar::Number_Letter)
+ return NameBeginning;
+ if ((cat >= QChar::Number_DecimalDigit && cat <= QChar::Number_Other)
+ || (cat >= QChar::Mark_NonSpacing && cat <= QChar::Mark_Enclosing))
+ return NameNotBeginning;
+ return NotName;
+}
+
+static NameChar determineNameChar(QChar ch)
+{
+ return fastDetermineNameChar(ch);
+}
+
+/*!
+ Constructs a simple XML reader.
+
+*/
+QXmlSimpleReader::QXmlSimpleReader()
+{
+ d_ptr = new QXmlSimpleReaderPrivate();
+ Q_D(QXmlSimpleReader);
+ d->q_ptr = this;
+
+ d->locator = new QXmlSimpleReaderLocator(this);
+
+ d->entityRes = 0;
+ d->dtdHnd = 0;
+ d->contentHnd = 0;
+ d->errorHnd = 0;
+ d->lexicalHnd = 0;
+ d->declHnd = 0;
+
+ // default feature settings
+ d->useNamespaces = true;
+ d->useNamespacePrefixes = false;
+ d->reportWhitespaceCharData = true;
+ d->reportEntities = false;
+}
+
+/*!
+ Destroys the simple XML reader.
+*/
+QXmlSimpleReader::~QXmlSimpleReader()
+{
+ Q_D(QXmlSimpleReader);
+ delete d->locator;
+ delete d;
+}
+
+/*!
+ \reimp
+*/
+bool QXmlSimpleReader::feature(const QString& name, bool *ok) const
+{
+ const QXmlSimpleReaderPrivate *d = d_func();
+
+ // Qt5 ###: Change these strings to qtsoftware.com
+ if (ok != 0)
+ *ok = true;
+ if (name == QLatin1String("http://xml.org/sax/features/namespaces")) {
+ return d->useNamespaces;
+ } else if (name == QLatin1String("http://xml.org/sax/features/namespace-prefixes")) {
+ return d->useNamespacePrefixes;
+ } else if (name == QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData")) { // Shouldn't change in Qt 4
+ return d->reportWhitespaceCharData;
+ } else if (name == QLatin1String("http://trolltech.com/xml/features/report-start-end-entity")) { // Shouldn't change in Qt 4
+ return d->reportEntities;
+ } else {
+ qWarning("Unknown feature %s", name.toLatin1().data());
+ if (ok != 0)
+ *ok = false;
+ }
+ return false;
+}
+
+/*!
+ Turns on the feature \a name if \a enable is true; otherwise turns it off.
+
+ The \a name parameter must be one of the following strings:
+ \table
+ \header \i Feature \i Default \i Notes
+ \row \i \e http://xml.org/sax/features/namespaces
+ \i true
+ \i If enabled, namespaces are reported to the content handler.
+ \row \i \e http://xml.org/sax/features/namespace-prefixes
+ \i false
+ \i If enabled, the original prefixed names
+ and attributes used for namespace declarations are
+ reported.
+ \row \i \e http://trolltech.com/xml/features/report-whitespace-only-CharData
+ \i true
+ \i If enabled, CharData that consist of
+ only whitespace characters are reported
+ using QXmlContentHandler::characters(). If disabled, whitespace is silently
+ discarded.
+ \row \i \e http://trolltech.com/xml/features/report-start-end-entity
+ \i false
+ \i If enabled, the parser reports
+ QXmlContentHandler::startEntity() and
+ QXmlContentHandler::endEntity() events, so character data
+ might be reported in chunks.
+ If disabled, the parser does not report these events, but
+ silently substitutes the entities, and reports the character
+ data in one chunk.
+ \endtable
+
+ \sa feature(), hasFeature(), {SAX2 Features}
+*/
+void QXmlSimpleReader::setFeature(const QString& name, bool enable)
+{
+ Q_D(QXmlSimpleReader);
+ // Qt5 ###: Change these strings to qtsoftware.com
+ if (name == QLatin1String("http://xml.org/sax/features/namespaces")) {
+ d->useNamespaces = enable;
+ } else if (name == QLatin1String("http://xml.org/sax/features/namespace-prefixes")) {
+ d->useNamespacePrefixes = enable;
+ } else if (name == QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData")) { // Shouldn't change in Qt 4
+ d->reportWhitespaceCharData = enable;
+ } else if (name == QLatin1String("http://trolltech.com/xml/features/report-start-end-entity")) { // Shouldn't change in Qt 4
+ d->reportEntities = enable;
+ } else {
+ qWarning("Unknown feature %s", name.toLatin1().data());
+ }
+}
+
+/*! \reimp
+*/
+bool QXmlSimpleReader::hasFeature(const QString& name) const
+{
+ // Qt5 ###: Change these strings to qtsoftware.com
+ if (name == QLatin1String("http://xml.org/sax/features/namespaces")
+ || name == QLatin1String("http://xml.org/sax/features/namespace-prefixes")
+ || name == QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData") // Shouldn't change in Qt 4
+ || name == QLatin1String("http://trolltech.com/xml/features/report-start-end-entity")) { // Shouldn't change in Qt 4
+ return true;
+ } else {
+ return false;
+ }
+}
+
+/*! \reimp
+*/
+void* QXmlSimpleReader::property(const QString&, bool *ok) const
+{
+ if (ok != 0)
+ *ok = false;
+ return 0;
+}
+
+/*! \reimp
+*/
+void QXmlSimpleReader::setProperty(const QString&, void*)
+{
+}
+
+/*!
+ \reimp
+*/
+bool QXmlSimpleReader::hasProperty(const QString&) const
+{
+ return false;
+}
+
+/*!
+ \reimp
+*/
+void QXmlSimpleReader::setEntityResolver(QXmlEntityResolver* handler)
+{
+ Q_D(QXmlSimpleReader);
+ d->entityRes = handler;
+}
+
+/*!
+ \reimp
+*/
+QXmlEntityResolver* QXmlSimpleReader::entityResolver() const
+{
+ const QXmlSimpleReaderPrivate *d = d_func();
+ return d->entityRes;
+}
+
+/*!
+ \reimp
+*/
+void QXmlSimpleReader::setDTDHandler(QXmlDTDHandler* handler)
+{
+ Q_D(QXmlSimpleReader);
+ d->dtdHnd = handler;
+}
+
+/*!
+ \reimp
+*/
+QXmlDTDHandler* QXmlSimpleReader::DTDHandler() const
+{
+ const QXmlSimpleReaderPrivate *d = d_func();
+ return d->dtdHnd;
+}
+
+/*!
+ \reimp
+*/
+void QXmlSimpleReader::setContentHandler(QXmlContentHandler* handler)
+{
+ Q_D(QXmlSimpleReader);
+ d->contentHnd = handler;
+}
+
+/*!
+ \reimp
+*/
+QXmlContentHandler* QXmlSimpleReader::contentHandler() const
+{
+ const QXmlSimpleReaderPrivate *d = d_func();
+ return d->contentHnd;
+}
+
+/*!
+ \reimp
+*/
+void QXmlSimpleReader::setErrorHandler(QXmlErrorHandler* handler)
+{
+ Q_D(QXmlSimpleReader);
+ d->errorHnd = handler;
+}
+
+/*!
+ \reimp
+*/
+QXmlErrorHandler* QXmlSimpleReader::errorHandler() const
+{
+ const QXmlSimpleReaderPrivate *d = d_func();
+ return d->errorHnd;
+}
+
+/*!
+ \reimp
+*/
+void QXmlSimpleReader::setLexicalHandler(QXmlLexicalHandler* handler)
+{
+ Q_D(QXmlSimpleReader);
+ d->lexicalHnd = handler;
+}
+
+/*!
+ \reimp
+*/
+QXmlLexicalHandler* QXmlSimpleReader::lexicalHandler() const
+{
+ const QXmlSimpleReaderPrivate *d = d_func();
+ return d->lexicalHnd;
+}
+
+/*!
+ \reimp
+*/
+void QXmlSimpleReader::setDeclHandler(QXmlDeclHandler* handler)
+{
+ Q_D(QXmlSimpleReader);
+ d->declHnd = handler;
+}
+
+/*!
+ \reimp
+*/
+QXmlDeclHandler* QXmlSimpleReader::declHandler() const
+{
+ const QXmlSimpleReaderPrivate *d = d_func();
+ return d->declHnd;
+}
+
+
+
+/*!
+ \reimp
+*/
+bool QXmlSimpleReader::parse(const QXmlInputSource& input)
+{
+ return parse(&input, false);
+}
+
+/*!
+ Reads an XML document from \a input and parses it in one pass (non-incrementally).
+ Returns true if the parsing was successful; otherwise returns false.
+*/
+bool QXmlSimpleReader::parse(const QXmlInputSource* input)
+{
+ return parse(input, false);
+}
+
+/*!
+ Reads an XML document from \a input and parses it. Returns true
+ if the parsing is completed successfully; otherwise returns false,
+ indicating that an error occurred.
+
+ If \a incremental is false, this function will return false if the XML
+ file is not read completely. The parsing cannot be continued in this
+ case.
+
+ If \a incremental is true, the parser does not return false if
+ it reaches the end of the \a input before reaching the end
+ of the XML file. Instead, it stores the state of the parser so that
+ parsing can be continued later when more data is available.
+ In such a case, you can use the function parseContinue() to
+ continue with parsing. This class stores a pointer to the input
+ source \a input and the parseContinue() function tries to read from
+ that input source. Therefore, you should not delete the input
+ source \a input until you no longer need to call parseContinue().
+
+ If this function is called with \a incremental set to true
+ while an incremental parse is in progress, a new parsing
+ session will be started, and the previous session will be lost.
+
+ \sa parseContinue(), QTcpSocket
+*/
+bool QXmlSimpleReader::parse(const QXmlInputSource *input, bool incremental)
+{
+ Q_D(QXmlSimpleReader);
+
+ if (incremental) {
+ d->initIncrementalParsing();
+ } else {
+ delete d->parseStack;
+ d->parseStack = 0;
+ }
+ d->init(input);
+
+ // call the handler
+ if (d->contentHnd) {
+ d->contentHnd->setDocumentLocator(d->locator);
+ if (!d->contentHnd->startDocument()) {
+ d->reportParseError(d->contentHnd->errorString());
+ d->tags.clear();
+ return false;
+ }
+ }
+ qt_xml_skipped_entity_in_content = false;
+ return d->parseBeginOrContinue(0, incremental);
+}
+
+/*!
+ Continues incremental parsing, taking input from the
+ QXmlInputSource that was specified with the most recent
+ call to parse(). To use this function, you \e must have called
+ parse() with the incremental argument set to true.
+
+ Returns false if a parsing error occurs; otherwise returns true,
+ even if the end of the XML file has not been reached. You can
+ continue parsing at a later stage by calling this function again
+ when there is more data available to parse.
+
+ Calling this function when there is no data available in the input
+ source indicates to the reader that the end of the XML file has
+ been reached. If the input supplied up to this point was
+ not well-formed then a parsing error occurs, and false is returned.
+ If the input supplied was well-formed, true is returned.
+ It is important to end the input in this way because it allows you
+ to reuse the reader to parse other XML files.
+
+ Calling this function after the end of file has been reached, but
+ without available data will cause false to be returned whether the
+ previous input was well-formed or not.
+
+ \sa parse(), QXmlInputSource::data(), QXmlInputSource::next()
+*/
+bool QXmlSimpleReader::parseContinue()
+{
+ Q_D(QXmlSimpleReader);
+ if (d->parseStack == 0 || d->parseStack->isEmpty())
+ return false;
+ d->initData();
+ int state = d->parseStack->pop().state;
+ return d->parseBeginOrContinue(state, true);
+}
+
+/*
+ Common part of parse() and parseContinue()
+*/
+bool QXmlSimpleReaderPrivate::parseBeginOrContinue(int state, bool incremental)
+{
+ bool atEndOrig = atEnd();
+
+ if (state==0) {
+ if (!parseProlog()) {
+ if (incremental && error.isNull()) {
+ pushParseState(0, 0);
+ return true;
+ } else {
+ tags.clear();
+ return false;
+ }
+ }
+ state = 1;
+ }
+ if (state==1) {
+ if (!parseElement()) {
+ if (incremental && error.isNull()) {
+ pushParseState(0, 1);
+ return true;
+ } else {
+ tags.clear();
+ return false;
+ }
+ }
+ state = 2;
+ }
+ // parse Misc*
+ while (!atEnd()) {
+ if (!parseMisc()) {
+ if (incremental && error.isNull()) {
+ pushParseState(0, 2);
+ return true;
+ } else {
+ tags.clear();
+ return false;
+ }
+ }
+ }
+ if (!atEndOrig && incremental) {
+ // we parsed something at all, so be prepared to come back later
+ pushParseState(0, 2);
+ return true;
+ }
+ // is stack empty?
+ if (!tags.isEmpty() && !error.isNull()) {
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
+ tags.clear();
+ return false;
+ }
+ // call the handler
+ if (contentHnd) {
+ delete parseStack;
+ parseStack = 0;
+ if (!contentHnd->endDocument()) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ return true;
+}
+
+//
+// The following private parse functions have another semantics for the return
+// value: They return true iff parsing has finished successfully (i.e. the end
+// of the XML file must be reached!). If one of these functions return false,
+// there is only an error when d->error.isNULL() is also false.
+//
+
+/*
+ For the incremental parsing, it is very important that the parse...()
+ functions have a certain structure. Since it might be hard to understand how
+ they work, here is a description of the layout of these functions:
+
+ bool QXmlSimpleReader::parse...()
+ {
+(1) const signed char Init = 0;
+ ...
+
+(2) const signed char Inp... = 0;
+ ...
+
+(3) static const signed char table[3][2] = {
+ ...
+ };
+ signed char state;
+ signed char input;
+
+(4) if (d->parseStack == 0 || d->parseStack->isEmpty()) {
+(4a) ...
+ } else {
+(4b) ...
+ }
+
+ for (; ;) {
+(5) switch (state) {
+ ...
+ }
+
+(6)
+(6a) if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReader::parseNmtoken, state);
+ return false;
+ }
+(6b) if (determineNameChar(c) != NotName) {
+ ...
+ }
+(7) state = table[state][input];
+
+(8) switch (state) {
+ ...
+ }
+ }
+ }
+
+ Explanation:
+ ad 1: constants for the states (used in the transition table)
+ ad 2: constants for the input (used in the transition table)
+ ad 3: the transition table for the state machine
+ ad 4: test if we are in a parseContinue() step
+ a) if no, do inititalizations
+ b) if yes, restore the state and call parse functions recursively
+ ad 5: Do some actions according to the state; from the logical execution
+ order, this code belongs after 8 (see there for an explanation)
+ ad 6: Check the character that is at the actual "cursor" position:
+ a) If we reached the EOF, report either error or push the state (in the
+ case of incremental parsing).
+ b) Otherwise, set the input character constant for the transition
+ table.
+ ad 7: Get the new state according to the input that was read.
+ ad 8: Do some actions according to the state. The last line in every case
+ statement reads new data (i.e. it move the cursor). This can also be
+ done by calling another parse...() function. If you need processing for
+ this state after that, you have to put it into the switch statement 5.
+ This ensures that you have a well defined re-entry point, when you ran
+ out of data.
+*/
+
+/*
+ Parses the prolog [22].
+*/
+
+bool QXmlSimpleReaderPrivate::parseProlog()
+{
+ const signed char Init = 0;
+ const signed char EatWS = 1; // eat white spaces
+ const signed char Lt = 2; // '<' read
+ const signed char Em = 3; // '!' read
+ const signed char DocType = 4; // read doctype
+ const signed char Comment = 5; // read comment
+ const signed char CommentR = 6; // same as Comment, but already reported
+ const signed char PInstr = 7; // read PI
+ const signed char PInstrR = 8; // same as PInstr, but already reported
+ const signed char Done = 9;
+
+ const signed char InpWs = 0;
+ const signed char InpLt = 1; // <
+ const signed char InpQm = 2; // ?
+ const signed char InpEm = 3; // !
+ const signed char InpD = 4; // D
+ const signed char InpDash = 5; // -
+ const signed char InpUnknown = 6;
+
+ static const signed char table[9][7] = {
+ /* InpWs InpLt InpQm InpEm InpD InpDash InpUnknown */
+ { EatWS, Lt, -1, -1, -1, -1, -1 }, // Init
+ { -1, Lt, -1, -1, -1, -1, -1 }, // EatWS
+ { -1, -1, PInstr,Em, Done, -1, Done }, // Lt
+ { -1, -1, -1, -1, DocType, Comment, -1 }, // Em
+ { EatWS, Lt, -1, -1, -1, -1, -1 }, // DocType
+ { EatWS, Lt, -1, -1, -1, -1, -1 }, // Comment
+ { EatWS, Lt, -1, -1, -1, -1, -1 }, // CommentR
+ { EatWS, Lt, -1, -1, -1, -1, -1 }, // PInstr
+ { EatWS, Lt, -1, -1, -1, -1, -1 } // PInstrR
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack == 0 || parseStack->isEmpty()) {
+ xmldecl_possible = true;
+ doctype_read = false;
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseProlog (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case DocType:
+ if (doctype_read) {
+ reportParseError(QLatin1String(XMLERR_MORETHANONEDOCTYPE));
+ return false;
+ } else {
+ doctype_read = false;
+ }
+ break;
+ case Comment:
+ if (lexicalHnd) {
+ if (!lexicalHnd->comment(string())) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ state = CommentR;
+ break;
+ case PInstr:
+ // call the handler
+ if (contentHnd) {
+ if (xmldecl_possible && !xmlVersion.isEmpty()) {
+ QString value(QLatin1String("version='"));
+ value += xmlVersion;
+ value += QLatin1Char('\'');
+ if (!encoding.isEmpty()) {
+ value += QLatin1String(" encoding='");
+ value += encoding;
+ value += QLatin1Char('\'');
+ }
+ if (standalone == QXmlSimpleReaderPrivate::Yes) {
+ value += QLatin1String(" standalone='yes'");
+ } else if (standalone == QXmlSimpleReaderPrivate::No) {
+ value += QLatin1String(" standalone='no'");
+ }
+ if (!contentHnd->processingInstruction(QLatin1String("xml"), value)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ } else {
+ if (!contentHnd->processingInstruction(name(), string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ // XML declaration only on first position possible
+ xmldecl_possible = false;
+ state = PInstrR;
+ break;
+ case Done:
+ return true;
+ case -1:
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGELEMENT));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseProlog, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('<')) {
+ input = InpLt;
+ } else if (c == QLatin1Char('?')) {
+ input = InpQm;
+ } else if (c == QLatin1Char('!')) {
+ input = InpEm;
+ } else if (c == QLatin1Char('D')) {
+ input = InpD;
+ } else if (c == QLatin1Char('-')) {
+ input = InpDash;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case EatWS:
+ // XML declaration only on first position possible
+ xmldecl_possible = false;
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+ return false;
+ }
+ break;
+ case Lt:
+ next();
+ break;
+ case Em:
+ // XML declaration only on first position possible
+ xmldecl_possible = false;
+ next();
+ break;
+ case DocType:
+ if (!parseDoctype()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+ return false;
+ }
+ break;
+ case Comment:
+ case CommentR:
+ if (!parseComment()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+ return false;
+ }
+ break;
+ case PInstr:
+ case PInstrR:
+ parsePI_xmldecl = xmldecl_possible;
+ if (!parsePI()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+ return false;
+ }
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse an element [39].
+
+ Precondition: the opening '<' is already read.
+*/
+bool QXmlSimpleReaderPrivate::parseElement()
+{
+ const int Init = 0;
+ const int ReadName = 1;
+ const int Ws1 = 2;
+ const int STagEnd = 3;
+ const int STagEnd2 = 4;
+ const int ETagBegin = 5;
+ const int ETagBegin2 = 6;
+ const int Ws2 = 7;
+ const int EmptyTag = 8;
+ const int Attrib = 9;
+ const int AttribPro = 10; // like Attrib, but processAttribute was already called
+ const int Ws3 = 11;
+ const int Done = 12;
+
+ const int InpWs = 0; // whitespace
+ const int InpNameBe = 1; // NameBeginning
+ const int InpGt = 2; // >
+ const int InpSlash = 3; // /
+ const int InpUnknown = 4;
+
+ static const int table[12][5] = {
+ /* InpWs InpNameBe InpGt InpSlash InpUnknown */
+ { -1, ReadName, -1, -1, -1 }, // Init
+ { Ws1, Attrib, STagEnd, EmptyTag, -1 }, // ReadName
+ { -1, Attrib, STagEnd, EmptyTag, -1 }, // Ws1
+ { STagEnd2, STagEnd2, STagEnd2, STagEnd2, STagEnd2 }, // STagEnd
+ { -1, -1, -1, ETagBegin, -1 }, // STagEnd2
+ { -1, ETagBegin2, -1, -1, -1 }, // ETagBegin
+ { Ws2, -1, Done, -1, -1 }, // ETagBegin2
+ { -1, -1, Done, -1, -1 }, // Ws2
+ { -1, -1, Done, -1, -1 }, // EmptyTag
+ { Ws3, Attrib, STagEnd, EmptyTag, -1 }, // Attrib
+ { Ws3, Attrib, STagEnd, EmptyTag, -1 }, // AttribPro
+ { -1, Attrib, STagEnd, EmptyTag, -1 } // Ws3
+ };
+ int state;
+ int input;
+
+ if (parseStack == 0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseElement (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case ReadName:
+ // store it on the stack
+ tags.push(name());
+ // empty the attributes
+ attList.clear();
+ if (useNamespaces)
+ namespaceSupport.pushContext();
+ break;
+ case ETagBegin2:
+ if (!processElementETagBegin2())
+ return false;
+ break;
+ case Attrib:
+ if (!processElementAttribute())
+ return false;
+ state = AttribPro;
+ break;
+ case Done:
+ return true;
+ case -1:
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGELEMENT));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseElement, state);
+ return false;
+ }
+ if (fastDetermineNameChar(c) == NameBeginning) {
+ input = InpNameBe;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('/')) {
+ input = InpSlash;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case ReadName:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+ return false;
+ }
+ break;
+ case Ws1:
+ case Ws2:
+ case Ws3:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+ return false;
+ }
+ break;
+ case STagEnd:
+ // call the handler
+ if (contentHnd) {
+ const QString &tagsTop = tags.top();
+ if (useNamespaces) {
+ QString uri, lname;
+ namespaceSupport.processName(tagsTop, false, uri, lname);
+ if (!contentHnd->startElement(uri, lname, tagsTop, attList)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ } else {
+ if (!contentHnd->startElement(QString(), QString(), tagsTop, attList)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ next();
+ break;
+ case STagEnd2:
+ if (!parseContent()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+ return false;
+ }
+ break;
+ case ETagBegin:
+ next();
+ break;
+ case ETagBegin2:
+ // get the name of the tag
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+ return false;
+ }
+ break;
+ case EmptyTag:
+ if (tags.isEmpty()) {
+ reportParseError(QLatin1String(XMLERR_TAGMISMATCH));
+ return false;
+ }
+ if (!processElementEmptyTag())
+ return false;
+ next();
+ break;
+ case Attrib:
+ case AttribPro:
+ // get name and value of attribute
+ if (!parseAttribute()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+ return false;
+ }
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Helper to break down the size of the code in the case statement.
+ Return false on error, otherwise true.
+*/
+bool QXmlSimpleReaderPrivate::processElementEmptyTag()
+{
+ QString uri, lname;
+ // pop the stack and call the handler
+ if (contentHnd) {
+ if (useNamespaces) {
+ // report startElement first...
+ namespaceSupport.processName(tags.top(), false, uri, lname);
+ if (!contentHnd->startElement(uri, lname, tags.top(), attList)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ // ... followed by endElement...
+ if (!contentHnd->endElement(uri, lname, tags.pop())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ // ... followed by endPrefixMapping
+ QStringList prefixesBefore, prefixesAfter;
+ if (contentHnd) {
+ prefixesBefore = namespaceSupport.prefixes();
+ }
+ namespaceSupport.popContext();
+ // call the handler for prefix mapping
+ prefixesAfter = namespaceSupport.prefixes();
+ for (QStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it) {
+ if (!prefixesAfter.contains(*it)) {
+ if (!contentHnd->endPrefixMapping(*it)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ } else {
+ // report startElement first...
+ if (!contentHnd->startElement(QString(), QString(), tags.top(), attList)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ // ... followed by endElement
+ if (!contentHnd->endElement(QString(), QString(), tags.pop())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ } else {
+ tags.pop_back();
+ namespaceSupport.popContext();
+ }
+ return true;
+}
+/*
+ Helper to break down the size of the code in the case statement.
+ Return false on error, otherwise true.
+*/
+bool QXmlSimpleReaderPrivate::processElementETagBegin2()
+{
+ const QString &name = QXmlSimpleReaderPrivate::name();
+
+ // pop the stack and compare it with the name
+ if (tags.pop() != name) {
+ reportParseError(QLatin1String(XMLERR_TAGMISMATCH));
+ return false;
+ }
+ // call the handler
+ if (contentHnd) {
+ QString uri, lname;
+
+ if (useNamespaces)
+ namespaceSupport.processName(name, false, uri, lname);
+ if (!contentHnd->endElement(uri, lname, name)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ if (useNamespaces) {
+ NamespaceMap prefixesBefore, prefixesAfter;
+ if (contentHnd)
+ prefixesBefore = namespaceSupport.d->ns;
+
+ namespaceSupport.popContext();
+ // call the handler for prefix mapping
+ if (contentHnd) {
+ prefixesAfter = namespaceSupport.d->ns;
+ if (prefixesBefore.size() != prefixesAfter.size()) {
+ for (NamespaceMap::const_iterator it = prefixesBefore.constBegin(); it != prefixesBefore.constEnd(); ++it) {
+ if (!it.key().isEmpty() && !prefixesAfter.contains(it.key())) {
+ if (!contentHnd->endPrefixMapping(it.key())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ }
+ }
+ }
+ return true;
+}
+/*
+ Helper to break down the size of the code in the case statement.
+ Return false on error, otherwise true.
+*/
+bool QXmlSimpleReaderPrivate::processElementAttribute()
+{
+ QString uri, lname, prefix;
+ const QString &name = QXmlSimpleReaderPrivate::name();
+ const QString &string = QXmlSimpleReaderPrivate::string();
+
+ // add the attribute to the list
+ if (useNamespaces) {
+ // is it a namespace declaration?
+ namespaceSupport.splitName(name, prefix, lname);
+ if (prefix == QLatin1String("xmlns")) {
+ // namespace declaration
+ namespaceSupport.setPrefix(lname, string);
+ if (useNamespacePrefixes) {
+ // according to http://www.w3.org/2000/xmlns/, the "prefix"
+ // xmlns maps to the namespace name
+ // http://www.w3.org/2000/xmlns/
+ attList.append(name, QLatin1String("http://www.w3.org/2000/xmlns/"), lname, string);
+ }
+ // call the handler for prefix mapping
+ if (contentHnd) {
+ if (!contentHnd->startPrefixMapping(lname, string)) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ } else {
+ // no namespace delcaration
+ namespaceSupport.processName(name, true, uri, lname);
+ attList.append(name, uri, lname, string);
+ }
+ } else {
+ // no namespace support
+ attList.append(name, uri, lname, string);
+ }
+ return true;
+}
+
+/*
+ Parse a content [43].
+
+ A content is only used between tags. If a end tag is found the < is already
+ read and the head stand on the '/' of the end tag '</name>'.
+*/
+bool QXmlSimpleReaderPrivate::parseContent()
+{
+ const signed char Init = 0;
+ const signed char ChD = 1; // CharData
+ const signed char ChD1 = 2; // CharData help state
+ const signed char ChD2 = 3; // CharData help state
+ const signed char Ref = 4; // Reference
+ const signed char Lt = 5; // '<' read
+ const signed char PInstr = 6; // PI
+ const signed char PInstrR = 7; // same as PInstr, but already reported
+ const signed char Elem = 8; // Element
+ const signed char Em = 9; // '!' read
+ const signed char Com = 10; // Comment
+ const signed char ComR = 11; // same as Com, but already reported
+ const signed char CDS = 12; // CDSect
+ const signed char CDS1 = 13; // read a CDSect
+ const signed char CDS2 = 14; // read a CDSect (help state)
+ const signed char CDS3 = 15; // read a CDSect (help state)
+ const signed char Done = 16; // finished reading content
+
+ const signed char InpLt = 0; // <
+ const signed char InpGt = 1; // >
+ const signed char InpSlash = 2; // /
+ const signed char InpQMark = 3; // ?
+ const signed char InpEMark = 4; // !
+ const signed char InpAmp = 5; // &
+ const signed char InpDash = 6; // -
+ const signed char InpOpenB = 7; // [
+ const signed char InpCloseB = 8; //]
+ const signed char InpUnknown = 9;
+
+ static const signed char mapCLT2FSMChar[] = {
+ InpUnknown, // white space
+ InpUnknown, // %
+ InpAmp, // &
+ InpGt, // >
+ InpLt, // <
+ InpSlash, // /
+ InpQMark, // ?
+ InpEMark, // !
+ InpDash, // -
+ InpCloseB, //]
+ InpOpenB, // [
+ InpUnknown, // =
+ InpUnknown, // "
+ InpUnknown, // '
+ InpUnknown // unknown
+ };
+
+ static const signed char table[16][10] = {
+ /* InpLt InpGt InpSlash InpQMark InpEMark InpAmp InpDash InpOpenB InpCloseB InpUnknown */
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD1, ChD }, // Init
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD1, ChD }, // ChD
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD2, ChD }, // ChD1
+ { Lt, -1, ChD, ChD, ChD, Ref, ChD, ChD, ChD2, ChD }, // ChD2
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // Ref (same as Init)
+ { -1, -1, Done, PInstr, Em, -1, -1, -1, -1, Elem }, // Lt
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // PInstr (same as Init)
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // PInstrR
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // Elem (same as Init)
+ { -1, -1, -1, -1, -1, -1, Com, CDS, -1, -1 }, // Em
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // Com (same as Init)
+ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // ComR
+ { CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS2, CDS1 }, // CDS
+ { CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS2, CDS1 }, // CDS1
+ { CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS3, CDS1 }, // CDS2
+ { CDS1, Init, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS3, CDS1 } // CDS3
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack == 0 || parseStack->isEmpty()) {
+ contentCharDataRead = false;
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseContent (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Ref:
+ if (!contentCharDataRead)
+ contentCharDataRead = parseReference_charDataRead;
+ break;
+ case PInstr:
+ if (contentHnd) {
+ if (!contentHnd->processingInstruction(name(),string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ state = PInstrR;
+ break;
+ case Com:
+ if (lexicalHnd) {
+ if (!lexicalHnd->comment(string())) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ state = ComR;
+ break;
+ case CDS:
+ stringClear();
+ break;
+ case CDS2:
+ if (!atEnd() && c != QLatin1Char(']'))
+ stringAddC(QLatin1Char(']'));
+ break;
+ case CDS3:
+ // test if this skipping was legal
+ if (!atEnd()) {
+ if (c == QLatin1Char('>')) {
+ // the end of the CDSect
+ if (lexicalHnd) {
+ if (!lexicalHnd->startCDATA()) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ if (contentHnd) {
+ if (!contentHnd->characters(string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ if (lexicalHnd) {
+ if (!lexicalHnd->endCDATA()) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ } else if (c == QLatin1Char(']')) {
+ // three or more ']'
+ stringAddC(QLatin1Char(']'));
+ } else {
+ // after ']]' comes another character
+ stringAddC(QLatin1Char(']'));
+ stringAddC(QLatin1Char(']'));
+ }
+ }
+ break;
+ case Done:
+ // call the handler for CharData
+ if (contentHnd) {
+ if (contentCharDataRead) {
+ if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+ if (!contentHnd->characters(string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ }
+ // Done
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGCONTENT));
+ return false;
+ }
+
+ // get input (use lookup-table instead of nested ifs for performance
+ // reasons)
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ if (c.row()) {
+ input = InpUnknown;
+ } else {
+ input = mapCLT2FSMChar[charLookupTable[c.cell()]];
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Init:
+ // skip the ending '>' of a CDATASection
+ next();
+ break;
+ case ChD:
+ // on first call: clear string
+ if (!contentCharDataRead) {
+ contentCharDataRead = true;
+ stringClear();
+ }
+ stringAddC();
+ if (reportEntities) {
+ if (!reportEndEntities())
+ return false;
+ }
+ next();
+ break;
+ case ChD1:
+ // on first call: clear string
+ if (!contentCharDataRead) {
+ contentCharDataRead = true;
+ stringClear();
+ }
+ stringAddC();
+ if (reportEntities) {
+ if (!reportEndEntities())
+ return false;
+ }
+ next();
+ break;
+ case ChD2:
+ stringAddC();
+ if (reportEntities) {
+ if (!reportEndEntities())
+ return false;
+ }
+ next();
+ break;
+ case Ref:
+ if (!contentCharDataRead) {
+ // reference may be CharData; so clear string to be safe
+ stringClear();
+ parseReference_context = InContent;
+ if (!parseReference()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ } else {
+ if (reportEntities) {
+ // report character data in chunks
+ if (contentHnd) {
+ if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+ if (!contentHnd->characters(string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ stringClear();
+ }
+ parseReference_context = InContent;
+ if (!parseReference()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ }
+ break;
+ case Lt:
+ // call the handler for CharData
+ if (contentHnd) {
+ if (contentCharDataRead) {
+ if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+ if (!contentHnd->characters(string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ }
+ contentCharDataRead = false;
+ next();
+ break;
+ case PInstr:
+ case PInstrR:
+ parsePI_xmldecl = false;
+ if (!parsePI()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ break;
+ case Elem:
+ if (!parseElement()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ break;
+ case Em:
+ next();
+ break;
+ case Com:
+ case ComR:
+ if (!parseComment()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ break;
+ case CDS:
+ parseString_s = QLatin1String("[CDATA[");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+ return false;
+ }
+ break;
+ case CDS1:
+ stringAddC();
+ next();
+ break;
+ case CDS2:
+ // skip ']'
+ next();
+ break;
+ case CDS3:
+ // skip ']'...
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+bool QXmlSimpleReaderPrivate::reportEndEntities()
+{
+ int count = (int)xmlRefStack.count();
+ while (count != 0 && xmlRefStack.top().isEmpty()) {
+ if (contentHnd) {
+ if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+ if (!contentHnd->characters(string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ }
+ stringClear();
+ if (lexicalHnd) {
+ if (!lexicalHnd->endEntity(xmlRefStack.top().name)) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ xmlRefStack.pop_back();
+ count--;
+ }
+ return true;
+}
+
+/*
+ Parse Misc [27].
+*/
+bool QXmlSimpleReaderPrivate::parseMisc()
+{
+ const signed char Init = 0;
+ const signed char Lt = 1; // '<' was read
+ const signed char Comment = 2; // read comment
+ const signed char eatWS = 3; // eat whitespaces
+ const signed char PInstr = 4; // read PI
+ const signed char Comment2 = 5; // read comment
+
+ const signed char InpWs = 0; // S
+ const signed char InpLt = 1; // <
+ const signed char InpQm = 2; // ?
+ const signed char InpEm = 3; // !
+ const signed char InpUnknown = 4;
+
+ static const signed char table[3][5] = {
+ /* InpWs InpLt InpQm InpEm InpUnknown */
+ { eatWS, Lt, -1, -1, -1 }, // Init
+ { -1, -1, PInstr,Comment, -1 }, // Lt
+ { -1, -1, -1, -1, Comment2 } // Comment
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseMisc (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case eatWS:
+ return true;
+ case PInstr:
+ if (contentHnd) {
+ if (!contentHnd->processingInstruction(name(),string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ return true;
+ case Comment2:
+ if (lexicalHnd) {
+ if (!lexicalHnd->comment(string())) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseMisc, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('<')) {
+ input = InpLt;
+ } else if (c == QLatin1Char('?')) {
+ input = InpQm;
+ } else if (c == QLatin1Char('!')) {
+ input = InpEm;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case eatWS:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+ return false;
+ }
+ break;
+ case Lt:
+ next();
+ break;
+ case PInstr:
+ parsePI_xmldecl = false;
+ if (!parsePI()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+ return false;
+ }
+ break;
+ case Comment:
+ next();
+ break;
+ case Comment2:
+ if (!parseComment()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+ return false;
+ }
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a processing instruction [16].
+
+ If xmldec is true, it tries to parse a PI or a XML declaration [23].
+
+ Precondition: the beginning '<' of the PI is already read and the head stand
+ on the '?' of '<?'.
+
+ If this funktion was successful, the head-position is on the first
+ character after the PI.
+*/
+bool QXmlSimpleReaderPrivate::parsePI()
+{
+ const signed char Init = 0;
+ const signed char QmI = 1; // ? was read
+ const signed char Name = 2; // read Name
+ const signed char XMLDecl = 3; // read XMLDecl
+ const signed char Ws1 = 4; // eat ws after "xml" of XMLDecl
+ const signed char PInstr = 5; // read PI
+ const signed char Ws2 = 6; // eat ws after Name of PI
+ const signed char Version = 7; // read versionInfo
+ const signed char Ws3 = 8; // eat ws after versionInfo
+ const signed char EorSD = 9; // read EDecl or SDDecl
+ const signed char Ws4 = 10; // eat ws after EDecl or SDDecl
+ const signed char SD = 11; // read SDDecl
+ const signed char Ws5 = 12; // eat ws after SDDecl
+ const signed char ADone = 13; // almost done
+ const signed char Char = 14; // Char was read
+ const signed char Qm = 15; // Qm was read
+ const signed char Done = 16; // finished reading content
+
+ const signed char InpWs = 0; // whitespace
+ const signed char InpNameBe = 1; // NameBeginning
+ const signed char InpGt = 2; // >
+ const signed char InpQm = 3; // ?
+ const signed char InpUnknown = 4;
+
+ static const signed char table[16][5] = {
+ /* InpWs, InpNameBe InpGt InpQm InpUnknown */
+ { -1, -1, -1, QmI, -1 }, // Init
+ { -1, Name, -1, -1, -1 }, // QmI
+ { -1, -1, -1, -1, -1 }, // Name (this state is left not through input)
+ { Ws1, -1, -1, -1, -1 }, // XMLDecl
+ { -1, Version, -1, -1, -1 }, // Ws1
+ { Ws2, -1, -1, Qm, -1 }, // PInstr
+ { Char, Char, Char, Qm, Char }, // Ws2
+ { Ws3, -1, -1, ADone, -1 }, // Version
+ { -1, EorSD, -1, ADone, -1 }, // Ws3
+ { Ws4, -1, -1, ADone, -1 }, // EorSD
+ { -1, SD, -1, ADone, -1 }, // Ws4
+ { Ws5, -1, -1, ADone, -1 }, // SD
+ { -1, -1, -1, ADone, -1 }, // Ws5
+ { -1, -1, Done, -1, -1 }, // ADone
+ { Char, Char, Char, Qm, Char }, // Char
+ { Char, Char, Done, Qm, Char }, // Qm
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parsePI (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Name:
+ // test what name was read and determine the next state
+ // (not very beautiful, I admit)
+ if (name().toLower() == QLatin1String("xml")) {
+ if (parsePI_xmldecl && name() == QLatin1String("xml")) {
+ state = XMLDecl;
+ } else {
+ reportParseError(QLatin1String(XMLERR_INVALIDNAMEFORPI));
+ return false;
+ }
+ } else {
+ state = PInstr;
+ stringClear();
+ }
+ break;
+ case Version:
+ // get version (syntax like an attribute)
+ if (name() != QLatin1String("version")) {
+ reportParseError(QLatin1String(XMLERR_VERSIONEXPECTED));
+ return false;
+ }
+ xmlVersion = string();
+ break;
+ case EorSD:
+ // get the EDecl or SDDecl (syntax like an attribute)
+ if (name() == QLatin1String("standalone")) {
+ if (string()== QLatin1String("yes")) {
+ standalone = QXmlSimpleReaderPrivate::Yes;
+ } else if (string() == QLatin1String("no")) {
+ standalone = QXmlSimpleReaderPrivate::No;
+ } else {
+ reportParseError(QLatin1String(XMLERR_WRONGVALUEFORSDECL));
+ return false;
+ }
+ } else if (name() == QLatin1String("encoding")) {
+ encoding = string();
+ } else {
+ reportParseError(QLatin1String(XMLERR_EDECLORSDDECLEXPECTED));
+ return false;
+ }
+ break;
+ case SD:
+ if (name() != QLatin1String("standalone")) {
+ reportParseError(QLatin1String(XMLERR_SDDECLEXPECTED));
+ return false;
+ }
+ if (string() == QLatin1String("yes")) {
+ standalone = QXmlSimpleReaderPrivate::Yes;
+ } else if (string() == QLatin1String("no")) {
+ standalone = QXmlSimpleReaderPrivate::No;
+ } else {
+ reportParseError(QLatin1String(XMLERR_WRONGVALUEFORSDECL));
+ return false;
+ }
+ break;
+ case Qm:
+ // test if the skipping was legal
+ if (!atEnd() && c != QLatin1Char('>'))
+ stringAddC(QLatin1Char('?'));
+ break;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parsePI, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (determineNameChar(c) == NameBeginning) {
+ input = InpNameBe;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else if (c == QLatin1Char('?')) {
+ input = InpQm;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case QmI:
+ next();
+ break;
+ case Name:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+ return false;
+ }
+ break;
+ case Ws1:
+ case Ws2:
+ case Ws3:
+ case Ws4:
+ case Ws5:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+ return false;
+ }
+ break;
+ case Version:
+ if (!parseAttribute()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+ return false;
+ }
+ break;
+ case EorSD:
+ if (!parseAttribute()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+ return false;
+ }
+ break;
+ case SD:
+ // get the SDDecl (syntax like an attribute)
+ if (standalone != QXmlSimpleReaderPrivate::Unknown) {
+ // already parsed the standalone declaration
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+ if (!parseAttribute()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+ return false;
+ }
+ break;
+ case ADone:
+ next();
+ break;
+ case Char:
+ stringAddC();
+ next();
+ break;
+ case Qm:
+ // skip the '?'
+ next();
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a document type definition (doctypedecl [28]).
+
+ Precondition: the beginning '<!' of the doctype is already read the head
+ stands on the 'D' of '<!DOCTYPE'.
+
+ If this function was successful, the head-position is on the first
+ character after the document type definition.
+*/
+bool QXmlSimpleReaderPrivate::parseDoctype()
+{
+ const signed char Init = 0;
+ const signed char Doctype = 1; // read the doctype
+ const signed char Ws1 = 2; // eat_ws
+ const signed char Doctype2 = 3; // read the doctype, part 2
+ const signed char Ws2 = 4; // eat_ws
+ const signed char Sys = 5; // read SYSTEM or PUBLIC
+ const signed char Ws3 = 6; // eat_ws
+ const signed char MP = 7; // markupdecl or PEReference
+ const signed char MPR = 8; // same as MP, but already reported
+ const signed char PER = 9; // PERReference
+ const signed char Mup = 10; // markupdecl
+ const signed char Ws4 = 11; // eat_ws
+ const signed char MPE = 12; // end of markupdecl or PEReference
+ const signed char Done = 13;
+
+ const signed char InpWs = 0;
+ const signed char InpD = 1; // 'D'
+ const signed char InpS = 2; // 'S' or 'P'
+ const signed char InpOB = 3; // [
+ const signed char InpCB = 4; //]
+ const signed char InpPer = 5; // %
+ const signed char InpGt = 6; // >
+ const signed char InpUnknown = 7;
+
+ static const signed char table[13][8] = {
+ /* InpWs, InpD InpS InpOB InpCB InpPer InpGt InpUnknown */
+ { -1, Doctype, -1, -1, -1, -1, -1, -1 }, // Init
+ { Ws1, -1, -1, -1, -1, -1, -1, -1 }, // Doctype
+ { -1, Doctype2, Doctype2, -1, -1, -1, -1, Doctype2 }, // Ws1
+ { Ws2, -1, Sys, MP, -1, -1, Done, -1 }, // Doctype2
+ { -1, -1, Sys, MP, -1, -1, Done, -1 }, // Ws2
+ { Ws3, -1, -1, MP, -1, -1, Done, -1 }, // Sys
+ { -1, -1, -1, MP, -1, -1, Done, -1 }, // Ws3
+ { -1, -1, -1, -1, MPE, PER, -1, Mup }, // MP
+ { -1, -1, -1, -1, MPE, PER, -1, Mup }, // MPR
+ { Ws4, -1, -1, -1, MPE, PER, -1, Mup }, // PER
+ { Ws4, -1, -1, -1, MPE, PER, -1, Mup }, // Mup
+ { -1, -1, -1, -1, MPE, PER, -1, Mup }, // Ws4
+ { -1, -1, -1, -1, -1, -1, Done, -1 } // MPE
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ startDTDwasReported = false;
+ systemId.clear();
+ publicId.clear();
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseDoctype (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Doctype2:
+ doctype = name();
+ break;
+ case MP:
+ if (!startDTDwasReported && lexicalHnd ) {
+ startDTDwasReported = true;
+ if (!lexicalHnd->startDTD(doctype, publicId, systemId)) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ state = MPR;
+ break;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGDOCTYPE));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('D')) {
+ input = InpD;
+ } else if (c == QLatin1Char('S')) {
+ input = InpS;
+ } else if (c == QLatin1Char('P')) {
+ input = InpS;
+ } else if (c == QLatin1Char('[')) {
+ input = InpOB;
+ } else if (c == QLatin1Char(']')) {
+ input = InpCB;
+ } else if (c == QLatin1Char('%')) {
+ input = InpPer;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Doctype:
+ parseString_s = QLatin1String("DOCTYPE");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ break;
+ case Ws1:
+ case Ws2:
+ case Ws3:
+ case Ws4:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ break;
+ case Doctype2:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ break;
+ case Sys:
+ parseExternalID_allowPublicID = false;
+ if (!parseExternalID()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ thisPublicId = publicId;
+ thisSystemId = systemId;
+ break;
+ case MP:
+ case MPR:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ break;
+ case PER:
+ parsePEReference_context = InDTD;
+ if (!parsePEReference()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ break;
+ case Mup:
+ if (!parseMarkupdecl()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ break;
+ case MPE:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+ return false;
+ }
+ break;
+ case Done:
+ if (lexicalHnd) {
+ if (!startDTDwasReported) {
+ startDTDwasReported = true;
+ if (!lexicalHnd->startDTD(doctype, publicId, systemId)) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ if (!lexicalHnd->endDTD()) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a ExternalID [75].
+
+ If allowPublicID is true parse ExternalID [75] or PublicID [83].
+*/
+bool QXmlSimpleReaderPrivate::parseExternalID()
+{
+ const signed char Init = 0;
+ const signed char Sys = 1; // parse 'SYSTEM'
+ const signed char SysWS = 2; // parse the whitespace after 'SYSTEM'
+ const signed char SysSQ = 3; // parse SystemLiteral with '
+ const signed char SysSQ2 = 4; // parse SystemLiteral with '
+ const signed char SysDQ = 5; // parse SystemLiteral with "
+ const signed char SysDQ2 = 6; // parse SystemLiteral with "
+ const signed char Pub = 7; // parse 'PUBLIC'
+ const signed char PubWS = 8; // parse the whitespace after 'PUBLIC'
+ const signed char PubSQ = 9; // parse PubidLiteral with '
+ const signed char PubSQ2 = 10; // parse PubidLiteral with '
+ const signed char PubDQ = 11; // parse PubidLiteral with "
+ const signed char PubDQ2 = 12; // parse PubidLiteral with "
+ const signed char PubE = 13; // finished parsing the PubidLiteral
+ const signed char PubWS2 = 14; // parse the whitespace after the PubidLiteral
+ const signed char PDone = 15; // done if allowPublicID is true
+ const signed char Done = 16;
+
+ const signed char InpSQ = 0; // '
+ const signed char InpDQ = 1; // "
+ const signed char InpS = 2; // S
+ const signed char InpP = 3; // P
+ const signed char InpWs = 4; // white space
+ const signed char InpUnknown = 5;
+
+ static const signed char table[15][6] = {
+ /* InpSQ InpDQ InpS InpP InpWs InpUnknown */
+ { -1, -1, Sys, Pub, -1, -1 }, // Init
+ { -1, -1, -1, -1, SysWS, -1 }, // Sys
+ { SysSQ, SysDQ, -1, -1, -1, -1 }, // SysWS
+ { Done, SysSQ2, SysSQ2, SysSQ2, SysSQ2, SysSQ2 }, // SysSQ
+ { Done, SysSQ2, SysSQ2, SysSQ2, SysSQ2, SysSQ2 }, // SysSQ2
+ { SysDQ2, Done, SysDQ2, SysDQ2, SysDQ2, SysDQ2 }, // SysDQ
+ { SysDQ2, Done, SysDQ2, SysDQ2, SysDQ2, SysDQ2 }, // SysDQ2
+ { -1, -1, -1, -1, PubWS, -1 }, // Pub
+ { PubSQ, PubDQ, -1, -1, -1, -1 }, // PubWS
+ { PubE, -1, PubSQ2, PubSQ2, PubSQ2, PubSQ2 }, // PubSQ
+ { PubE, -1, PubSQ2, PubSQ2, PubSQ2, PubSQ2 }, // PubSQ2
+ { -1, PubE, PubDQ2, PubDQ2, PubDQ2, PubDQ2 }, // PubDQ
+ { -1, PubE, PubDQ2, PubDQ2, PubDQ2, PubDQ2 }, // PubDQ2
+ { PDone, PDone, PDone, PDone, PubWS2, PDone }, // PubE
+ { SysSQ, SysDQ, PDone, PDone, PDone, PDone } // PubWS2
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ systemId.clear();
+ publicId.clear();
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseExternalID (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case PDone:
+ if (parseExternalID_allowPublicID) {
+ publicId = string();
+ return true;
+ } else {
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseExternalID, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('\'')) {
+ input = InpSQ;
+ } else if (c == QLatin1Char('"')) {
+ input = InpDQ;
+ } else if (c == QLatin1Char('S')) {
+ input = InpS;
+ } else if (c == QLatin1Char('P')) {
+ input = InpP;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Sys:
+ parseString_s = QLatin1String("SYSTEM");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+ return false;
+ }
+ break;
+ case SysWS:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+ return false;
+ }
+ break;
+ case SysSQ:
+ case SysDQ:
+ stringClear();
+ next();
+ break;
+ case SysSQ2:
+ case SysDQ2:
+ stringAddC();
+ next();
+ break;
+ case Pub:
+ parseString_s = QLatin1String("PUBLIC");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+ return false;
+ }
+ break;
+ case PubWS:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+ return false;
+ }
+ break;
+ case PubSQ:
+ case PubDQ:
+ stringClear();
+ next();
+ break;
+ case PubSQ2:
+ case PubDQ2:
+ stringAddC();
+ next();
+ break;
+ case PubE:
+ next();
+ break;
+ case PubWS2:
+ publicId = string();
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+ return false;
+ }
+ break;
+ case Done:
+ systemId = string();
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a markupdecl [29].
+*/
+bool QXmlSimpleReaderPrivate::parseMarkupdecl()
+{
+ const signed char Init = 0;
+ const signed char Lt = 1; // < was read
+ const signed char Em = 2; // ! was read
+ const signed char CE = 3; // E was read
+ const signed char Qm = 4; // ? was read
+ const signed char Dash = 5; // - was read
+ const signed char CA = 6; // A was read
+ const signed char CEL = 7; // EL was read
+ const signed char CEN = 8; // EN was read
+ const signed char CN = 9; // N was read
+ const signed char Done = 10;
+
+ const signed char InpLt = 0; // <
+ const signed char InpQm = 1; // ?
+ const signed char InpEm = 2; // !
+ const signed char InpDash = 3; // -
+ const signed char InpA = 4; // A
+ const signed char InpE = 5; // E
+ const signed char InpL = 6; // L
+ const signed char InpN = 7; // N
+ const signed char InpUnknown = 8;
+
+ static const signed char table[4][9] = {
+ /* InpLt InpQm InpEm InpDash InpA InpE InpL InpN InpUnknown */
+ { Lt, -1, -1, -1, -1, -1, -1, -1, -1 }, // Init
+ { -1, Qm, Em, -1, -1, -1, -1, -1, -1 }, // Lt
+ { -1, -1, -1, Dash, CA, CE, -1, CN, -1 }, // Em
+ { -1, -1, -1, -1, -1, -1, CEL, CEN, -1 } // CE
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseMarkupdecl (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Qm:
+ if (contentHnd) {
+ if (!contentHnd->processingInstruction(name(),string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ return true;
+ case Dash:
+ if (lexicalHnd) {
+ if (!lexicalHnd->comment(string())) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ return true;
+ case CA:
+ return true;
+ case CEL:
+ return true;
+ case CEN:
+ return true;
+ case CN:
+ return true;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ if (c == QLatin1Char('<')) {
+ input = InpLt;
+ } else if (c == QLatin1Char('?')) {
+ input = InpQm;
+ } else if (c == QLatin1Char('!')) {
+ input = InpEm;
+ } else if (c == QLatin1Char('-')) {
+ input = InpDash;
+ } else if (c == QLatin1Char('A')) {
+ input = InpA;
+ } else if (c == QLatin1Char('E')) {
+ input = InpE;
+ } else if (c == QLatin1Char('L')) {
+ input = InpL;
+ } else if (c == QLatin1Char('N')) {
+ input = InpN;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Lt:
+ next();
+ break;
+ case Em:
+ next();
+ break;
+ case CE:
+ next();
+ break;
+ case Qm:
+ parsePI_xmldecl = false;
+ if (!parsePI()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ break;
+ case Dash:
+ if (!parseComment()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ break;
+ case CA:
+ if (!parseAttlistDecl()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ break;
+ case CEL:
+ if (!parseElementDecl()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ break;
+ case CEN:
+ if (!parseEntityDecl()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ break;
+ case CN:
+ if (!parseNotationDecl()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+ return false;
+ }
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a PEReference [69]
+*/
+bool QXmlSimpleReaderPrivate::parsePEReference()
+{
+ const signed char Init = 0;
+ const signed char Next = 1;
+ const signed char Name = 2;
+ const signed char NameR = 3; // same as Name, but already reported
+ const signed char Done = 4;
+
+ const signed char InpSemi = 0; // ;
+ const signed char InpPer = 1; // %
+ const signed char InpUnknown = 2;
+
+ static const signed char table[4][3] = {
+ /* InpSemi InpPer InpUnknown */
+ { -1, Next, -1 }, // Init
+ { -1, -1, Name }, // Next
+ { Done, -1, -1 }, // Name
+ { Done, -1, -1 } // NameR
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parsePEReference (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePEReference, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Name:
+ {
+ bool skipIt = true;
+ QString xmlRefString;
+
+ QMap<QString,QString>::Iterator it;
+ it = parameterEntities.find(ref());
+ if (it != parameterEntities.end()) {
+ skipIt = false;
+ xmlRefString = *it;
+ } else if (entityRes) {
+ QMap<QString,QXmlSimpleReaderPrivate::ExternParameterEntity>::Iterator it2;
+ it2 = externParameterEntities.find(ref());
+ QXmlInputSource *ret = 0;
+ if (it2 != externParameterEntities.end()) {
+ if (!entityRes->resolveEntity((*it2).publicId, (*it2).systemId, ret)) {
+ delete ret;
+ reportParseError(entityRes->errorString());
+ return false;
+ }
+ if (ret) {
+ xmlRefString = ret->data();
+ delete ret;
+ if (!stripTextDecl(xmlRefString)) {
+ reportParseError(QLatin1String(XMLERR_ERRORINTEXTDECL));
+ return false;
+ }
+ skipIt = false;
+ }
+ }
+ }
+
+ if (skipIt) {
+ if (contentHnd) {
+ if (!contentHnd->skippedEntity(QString::fromLatin1("%") + ref())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ } else {
+ if (parsePEReference_context == InEntityValue) {
+ // Included in literal
+ if (!insertXmlRef(xmlRefString, ref(), true))
+ return false;
+ } else if (parsePEReference_context == InDTD) {
+ // Included as PE
+ if (!insertXmlRef(QString::fromLatin1(" ")+xmlRefString+QString::fromLatin1(" "), ref(), false))
+ return false;
+ }
+ }
+ }
+ state = NameR;
+ break;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parsePEReference, state);
+ return false;
+ }
+ if (c == QLatin1Char(';')) {
+ input = InpSemi;
+ } else if (c == QLatin1Char('%')) {
+ input = InpPer;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Next:
+ next();
+ break;
+ case Name:
+ case NameR:
+ parseName_useRef = true;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parsePEReference, state);
+ return false;
+ }
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a AttlistDecl [52].
+
+ Precondition: the beginning '<!' is already read and the head
+ stands on the 'A' of '<!ATTLIST'
+*/
+bool QXmlSimpleReaderPrivate::parseAttlistDecl()
+{
+ const signed char Init = 0;
+ const signed char Attlist = 1; // parse the string "ATTLIST"
+ const signed char Ws = 2; // whitespace read
+ const signed char Name = 3; // parse name
+ const signed char Ws1 = 4; // whitespace read
+ const signed char Attdef = 5; // parse the AttDef
+ const signed char Ws2 = 6; // whitespace read
+ const signed char Atttype = 7; // parse the AttType
+ const signed char Ws3 = 8; // whitespace read
+ const signed char DDecH = 9; // DefaultDecl with #
+ const signed char DefReq = 10; // parse the string "REQUIRED"
+ const signed char DefImp = 11; // parse the string "IMPLIED"
+ const signed char DefFix = 12; // parse the string "FIXED"
+ const signed char Attval = 13; // parse the AttValue
+ const signed char Ws4 = 14; // whitespace read
+ const signed char Done = 15;
+
+ const signed char InpWs = 0; // white space
+ const signed char InpGt = 1; // >
+ const signed char InpHash = 2; // #
+ const signed char InpA = 3; // A
+ const signed char InpI = 4; // I
+ const signed char InpF = 5; // F
+ const signed char InpR = 6; // R
+ const signed char InpUnknown = 7;
+
+ static const signed char table[15][8] = {
+ /* InpWs InpGt InpHash InpA InpI InpF InpR InpUnknown */
+ { -1, -1, -1, Attlist, -1, -1, -1, -1 }, // Init
+ { Ws, -1, -1, -1, -1, -1, -1, -1 }, // Attlist
+ { -1, -1, -1, Name, Name, Name, Name, Name }, // Ws
+ { Ws1, Done, Attdef, Attdef, Attdef, Attdef, Attdef, Attdef }, // Name
+ { -1, Done, Attdef, Attdef, Attdef, Attdef, Attdef, Attdef }, // Ws1
+ { Ws2, -1, -1, -1, -1, -1, -1, -1 }, // Attdef
+ { -1, Atttype, Atttype, Atttype, Atttype, Atttype, Atttype, Atttype }, // Ws2
+ { Ws3, -1, -1, -1, -1, -1, -1, -1 }, // Attype
+ { -1, Attval, DDecH, Attval, Attval, Attval, Attval, Attval }, // Ws3
+ { -1, -1, -1, -1, DefImp, DefFix, DefReq, -1 }, // DDecH
+ { Ws4, Ws4, -1, -1, -1, -1, -1, -1 }, // DefReq
+ { Ws4, Ws4, -1, -1, -1, -1, -1, -1 }, // DefImp
+ { Ws3, -1, -1, -1, -1, -1, -1, -1 }, // DefFix
+ { Ws4, Ws4, -1, -1, -1, -1, -1, -1 }, // Attval
+ { -1, Done, Attdef, Attdef, Attdef, Attdef, Attdef, Attdef } // Ws4
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseAttlistDecl (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Name:
+ attDeclEName = name();
+ break;
+ case Attdef:
+ attDeclAName = name();
+ break;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else if (c == QLatin1Char('#')) {
+ input = InpHash;
+ } else if (c == QLatin1Char('A')) {
+ input = InpA;
+ } else if (c == QLatin1Char('I')) {
+ input = InpI;
+ } else if (c == QLatin1Char('F')) {
+ input = InpF;
+ } else if (c == QLatin1Char('R')) {
+ input = InpR;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Attlist:
+ parseString_s = QLatin1String("ATTLIST");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case Ws:
+ case Ws1:
+ case Ws2:
+ case Ws3:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case Name:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case Attdef:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case Atttype:
+ if (!parseAttType()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case DDecH:
+ next();
+ break;
+ case DefReq:
+ parseString_s = QLatin1String("REQUIRED");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case DefImp:
+ parseString_s = QLatin1String("IMPLIED");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case DefFix:
+ parseString_s = QLatin1String("FIXED");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case Attval:
+ if (!parseAttValue()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case Ws4:
+ if (declHnd) {
+ // ### not all values are computed yet...
+ if (!declHnd->attributeDecl(attDeclEName, attDeclAName, QLatin1String(""), QLatin1String(""), QLatin1String(""))) {
+ reportParseError(declHnd->errorString());
+ return false;
+ }
+ }
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+ return false;
+ }
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a AttType [54]
+*/
+bool QXmlSimpleReaderPrivate::parseAttType()
+{
+ const signed char Init = 0;
+ const signed char ST = 1; // StringType
+ const signed char TTI = 2; // TokenizedType starting with 'I'
+ const signed char TTI2 = 3; // TokenizedType helpstate
+ const signed char TTI3 = 4; // TokenizedType helpstate
+ const signed char TTE = 5; // TokenizedType starting with 'E'
+ const signed char TTEY = 6; // TokenizedType starting with 'ENTITY'
+ const signed char TTEI = 7; // TokenizedType starting with 'ENTITI'
+ const signed char N = 8; // N read (TokenizedType or Notation)
+ const signed char TTNM = 9; // TokenizedType starting with 'NM'
+ const signed char TTNM2 = 10; // TokenizedType helpstate
+ const signed char NO = 11; // Notation
+ const signed char NO2 = 12; // Notation helpstate
+ const signed char NO3 = 13; // Notation helpstate
+ const signed char NOName = 14; // Notation, read name
+ const signed char NO4 = 15; // Notation helpstate
+ const signed char EN = 16; // Enumeration
+ const signed char ENNmt = 17; // Enumeration, read Nmtoken
+ const signed char EN2 = 18; // Enumeration helpstate
+ const signed char ADone = 19; // almost done (make next and accept)
+ const signed char Done = 20;
+
+ const signed char InpWs = 0; // whitespace
+ const signed char InpOp = 1; // (
+ const signed char InpCp = 2; //)
+ const signed char InpPipe = 3; // |
+ const signed char InpC = 4; // C
+ const signed char InpE = 5; // E
+ const signed char InpI = 6; // I
+ const signed char InpM = 7; // M
+ const signed char InpN = 8; // N
+ const signed char InpO = 9; // O
+ const signed char InpR = 10; // R
+ const signed char InpS = 11; // S
+ const signed char InpY = 12; // Y
+ const signed char InpUnknown = 13;
+
+ static const signed char table[19][14] = {
+ /* InpWs InpOp InpCp InpPipe InpC InpE InpI InpM InpN InpO InpR InpS InpY InpUnknown */
+ { -1, EN, -1, -1, ST, TTE, TTI, -1, N, -1, -1, -1, -1, -1 }, // Init
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // ST
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, TTI2, Done, Done, Done }, // TTI
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, TTI3, Done, Done }, // TTI2
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTI3
+ { -1, -1, -1, -1, -1, -1, TTEI, -1, -1, -1, -1, -1, TTEY, -1 }, // TTE
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTEY
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTEI
+ { -1, -1, -1, -1, -1, -1, -1, TTNM, -1, NO, -1, -1, -1, -1 }, // N
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, TTNM2, Done, Done }, // TTNM
+ { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTNM2
+ { NO2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NO
+ { -1, NO3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NO2
+ { NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName }, // NO3
+ { NO4, -1, ADone, NO3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NOName
+ { -1, -1, ADone, NO3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NO4
+ { -1, -1, ENNmt, -1, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt }, // EN
+ { EN2, -1, ADone, EN, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // ENNmt
+ { -1, -1, ADone, EN, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } // EN2
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseAttType (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case ADone:
+ return true;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('(')) {
+ input = InpOp;
+ } else if (c == QLatin1Char(')')) {
+ input = InpCp;
+ } else if (c == QLatin1Char('|')) {
+ input = InpPipe;
+ } else if (c == QLatin1Char('C')) {
+ input = InpC;
+ } else if (c == QLatin1Char('E')) {
+ input = InpE;
+ } else if (c == QLatin1Char('I')) {
+ input = InpI;
+ } else if (c == QLatin1Char('M')) {
+ input = InpM;
+ } else if (c == QLatin1Char('N')) {
+ input = InpN;
+ } else if (c == QLatin1Char('O')) {
+ input = InpO;
+ } else if (c == QLatin1Char('R')) {
+ input = InpR;
+ } else if (c == QLatin1Char('S')) {
+ input = InpS;
+ } else if (c == QLatin1Char('Y')) {
+ input = InpY;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case ST:
+ parseString_s = QLatin1String("CDATA");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case TTI:
+ parseString_s = QLatin1String("ID");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case TTI2:
+ parseString_s = QLatin1String("REF");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case TTI3:
+ next(); // S
+ break;
+ case TTE:
+ parseString_s = QLatin1String("ENTIT");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case TTEY:
+ next(); // Y
+ break;
+ case TTEI:
+ parseString_s = QLatin1String("IES");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case N:
+ next(); // N
+ break;
+ case TTNM:
+ parseString_s = QLatin1String("MTOKEN");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case TTNM2:
+ next(); // S
+ break;
+ case NO:
+ parseString_s = QLatin1String("OTATION");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case NO2:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case NO3:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case NOName:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case NO4:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case EN:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case ENNmt:
+ if (!parseNmtoken()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case EN2:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+ return false;
+ }
+ break;
+ case ADone:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a AttValue [10]
+
+ Precondition: the head stands on the beginning " or '
+
+ If this function was successful, the head stands on the first
+ character after the closing " or ' and the value of the attribute
+ is in string().
+*/
+bool QXmlSimpleReaderPrivate::parseAttValue()
+{
+ const signed char Init = 0;
+ const signed char Dq = 1; // double quotes were read
+ const signed char DqRef = 2; // read references in double quotes
+ const signed char DqC = 3; // signed character read in double quotes
+ const signed char Sq = 4; // single quotes were read
+ const signed char SqRef = 5; // read references in single quotes
+ const signed char SqC = 6; // signed character read in single quotes
+ const signed char Done = 7;
+
+ const signed char InpDq = 0; // "
+ const signed char InpSq = 1; // '
+ const signed char InpAmp = 2; // &
+ const signed char InpLt = 3; // <
+ const signed char InpUnknown = 4;
+
+ static const signed char table[7][5] = {
+ /* InpDq InpSq InpAmp InpLt InpUnknown */
+ { Dq, Sq, -1, -1, -1 }, // Init
+ { Done, DqC, DqRef, -1, DqC }, // Dq
+ { Done, DqC, DqRef, -1, DqC }, // DqRef
+ { Done, DqC, DqRef, -1, DqC }, // DqC
+ { SqC, Done, SqRef, -1, SqC }, // Sq
+ { SqC, Done, SqRef, -1, SqC }, // SqRef
+ { SqC, Done, SqRef, -1, SqC } // SqRef
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseAttValue (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttValue, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseAttValue, state);
+ return false;
+ }
+ if (c == QLatin1Char('"')) {
+ input = InpDq;
+ } else if (c == QLatin1Char('\'')) {
+ input = InpSq;
+ } else if (c == QLatin1Char('&')) {
+ input = InpAmp;
+ } else if (c == QLatin1Char('<')) {
+ input = InpLt;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Dq:
+ case Sq:
+ stringClear();
+ next();
+ break;
+ case DqRef:
+ case SqRef:
+ parseReference_context = InAttributeValue;
+ if (!parseReference()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttValue, state);
+ return false;
+ }
+ break;
+ case DqC:
+ case SqC:
+ stringAddC();
+ next();
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a elementdecl [45].
+
+ Precondition: the beginning '<!E' is already read and the head
+ stands on the 'L' of '<!ELEMENT'
+*/
+bool QXmlSimpleReaderPrivate::parseElementDecl()
+{
+ const signed char Init = 0;
+ const signed char Elem = 1; // parse the beginning string
+ const signed char Ws1 = 2; // whitespace required
+ const signed char Nam = 3; // parse Name
+ const signed char Ws2 = 4; // whitespace required
+ const signed char Empty = 5; // read EMPTY
+ const signed char Any = 6; // read ANY
+ const signed char Cont = 7; // read contentspec (except ANY or EMPTY)
+ const signed char Mix = 8; // read Mixed
+ const signed char Mix2 = 9; //
+ const signed char Mix3 = 10; //
+ const signed char MixN1 = 11; //
+ const signed char MixN2 = 12; //
+ const signed char MixN3 = 13; //
+ const signed char MixN4 = 14; //
+ const signed char Cp = 15; // parse cp
+ const signed char Cp2 = 16; //
+ const signed char WsD = 17; // eat whitespace before Done
+ const signed char Done = 18;
+
+ const signed char InpWs = 0;
+ const signed char InpGt = 1; // >
+ const signed char InpPipe = 2; // |
+ const signed char InpOp = 3; // (
+ const signed char InpCp = 4; //)
+ const signed char InpHash = 5; // #
+ const signed char InpQm = 6; // ?
+ const signed char InpAst = 7; // *
+ const signed char InpPlus = 8; // +
+ const signed char InpA = 9; // A
+ const signed char InpE = 10; // E
+ const signed char InpL = 11; // L
+ const signed char InpUnknown = 12;
+
+ static const signed char table[18][13] = {
+ /* InpWs InpGt InpPipe InpOp InpCp InpHash InpQm InpAst InpPlus InpA InpE InpL InpUnknown */
+ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, Elem, -1 }, // Init
+ { Ws1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Elem
+ { -1, -1, -1, -1, -1, -1, -1, -1, -1, Nam, Nam, Nam, Nam }, // Ws1
+ { Ws2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Nam
+ { -1, -1, -1, Cont, -1, -1, -1, -1, -1, Any, Empty, -1, -1 }, // Ws2
+ { WsD, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Empty
+ { WsD, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Any
+ { -1, -1, -1, Cp, Cp, Mix, -1, -1, -1, Cp, Cp, Cp, Cp }, // Cont
+ { Mix2, -1, MixN1, -1, Mix3, -1, -1, -1, -1, -1, -1, -1, -1 }, // Mix
+ { -1, -1, MixN1, -1, Mix3, -1, -1, -1, -1, -1, -1, -1, -1 }, // Mix2
+ { WsD, Done, -1, -1, -1, -1, -1, WsD, -1, -1, -1, -1, -1 }, // Mix3
+ { -1, -1, -1, -1, -1, -1, -1, -1, -1, MixN2, MixN2, MixN2, MixN2 }, // MixN1
+ { MixN3, -1, MixN1, -1, MixN4, -1, -1, -1, -1, -1, -1, -1, -1 }, // MixN2
+ { -1, -1, MixN1, -1, MixN4, -1, -1, -1, -1, -1, -1, -1, -1 }, // MixN3
+ { -1, -1, -1, -1, -1, -1, -1, WsD, -1, -1, -1, -1, -1 }, // MixN4
+ { WsD, Done, -1, -1, -1, -1, Cp2, Cp2, Cp2, -1, -1, -1, -1 }, // Cp
+ { WsD, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Cp2
+ { -1, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } // WsD
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseElementDecl (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Done:
+ return true;
+ case -1:
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else if (c == QLatin1Char('|')) {
+ input = InpPipe;
+ } else if (c == QLatin1Char('(')) {
+ input = InpOp;
+ } else if (c == QLatin1Char(')')) {
+ input = InpCp;
+ } else if (c == QLatin1Char('#')) {
+ input = InpHash;
+ } else if (c == QLatin1Char('?')) {
+ input = InpQm;
+ } else if (c == QLatin1Char('*')) {
+ input = InpAst;
+ } else if (c == QLatin1Char('+')) {
+ input = InpPlus;
+ } else if (c == QLatin1Char('A')) {
+ input = InpA;
+ } else if (c == QLatin1Char('E')) {
+ input = InpE;
+ } else if (c == QLatin1Char('L')) {
+ input = InpL;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Elem:
+ parseString_s = QLatin1String("LEMENT");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Ws1:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Nam:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Ws2:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Empty:
+ parseString_s = QLatin1String("EMPTY");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Any:
+ parseString_s = QLatin1String("ANY");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Cont:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Mix:
+ parseString_s = QLatin1String("#PCDATA");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Mix2:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Mix3:
+ next();
+ break;
+ case MixN1:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case MixN2:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case MixN3:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case MixN4:
+ next();
+ break;
+ case Cp:
+ if (!parseChoiceSeq()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Cp2:
+ next();
+ break;
+ case WsD:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+ return false;
+ }
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a NotationDecl [82].
+
+ Precondition: the beginning '<!' is already read and the head
+ stands on the 'N' of '<!NOTATION'
+*/
+bool QXmlSimpleReaderPrivate::parseNotationDecl()
+{
+ const signed char Init = 0;
+ const signed char Not = 1; // read NOTATION
+ const signed char Ws1 = 2; // eat whitespaces
+ const signed char Nam = 3; // read Name
+ const signed char Ws2 = 4; // eat whitespaces
+ const signed char ExtID = 5; // parse ExternalID
+ const signed char ExtIDR = 6; // same as ExtID, but already reported
+ const signed char Ws3 = 7; // eat whitespaces
+ const signed char Done = 8;
+
+ const signed char InpWs = 0;
+ const signed char InpGt = 1; // >
+ const signed char InpN = 2; // N
+ const signed char InpUnknown = 3;
+
+ static const signed char table[8][4] = {
+ /* InpWs InpGt InpN InpUnknown */
+ { -1, -1, Not, -1 }, // Init
+ { Ws1, -1, -1, -1 }, // Not
+ { -1, -1, Nam, Nam }, // Ws1
+ { Ws2, Done, -1, -1 }, // Nam
+ { -1, Done, ExtID, ExtID }, // Ws2
+ { Ws3, Done, -1, -1 }, // ExtID
+ { Ws3, Done, -1, -1 }, // ExtIDR
+ { -1, Done, -1, -1 } // Ws3
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseNotationDecl (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case ExtID:
+ // call the handler
+ if (dtdHnd) {
+ if (!dtdHnd->notationDecl(name(), publicId, systemId)) {
+ reportParseError(dtdHnd->errorString());
+ return false;
+ }
+ }
+ state = ExtIDR;
+ break;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else if (c == QLatin1Char('N')) {
+ input = InpN;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Not:
+ parseString_s = QLatin1String("NOTATION");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ break;
+ case Ws1:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ break;
+ case Nam:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ break;
+ case Ws2:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ break;
+ case ExtID:
+ case ExtIDR:
+ parseExternalID_allowPublicID = true;
+ if (!parseExternalID()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ break;
+ case Ws3:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+ return false;
+ }
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse choice [49] or seq [50].
+
+ Precondition: the beginning '('S? is already read and the head
+ stands on the first non-whitespace character after it.
+*/
+bool QXmlSimpleReaderPrivate::parseChoiceSeq()
+{
+ const signed char Init = 0;
+ const signed char Ws1 = 1; // eat whitespace
+ const signed char CoS = 2; // choice or set
+ const signed char Ws2 = 3; // eat whitespace
+ const signed char More = 4; // more cp to read
+ const signed char Name = 5; // read name
+ const signed char Done = 6; //
+
+ const signed char InpWs = 0; // S
+ const signed char InpOp = 1; // (
+ const signed char InpCp = 2; //)
+ const signed char InpQm = 3; // ?
+ const signed char InpAst = 4; // *
+ const signed char InpPlus = 5; // +
+ const signed char InpPipe = 6; // |
+ const signed char InpComm = 7; // ,
+ const signed char InpUnknown = 8;
+
+ static const signed char table[6][9] = {
+ /* InpWs InpOp InpCp InpQm InpAst InpPlus InpPipe InpComm InpUnknown */
+ { -1, Ws1, -1, -1, -1, -1, -1, -1, Name }, // Init
+ { -1, CoS, -1, -1, -1, -1, -1, -1, CoS }, // Ws1
+ { Ws2, -1, Done, Ws2, Ws2, Ws2, More, More, -1 }, // CS
+ { -1, -1, Done, -1, -1, -1, More, More, -1 }, // Ws2
+ { -1, Ws1, -1, -1, -1, -1, -1, -1, Name }, // More (same as Init)
+ { Ws2, -1, Done, Ws2, Ws2, Ws2, More, More, -1 } // Name (same as CS)
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseChoiceSeq (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('(')) {
+ input = InpOp;
+ } else if (c == QLatin1Char(')')) {
+ input = InpCp;
+ } else if (c == QLatin1Char('?')) {
+ input = InpQm;
+ } else if (c == QLatin1Char('*')) {
+ input = InpAst;
+ } else if (c == QLatin1Char('+')) {
+ input = InpPlus;
+ } else if (c == QLatin1Char('|')) {
+ input = InpPipe;
+ } else if (c == QLatin1Char(',')) {
+ input = InpComm;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Ws1:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+ return false;
+ }
+ break;
+ case CoS:
+ if (!parseChoiceSeq()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+ return false;
+ }
+ break;
+ case Ws2:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+ return false;
+ }
+ break;
+ case More:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+ return false;
+ }
+ break;
+ case Name:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+ return false;
+ }
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a EntityDecl [70].
+
+ Precondition: the beginning '<!E' is already read and the head
+ stand on the 'N' of '<!ENTITY'
+*/
+bool QXmlSimpleReaderPrivate::parseEntityDecl()
+{
+ const signed char Init = 0;
+ const signed char Ent = 1; // parse "ENTITY"
+ const signed char Ws1 = 2; // white space read
+ const signed char Name = 3; // parse name
+ const signed char Ws2 = 4; // white space read
+ const signed char EValue = 5; // parse entity value
+ const signed char EValueR = 6; // same as EValue, but already reported
+ const signed char ExtID = 7; // parse ExternalID
+ const signed char Ws3 = 8; // white space read
+ const signed char Ndata = 9; // parse "NDATA"
+ const signed char Ws4 = 10; // white space read
+ const signed char NNam = 11; // parse name
+ const signed char NNamR = 12; // same as NNam, but already reported
+ const signed char PEDec = 13; // parse PEDecl
+ const signed char Ws6 = 14; // white space read
+ const signed char PENam = 15; // parse name
+ const signed char Ws7 = 16; // white space read
+ const signed char PEVal = 17; // parse entity value
+ const signed char PEValR = 18; // same as PEVal, but already reported
+ const signed char PEEID = 19; // parse ExternalID
+ const signed char PEEIDR = 20; // same as PEEID, but already reported
+ const signed char WsE = 21; // white space read
+ const signed char Done = 22;
+ const signed char EDDone = 23; // done, but also report an external, unparsed entity decl
+
+ const signed char InpWs = 0; // white space
+ const signed char InpPer = 1; // %
+ const signed char InpQuot = 2; // " or '
+ const signed char InpGt = 3; // >
+ const signed char InpN = 4; // N
+ const signed char InpUnknown = 5;
+
+ static const signed char table[22][6] = {
+ /* InpWs InpPer InpQuot InpGt InpN InpUnknown */
+ { -1, -1, -1, -1, Ent, -1 }, // Init
+ { Ws1, -1, -1, -1, -1, -1 }, // Ent
+ { -1, PEDec, -1, -1, Name, Name }, // Ws1
+ { Ws2, -1, -1, -1, -1, -1 }, // Name
+ { -1, -1, EValue, -1, -1, ExtID }, // Ws2
+ { WsE, -1, -1, Done, -1, -1 }, // EValue
+ { WsE, -1, -1, Done, -1, -1 }, // EValueR
+ { Ws3, -1, -1, EDDone,-1, -1 }, // ExtID
+ { -1, -1, -1, EDDone,Ndata, -1 }, // Ws3
+ { Ws4, -1, -1, -1, -1, -1 }, // Ndata
+ { -1, -1, -1, -1, NNam, NNam }, // Ws4
+ { WsE, -1, -1, Done, -1, -1 }, // NNam
+ { WsE, -1, -1, Done, -1, -1 }, // NNamR
+ { Ws6, -1, -1, -1, -1, -1 }, // PEDec
+ { -1, -1, -1, -1, PENam, PENam }, // Ws6
+ { Ws7, -1, -1, -1, -1, -1 }, // PENam
+ { -1, -1, PEVal, -1, -1, PEEID }, // Ws7
+ { WsE, -1, -1, Done, -1, -1 }, // PEVal
+ { WsE, -1, -1, Done, -1, -1 }, // PEValR
+ { WsE, -1, -1, Done, -1, -1 }, // PEEID
+ { WsE, -1, -1, Done, -1, -1 }, // PEEIDR
+ { -1, -1, -1, Done, -1, -1 } // WsE
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseEntityDecl (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case EValue:
+ if ( !entityExist(name())) {
+ entities.insert(name(), string());
+ if (declHnd) {
+ if (!declHnd->internalEntityDecl(name(), string())) {
+ reportParseError(declHnd->errorString());
+ return false;
+ }
+ }
+ }
+ state = EValueR;
+ break;
+ case NNam:
+ if ( !entityExist(name())) {
+ externEntities.insert(name(), QXmlSimpleReaderPrivate::ExternEntity(publicId, systemId, ref()));
+ if (dtdHnd) {
+ if (!dtdHnd->unparsedEntityDecl(name(), publicId, systemId, ref())) {
+ reportParseError(declHnd->errorString());
+ return false;
+ }
+ }
+ }
+ state = NNamR;
+ break;
+ case PEVal:
+ if ( !entityExist(name())) {
+ parameterEntities.insert(name(), string());
+ if (declHnd) {
+ if (!declHnd->internalEntityDecl(QString::fromLatin1("%")+name(), string())) {
+ reportParseError(declHnd->errorString());
+ return false;
+ }
+ }
+ }
+ state = PEValR;
+ break;
+ case PEEID:
+ if ( !entityExist(name())) {
+ externParameterEntities.insert(name(), QXmlSimpleReaderPrivate::ExternParameterEntity(publicId, systemId));
+ if (declHnd) {
+ if (!declHnd->externalEntityDecl(QString::fromLatin1("%")+name(), publicId, systemId)) {
+ reportParseError(declHnd->errorString());
+ return false;
+ }
+ }
+ }
+ state = PEEIDR;
+ break;
+ case EDDone:
+ if ( !entityExist(name())) {
+ externEntities.insert(name(), QXmlSimpleReaderPrivate::ExternEntity(publicId, systemId, QString()));
+ if (declHnd) {
+ if (!declHnd->externalEntityDecl(name(), publicId, systemId)) {
+ reportParseError(declHnd->errorString());
+ return false;
+ }
+ }
+ }
+ return true;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ if (is_S(c)) {
+ input = InpWs;
+ } else if (c == QLatin1Char('%')) {
+ input = InpPer;
+ } else if (c == QLatin1Char('"') || c == QLatin1Char('\'')) {
+ input = InpQuot;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else if (c == QLatin1Char('N')) {
+ input = InpN;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Ent:
+ parseString_s = QLatin1String("NTITY");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case Ws1:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case Name:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case Ws2:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case EValue:
+ case EValueR:
+ if (!parseEntityValue()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case ExtID:
+ parseExternalID_allowPublicID = false;
+ if (!parseExternalID()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case Ws3:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case Ndata:
+ parseString_s = QLatin1String("NDATA");
+ if (!parseString()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case Ws4:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case NNam:
+ case NNamR:
+ parseName_useRef = true;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case PEDec:
+ next();
+ break;
+ case Ws6:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case PENam:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case Ws7:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case PEVal:
+ case PEValR:
+ if (!parseEntityValue()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case PEEID:
+ case PEEIDR:
+ parseExternalID_allowPublicID = false;
+ if (!parseExternalID()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case WsE:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+ return false;
+ }
+ break;
+ case EDDone:
+ next();
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a EntityValue [9]
+*/
+bool QXmlSimpleReaderPrivate::parseEntityValue()
+{
+ const signed char Init = 0;
+ const signed char Dq = 1; // EntityValue is double quoted
+ const signed char DqC = 2; // signed character
+ const signed char DqPER = 3; // PERefence
+ const signed char DqRef = 4; // Reference
+ const signed char Sq = 5; // EntityValue is double quoted
+ const signed char SqC = 6; // signed character
+ const signed char SqPER = 7; // PERefence
+ const signed char SqRef = 8; // Reference
+ const signed char Done = 9;
+
+ const signed char InpDq = 0; // "
+ const signed char InpSq = 1; // '
+ const signed char InpAmp = 2; // &
+ const signed char InpPer = 3; // %
+ const signed char InpUnknown = 4;
+
+ static const signed char table[9][5] = {
+ /* InpDq InpSq InpAmp InpPer InpUnknown */
+ { Dq, Sq, -1, -1, -1 }, // Init
+ { Done, DqC, DqRef, DqPER, DqC }, // Dq
+ { Done, DqC, DqRef, DqPER, DqC }, // DqC
+ { Done, DqC, DqRef, DqPER, DqC }, // DqPER
+ { Done, DqC, DqRef, DqPER, DqC }, // DqRef
+ { SqC, Done, SqRef, SqPER, SqC }, // Sq
+ { SqC, Done, SqRef, SqPER, SqC }, // SqC
+ { SqC, Done, SqRef, SqPER, SqC }, // SqPER
+ { SqC, Done, SqRef, SqPER, SqC } // SqRef
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseEntityValue (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+ return false;
+ }
+ if (c == QLatin1Char('"')) {
+ input = InpDq;
+ } else if (c == QLatin1Char('\'')) {
+ input = InpSq;
+ } else if (c == QLatin1Char('&')) {
+ input = InpAmp;
+ } else if (c == QLatin1Char('%')) {
+ input = InpPer;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Dq:
+ case Sq:
+ stringClear();
+ next();
+ break;
+ case DqC:
+ case SqC:
+ stringAddC();
+ next();
+ break;
+ case DqPER:
+ case SqPER:
+ parsePEReference_context = InEntityValue;
+ if (!parsePEReference()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+ return false;
+ }
+ break;
+ case DqRef:
+ case SqRef:
+ parseReference_context = InEntityValue;
+ if (!parseReference()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+ return false;
+ }
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a comment [15].
+
+ Precondition: the beginning '<!' of the comment is already read and the head
+ stands on the first '-' of '<!--'.
+
+ If this funktion was successful, the head-position is on the first
+ character after the comment.
+*/
+bool QXmlSimpleReaderPrivate::parseComment()
+{
+ const signed char Init = 0;
+ const signed char Dash1 = 1; // the first dash was read
+ const signed char Dash2 = 2; // the second dash was read
+ const signed char Com = 3; // read comment
+ const signed char Com2 = 4; // read comment (help state)
+ const signed char ComE = 5; // finished reading comment
+ const signed char Done = 6;
+
+ const signed char InpDash = 0; // -
+ const signed char InpGt = 1; // >
+ const signed char InpUnknown = 2;
+
+ static const signed char table[6][3] = {
+ /* InpDash InpGt InpUnknown */
+ { Dash1, -1, -1 }, // Init
+ { Dash2, -1, -1 }, // Dash1
+ { Com2, Com, Com }, // Dash2
+ { Com2, Com, Com }, // Com
+ { ComE, Com, Com }, // Com2
+ { -1, Done, -1 } // ComE
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseComment (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseComment, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Dash2:
+ stringClear();
+ break;
+ case Com2:
+ // if next character is not a dash than don't skip it
+ if (!atEnd() && c != QLatin1Char('-'))
+ stringAddC(QLatin1Char('-'));
+ break;
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGCOMMENT));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseComment, state);
+ return false;
+ }
+ if (c == QLatin1Char('-')) {
+ input = InpDash;
+ } else if (c == QLatin1Char('>')) {
+ input = InpGt;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case Dash1:
+ next();
+ break;
+ case Dash2:
+ next();
+ break;
+ case Com:
+ stringAddC();
+ next();
+ break;
+ case Com2:
+ next();
+ break;
+ case ComE:
+ next();
+ break;
+ case Done:
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse an Attribute [41].
+
+ Precondition: the head stands on the first character of the name
+ of the attribute (i.e. all whitespaces are already parsed).
+
+ The head stand on the next character after the end quotes. The
+ variable name contains the name of the attribute and the variable
+ string contains the value of the attribute.
+*/
+bool QXmlSimpleReaderPrivate::parseAttribute()
+{
+ const int Init = 0;
+ const int PName = 1; // parse name
+ const int Ws = 2; // eat ws
+ const int Eq = 3; // the '=' was read
+ const int Quotes = 4; // " or ' were read
+
+ const int InpNameBe = 0;
+ const int InpEq = 1; // =
+ const int InpDq = 2; // "
+ const int InpSq = 3; // '
+ const int InpUnknown = 4;
+
+ static const int table[4][5] = {
+ /* InpNameBe InpEq InpDq InpSq InpUnknown */
+ { PName, -1, -1, -1, -1 }, // Init
+ { -1, Eq, -1, -1, Ws }, // PName
+ { -1, Eq, -1, -1, -1 }, // Ws
+ { -1, -1, Quotes, Quotes, -1 } // Eq
+ };
+ int state;
+ int input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseAttribute (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Quotes:
+ // Done
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseAttribute, state);
+ return false;
+ }
+ if (determineNameChar(c) == NameBeginning) {
+ input = InpNameBe;
+ } else if (c == QLatin1Char('=')) {
+ input = InpEq;
+ } else if (c == QLatin1Char('"')) {
+ input = InpDq;
+ } else if (c == QLatin1Char('\'')) {
+ input = InpSq;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case PName:
+ parseName_useRef = false;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+ return false;
+ }
+ break;
+ case Ws:
+ if (!eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+ return false;
+ }
+ break;
+ case Eq:
+ if (!next_eat_ws()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+ return false;
+ }
+ break;
+ case Quotes:
+ if (!parseAttValue()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+ return false;
+ }
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a Name [5] and store the name in name or ref (if useRef is true).
+*/
+bool QXmlSimpleReaderPrivate::parseName()
+{
+ const int Init = 0;
+ const int Name1 = 1; // parse first character of the name
+ const int Name = 2; // parse name
+ const int Done = 3;
+
+ static const int table[3][3] = {
+ /* InpNameBe InpNameCh InpUnknown */
+ { Name1, -1, -1 }, // Init
+ { Name, Name, Done }, // Name1
+ { Name, Name, Done } // Name
+ };
+ int state;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseName (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseName, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseName, state);
+ return false;
+ }
+
+ // we can safely do the (int) cast thanks to the Q_ASSERTs earlier in this function
+ state = table[state][(int)fastDetermineNameChar(c)];
+
+ switch (state) {
+ case Name1:
+ if (parseName_useRef) {
+ refClear();
+ refAddC();
+ } else {
+ nameClear();
+ nameAddC();
+ }
+ next();
+ break;
+ case Name:
+ if (parseName_useRef) {
+ refAddC();
+ } else {
+ nameAddC();
+ }
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a Nmtoken [7] and store the name in name.
+*/
+bool QXmlSimpleReaderPrivate::parseNmtoken()
+{
+ const signed char Init = 0;
+ const signed char NameF = 1;
+ const signed char Name = 2;
+ const signed char Done = 3;
+
+ const signed char InpNameCh = 0; // NameChar without InpNameBe
+ const signed char InpUnknown = 1;
+
+ static const signed char table[3][2] = {
+ /* InpNameCh InpUnknown */
+ { NameF, -1 }, // Init
+ { Name, Done }, // NameF
+ { Name, Done } // Name
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseNmtoken (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseNmtoken, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case Done:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseNmtoken, state);
+ return false;
+ }
+ if (determineNameChar(c) == NotName) {
+ input = InpUnknown;
+ } else {
+ input = InpNameCh;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case NameF:
+ nameClear();
+ nameAddC();
+ next();
+ break;
+ case Name:
+ nameAddC();
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Parse a Reference [67].
+
+ parseReference_charDataRead is set to true if the reference must not be
+ parsed. The character(s) which the reference mapped to are appended to
+ string. The head stands on the first character after the reference.
+
+ parseReference_charDataRead is set to false if the reference must be parsed.
+ The charachter(s) which the reference mapped to are inserted at the reference
+ position. The head stands on the first character of the replacement).
+*/
+bool QXmlSimpleReaderPrivate::parseReference()
+{
+ // temporary variables (only used in very local context, so they don't
+ // interfere with incremental parsing)
+ uint tmp;
+ bool ok;
+
+ const signed char Init = 0;
+ const signed char SRef = 1; // start of a reference
+ const signed char ChRef = 2; // parse CharRef
+ const signed char ChDec = 3; // parse CharRef decimal
+ const signed char ChHexS = 4; // start CharRef hexadecimal
+ const signed char ChHex = 5; // parse CharRef hexadecimal
+ const signed char Name = 6; // parse name
+ const signed char DoneD = 7; // done CharRef decimal
+ const signed char DoneH = 8; // done CharRef hexadecimal
+ const signed char DoneN = 9; // done EntityRef
+
+ const signed char InpAmp = 0; // &
+ const signed char InpSemi = 1; // ;
+ const signed char InpHash = 2; // #
+ const signed char InpX = 3; // x
+ const signed char InpNum = 4; // 0-9
+ const signed char InpHex = 5; // a-f A-F
+ const signed char InpUnknown = 6;
+
+ static const signed char table[8][7] = {
+ /* InpAmp InpSemi InpHash InpX InpNum InpHex InpUnknown */
+ { SRef, -1, -1, -1, -1, -1, -1 }, // Init
+ { -1, -1, ChRef, Name, Name, Name, Name }, // SRef
+ { -1, -1, -1, ChHexS, ChDec, -1, -1 }, // ChRef
+ { -1, DoneD, -1, -1, ChDec, -1, -1 }, // ChDec
+ { -1, -1, -1, -1, ChHex, ChHex, -1 }, // ChHexS
+ { -1, DoneH, -1, -1, ChHex, ChHex, -1 }, // ChHex
+ { -1, DoneN, -1, -1, -1, -1, -1 } // Name
+ };
+ signed char state;
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ parseReference_charDataRead = false;
+ state = Init;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseReference (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseReference, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ switch (state) {
+ case DoneD:
+ return true;
+ case DoneH:
+ return true;
+ case DoneN:
+ return true;
+ case -1:
+ // Error
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
+ return false;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseReference, state);
+ return false;
+ }
+ if (c.row()) {
+ input = InpUnknown;
+ } else if (c.cell() == '&') {
+ input = InpAmp;
+ } else if (c.cell() == ';') {
+ input = InpSemi;
+ } else if (c.cell() == '#') {
+ input = InpHash;
+ } else if (c.cell() == 'x') {
+ input = InpX;
+ } else if ('0' <= c.cell() && c.cell() <= '9') {
+ input = InpNum;
+ } else if ('a' <= c.cell() && c.cell() <= 'f') {
+ input = InpHex;
+ } else if ('A' <= c.cell() && c.cell() <= 'F') {
+ input = InpHex;
+ } else {
+ input = InpUnknown;
+ }
+ state = table[state][input];
+
+ switch (state) {
+ case SRef:
+ refClear();
+ next();
+ break;
+ case ChRef:
+ next();
+ break;
+ case ChDec:
+ refAddC();
+ next();
+ break;
+ case ChHexS:
+ next();
+ break;
+ case ChHex:
+ refAddC();
+ next();
+ break;
+ case Name:
+ // read the name into the ref
+ parseName_useRef = true;
+ if (!parseName()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseReference, state);
+ return false;
+ }
+ break;
+ case DoneD:
+ tmp = ref().toUInt(&ok, 10);
+ if (ok) {
+ stringAddC(QChar(tmp));
+ } else {
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
+ return false;
+ }
+ parseReference_charDataRead = true;
+ next();
+ break;
+ case DoneH:
+ tmp = ref().toUInt(&ok, 16);
+ if (ok) {
+ stringAddC(QChar(tmp));
+ } else {
+ reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
+ return false;
+ }
+ parseReference_charDataRead = true;
+ next();
+ break;
+ case DoneN:
+ if (!processReference())
+ return false;
+ next();
+ break;
+ }
+ }
+ return false;
+}
+
+/*
+ Helper function for parseReference()
+*/
+bool QXmlSimpleReaderPrivate::processReference()
+{
+ QString reference = ref();
+ if (reference == QLatin1String("amp")) {
+ if (parseReference_context == InEntityValue) {
+ // Bypassed
+ stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('a')); stringAddC(QLatin1Char('m')); stringAddC(QLatin1Char('p')); stringAddC(QLatin1Char(';'));
+ } else {
+ // Included or Included in literal
+ stringAddC(QLatin1Char('&'));
+ }
+ parseReference_charDataRead = true;
+ } else if (reference == QLatin1String("lt")) {
+ if (parseReference_context == InEntityValue) {
+ // Bypassed
+ stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('l')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
+ } else {
+ // Included or Included in literal
+ stringAddC(QLatin1Char('<'));
+ }
+ parseReference_charDataRead = true;
+ } else if (reference == QLatin1String("gt")) {
+ if (parseReference_context == InEntityValue) {
+ // Bypassed
+ stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('g')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
+ } else {
+ // Included or Included in literal
+ stringAddC(QLatin1Char('>'));
+ }
+ parseReference_charDataRead = true;
+ } else if (reference == QLatin1String("apos")) {
+ if (parseReference_context == InEntityValue) {
+ // Bypassed
+ stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('a')); stringAddC(QLatin1Char('p')); stringAddC(QLatin1Char('o')); stringAddC(QLatin1Char('s')); stringAddC(QLatin1Char(';'));
+ } else {
+ // Included or Included in literal
+ stringAddC(QLatin1Char('\''));
+ }
+ parseReference_charDataRead = true;
+ } else if (reference == QLatin1String("quot")) {
+ if (parseReference_context == InEntityValue) {
+ // Bypassed
+ stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('q')); stringAddC(QLatin1Char('u')); stringAddC(QLatin1Char('o')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
+ } else {
+ // Included or Included in literal
+ stringAddC(QLatin1Char('"'));
+ }
+ parseReference_charDataRead = true;
+ } else {
+ QMap<QString,QString>::Iterator it;
+ it = entities.find(reference);
+ if (it != entities.end()) {
+ // "Internal General"
+ switch (parseReference_context) {
+ case InContent:
+ // Included
+ if (!insertXmlRef(*it, reference, false))
+ return false;
+ parseReference_charDataRead = false;
+ break;
+ case InAttributeValue:
+ // Included in literal
+ if (!insertXmlRef(*it, reference, true))
+ return false;
+ parseReference_charDataRead = false;
+ break;
+ case InEntityValue:
+ {
+ // Bypassed
+ stringAddC(QLatin1Char('&'));
+ for (int i=0; i<(int)reference.length(); i++) {
+ stringAddC(reference[i]);
+ }
+ stringAddC(QLatin1Char(';'));
+ parseReference_charDataRead = true;
+ }
+ break;
+ case InDTD:
+ // Forbidden
+ parseReference_charDataRead = false;
+ reportParseError(QLatin1String(XMLERR_INTERNALGENERALENTITYINDTD));
+ return false;
+ }
+ } else {
+ QMap<QString,QXmlSimpleReaderPrivate::ExternEntity>::Iterator itExtern;
+ itExtern = externEntities.find(reference);
+ if (itExtern == externEntities.end()) {
+ // entity not declared
+ // ### check this case for conformance
+ if (parseReference_context == InEntityValue) {
+ // Bypassed
+ stringAddC(QLatin1Char('&'));
+ for (int i=0; i<(int)reference.length(); i++) {
+ stringAddC(reference[i]);
+ }
+ stringAddC(QLatin1Char(';'));
+ parseReference_charDataRead = true;
+ } else {
+ // if we have some char data read, report it now
+ if (parseReference_context == InContent) {
+ if (contentCharDataRead) {
+ if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+ if (contentHnd != 0 && !contentHnd->characters(string())) {
+ reportParseError(contentHnd->errorString());
+ return false;
+ }
+ }
+ stringClear();
+ contentCharDataRead = false;
+ }
+ }
+
+ if (contentHnd) {
+ qt_xml_skipped_entity_in_content = parseReference_context == InContent;
+ if (!contentHnd->skippedEntity(reference)) {
+ qt_xml_skipped_entity_in_content = false;
+ reportParseError(contentHnd->errorString());
+ return false; // error
+ }
+ qt_xml_skipped_entity_in_content = false;
+ }
+ }
+ } else if ((*itExtern).notation.isNull()) {
+ // "External Parsed General"
+ switch (parseReference_context) {
+ case InContent:
+ {
+ // Included if validating
+ bool skipIt = true;
+ if (entityRes) {
+ QXmlInputSource *ret = 0;
+ if (!entityRes->resolveEntity((*itExtern).publicId, (*itExtern).systemId, ret)) {
+ delete ret;
+ reportParseError(entityRes->errorString());
+ return false;
+ }
+ if (ret) {
+ QString xmlRefString = ret->data();
+ delete ret;
+ if (!stripTextDecl(xmlRefString)) {
+ reportParseError(QLatin1String(XMLERR_ERRORINTEXTDECL));
+ return false;
+ }
+ if (!insertXmlRef(xmlRefString, reference, false))
+ return false;
+ skipIt = false;
+ }
+ }
+ if (skipIt && contentHnd) {
+ qt_xml_skipped_entity_in_content = true;
+ if (!contentHnd->skippedEntity(reference)) {
+ qt_xml_skipped_entity_in_content = false;
+ reportParseError(contentHnd->errorString());
+ return false; // error
+ }
+ qt_xml_skipped_entity_in_content = false;
+ }
+ parseReference_charDataRead = false;
+ } break;
+ case InAttributeValue:
+ // Forbidden
+ parseReference_charDataRead = false;
+ reportParseError(QLatin1String(XMLERR_EXTERNALGENERALENTITYINAV));
+ return false;
+ case InEntityValue:
+ {
+ // Bypassed
+ stringAddC(QLatin1Char('&'));
+ for (int i=0; i<(int)reference.length(); i++) {
+ stringAddC(reference[i]);
+ }
+ stringAddC(QLatin1Char(';'));
+ parseReference_charDataRead = true;
+ }
+ break;
+ case InDTD:
+ // Forbidden
+ parseReference_charDataRead = false;
+ reportParseError(QLatin1String(XMLERR_EXTERNALGENERALENTITYINDTD));
+ return false;
+ }
+ } else {
+ // "Unparsed"
+ // ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway)
+ // Forbidden
+ parseReference_charDataRead = false;
+ reportParseError(QLatin1String(XMLERR_UNPARSEDENTITYREFERENCE));
+ return false; // error
+ }
+ }
+ }
+ return true; // no error
+}
+
+
+/*
+ Parses over a simple string.
+
+ After the string was successfully parsed, the head is on the first
+ character after the string.
+*/
+bool QXmlSimpleReaderPrivate::parseString()
+{
+ const signed char InpCharExpected = 0; // the character that was expected
+ const signed char InpUnknown = 1;
+
+ signed char state; // state in this function is the position in the string s
+ signed char input;
+
+ if (parseStack==0 || parseStack->isEmpty()) {
+ Done = parseString_s.length();
+ state = 0;
+ } else {
+ state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: parseString (cont) in state %d", state);
+#endif
+ if (!parseStack->isEmpty()) {
+ ParseFunction function = parseStack->top().function;
+ if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+ parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+ qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+ }
+ if (!(this->*function)()) {
+ parseFailed(&QXmlSimpleReaderPrivate::parseString, state);
+ return false;
+ }
+ }
+ }
+
+ for (;;) {
+ if (state == Done) {
+ return true;
+ }
+
+ if (atEnd()) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::parseString, state);
+ return false;
+ }
+ if (c == parseString_s[(int)state]) {
+ input = InpCharExpected;
+ } else {
+ input = InpUnknown;
+ }
+ if (input == InpCharExpected) {
+ state++;
+ } else {
+ // Error
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+ return false;
+ }
+
+ next();
+ }
+ return false;
+}
+
+/*
+ This private function inserts and reports an entity substitution. The
+ substituted string is \a data and the name of the entity reference is \a
+ name. If \a inLiteral is true, the entity is IncludedInLiteral (i.e., " and '
+ must be quoted. Otherwise they are not quoted.
+
+ This function returns false on error.
+*/
+bool QXmlSimpleReaderPrivate::insertXmlRef(const QString &data, const QString &name, bool inLiteral)
+{
+ if (inLiteral) {
+ QString tmp = data;
+ xmlRefStack.push(XmlRef(name, tmp.replace(QLatin1String("\""),
+ QLatin1String("&quot;")).replace(QLatin1String("'"), QLatin1String("&apos;"))));
+ } else {
+ xmlRefStack.push(XmlRef(name, data));
+ }
+ int n = qMax(parameterEntities.count(), entities.count());
+ if (xmlRefStack.count() > n+1) {
+ // recursive entities
+ reportParseError(QLatin1String(XMLERR_RECURSIVEENTITIES));
+ return false;
+ }
+ if (reportEntities && lexicalHnd) {
+ if (!lexicalHnd->startEntity(name)) {
+ reportParseError(lexicalHnd->errorString());
+ return false;
+ }
+ }
+ return true;
+}
+
+/*
+ This private function moves the cursor to the next character.
+*/
+void QXmlSimpleReaderPrivate::next()
+{
+ int count = xmlRefStack.size();
+ while (count != 0) {
+ if (xmlRefStack.top().isEmpty()) {
+ xmlRefStack.pop_back();
+ count--;
+ } else {
+ c = xmlRefStack.top().next();
+ return;
+ }
+ }
+
+ // the following could be written nicer, but since it is a time-critical
+ // function, rather optimize for speed
+ ushort uc = c.unicode();
+ c = inputSource->next();
+ // If we are not incremental parsing, we just skip over EndOfData chars to give the
+ // parser an uninterrupted stream of document chars.
+ if (c == QXmlInputSource::EndOfData && parseStack == 0)
+ c = inputSource->next();
+ if (uc == '\n') {
+ lineNr++;
+ columnNr = -1;
+ } else if (uc == '\r') {
+ if (c != QLatin1Char('\n')) {
+ lineNr++;
+ columnNr = -1;
+ }
+ }
+ ++columnNr;
+}
+
+/*
+ This private function moves the cursor to the next non-whitespace character.
+ This function does not move the cursor if the actual cursor position is a
+ non-whitespace charcter.
+
+ Returns false when you use incremental parsing and this function reaches EOF
+ with reading only whitespace characters. In this case it also poplulates the
+ parseStack with useful information. In all other cases, this function returns
+ true.
+*/
+bool QXmlSimpleReaderPrivate::eat_ws()
+{
+ while (!atEnd()) {
+ if (!is_S(c)) {
+ return true;
+ }
+ next();
+ }
+ if (parseStack != 0) {
+ unexpectedEof(&QXmlSimpleReaderPrivate::eat_ws, 0);
+ return false;
+ }
+ return true;
+}
+
+bool QXmlSimpleReaderPrivate::next_eat_ws()
+{
+ next();
+ return eat_ws();
+}
+
+
+/*
+ This private function initializes the reader. \a i is the input source to
+ read the data from.
+*/
+void QXmlSimpleReaderPrivate::init(const QXmlInputSource *i)
+{
+ lineNr = 0;
+ columnNr = -1;
+ inputSource = const_cast<QXmlInputSource *>(i);
+ initData();
+
+ externParameterEntities.clear();
+ parameterEntities.clear();
+ externEntities.clear();
+ entities.clear();
+
+ tags.clear();
+
+ doctype.clear();
+ xmlVersion.clear();
+ encoding.clear();
+ standalone = QXmlSimpleReaderPrivate::Unknown;
+ error.clear();
+}
+
+/*
+ This private function initializes the XML data related variables. Especially,
+ it reads the data from the input source.
+*/
+void QXmlSimpleReaderPrivate::initData()
+{
+ c = QXmlInputSource::EndOfData;
+ xmlRefStack.clear();
+ next();
+}
+
+/*
+ Returns true if a entity with the name \a e exists,
+ otherwise returns false.
+*/
+bool QXmlSimpleReaderPrivate::entityExist(const QString& e) const
+{
+ if ( parameterEntities.find(e) == parameterEntities.end() &&
+ externParameterEntities.find(e) == externParameterEntities.end() &&
+ externEntities.find(e) == externEntities.end() &&
+ entities.find(e) == entities.end()) {
+ return false;
+ } else {
+ return true;
+ }
+}
+
+void QXmlSimpleReaderPrivate::reportParseError(const QString& error)
+{
+ this->error = error;
+ if (errorHnd) {
+ if (this->error.isNull()) {
+ const QXmlParseException ex(QLatin1String(XMLERR_OK), columnNr+1, lineNr+1,
+ thisPublicId, thisSystemId);
+ errorHnd->fatalError(ex);
+ } else {
+ const QXmlParseException ex(this->error, columnNr+1, lineNr+1,
+ thisPublicId, thisSystemId);
+ errorHnd->fatalError(ex);
+ }
+ }
+}
+
+/*
+ This private function is called when a parsing function encounters an
+ unexpected EOF. It decides what to do (depending on incremental parsing or
+ not). \a where is a pointer to the function where the error occurred and \a
+ state is the parsing state in this function.
+*/
+void QXmlSimpleReaderPrivate::unexpectedEof(ParseFunction where, int state)
+{
+ if (parseStack == 0) {
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
+ } else {
+ if (c == QXmlInputSource::EndOfDocument) {
+ reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
+ } else {
+ pushParseState(where, state);
+ }
+ }
+}
+
+/*
+ This private function is called when a parse...() function returned false. It
+ determines if there was an error or if incremental parsing simply went out of
+ data and does the right thing for the case. \a where is a pointer to the
+ function where the error occurred and \a state is the parsing state in this
+ function.
+*/
+void QXmlSimpleReaderPrivate::parseFailed(ParseFunction where, int state)
+{
+ if (parseStack!=0 && error.isNull()) {
+ pushParseState(where, state);
+ }
+}
+
+/*
+ This private function pushes the function pointer \a function and state \a
+ state to the parse stack. This is used when you are doing an incremental
+ parsing and reach the end of file too early.
+
+ Only call this function when d->parseStack!=0.
+*/
+void QXmlSimpleReaderPrivate::pushParseState(ParseFunction function, int state)
+{
+ QXmlSimpleReaderPrivate::ParseState ps;
+ ps.function = function;
+ ps.state = state;
+ parseStack->push(ps);
+}
+
+inline static void updateValue(QString &value, const QChar *array, int &arrayPos, int &valueLen)
+{
+ value.resize(valueLen + arrayPos);
+ memcpy(value.data() + valueLen, array, arrayPos * sizeof(QChar));
+ valueLen += arrayPos;
+ arrayPos = 0;
+}
+
+// use buffers instead of QString::operator+= when single characters are read
+const QString& QXmlSimpleReaderPrivate::string()
+{
+ updateValue(stringValue, stringArray, stringArrayPos, stringValueLen);
+ return stringValue;
+}
+const QString& QXmlSimpleReaderPrivate::name()
+{
+ updateValue(nameValue, nameArray, nameArrayPos, nameValueLen);
+ return nameValue;
+}
+const QString& QXmlSimpleReaderPrivate::ref()
+{
+ updateValue(refValue, refArray, refArrayPos, refValueLen);
+ return refValue;
+}
+
+void QXmlSimpleReaderPrivate::stringAddC(QChar ch)
+{
+ if (stringArrayPos == 256)
+ updateValue(stringValue, stringArray, stringArrayPos, stringValueLen);
+ stringArray[stringArrayPos++] = ch;
+}
+void QXmlSimpleReaderPrivate::nameAddC(QChar ch)
+{
+ if (nameArrayPos == 256)
+ updateValue(nameValue, nameArray, nameArrayPos, nameValueLen);
+ nameArray[nameArrayPos++] = ch;
+}
+void QXmlSimpleReaderPrivate::refAddC(QChar ch)
+{
+ if (refArrayPos == 256)
+ updateValue(refValue, refArray, refArrayPos, refValueLen);
+ refArray[refArrayPos++] = ch;
+}
+QT_END_NAMESPACE
diff --git a/src/xml/sax/qxml.h b/src/xml/sax/qxml.h
new file mode 100644
index 0000000..e0165d3
--- /dev/null
+++ b/src/xml/sax/qxml.h
@@ -0,0 +1,425 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QXML_H
+#define QXML_H
+
+#include <QtCore/qtextstream.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Xml)
+
+class QXmlNamespaceSupport;
+class QXmlAttributes;
+class QXmlContentHandler;
+class QXmlDefaultHandler;
+class QXmlDTDHandler;
+class QXmlEntityResolver;
+class QXmlErrorHandler;
+class QXmlLexicalHandler;
+class QXmlDeclHandler;
+class QXmlInputSource;
+class QXmlLocator;
+class QXmlNamespaceSupport;
+class QXmlParseException;
+
+class QXmlReader;
+class QXmlSimpleReader;
+
+class QXmlSimpleReaderPrivate;
+class QXmlNamespaceSupportPrivate;
+class QXmlAttributesPrivate;
+class QXmlInputSourcePrivate;
+class QXmlParseExceptionPrivate;
+class QXmlLocatorPrivate;
+class QXmlDefaultHandlerPrivate;
+
+
+//
+// SAX Namespace Support
+//
+
+class Q_XML_EXPORT QXmlNamespaceSupport
+{
+public:
+ QXmlNamespaceSupport();
+ ~QXmlNamespaceSupport();
+
+ void setPrefix(const QString&, const QString&);
+
+ QString prefix(const QString&) const;
+ QString uri(const QString&) const;
+ void splitName(const QString&, QString&, QString&) const;
+ void processName(const QString&, bool, QString&, QString&) const;
+ QStringList prefixes() const;
+ QStringList prefixes(const QString&) const;
+
+ void pushContext();
+ void popContext();
+ void reset();
+
+private:
+ QXmlNamespaceSupportPrivate *d;
+
+ friend class QXmlSimpleReaderPrivate;
+ Q_DISABLE_COPY(QXmlNamespaceSupport)
+};
+
+
+//
+// SAX Attributes
+//
+
+class Q_XML_EXPORT QXmlAttributes
+{
+public:
+ QXmlAttributes() {}
+ virtual ~QXmlAttributes() {}
+
+ int index(const QString& qName) const;
+ int index(const QLatin1String& qName) const;
+ int index(const QString& uri, const QString& localPart) const;
+ int length() const;
+ int count() const;
+ QString localName(int index) const;
+ QString qName(int index) const;
+ QString uri(int index) const;
+ QString type(int index) const;
+ QString type(const QString& qName) const;
+ QString type(const QString& uri, const QString& localName) const;
+ QString value(int index) const;
+ QString value(const QString& qName) const;
+ QString value(const QLatin1String& qName) const;
+ QString value(const QString& uri, const QString& localName) const;
+
+ void clear();
+ void append(const QString &qName, const QString &uri, const QString &localPart, const QString &value);
+
+private:
+ struct Attribute {
+ QString qname, uri, localname, value;
+ };
+ typedef QList<Attribute> AttributeList;
+ AttributeList attList;
+
+ QXmlAttributesPrivate *d;
+};
+
+//
+// SAX Input Source
+//
+
+class Q_XML_EXPORT QXmlInputSource
+{
+public:
+ QXmlInputSource();
+ QXmlInputSource(QIODevice *dev);
+ virtual ~QXmlInputSource();
+
+ virtual void setData(const QString& dat);
+ virtual void setData(const QByteArray& dat);
+ virtual void fetchData();
+ virtual QString data() const;
+ virtual QChar next();
+ virtual void reset();
+
+ static const ushort EndOfData;
+ static const ushort EndOfDocument;
+
+#ifdef QT3_SUPPORT
+ QT3_SUPPORT_CONSTRUCTOR QXmlInputSource(QFile& file);
+ QT3_SUPPORT_CONSTRUCTOR QXmlInputSource(QTextStream& stream);
+#endif
+
+protected:
+ virtual QString fromRawData(const QByteArray &data, bool beginning = false);
+
+private:
+ void init();
+ QXmlInputSourcePrivate *d;
+};
+
+//
+// SAX Exception Classes
+//
+
+class Q_XML_EXPORT QXmlParseException
+{
+public:
+ explicit QXmlParseException(const QString &name = QString(), int c = -1, int l = -1,
+ const QString &p = QString(), const QString &s = QString());
+ ~QXmlParseException();
+
+ int columnNumber() const;
+ int lineNumber() const;
+ QString publicId() const;
+ QString systemId() const;
+ QString message() const;
+
+private:
+ QXmlParseExceptionPrivate *d;
+};
+
+
+//
+// XML Reader
+//
+
+class Q_XML_EXPORT QXmlReader
+{
+public:
+ virtual ~QXmlReader() {}
+ virtual bool feature(const QString& name, bool *ok = 0) const = 0;
+ virtual void setFeature(const QString& name, bool value) = 0;
+ virtual bool hasFeature(const QString& name) const = 0;
+ virtual void* property(const QString& name, bool *ok = 0) const = 0;
+ virtual void setProperty(const QString& name, void* value) = 0;
+ virtual bool hasProperty(const QString& name) const = 0;
+ virtual void setEntityResolver(QXmlEntityResolver* handler) = 0;
+ virtual QXmlEntityResolver* entityResolver() const = 0;
+ virtual void setDTDHandler(QXmlDTDHandler* handler) = 0;
+ virtual QXmlDTDHandler* DTDHandler() const = 0;
+ virtual void setContentHandler(QXmlContentHandler* handler) = 0;
+ virtual QXmlContentHandler* contentHandler() const = 0;
+ virtual void setErrorHandler(QXmlErrorHandler* handler) = 0;
+ virtual QXmlErrorHandler* errorHandler() const = 0;
+ virtual void setLexicalHandler(QXmlLexicalHandler* handler) = 0;
+ virtual QXmlLexicalHandler* lexicalHandler() const = 0;
+ virtual void setDeclHandler(QXmlDeclHandler* handler) = 0;
+ virtual QXmlDeclHandler* declHandler() const = 0;
+ virtual bool parse(const QXmlInputSource& input) = 0;
+ virtual bool parse(const QXmlInputSource* input) = 0;
+};
+
+class Q_XML_EXPORT QXmlSimpleReader : public QXmlReader
+{
+public:
+ QXmlSimpleReader();
+ virtual ~QXmlSimpleReader();
+
+ bool feature(const QString& name, bool *ok = 0) const;
+ void setFeature(const QString& name, bool value);
+ bool hasFeature(const QString& name) const;
+
+ void* property(const QString& name, bool *ok = 0) const;
+ void setProperty(const QString& name, void* value);
+ bool hasProperty(const QString& name) const;
+
+ void setEntityResolver(QXmlEntityResolver* handler);
+ QXmlEntityResolver* entityResolver() const;
+ void setDTDHandler(QXmlDTDHandler* handler);
+ QXmlDTDHandler* DTDHandler() const;
+ void setContentHandler(QXmlContentHandler* handler);
+ QXmlContentHandler* contentHandler() const;
+ void setErrorHandler(QXmlErrorHandler* handler);
+ QXmlErrorHandler* errorHandler() const;
+ void setLexicalHandler(QXmlLexicalHandler* handler);
+ QXmlLexicalHandler* lexicalHandler() const;
+ void setDeclHandler(QXmlDeclHandler* handler);
+ QXmlDeclHandler* declHandler() const;
+
+ bool parse(const QXmlInputSource& input);
+ bool parse(const QXmlInputSource* input);
+ virtual bool parse(const QXmlInputSource* input, bool incremental);
+ virtual bool parseContinue();
+
+private:
+ Q_DISABLE_COPY(QXmlSimpleReader)
+ Q_DECLARE_PRIVATE(QXmlSimpleReader)
+ QXmlSimpleReaderPrivate* d_ptr;
+
+ friend class QXmlSimpleReaderLocator;
+};
+
+//
+// SAX Locator
+//
+
+class Q_XML_EXPORT QXmlLocator
+{
+public:
+ QXmlLocator();
+ virtual ~QXmlLocator();
+
+ virtual int columnNumber() const = 0;
+ virtual int lineNumber() const = 0;
+// QString getPublicId() const
+// QString getSystemId() const
+};
+
+//
+// SAX handler classes
+//
+
+class Q_XML_EXPORT QXmlContentHandler
+{
+public:
+ virtual ~QXmlContentHandler() {}
+ virtual void setDocumentLocator(QXmlLocator* locator) = 0;
+ virtual bool startDocument() = 0;
+ virtual bool endDocument() = 0;
+ virtual bool startPrefixMapping(const QString& prefix, const QString& uri) = 0;
+ virtual bool endPrefixMapping(const QString& prefix) = 0;
+ virtual bool startElement(const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts) = 0;
+ virtual bool endElement(const QString& namespaceURI, const QString& localName, const QString& qName) = 0;
+ virtual bool characters(const QString& ch) = 0;
+ virtual bool ignorableWhitespace(const QString& ch) = 0;
+ virtual bool processingInstruction(const QString& target, const QString& data) = 0;
+ virtual bool skippedEntity(const QString& name) = 0;
+ virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlErrorHandler
+{
+public:
+ virtual ~QXmlErrorHandler() {}
+ virtual bool warning(const QXmlParseException& exception) = 0;
+ virtual bool error(const QXmlParseException& exception) = 0;
+ virtual bool fatalError(const QXmlParseException& exception) = 0;
+ virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlDTDHandler
+{
+public:
+ virtual ~QXmlDTDHandler() {}
+ virtual bool notationDecl(const QString& name, const QString& publicId, const QString& systemId) = 0;
+ virtual bool unparsedEntityDecl(const QString& name, const QString& publicId, const QString& systemId, const QString& notationName) = 0;
+ virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlEntityResolver
+{
+public:
+ virtual ~QXmlEntityResolver() {}
+ virtual bool resolveEntity(const QString& publicId, const QString& systemId, QXmlInputSource*& ret) = 0;
+ virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlLexicalHandler
+{
+public:
+ virtual ~QXmlLexicalHandler() {}
+ virtual bool startDTD(const QString& name, const QString& publicId, const QString& systemId) = 0;
+ virtual bool endDTD() = 0;
+ virtual bool startEntity(const QString& name) = 0;
+ virtual bool endEntity(const QString& name) = 0;
+ virtual bool startCDATA() = 0;
+ virtual bool endCDATA() = 0;
+ virtual bool comment(const QString& ch) = 0;
+ virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlDeclHandler
+{
+public:
+ virtual ~QXmlDeclHandler() {}
+ virtual bool attributeDecl(const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value) = 0;
+ virtual bool internalEntityDecl(const QString& name, const QString& value) = 0;
+ virtual bool externalEntityDecl(const QString& name, const QString& publicId, const QString& systemId) = 0;
+ virtual QString errorString() const = 0;
+ // ### Qt 5: Conform to SAX by adding elementDecl
+};
+
+
+class Q_XML_EXPORT QXmlDefaultHandler : public QXmlContentHandler, public QXmlErrorHandler, public QXmlDTDHandler, public QXmlEntityResolver, public QXmlLexicalHandler, public QXmlDeclHandler
+{
+public:
+ QXmlDefaultHandler() { }
+ virtual ~QXmlDefaultHandler() { }
+
+ void setDocumentLocator(QXmlLocator* locator);
+ bool startDocument();
+ bool endDocument();
+ bool startPrefixMapping(const QString& prefix, const QString& uri);
+ bool endPrefixMapping(const QString& prefix);
+ bool startElement(const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts);
+ bool endElement(const QString& namespaceURI, const QString& localName, const QString& qName);
+ bool characters(const QString& ch);
+ bool ignorableWhitespace(const QString& ch);
+ bool processingInstruction(const QString& target, const QString& data);
+ bool skippedEntity(const QString& name);
+
+ bool warning(const QXmlParseException& exception);
+ bool error(const QXmlParseException& exception);
+ bool fatalError(const QXmlParseException& exception);
+
+ bool notationDecl(const QString& name, const QString& publicId, const QString& systemId);
+ bool unparsedEntityDecl(const QString& name, const QString& publicId, const QString& systemId, const QString& notationName);
+
+ bool resolveEntity(const QString& publicId, const QString& systemId, QXmlInputSource*& ret);
+
+ bool startDTD(const QString& name, const QString& publicId, const QString& systemId);
+ bool endDTD();
+ bool startEntity(const QString& name);
+ bool endEntity(const QString& name);
+ bool startCDATA();
+ bool endCDATA();
+ bool comment(const QString& ch);
+
+ bool attributeDecl(const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value);
+ bool internalEntityDecl(const QString& name, const QString& value);
+ bool externalEntityDecl(const QString& name, const QString& publicId, const QString& systemId);
+
+ QString errorString() const;
+
+private:
+ QXmlDefaultHandlerPrivate *d;
+ Q_DISABLE_COPY(QXmlDefaultHandler)
+};
+
+// inlines
+
+inline int QXmlAttributes::count() const
+{ return length(); }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QXML_H
diff --git a/src/xml/sax/sax.pri b/src/xml/sax/sax.pri
new file mode 100644
index 0000000..6591627
--- /dev/null
+++ b/src/xml/sax/sax.pri
@@ -0,0 +1,2 @@
+SOURCES += $$PWD/qxml.cpp
+HEADERS += $$PWD/qxml.h
diff --git a/src/xml/stream/qxmlstream.h b/src/xml/stream/qxmlstream.h
new file mode 100644
index 0000000..11fd148
--- /dev/null
+++ b/src/xml/stream/qxmlstream.h
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef OLD_QXMLSTREAM_H
+#define OLD_QXMLSTREAM_H
+
+#include <QtCore/qxmlstream.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Xml)
+
+#if 0
+// make syncqt generate forwarding headers for this file too
+#pragma qt_class(QXmlStreamAttribute)
+#pragma qt_class(QXmlStreamAttributes)
+#pragma qt_class(QXmlStreamEntityDeclaration)
+#pragma qt_class(QXmlStreamEntityDeclarations)
+#pragma qt_class(QXmlStreamEntityResolver)
+#pragma qt_class(QXmlStreamNamespaceDeclaration)
+#pragma qt_class(QXmlStreamNamespaceDeclarations)
+#pragma qt_class(QXmlStreamNotationDeclaration)
+#pragma qt_class(QXmlStreamNotationDeclarations)
+#pragma qt_class(QXmlStreamReader)
+#pragma qt_class(QXmlStreamStringRef)
+#pragma qt_class(QXmlStreamWriter)
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // OLD_QXMLSTREAM_H
diff --git a/src/xml/stream/stream.pri b/src/xml/stream/stream.pri
new file mode 100644
index 0000000..a5ba3a2
--- /dev/null
+++ b/src/xml/stream/stream.pri
@@ -0,0 +1,9 @@
+# compatibility header:
+HEADERS += stream/qxmlstream.h
+
+!static {
+ # The platforms that require the symbol to be present in QtXml:
+ win32:!wince-*:SOURCES += ../corelib/xml/qxmlstream.cpp
+ mac:SOURCES += ../corelib/xml/qxmlstream.cpp
+ aix-*:SOURCES += ../corelib/xml/qxmlstream.cpp
+}
diff --git a/src/xml/xml.pro b/src/xml/xml.pro
new file mode 100644
index 0000000..0c7133c
--- /dev/null
+++ b/src/xml/xml.pro
@@ -0,0 +1,20 @@
+TARGET = QtXml
+QPRO_PWD = $$PWD
+QT = core
+DEFINES += QT_BUILD_XML_LIB QT_NO_USING_NAMESPACE
+win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x61000000
+
+unix:QMAKE_PKGCONFIG_REQUIRES = QtCore
+
+include(../qbase.pri)
+
+PRECOMPILED_HEADER = ../corelib/global/qt_pch.h
+
+win32-borland {
+ QMAKE_CFLAGS_WARN_ON += -w-use
+ QMAKE_CXXFLAGS_WARN_ON += -w-use
+}
+
+include(dom/dom.pri)
+include(sax/sax.pri)
+include(stream/stream.pri)