Add Qt3 development HEAD version

7 files changed, 17676 insertions, 0 deletions

diff --git a/src/xml/qdom.cpp b/src/xml/qdom.cpp
new file mode 100644
index 0000000..524c638
--- /dev/null
+++ b/src/xml/qdom.cpp
@@ -0,0 +1,7092 @@
+/****************************************************************************
+**
+** Implementation of QDomDocument and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qdom.h"
+
+#ifndef QT_NO_DOM
+
+#include "qxml.h"
+#include "qptrlist.h"
+#include "qdict.h"
+#include "qtextstream.h"
+#include "qtextcodec.h"
+#include "qiodevice.h"
+#include "qregexp.h"
+#include "qbuffer.h"
+
+/*
+  ### 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.
+*/
+
+/*
+  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.find( ':' );
+    if ( i == -1 ) {
+	if ( hasURI )
+	    prefix = "";
+	else
+	    prefix = QString::null;
+	name = qName;
+    } else {
+	prefix = qName.left( i );
+	name = qName.mid( i + 1 );
+    }
+}
+
+/*
+  Counter for the QDomNodeListPrivate timestamps.
+*/
+static volatile long qt_nodeListTime = 0;
+
+/**************************************************************
+ *
+ * Private class declerations
+ *
+ **************************************************************/
+
+class QDomImplementationPrivate : public QShared
+{
+public:
+    QDomImplementationPrivate();
+    ~QDomImplementationPrivate();
+
+    QDomImplementationPrivate* clone();
+
+};
+
+class QDomNodePrivate : public QShared
+{
+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 QDomNamedNodeMapPrivate* attributes();
+    virtual bool hasAttributes() { return FALSE; }
+    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();
+
+    QDomNodePrivate* parent() { return hasParent ? ownerNode : 0; }
+    void setParent( QDomNodePrivate *p ) { ownerNode = p; hasParent = TRUE; }
+    void setNoParent() {
+	ownerNode = hasParent ? (QDomNodePrivate*)ownerDocument() : 0;
+	hasParent = FALSE;
+    }
+
+    // Dynamic cast
+    virtual bool isAttr() { return FALSE; }
+    virtual bool isCDATASection() { return FALSE; }
+    virtual bool isDocumentFragment() { return FALSE; }
+    virtual bool isDocument() { return FALSE; }
+    virtual bool isDocumentType() { return FALSE; }
+    virtual bool isElement() { return FALSE; }
+    virtual bool isEntityReference() { return FALSE; }
+    virtual bool isText() { return FALSE; }
+    virtual bool isEntity() { return FALSE; }
+    virtual bool isNotation() { return FALSE; }
+    virtual bool isProcessingInstruction() { return FALSE; }
+    virtual bool isCharacterData() { return FALSE; }
+    virtual bool isComment() { return FALSE; }
+    virtual QDomNode::NodeType nodeType() const { return QDomNode::BaseNode; }
+
+    virtual void save( QTextStream&, int, int ) const;
+
+    // Variables
+    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;
+    bool hasParent;
+};
+
+class QDomNodeListPrivate : public QShared
+{
+public:
+    QDomNodeListPrivate( QDomNodePrivate* );
+    QDomNodeListPrivate( QDomNodePrivate*, const QString&  );
+    QDomNodeListPrivate( QDomNodePrivate*, const QString&, const QString&  );
+    virtual ~QDomNodeListPrivate();
+
+    virtual bool operator== ( const QDomNodeListPrivate& ) const;
+    virtual bool operator!= ( const QDomNodeListPrivate& ) const;
+
+    void createList();
+    virtual QDomNodePrivate* item( int index );
+    virtual uint length() const;
+
+    QDomNodePrivate* node_impl;
+    QString tagname;
+    QString nsURI;
+    QPtrList<QDomNodePrivate> list;
+    long timestamp;
+};
+
+class QDomNamedNodeMapPrivate : public QShared
+{
+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
+    QDict<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 );
+
+    bool isDocumentType() { 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 );
+    ~QDomDocumentFragmentPrivate();
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isDocumentFragment() { 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 );
+    ~QDomCharacterDataPrivate();
+
+    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
+    bool isCharacterData() { 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& value );
+    QDomTextPrivate( QDomTextPrivate* n, bool deep );
+    ~QDomTextPrivate();
+
+    QDomTextPrivate* splitText( int offset );
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isText() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::TextNode; }
+    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 );
+    ~QDomAttrPrivate();
+
+    bool specified() const;
+
+    // Reimplemented from QDomNodePrivate
+    void setNodeValue( const QString& v );
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isAttr() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::AttributeNode; }
+    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 ); }
+    bool isElement() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::ElementNode; }
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    void save( QTextStream& s, int, int ) const;
+
+    // Variables
+    QDomNamedNodeMapPrivate* m_attr;
+};
+
+
+class QDomCommentPrivate : public QDomCharacterDataPrivate
+{
+public:
+    QDomCommentPrivate( QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& value );
+    QDomCommentPrivate( QDomCommentPrivate* n, bool deep );
+    ~QDomCommentPrivate();
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isComment() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::CommentNode; }
+    void save( QTextStream& s, int, int ) const;
+
+};
+
+class QDomCDATASectionPrivate : public QDomTextPrivate
+{
+public:
+    QDomCDATASectionPrivate( QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& value );
+    QDomCDATASectionPrivate( QDomCDATASectionPrivate* n, bool deep );
+    ~QDomCDATASectionPrivate();
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isCDATASection() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::CDATASectionNode; }
+    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 );
+    ~QDomNotationPrivate();
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isNotation() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::NotationNode; }
+    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 );
+    ~QDomEntityPrivate();
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isEntity() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::EntityNode; }
+    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 );
+    ~QDomEntityReferencePrivate();
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isEntityReference() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::EntityReferenceNode; }
+    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 );
+    ~QDomProcessingInstructionPrivate();
+
+    // Reimplemented from QDomNodePrivate
+    QDomNodePrivate* cloneNode( bool deep = TRUE );
+    bool isProcessingInstruction() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::ProcessingInstructionNode; }
+    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() { return TRUE; }
+    QDomNode::NodeType nodeType() const { return QDomNode::DocumentNode; }
+    void clear();
+    void save( QTextStream&, int, int ) const;
+
+    // Variables
+    QDomImplementationPrivate* impl;
+    QDomDocumentTypePrivate* type;
+};
+
+/**************************************************************
+ *
+ * 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 ) ;
+
+    QString errorMsg;
+    int errorLine;
+    int errorColumn;
+
+private:
+    QDomDocumentPrivate *doc;
+    QDomNodePrivate *node;
+    QString entityName;
+    bool cdata;
+    bool nsProcessing;
+};
+
+/**************************************************************
+ *
+ * QDomImplementationPrivate
+ *
+ **************************************************************/
+
+QDomImplementationPrivate::QDomImplementationPrivate()
+{
+}
+
+QDomImplementationPrivate::~QDomImplementationPrivate()
+{
+}
+
+QDomImplementationPrivate* QDomImplementationPrivate::clone()
+{
+    QDomImplementationPrivate* p = new QDomImplementationPrivate;
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+/**************************************************************
+ *
+ * QDomImplementation
+ *
+ **************************************************************/
+
+/*!
+    \class QDomImplementation qdom.h
+    \reentrant
+    \brief The QDomImplementation class provides information about the
+    features of the DOM implementation.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 \link
+    http://www.w3.org/TR/REC-DOM-Level-1/\endlink and \link
+    http://www.w3.org/TR/DOM-Level-2-Core/\endlink. For a more general
+    introduction of the DOM implementation see the QDomDocument
+    documentation.
+
+    \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();
+}
+
+QDomImplementation::QDomImplementation( QDomImplementationPrivate* p )
+{
+    // We want to be co-owners, so increase the reference count
+    impl = p;
+    if (impl)
+    	impl->ref();
+}
+
+/*!
+    Assigns \a x to this DOM implementation.
+*/
+QDomImplementation& QDomImplementation::operator= ( const QDomImplementation& x )
+{
+    if ( x.impl )
+	x.impl->ref(); // avoid x=x
+    if ( impl && impl->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->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 )
+{
+    if ( feature == "XML" ) {
+	if ( version.isEmpty() || version == "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 QString::null 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 QString::null 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 QString::null 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.
+
+    \sa createDocument();
+*/
+QDomDocumentType QDomImplementation::createDocumentType( const QString& qName, const QString& publicId, const QString& systemId )
+{
+    QDomDocumentTypePrivate *dt = new QDomDocumentTypePrivate( 0 );
+    dt->name = qName;
+    if ( systemId.isNull() ) {
+	dt->publicId = QString::null;
+	dt->systemId = QString::null;
+    } else {
+	dt->publicId = publicId;
+	dt->systemId = systemId;
+    }
+    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 );
+    doc.appendChild( root );
+    return doc;
+}
+
+/*!
+    Returns FALSE if the object was created by
+    QDomDocument::implementation(); otherwise returns TRUE.
+*/
+bool QDomImplementation::isNull()
+{
+    return ( impl == 0 );
+}
+
+/**************************************************************
+ *
+ * QDomNodeListPrivate
+ *
+ **************************************************************/
+
+QDomNodeListPrivate::QDomNodeListPrivate( QDomNodePrivate* n_impl )
+{
+    node_impl = n_impl;
+    if ( node_impl )
+	node_impl->ref();
+    timestamp = -1;
+}
+
+QDomNodeListPrivate::QDomNodeListPrivate( QDomNodePrivate* n_impl, const QString& name )
+{
+    node_impl = n_impl;
+    if ( node_impl )
+	node_impl->ref();
+    tagname = name;
+    timestamp = -1;
+}
+
+QDomNodeListPrivate::QDomNodeListPrivate( QDomNodePrivate* n_impl, const QString& _nsURI, const QString& localName )
+{
+    node_impl = n_impl;
+    if ( node_impl )
+	node_impl->ref();
+    tagname = localName;
+    nsURI = _nsURI;
+    timestamp = -1;
+}
+
+QDomNodeListPrivate::~QDomNodeListPrivate()
+{
+    if ( node_impl && node_impl->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;
+    timestamp = qt_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;
+    if ( timestamp < qt_nodeListTime )
+	createList();
+    return list.at( index );
+}
+
+uint QDomNodeListPrivate::length() const
+{
+    if ( !node_impl )
+	return 0;
+    if ( timestamp < qt_nodeListTime ) {
+	QDomNodeListPrivate *that = (QDomNodeListPrivate*)this;
+	that->createList();
+    }
+    return list.count();
+}
+
+/**************************************************************
+ *
+ * QDomNodeList
+ *
+ **************************************************************/
+
+/*!
+    \class QDomNodeList qdom.h
+    \reentrant
+    \brief The QDomNodeList class is a list of QDomNode objects.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 count() (and by
+    length()).
+
+    For further information about the Document Object Model see \link
+    http://www.w3.org/TR/REC-DOM-Level-1/\endlink and \link
+    http://www.w3.org/TR/DOM-Level-2-Core/\endlink. 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();
+}
+
+/*!
+    Assigns \a n to this node list.
+*/
+QDomNodeList& QDomNodeList::operator= ( const QDomNodeList& n )
+{
+    if ( n.impl )
+	n.impl->ref();
+    if ( impl && impl->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->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 count()
+*/
+QDomNode QDomNodeList::item( int index ) const
+{
+    if ( !impl )
+	return QDomNode();
+
+    return QDomNode( impl->item( index ) );
+}
+
+/*!
+    Returns the number of nodes in the list.
+
+    This function is the same as count().
+*/
+uint QDomNodeList::length() const
+{
+    if ( !impl )
+	return 0;
+    return impl->length();
+}
+
+/*!
+    \fn uint QDomNodeList::count() const
+
+    Returns the number of nodes in the list.
+
+    This function is the same as length().
+*/
+
+
+/**************************************************************
+ *
+ * QDomNodePrivate
+ *
+ **************************************************************/
+
+inline void QDomNodePrivate::setOwnerDocument( QDomDocumentPrivate* doc )
+{
+    ownerNode = doc;
+    hasParent = FALSE;
+}
+
+QDomNodePrivate::QDomNodePrivate( QDomDocumentPrivate* doc, QDomNodePrivate *par )
+{
+    if ( par )
+	setParent( par );
+    else
+	setOwnerDocument( doc );
+    prev = 0;
+    next = 0;
+    first = 0;
+    last = 0;
+    createdWithDom1Interface = TRUE;
+}
+
+QDomNodePrivate::QDomNodePrivate( QDomNodePrivate* n, bool deep )
+{
+    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;
+
+    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->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->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;
+}
+
+QDomNamedNodeMapPrivate* QDomNodePrivate::attributes()
+{
+    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"
+    qt_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();
+
+    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"
+    qt_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();
+
+    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 ( oldChild->parent() != this )
+	return 0;
+    if ( !newChild || !oldChild )
+	return 0;
+    if ( newChild == oldChild )
+	return 0;
+
+    // mark lists as dirty
+    qt_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->deref();
+
+	return oldChild;
+    }
+
+    // No more errors can occur now, so we take
+    // ownership of the node
+    newChild->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->deref();
+
+    return oldChild;
+}
+
+QDomNodePrivate* QDomNodePrivate::removeChild( QDomNodePrivate* oldChild )
+{
+    // Error check
+    if ( oldChild->parent() != this )
+	return 0;
+
+    // "mark lists as dirty"
+    qt_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->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 (QDomDocumentPrivate*)p;
+}
+
+QDomNodePrivate* QDomNodePrivate::cloneNode( bool deep )
+{
+    QDomNodePrivate* p = new QDomNodePrivate( this, deep );
+    // We are not interested in this node
+    p->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 );
+}
+
+void QDomNodePrivate::save( QTextStream& s, int depth, int indent ) const
+{
+    const QDomNodePrivate* n = first;
+    while ( n ) {
+	n->save( s, depth, indent );
+	n = n->next;
+    }
+}
+
+/**************************************************************
+ *
+ * QDomNode
+ *
+ **************************************************************/
+
+#define IMPL ((QDomNodePrivate*)impl)
+
+/*!
+    \class QDomNode qdom.h
+    \reentrant
+    \brief The QDomNode class is the base class for all the nodes in a DOM tree.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    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().
+
+    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.
+    \code
+    QDomDocument d;
+    d.setContent( someXML );
+    QDomNode n = d.firstChild();
+    while ( !n.isNull() ) {
+	if ( n.isElement() ) {
+	    QDomElement e = n.toElement();
+	    cout << "Element name: " << e.tagName() << endl;
+	    break;
+	}
+	n = n.nextSibling();
+    }
+    \endcode
+
+    For further information about the Document Object Model see \link
+    http://www.w3.org/TR/REC-DOM-Level-1/\endlink and \link
+    http://www.w3.org/TR/DOM-Level-2-Core/\endlink. 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();
+}
+
+/*!  \internal
+  Constructs a new node for the data \a n.
+*/
+QDomNode::QDomNode( QDomNodePrivate* n )
+{
+    impl = n;
+    if ( impl ) impl->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();
+    if ( impl && impl->deref() ) delete impl;
+    impl = n.impl;
+
+    return *this;
+}
+
+/*!
+    Returns TRUE if \a n and this DOM node are equal; otherwise
+    returns FALSE.
+*/
+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->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
+
+    \sa nodeValue()
+*/
+QString QDomNode::nodeName() const
+{
+    if ( !impl )
+	return QString::null;
+
+    if ( !IMPL->prefix.isEmpty() )
+	return IMPL->prefix + ":" + 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 intruction
+    \row \i QDomText \i The text
+    \endtable
+
+    All the other subclasses do not have a node value and will return
+    QString::null.
+
+    \sa setNodeValue() nodeName()
+*/
+QString QDomNode::nodeValue() const
+{
+    if ( !impl )
+	return QString::null;
+    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:
+    \code
+    <body>
+    <h1>Heading</h1>
+    <p>Hello <b>you</b></p>
+    </body>
+    \endcode
+    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:
+    \code
+    <h1>Heading</h1>
+    <p>The text...</p>
+    <h2>Next heading</h2>
+    \endcode
+    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:
+    \code
+    <h1>Heading</h1>
+    <p>The text...</p>
+    <h2>Next heading</h2>
+    \endcode
+    and this QDomNode represents the &lt;p&gt; tag, nextSibling() will
+    return the node representing the &lt;h2&gt; tag.
+
+    \sa previousSibling()
+*/
+QDomNode QDomNode::nextSibling() const
+{
+    if ( !impl )
+	return QDomNode();
+    return QDomNode( IMPL->next );
+}
+
+/*!
+    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 )
+	return QDomNamedNodeMap();
+
+    return QDomNamedNodeMap( 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 QString::null 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::null;
+    return IMPL->namespaceURI;
+}
+
+/*!
+    Returns the namespace prefix of the node or QString::null 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 QString::null. If you use
+    QDomDocument::createElementNS() or
+    QDomDocument::createAttributeNS() instead, the prefix will not be
+    QString::null; 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::null;
+    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 QString::null.
+
+    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::null;
+    return IMPL->name;
+}
+
+/*!
+    Returns TRUE if the node has attributes; otherwise returns FALSE.
+
+    \sa attributes()
+*/
+bool QDomNode::hasAttributes() const
+{
+    if ( !impl )
+	return FALSE;
+    return 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.
+
+    \sa insertAfter() replaceChild() removeChild() appendChild()
+*/
+QDomNode QDomNode::insertBefore( const QDomNode& newChild, const QDomNode& refChild )
+{
+    if ( !impl ) {
+        if (nodeType() == DocumentNode)
+            impl = new QDomDocumentPrivate;
+        else
+            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.
+
+    \sa insertBefore() replaceChild() removeChild() appendChild()
+*/
+QDomNode QDomNode::insertAfter( const QDomNode& newChild, const QDomNode& refChild )
+{
+    if ( !impl ) {
+        if (nodeType() == DocumentNode)
+            impl = new QDomDocumentPrivate;
+        else
+            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 ) {
+        if (nodeType() == DocumentNode)
+            impl = new QDomDocumentPrivate;
+        else
+            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.
+
+    Returns a new reference to \a newChild.
+
+    \sa insertBefore() insertAfter() replaceChild() removeChild()
+*/
+QDomNode QDomNode::appendChild( const QDomNode& newChild )
+{
+    if ( !impl ) {
+        if (nodeType() == DocumentNode)
+            impl = new QDomDocumentPrivate;
+        else
+            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->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.
+*/
+void QDomNode::save( QTextStream& str, int indent ) const
+{
+    if ( impl )
+	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
+
+/**************************************************************
+ *
+ * QDomNamedNodeMapPrivate
+ *
+ **************************************************************/
+
+QDomNamedNodeMapPrivate::QDomNamedNodeMapPrivate( QDomNodePrivate* n )
+{
+    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;
+
+    QDictIterator<QDomNodePrivate> it ( map );
+    for ( ; it.current(); ++it )
+	m->setNamedItem( it.current()->cloneNode() );
+
+    // we are no longer interested in ownership
+    m->deref();
+    return m;
+}
+
+void QDomNamedNodeMapPrivate::clearMap()
+{
+    // Dereference all of our children if we took references
+    if ( !appendToParent ) {
+	QDictIterator<QDomNodePrivate> it( map );
+	for ( ; it.current(); ++it )
+	    if ( it.current()->deref() )
+		delete it.current();
+    }
+
+    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
+{
+    QDictIterator<QDomNodePrivate> it( map );
+    QDomNodePrivate *n = it.current();
+    while ( n ) {
+	if ( !n->prefix.isNull() ) {
+	    // node has a namespace
+	    if ( n->namespaceURI==nsURI && n->name==localName ) {
+		return n;
+	    }
+	}
+	++it;
+	n = it.current();
+    }
+    return 0;
+}
+
+QDomNodePrivate* QDomNamedNodeMapPrivate::setNamedItem( QDomNodePrivate* arg )
+{
+    if ( readonly || !arg )
+	return 0;
+
+    if ( appendToParent )
+	return parent->appendChild( arg );
+
+    QDomNodePrivate *n = map[ arg->nodeName() ];
+    // We take a reference
+    arg->ref();
+    map.insert( 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();
+	map.insert( arg->nodeName(), arg );
+	return n;
+    } else {
+	// ### check the following code if it is ok
+	return setNamedItem( arg );
+    }
+}
+
+QDomNodePrivate* QDomNamedNodeMapPrivate::removeNamedItem( const QString& name )
+{
+    if ( readonly )
+	return 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->deref();
+    return p;
+}
+
+QDomNodePrivate* QDomNamedNodeMapPrivate::item( int index ) const
+{
+    if ( (uint)index >= length() )
+	return 0;
+
+    QDictIterator<QDomNodePrivate> it( map );
+    for ( int i = 0; i < index; ++i, ++it )
+	;
+    return it.current();
+}
+
+uint QDomNamedNodeMapPrivate::length() const
+{
+    return map.count();
+}
+
+bool QDomNamedNodeMapPrivate::contains( const QString& name ) const
+{
+    return ( map[ name ] != 0 );
+}
+
+bool QDomNamedNodeMapPrivate::containsNS( const QString& nsURI, const QString & localName ) const
+{
+    return ( namedItemNS( nsURI, localName ) != 0 );
+}
+
+/**************************************************************
+ *
+ * QDomNamedNodeMap
+ *
+ **************************************************************/
+
+#define IMPL ((QDomNamedNodeMapPrivate*)impl)
+
+/*!
+    \class QDomNamedNodeMap qdom.h
+    \reentrant
+    \brief The QDomNamedNodeMap class contains a collection of nodes
+    that can be accessed by name.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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();
+}
+
+QDomNamedNodeMap::QDomNamedNodeMap( QDomNamedNodeMapPrivate* n )
+{
+    impl = n;
+    if ( impl )
+	impl->ref();
+}
+
+/*!
+    Assigns \a n to this named node map.
+*/
+QDomNamedNodeMap& QDomNamedNodeMap::operator= ( const QDomNamedNodeMap& n )
+{
+    if ( impl && impl->deref() )
+	delete impl;
+    impl = n.impl;
+    if ( impl )
+	impl->ref();
+
+    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->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 uint QDomNamedNodeMap::count() const
+
+    Returns the number of nodes in the map.
+
+    This function is the same as length().
+*/
+
+/*!
+    Returns TRUE if the map contains a node called \a name; otherwise
+    returns FALSE.
+*/
+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.insert( p->nodeName(), p );
+	if ( p->isNotation() )
+	    // Dont use normal insert function since we would create infinite recursion
+	    notations->map.insert( p->nodeName(), p );
+    }
+}
+
+QDomDocumentTypePrivate::~QDomDocumentTypePrivate()
+{
+    if ( entities->deref() )
+	delete entities;
+    if ( notations->deref() )
+	delete notations;
+}
+
+void QDomDocumentTypePrivate::init()
+{
+    entities = new QDomNamedNodeMapPrivate( this );
+    notations = new QDomNamedNodeMapPrivate( this );
+    publicId = QString::null;
+    systemId = QString::null;
+    internalSubset = QString::null;
+
+    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->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.insert( p->nodeName(), p );
+    else if ( p && p->isNotation() )
+	notations->map.insert( p->nodeName(), p );
+
+    return p;
+}
+
+QDomNodePrivate* QDomDocumentTypePrivate::insertAfter( QDomNodePrivate* newChild, QDomNodePrivate* refChild )
+{
+    // Call the origianl implementation
+    QDomNodePrivate* p = QDomNodePrivate::insertAfter( newChild, refChild );
+    // Update the maps
+    if ( p && p->isEntity() )
+	entities->map.insert( p->nodeName(), p );
+    else if ( p && p->isNotation() )
+	notations->map.insert( p->nodeName(), p );
+
+    return p;
+}
+
+QDomNodePrivate* QDomDocumentTypePrivate::replaceChild( QDomNodePrivate* newChild, QDomNodePrivate* oldChild )
+{
+    // Call the 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.insert( p->nodeName(), p );
+	else if ( p->isNotation() )
+	    notations->map.insert( 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 );
+}
+
+void QDomDocumentTypePrivate::save( QTextStream& s, int, int indent ) const
+{
+    if ( name.isEmpty() )
+	return;
+
+    s << "<!DOCTYPE " << name;
+
+    if ( !publicId.isNull() ) {
+	s << " PUBLIC \"" << publicId << "\"";
+	if ( !systemId.isNull() )
+	    s << " \"" << systemId << "\"";
+    } else if ( !systemId.isNull() ) {
+	s << " SYSTEM \"" << systemId << "\"";
+    }
+
+    if ( entities->length()>0 || notations->length()>0 ) {
+	s << " [ " << endl;
+
+	QDictIterator<QDomNodePrivate> it2( notations->map );
+	for ( ; it2.current(); ++it2 )
+	    it2.current()->save( s, 0, indent );
+
+	QDictIterator<QDomNodePrivate> it( entities->map );
+	for ( ; it.current(); ++it )
+	    it.current()->save( s, 0, indent );
+
+	s << " ]";
+    }
+
+    s << ">" << endl;
+}
+
+/**************************************************************
+ *
+ * QDomDocumentType
+ *
+ **************************************************************/
+
+#define IMPL ((QDomDocumentTypePrivate*)impl)
+
+/*!
+    \class QDomDocumentType qdom.h
+    \reentrant
+    \brief The QDomDocumentType class is the representation of the DTD
+    in the document tree.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomDocumentType::~QDomDocumentType()
+{
+}
+
+/*!
+    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::null;
+
+    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
+    QString::null if there is no public identifier.
+
+    \sa systemId() internalSubset() QDomImplementation::createDocumentType()
+*/
+QString QDomDocumentType::publicId() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->publicId;
+}
+
+/*!
+    Returns the system identifier of the external DTD subset or
+    QString::null if there is no system identifier.
+
+    \sa publicId() internalSubset() QDomImplementation::createDocumentType()
+*/
+QString QDomDocumentType::systemId() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->systemId;
+}
+
+/*!
+    Returns the internal subset of the document type or QString::null
+    if there is no internal subset.
+
+    \sa publicId() systemId()
+*/
+QString QDomDocumentType::internalSubset() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->internalSubset;
+}
+
+/*!
+    Returns \c DocumentTypeNode.
+
+    \sa isDocumentType() QDomNode::toDocumentType()
+*/
+QDomNode::NodeType QDomDocumentType::nodeType() const
+{
+    return DocumentTypeNode;
+}
+
+/*!
+    This function overloads QDomNode::isDocumentType().
+
+    \sa nodeType() QDomNode::toDocumentType()
+*/
+bool QDomDocumentType::isDocumentType() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomDocumentFragmentPrivate
+ *
+ **************************************************************/
+
+QDomDocumentFragmentPrivate::QDomDocumentFragmentPrivate( QDomDocumentPrivate* doc, QDomNodePrivate* parent )
+    : QDomNodePrivate( doc, parent )
+{
+    name = "#document-fragment";
+}
+
+QDomDocumentFragmentPrivate::QDomDocumentFragmentPrivate( QDomNodePrivate* n, bool deep )
+    : QDomNodePrivate( n, deep )
+{
+}
+
+QDomDocumentFragmentPrivate::~QDomDocumentFragmentPrivate()
+{
+}
+
+QDomNodePrivate* QDomDocumentFragmentPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomDocumentFragmentPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+/**************************************************************
+ *
+ * QDomDocumentFragment
+ *
+ **************************************************************/
+
+#define IMPL ((QDomDocumentFragmentPrivate*)impl)
+
+/*!
+    \class QDomDocumentFragment qdom.h
+    \reentrant
+    \brief The QDomDocumentFragment class is a tree of QDomNodes which is not usually a complete QDomDocument.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomDocumentFragment::~QDomDocumentFragment()
+{
+}
+
+/*!
+    Returns \c DocumentFragment.
+
+    \sa isDocumentFragment() QDomNode::toDocumentFragment()
+*/
+QDomNode::NodeType QDomDocumentFragment::nodeType() const
+{
+    return QDomNode::DocumentFragmentNode;
+}
+
+/*!
+    This function reimplements QDomNode::isDocumentFragment().
+
+    \sa nodeType() QDomNode::toDocumentFragment()
+*/
+bool QDomDocumentFragment::isDocumentFragment() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomCharacterDataPrivate
+ *
+ **************************************************************/
+
+QDomCharacterDataPrivate::QDomCharacterDataPrivate( QDomDocumentPrivate* d, QDomNodePrivate* p,
+						      const QString& data )
+    : QDomNodePrivate( d, p )
+{
+    value = data;
+
+    name = "#character-data";
+}
+
+QDomCharacterDataPrivate::QDomCharacterDataPrivate( QDomCharacterDataPrivate* n, bool deep )
+    : QDomNodePrivate( n, deep )
+{
+}
+
+QDomCharacterDataPrivate::~QDomCharacterDataPrivate()
+{
+}
+
+QDomNodePrivate* QDomCharacterDataPrivate::cloneNode( bool deep )
+{
+    QDomNodePrivate* p = new QDomCharacterDataPrivate( this, deep );
+    // We are not interested in this node
+    p->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 qdom.h
+    \reentrant
+    \brief The QDomCharacterData class represents a generic string in the DOM.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomCharacterData::~QDomCharacterData()
+{
+}
+
+/*!
+    Returns the string stored in this object.
+
+    If the node is a \link isNull() null node\endlink, it will return
+    QString::null.
+*/
+QString QDomCharacterData::data() const
+{
+    if ( !impl )
+	return QString::null;
+    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::null;
+    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 \c CharacterDataNode is
+    returned.
+*/
+QDomNode::NodeType QDomCharacterData::nodeType() const
+{
+    if( !impl )
+	return CharacterDataNode;
+    return QDomNode::nodeType();
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomCharacterData::isCharacterData() const
+{
+    return TRUE;
+}
+
+#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();
+}
+
+QDomAttrPrivate::~QDomAttrPrivate()
+{
+}
+
+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->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->deref();
+    return p;
+}
+
+bool QDomAttrPrivate::specified() const
+{
+    return m_specified;
+}
+
+static bool isXmlChar(const QChar &c)
+{
+    // Characters in this range must be accepted by XML parsers.
+    // Consequently characters outside of this range need to be escaped.
+
+    ushort uc = c.unicode();
+
+    return uc == 0x9
+            || uc == 0xA
+            || uc == 0xD
+            || 0x20 <= uc && uc <= 0xD7FF
+            || 0xE000 <= uc && uc <= 0xFFFD;
+}
+
+/*
+  Encode an attribute value upon saving.
+*/
+static QString encodeAttr( const QString& str )
+{
+    QString tmp( str );
+    uint len = tmp.length();
+    uint i = 0;
+    while ( i < len ) {
+	if ( tmp[(int)i] == '<' ) {
+	    tmp.replace( i, 1, "&lt;" );
+	    len += 3;
+	    i += 4;
+	} else if ( tmp[(int)i] == '"' ) {
+	    tmp.replace( i, 1, "&quot;" );
+	    len += 5;
+	    i += 6;
+	} else if ( tmp[(int)i] == '&' ) {
+	    tmp.replace( i, 1, "&amp;" );
+	    len += 4;
+	    i += 5;
+	} else if ( tmp[(int)i] == '>' && i>=2 && tmp[(int)i-1]==']' && tmp[(int)i-2]==']' ) {
+	    tmp.replace( i, 1, "&gt;" );
+	    len += 3;
+	    i += 4;
+        } else if (!isXmlChar(tmp[(int)i])) {
+            QString repl = "&#x" + QString::number(tmp[(int)i].unicode(), 16) + ';';
+            qWarning("QDom: saving invalid character %s, the document will not be well-formed", repl.latin1());
+            tmp.replace(i, 1, repl);
+            len += repl.length() - 1;
+            i += repl.length();
+        } else {
+	    ++i;
+	}
+    }
+
+    return tmp;
+}
+
+void QDomAttrPrivate::save( QTextStream& s, int, int ) const
+{
+    if ( namespaceURI.isNull() ) {
+	s << name << "=\"" << encodeAttr( value ) << "\"";
+    } else {
+	// ### optimize this (see comment of QDomElementPrivate::save()
+	s << prefix << ":" << name << "=\"" << encodeAttr( value ) << "\""
+	    << " xmlns:" << prefix << "=\"" << encodeAttr( namespaceURI ) << "\"";
+    }
+}
+
+/**************************************************************
+ *
+ * QDomAttr
+ *
+ **************************************************************/
+
+#define IMPL ((QDomAttrPrivate*)impl)
+
+/*!
+    \class QDomAttr qdom.h
+    \reentrant
+    \brief The QDomAttr class represents one attribute of a QDomElement.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    For example, the following piece of XML produces an element with
+    no children, but two attributes:
+
+    \code
+    <link href="http://www.trolltech.com" color="red" />
+    \endcode
+
+    You can access the attributes of an element with code like this:
+
+    \code
+    QDomElement e = //...
+    //...
+    QDomAttr a = e.attributeNode( "href" );
+    cout << a.value() << endl;                // prints "http://www.trolltech.com"
+    a.setValue( "http://doc.trolltech.com" ); // change the node's attribute
+    QDomAttr a2 = e.attributeNode( "href" );
+    cout << a2.value() << endl;               // prints "http://doc.trolltech.com"
+    \endcode
+
+    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 either set in the document or set with
+    setValue(); otherwise the value hasn't been set. The node this
+    attribute is attached to (if any) is returned by ownerElement().
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomAttr::~QDomAttr()
+{
+}
+
+/*!
+    Returns the attribute's name.
+*/
+QString QDomAttr::name() const
+{
+    if ( !impl )
+	return QString::null;
+    return impl->nodeName();
+}
+
+/*!
+    Returns TRUE if the attribute has either been expicitly specified
+    in the XML document or was 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
+{
+    if ( !impl && !impl->parent()->isElement() )
+	return QDomElement();
+    return QDomElement( (QDomElementPrivate*)(impl->parent()) );
+}
+
+/*!
+    Returns the value of the attribute or QString::null if the
+    attribute has not been specified.
+
+    \sa specified() setValue()
+*/
+QString QDomAttr::value() const
+{
+    if ( !impl )
+	return QString::null;
+    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;
+}
+
+/*!
+    Returns \link QDomNode::NodeType AttributeNode\endlink.
+*/
+QDomNode::NodeType QDomAttr::nodeType() const
+{
+    return AttributeNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomAttr::isAttr() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomElementPrivate
+ *
+ **************************************************************/
+
+QDomElementPrivate::QDomElementPrivate( QDomDocumentPrivate* d, QDomNodePrivate* p,
+					  const QString& tagname )
+    : QDomNodePrivate( d, p )
+{
+    name = tagname;
+    m_attr = new QDomNamedNodeMapPrivate( this );
+}
+
+QDomElementPrivate::QDomElementPrivate( QDomDocumentPrivate* d, QDomNodePrivate* p,
+	const QString& nsURI, const QString& qName )
+    : QDomNodePrivate( d, p )
+{
+    qt_split_namespace( prefix, name, qName, !nsURI.isNull() );
+    namespaceURI = nsURI;
+    createdWithDom1Interface = FALSE;
+    m_attr = new QDomNamedNodeMapPrivate( this );
+}
+
+QDomElementPrivate::QDomElementPrivate( QDomElementPrivate* n, bool deep ) :
+    QDomNodePrivate( n, deep )
+{
+    m_attr = n->m_attr->clone( this );
+    // Reference is down to 0, so we set it to 1 here.
+    m_attr->ref();
+}
+
+QDomElementPrivate::~QDomElementPrivate()
+{
+    if ( m_attr->deref() )
+	delete m_attr;
+}
+
+QDomNodePrivate* QDomElementPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomElementPrivate( this, deep );
+    // We are not interested in this node
+    p->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->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->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->count == 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 );
+
+    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( "" );
+
+    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() ) )
+	for ( int i = 0; i < depth*indent; ++i )
+	    s << " ";
+
+    QString qName( name );
+    QString nsDecl( "" );
+    if ( !namespaceURI.isNull() ) {
+	// ### optimize this, so that you 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 (you have to
+	// take care if the DOM tree is modified, though)
+	if ( prefix.isEmpty() ) {
+	    nsDecl = " xmlns";
+	} else {
+	    qName = prefix + ":" + name;
+	    nsDecl = " xmlns:" + prefix;
+	}
+	nsDecl += "=\"" + encodeAttr( namespaceURI ) + "\"";
+    }
+    s << "<" << qName << nsDecl;
+
+    if ( !m_attr->map.isEmpty() ) {
+	s << " ";
+	QDictIterator<QDomNodePrivate> it( m_attr->map );
+	for ( ; it.current(); ++it ) {
+	    it.current()->save( s, 0, indent );
+	    s << " ";
+	}
+    }
+
+    if ( last ) {
+	// has child nodes
+	if ( first->isText() )
+	    s << ">";
+	else
+	    s << ">" << endl;
+	QDomNodePrivate::save( s, depth + 1, indent);
+	if ( !last->isText() )
+	    for( int i = 0; i < depth*indent; ++i )
+		s << " ";
+
+	s << "</" << qName << ">";
+    } else {
+	s << "/>";
+    }
+    if ( !( next && next->isText() ) )
+	s << endl;
+}
+
+/**************************************************************
+ *
+ * QDomElement
+ *
+ **************************************************************/
+
+#define IMPL ((QDomElementPrivate*)impl)
+
+/*!
+    \class QDomElement qdom.h
+    \reentrant
+    \brief The QDomElement class represents one element in the DOM tree.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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.
+    \code
+    QDomElement e = //...
+    //...
+    QString s = e.text()
+    \endcode
+    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.
+    \code
+    QString text;
+    QDomElement element = doc.documentElement();
+    for( QDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling() )
+    {
+	QDomText t = n.toText();
+	if ( !t.isNull() )
+	    text += t.data();
+    }
+    \endcode
+    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().
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomElement::~QDomElement()
+{
+}
+
+/*!
+    Returns \c ElementNode.
+*/
+QDomNode::NodeType QDomElement::nodeType() const
+{
+    return 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:
+    \code
+    <img src="myimg.png">
+    \endcode
+    the tagname would return "img".
+
+    \sa setTagName()
+*/
+QString QDomElement::tagName() const
+{
+    if ( !impl )
+	return QString::null;
+    return impl->nodeName();
+}
+
+/*!
+    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 );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttribute( const QString& name, int value )
+{
+    // ### 4.0: inline
+    setAttribute( name, long(value) );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttribute( const QString& name, uint value )
+{
+    // ### 4.0: inline
+    setAttribute( name, ulong(value) );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttribute( const QString& name, long value )
+{
+    if ( !impl )
+	return;
+    QString x;
+    x.setNum( value );
+    IMPL->setAttribute( name, x );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttribute( const QString& name, ulong value )
+{
+    if ( !impl )
+	return;
+    QString x;
+    x.setNum( value );
+    IMPL->setAttribute( name, x );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttribute( const QString& name, double value )
+{
+    if ( !impl )
+	return;
+    QString x;
+    x.setNum( value );
+    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 descendent elements of this
+    element that are called \a tagname. The order they are in the node
+    list is the order they are encountered in a preorder traversal of
+    the element tree.
+
+    \sa elementsByTagNameNS() QDomDocument::elementsByTagName()
+*/
+QDomNodeList QDomElement::elementsByTagName( const QString& tagname ) const
+{
+    return QDomNodeList( new QDomNodeListPrivate( impl, tagname ) );
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomElement::isElement() const
+{
+    return TRUE;
+}
+
+/*!
+    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 TRUE if this element has an attribute called \a name;
+    otherwise returns FALSE.
+*/
+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 );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttributeNS( const QString nsURI, const QString& qName, int value )
+{
+    // ### 4.0: inline
+    setAttributeNS( nsURI, qName, long(value) );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttributeNS( const QString nsURI, const QString& qName, uint value )
+{
+    // ### 4.0: inline
+    setAttributeNS( nsURI, qName, ulong(value) );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttributeNS( const QString nsURI, const QString& qName, long value )
+{
+    if ( !impl )
+	return;
+    QString x;
+    x.setNum( value );
+    IMPL->setAttributeNS( nsURI, qName, x );
+}
+
+/*!
+    \overload
+*/
+void QDomElement::setAttributeNS( const QString nsURI, const QString& qName, ulong 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 \link QDomNode::isNull() null
+    attribute\endlink is returned.
+
+    \sa setAttributeNode() attribute() setAttribute() attributeNodeNS()
+*/
+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 the descendent elements of
+    this element with the local name \a localName and the namespace
+    URI \a nsURI. The order they are in the node list is the order
+    they are encountered in a preorder traversal of the element tree.
+
+    \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 QString::null.
+
+    Example:
+    \code
+    <h1>Hello <b>Qt</b> <![CDATA[<xml is cool>]]></h1>
+    \endcode
+
+    The function text() of the QDomElement for the &lt;h1&gt; tag,
+    will return "Hello Qt &lt;xml is cool&gt;".
+
+    Comments are ignored by this function. It only evaluates QDomText
+    and QDomCDATASection objects.
+*/
+QString QDomElement::text() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->text();
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomTextPrivate
+ *
+ **************************************************************/
+
+QDomTextPrivate::QDomTextPrivate( QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& value )
+    : QDomCharacterDataPrivate( d, parent, value )
+{
+    name = "#text";
+}
+
+QDomTextPrivate::QDomTextPrivate( QDomTextPrivate* n, bool deep )
+    : QDomCharacterDataPrivate( n, deep )
+{
+}
+
+QDomTextPrivate::~QDomTextPrivate()
+{
+}
+
+QDomNodePrivate* QDomTextPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomTextPrivate( this, deep );
+    // We are not interested in this node
+    p->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
+{
+    s << encodeAttr( value );
+}
+
+/**************************************************************
+ *
+ * QDomText
+ *
+ **************************************************************/
+
+#define IMPL ((QDomTextPrivate*)impl)
+
+/*!
+    \class QDomText qdom.h
+    \reentrant
+    \brief The QDomText class represents text data in the parsed XML document.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomText::~QDomText()
+{
+}
+
+/*!
+    Returns \c TextNode.
+*/
+QDomNode::NodeType QDomText::nodeType() const
+{
+    return 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 ) );
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomText::isText() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomCommentPrivate
+ *
+ **************************************************************/
+
+QDomCommentPrivate::QDomCommentPrivate( QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& value )
+    : QDomCharacterDataPrivate( d, parent, value )
+{
+    name = "#comment";
+}
+
+QDomCommentPrivate::QDomCommentPrivate( QDomCommentPrivate* n, bool deep )
+    : QDomCharacterDataPrivate( n, deep )
+{
+}
+
+QDomCommentPrivate::~QDomCommentPrivate()
+{
+}
+
+QDomNodePrivate* QDomCommentPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomCommentPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void QDomCommentPrivate::save( QTextStream& s, int, int ) const
+{
+    s << "<!--" << value << "-->";
+}
+
+/**************************************************************
+ *
+ * QDomComment
+ *
+ **************************************************************/
+
+#define IMPL ((QDomCommentPrivate*)impl)
+
+/*!
+    \class QDomComment qdom.h
+    \reentrant
+    \brief The QDomComment class represents an XML comment.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    A comment in the parsed XML such as this:
+    \code
+    <!-- this is a comment -->
+    \endcode
+    is represented by QDomComment objects in the parsed Dom tree.
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomComment::~QDomComment()
+{
+}
+
+/*!
+    Returns \c CommentNode.
+*/
+QDomNode::NodeType QDomComment::nodeType() const
+{
+    return CommentNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomComment::isComment() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomCDATASectionPrivate
+ *
+ **************************************************************/
+
+QDomCDATASectionPrivate::QDomCDATASectionPrivate( QDomDocumentPrivate* d, QDomNodePrivate* parent,
+						    const QString& value )
+    : QDomTextPrivate( d, parent, value )
+{
+    name = "#cdata-section";
+}
+
+QDomCDATASectionPrivate::QDomCDATASectionPrivate( QDomCDATASectionPrivate* n, bool deep )
+    : QDomTextPrivate( n, deep )
+{
+}
+
+QDomCDATASectionPrivate::~QDomCDATASectionPrivate()
+{
+}
+
+QDomNodePrivate* QDomCDATASectionPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomCDATASectionPrivate( this, deep );
+    // We are not interested in this node
+    p->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
+ *
+ **************************************************************/
+
+#define IMPL ((QDomCDATASectionPrivate*)impl)
+
+/*!
+    \class QDomCDATASection qdom.h
+    \reentrant
+    \brief The QDomCDATASection class represents an XML CDATA section.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomCDATASection::~QDomCDATASection()
+{
+}
+
+/*!
+    Returns \c CDATASection.
+*/
+QDomNode::NodeType QDomCDATASection::nodeType() const
+{
+    return CDATASectionNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomCDATASection::isCDATASection() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * 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;
+}
+
+QDomNotationPrivate::~QDomNotationPrivate()
+{
+}
+
+QDomNodePrivate* QDomNotationPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomNotationPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void QDomNotationPrivate::save( QTextStream& s, int, int ) const
+{
+    s << "<!NOTATION " << name << " ";
+    if ( !m_pub.isNull() )  {
+	s << "PUBLIC \"" << m_pub << "\"";
+	if ( !m_sys.isNull() )
+	    s << " \"" << m_sys << "\"";
+    }  else {
+	s << "SYSTEM \"" << m_sys << "\"";
+    }
+    s << ">" << endl;
+}
+
+/**************************************************************
+ *
+ * QDomNotation
+ *
+ **************************************************************/
+
+#define IMPL ((QDomNotationPrivate*)impl)
+
+/*!
+    \class QDomNotation qdom.h
+    \reentrant
+    \brief The QDomNotation class represents an XML notation.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomNotation::~QDomNotation()
+{
+}
+
+/*!
+    Returns \c NotationNode.
+*/
+QDomNode::NodeType QDomNotation::nodeType() const
+{
+    return NotationNode;
+}
+
+/*!
+    Returns the public identifier of this notation.
+*/
+QString QDomNotation::publicId() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->m_pub;
+}
+
+/*!
+    Returns the system identifier of this notation.
+*/
+QString QDomNotation::systemId() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->m_sys;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomNotation::isNotation() const
+{
+    return TRUE;
+}
+
+#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;
+}
+
+QDomEntityPrivate::~QDomEntityPrivate()
+{
+}
+
+QDomNodePrivate* QDomEntityPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomEntityPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+/*
+  Encode an entity value upon saving.
+*/
+static QCString encodeEntity( const QCString& str )
+{
+    QCString tmp( str );
+    uint len = tmp.length();
+    uint i = 0;
+    const char* d = tmp.data();
+    while ( i < len ) {
+	if ( d[i] == '%' ){
+	    tmp.replace( i, 1, "&#60;" );
+	    d = tmp.data();
+	    len += 4;
+	    i += 5;
+	}
+	else if ( d[i] == '"' ) {
+	    tmp.replace( i, 1, "&#34;" );
+	    d = tmp.data();
+	    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.data();
+	    len += 4;
+	    i += 5;
+	} else {
+	    ++i;
+	}
+    }
+
+    return tmp;
+}
+
+void QDomEntityPrivate::save( QTextStream& s, int, int ) const
+{
+    if ( m_sys.isNull() && m_pub.isNull() ) {
+	s << "<!ENTITY " << name << " \"" << encodeEntity( value.utf8() ) << "\">" << endl;
+    } else {
+	s << "<!ENTITY " << name << " ";
+	if ( m_pub.isNull() ) {
+	    s << "SYSTEM \"" << m_sys << "\"";
+	} else {
+	    s << "PUBLIC \"" << m_pub << "\" \"" << m_sys << "\"";
+	}
+	if (! m_notationName.isNull() ) {
+	    s << " NDATA " << m_notationName;
+	}
+	s << ">" << endl;
+    }
+}
+
+/**************************************************************
+ *
+ * QDomEntity
+ *
+ **************************************************************/
+
+#define IMPL ((QDomEntityPrivate*)impl)
+
+/*!
+    \class QDomEntity qdom.h
+    \reentrant
+    \brief The QDomEntity class represents an XML entity.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 descendents 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
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomEntity::~QDomEntity()
+{
+}
+
+/*!
+    Returns \c EntityNode.
+*/
+QDomNode::NodeType QDomEntity::nodeType() const
+{
+    return EntityNode;
+}
+
+/*!
+    Returns the public identifier associated with this entity. If the
+    public identifier was not specified QString::null is returned.
+*/
+QString QDomEntity::publicId() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->m_pub;
+}
+
+/*!
+    Returns the system identifier associated with this entity. If the
+    system identifier was not specified QString::null is returned.
+*/
+QString QDomEntity::systemId() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->m_sys;
+}
+
+/*!
+    For unparsed entities this function returns the name of the
+    notation for the entity. For parsed entities this function returns
+    QString::null.
+*/
+QString QDomEntity::notationName() const
+{
+    if ( !impl )
+	return QString::null;
+    return IMPL->m_notationName;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomEntity::isEntity() const
+{
+    return TRUE;
+}
+
+#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 )
+{
+}
+
+QDomEntityReferencePrivate::~QDomEntityReferencePrivate()
+{
+}
+
+QDomNodePrivate* QDomEntityReferencePrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomEntityReferencePrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void QDomEntityReferencePrivate::save( QTextStream& s, int, int ) const
+{
+    s << "&" << name << ";";
+}
+
+/**************************************************************
+ *
+ * QDomEntityReference
+ *
+ **************************************************************/
+
+#define IMPL ((QDomEntityReferencePrivate*)impl)
+
+/*!
+    \class QDomEntityReference qdom.h
+    \reentrant
+    \brief The QDomEntityReference class represents an XML entity reference.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 descendents of the
+    entity reference are read-only.
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomEntityReference::~QDomEntityReference()
+{
+}
+
+/*!
+    Returns \c EntityReference.
+*/
+QDomNode::NodeType QDomEntityReference::nodeType() const
+{
+    return EntityReferenceNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomEntityReference::isEntityReference() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * 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 )
+{
+}
+
+QDomProcessingInstructionPrivate::~QDomProcessingInstructionPrivate()
+{
+}
+
+QDomNodePrivate* QDomProcessingInstructionPrivate::cloneNode( bool deep)
+{
+    QDomNodePrivate* p = new QDomProcessingInstructionPrivate( this, deep );
+    // We are not interested in this node
+    p->deref();
+    return p;
+}
+
+void QDomProcessingInstructionPrivate::save( QTextStream& s, int, int ) const
+{
+    s << "<?" << name << " " << value << "?>" << endl;
+}
+
+/**************************************************************
+ *
+ * QDomProcessingInstruction
+ *
+ **************************************************************/
+
+#define IMPL ((QDomProcessingInstructionPrivate*)impl)
+
+/*!
+    \class QDomProcessingInstruction qdom.h
+    \reentrant
+    \brief The QDomProcessingInstruction class represents an XML processing
+    instruction.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Processing instructions are used in XML to keep processor-specific
+    information in the text of the document.
+
+    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
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    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 );
+}
+
+/*!
+    Destroys the object and frees its resources.
+*/
+QDomProcessingInstruction::~QDomProcessingInstruction()
+{
+}
+
+/*!
+    Returns \c ProcessingInstructionNode.
+*/
+QDomNode::NodeType QDomProcessingInstruction::nodeType() const
+{
+    return ProcessingInstructionNode;
+}
+
+/*!
+    Returns the target of this processing instruction.
+
+    \sa data()
+*/
+QString QDomProcessingInstruction::target() const
+{
+    if ( !impl )
+	return QString::null;
+    return impl->nodeName();
+}
+
+/*!
+    Returns the content of this processing instruction.
+
+    \sa setData() target()
+*/
+QString QDomProcessingInstruction::data() const
+{
+    if ( !impl )
+	return QString::null;
+    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 );
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomProcessingInstruction::isProcessingInstruction() const
+{
+    return TRUE;
+}
+
+#undef IMPL
+
+/**************************************************************
+ *
+ * QDomDocumentPrivate
+ *
+ **************************************************************/
+
+QDomDocumentPrivate::QDomDocumentPrivate()
+    : QDomNodePrivate( 0 )
+{
+    impl = new QDomImplementationPrivate();
+    type = new QDomDocumentTypePrivate( this, this );
+
+    name = "#document";
+}
+
+QDomDocumentPrivate::QDomDocumentPrivate( const QString& aname )
+    : QDomNodePrivate( 0 )
+{
+    impl = new QDomImplementationPrivate();
+    type = new QDomDocumentTypePrivate( this, this );
+    type->name = aname;
+
+    name = "#document";
+}
+
+QDomDocumentPrivate::QDomDocumentPrivate( QDomDocumentTypePrivate* dt )
+    : QDomNodePrivate( 0 )
+{
+    impl = new QDomImplementationPrivate();
+    if ( dt != 0 ) {
+	type = dt;
+	type->ref();
+    } else {
+	type = new QDomDocumentTypePrivate( this, this );
+    }
+
+    name = "#document";
+}
+
+QDomDocumentPrivate::QDomDocumentPrivate( QDomDocumentPrivate* n, bool deep )
+    : QDomNodePrivate( n, deep )
+{
+    impl = n->impl->clone();
+    // Reference count is down to 0, so we set it to 1 here.
+    impl->ref();
+    type = (QDomDocumentTypePrivate*)n->type->cloneNode();
+    type->setParent( this );
+    // Reference count is down to 0, so we set it to 1 here.
+    type->ref();
+}
+
+QDomDocumentPrivate::~QDomDocumentPrivate()
+{
+    if ( impl->deref() ) delete impl;
+    if ( type->deref() ) delete type;
+}
+
+void QDomDocumentPrivate::clear()
+{
+    if ( impl->deref() ) delete impl;
+    if ( type->deref() ) delete type;
+    impl = 0;
+    type = 0;
+    QDomNodePrivate::clear();
+}
+
+bool QDomDocumentPrivate::setContent( QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn )
+{
+    QXmlSimpleReader reader;
+    if ( namespaceProcessing ) {
+	reader.setFeature( "http://xml.org/sax/features/namespaces", TRUE );
+	reader.setFeature( "http://xml.org/sax/features/namespace-prefixes", FALSE );
+    } else {
+	reader.setFeature( "http://xml.org/sax/features/namespaces", FALSE );
+	reader.setFeature( "http://xml.org/sax/features/namespace-prefixes", TRUE );
+    }
+    reader.setFeature( "http://trolltech.com/xml/features/report-whitespace-only-CharData", FALSE );
+    reader.setUndefEntityInAttrHack( TRUE );
+
+    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( "http://xml.org/sax/features/namespaces" )
+	&& !reader->feature( "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->deref();
+    return p;
+}
+
+QDomElementPrivate* QDomDocumentPrivate::documentElement()
+{
+    QDomNodePrivate* p = first;
+    while ( p && !p->isElement() )
+	p = p->next;
+
+    return (QDomElementPrivate*)p;
+}
+
+QDomElementPrivate* QDomDocumentPrivate::createElement( const QString& tagName )
+{
+    QDomElementPrivate* e = new QDomElementPrivate( this, 0, tagName );
+    e->deref();
+    return e;
+}
+
+QDomElementPrivate* QDomDocumentPrivate::createElementNS( const QString& nsURI, const QString& qName )
+{
+    QDomElementPrivate* e = new QDomElementPrivate( this, 0, nsURI, qName );
+    e->deref();
+    return e;
+}
+
+QDomDocumentFragmentPrivate* QDomDocumentPrivate::createDocumentFragment()
+{
+    QDomDocumentFragmentPrivate* f = new QDomDocumentFragmentPrivate( this, (QDomNodePrivate*)0 );
+    f->deref();
+    return f;
+}
+
+QDomTextPrivate* QDomDocumentPrivate::createTextNode( const QString& data )
+{
+    QDomTextPrivate* t = new QDomTextPrivate( this, 0, data );
+    t->deref();
+    return t;
+}
+
+QDomCommentPrivate* QDomDocumentPrivate::createComment( const QString& data )
+{
+    QDomCommentPrivate* c = new QDomCommentPrivate( this, 0, data );
+    c->deref();
+    return c;
+}
+
+QDomCDATASectionPrivate* QDomDocumentPrivate::createCDATASection( const QString& data )
+{
+    QDomCDATASectionPrivate* c = new QDomCDATASectionPrivate( this, 0, data );
+    c->deref();
+    return c;
+}
+
+QDomProcessingInstructionPrivate* QDomDocumentPrivate::createProcessingInstruction( const QString& target, const QString& data )
+{
+    QDomProcessingInstructionPrivate* p = new QDomProcessingInstructionPrivate( this, 0, target, data );
+    p->deref();
+    return p;
+}
+
+QDomAttrPrivate* QDomDocumentPrivate::createAttribute( const QString& aname )
+{
+    QDomAttrPrivate* a = new QDomAttrPrivate( this, 0, aname );
+    a->deref();
+    return a;
+}
+
+QDomAttrPrivate* QDomDocumentPrivate::createAttributeNS( const QString& nsURI, const QString& qName )
+{
+    QDomAttrPrivate* a = new QDomAttrPrivate( this, 0, nsURI, qName );
+    a->deref();
+    return a;
+}
+
+QDomEntityReferencePrivate* QDomDocumentPrivate::createEntityReference( const QString& aname )
+{
+    QDomEntityReferencePrivate* e = new QDomEntityReferencePrivate( this, 0, aname );
+    e->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->deref();
+    }
+    return node;
+}
+
+void QDomDocumentPrivate::save( QTextStream& s, int, int indent ) const
+{
+    bool doc = FALSE;
+
+    QDomNodePrivate* n = first;
+    if ( n && n->isProcessingInstruction() && n->nodeName()=="xml" ) {
+	// we have an XML declaration
+	QString data = n->nodeValue();
+	QRegExp encoding( QString::fromLatin1("encoding\\s*=\\s*((\"([^\"]*)\")|('([^']*)'))") );
+	encoding.search( data );
+	QString enc = encoding.cap(3);
+	if ( enc.isEmpty() ) {
+	    enc = encoding.cap(5);
+	}
+	if ( enc.isEmpty() ) {
+	    s.setEncoding( QTextStream::UnicodeUTF8 );
+	} else {
+	    s.setCodec( QTextCodec::codecForName( enc ) );
+	}
+    } else {
+	s.setEncoding( QTextStream::UnicodeUTF8 );
+    }
+    while ( n ) {
+	if ( !doc && !(n->isProcessingInstruction()&&n->nodeName()=="xml") ) {
+	    // save doctype after XML declaration
+	    type->save( s, 0, indent );
+	    doc = TRUE;
+	}
+	n->save( s, 0, indent );
+	n = n->next;
+    }
+}
+
+/**************************************************************
+ *
+ * QDomDocument
+ *
+ **************************************************************/
+
+#define IMPL ((QDomDocumentPrivate*)impl)
+
+/*!
+    \class QDomDocument qdom.h
+    \reentrant
+    \brief The QDomDocument class represents an XML document.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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:
+    \code
+    QDomDocument doc( "mydocument" );
+    QFile file( "mydocument.xml" );
+    if ( !file.open( IO_ReadOnly ) )
+	return;
+    if ( !doc.setContent( &file ) ) {
+	file.close();
+	return;
+    }
+    file.close();
+
+    // print out the element names of all elements that are direct children
+    // of the outermost element.
+    QDomElement docElem = doc.documentElement();
+
+    QDomNode n = docElem.firstChild();
+    while( !n.isNull() ) {
+	QDomElement e = n.toElement(); // try to convert the node to an element.
+	if( !e.isNull() ) {
+	    cout << e.tagName() << endl; // the node really is an element.
+	}
+	n = n.nextSibling();
+    }
+
+    // Here we append a new element to the end of the document
+    QDomElement elem = doc.createElement( "img" );
+    elem.setAttribute( "src", "myimage.png" );
+    docElem.appendChild( elem );
+    \endcode
+
+    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:
+    \code
+    QDomDocument doc( "MyML" );
+    QDomElement root = doc.createElement( "MyML" );
+    doc.appendChild( root );
+
+    QDomElement tag = doc.createElement( "Greeting" );
+    root.appendChild( tag );
+
+    QDomText t = doc.createTextNode( "Hello World" );
+    tag.appendChild( t );
+
+    QString xml = doc.toString();
+    \endcode
+
+    For further information about the Document Object Model see
+    \link http://www.w3.org/TR/REC-DOM-Level-1/\endlink and
+    \link http://www.w3.org/TR/DOM-Level-2-Core/\endlink.
+    For a more general introduction of the DOM implementation see the
+    QDomDocument documentation.
+*/
+
+
+/*!
+    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.
+    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 );
+}
+
+/*!
+    This function parses the XML document from the byte array \a
+    buffer 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, the function returns FALSE; otherwise it
+    returns TRUE. If a parse error occurs and \a errorMsg, \a
+    errorLine and \a errorColumn are not 0, the error message is
+    placed in \a *errorMsg, the line number \a *errorLine and the
+    column number in \a *errorColumn.
+
+    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.
+
+    If \a namespaceProcessing is FALSE, the functions
+    QDomNode::prefix(), QDomNode::localName() and
+    QDomNode::namespaceURI() return QString::null.
+
+    \sa QDomNode::namespaceURI() QDomNode::localName()
+    QDomNode::prefix() QString::isNull() QString::isEmpty()
+*/
+bool QDomDocument::setContent( const QByteArray& buffer, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn )
+{
+    if ( !impl )
+	impl = new QDomDocumentPrivate;
+    QBuffer buf( buffer );
+    QXmlInputSource source( &buf );
+    return IMPL->setContent( &source, namespaceProcessing, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the C string \a buffer.
+
+    \warning This function does not try to detect the encoding:
+    instead it assumes that the C string is UTF-8 encoded.
+*/
+bool QDomDocument::setContent( const QCString& buffer, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn )
+{
+    return setContent( QString::fromUtf8( buffer, buffer.length() ), namespaceProcessing, errorMsg, errorLine, errorColumn );
+}
+
+/*!
+    \overload
+
+    This function reads the XML document from the IO device \a dev.
+*/
+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
+
+    This function reads the XML document from the string \a text.
+    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.
+
+    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 C string \a buffer.
+
+    No namespace processing is performed.
+
+    \warning This function does not try to detect the encoding:
+    instead it assumes that the C string is UTF-8 encoded.
+*/
+bool QDomDocument::setContent( const QCString& 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.
+
+    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.
+
+    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 appropriate.
+
+    \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.
+
+    \sa toCString()
+*/
+QString QDomDocument::toString() const
+{
+    QString str;
+    QTextStream s( str, IO_WriteOnly );
+    save( s, 1 );
+
+    return str;
+}
+
+/*!
+    \overload
+
+    This function uses \a indent as the amount of space to indent
+    subelements.
+*/
+QString QDomDocument::toString( int indent ) const
+{
+    QString str;
+    QTextStream s( str, IO_WriteOnly );
+    save( s, indent );
+
+    return str;
+}
+
+/*!
+    Converts the parsed document back to its textual representation
+    and returns a QCString for that is encoded in UTF-8.
+
+    \sa toString()
+*/
+QCString QDomDocument::toCString() const
+{
+    // ### if there is an encoding specified in the xml declaration, this
+    // encoding declaration should be changed to utf8
+    return toString().utf8();
+}
+
+/*!
+    \overload
+
+    This function uses \a indent as the amount of space to indent
+    subelements.
+*/
+QCString QDomDocument::toCString( int indent ) const
+{
+    // ### if there is an encoding specified in the xml declaration, this
+    // encoding declaration should be changed to utf8
+    return toString( indent ).utf8();
+}
+
+
+/*!
+    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().
+
+    \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().
+
+    \warning All characters within an XML document must be in the range:
+
+    #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+
+    This rule also applies to characters encoded as character entities and
+    characters in CDATA sections. If you use this function to insert
+    characters outside of this range, the document will not be well-formed.
+
+    If you want to store binary data in an XML document you must either use
+    your own scheme to escape illegal characters, or you must store it in
+    an external unparsed entity.
+
+    \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().
+
+    \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().
+
+    \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.
+
+    \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().
+
+    \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().
+
+    \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 descendents 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 Behaviour
+    \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 Descendents 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).
+
+    \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).
+
+    \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*/ )
+{
+    return QDomElement();
+}
+
+/*!
+    Returns \c DocumentNode.
+*/
+QDomNode::NodeType QDomDocument::nodeType() const
+{
+    return DocumentNode;
+}
+
+/*!
+    Returns TRUE.
+*/
+bool QDomDocument::isDocument() const
+{
+    return TRUE;
+}
+
+
+#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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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()
+{
+    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 );
+    }
+    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;
+
+    if ( cdata ) {
+	node->appendChild( doc->createCDATASection( ch ) );
+    } else if ( !entityName.isEmpty() ) {
+	QDomEntityPrivate* e = new QDomEntityPrivate( doc, 0, entityName,
+		QString::null, QString::null, QString::null );
+	e->value = ch;
+	doc->doctype()->appendChild( e );
+	node->appendChild( doc->createEntityReference( entityName ) );
+    } else {
+	node->appendChild( doc->createTextNode( ch ) );
+    }
+
+    return TRUE;
+}
+
+bool QDomHandler::processingInstruction( const QString& target, const QString& data )
+{
+    node->appendChild( doc->createProcessingInstruction( target, data ) );
+    return TRUE;
+}
+
+bool QDomHandler::skippedEntity( const QString& name )
+{
+    node->appendChild( doc->createEntityReference( name ) );
+    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 = QString::null;
+    return TRUE;
+}
+
+bool QDomHandler::comment( const QString& ch )
+{
+    node->appendChild( doc->createComment( ch ) );
+    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::null );
+}
+
+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;
+}
+
+#endif //QT_NO_DOM
diff --git a/src/xml/qdom.h b/src/xml/qdom.h
new file mode 100644
index 0000000..4bc284f
--- /dev/null
+++ b/src/xml/qdom.h
@@ -0,0 +1,677 @@
+/****************************************************************************
+**
+** Definition of QDomDocument and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QDOM_H
+#define QDOM_H
+
+#ifndef QT_H
+#include "qstring.h"
+#endif // QT_H
+
+#if !defined(QT_MODULE_XML) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_XML )
+#define QM_EXPORT_DOM
+#else
+#define QM_EXPORT_DOM Q_EXPORT
+#endif
+
+#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 QM_EXPORT_DOM QDomImplementation
+{
+public:
+    QDomImplementation();
+    QDomImplementation( const QDomImplementation& );
+    virtual ~QDomImplementation();
+    QDomImplementation& operator= ( const QDomImplementation& );
+    bool operator== ( const QDomImplementation& ) const;
+    bool operator!= ( const QDomImplementation& ) const;
+
+    // functions
+    virtual bool hasFeature( const QString& feature, const QString& version );
+    virtual QDomDocumentType createDocumentType( const QString& qName, const QString& publicId, const QString& systemId );
+    virtual QDomDocument createDocument( const QString& nsURI, const QString& qName, const QDomDocumentType& doctype );
+
+    // Qt extension
+    bool isNull();
+
+private:
+    QDomImplementationPrivate* impl;
+    QDomImplementation( QDomImplementationPrivate* );
+
+    friend class QDomDocument;
+};
+
+class QM_EXPORT_DOM 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
+    };
+
+    QDomNode();
+    QDomNode( const QDomNode& );
+    QDomNode& operator= ( const QDomNode& );
+    bool operator== ( const QDomNode& ) const;
+    bool operator!= ( const QDomNode& ) const;
+    virtual ~QDomNode();
+
+    // DOM functions
+    virtual QDomNode insertBefore( const QDomNode& newChild, const QDomNode& refChild );
+    virtual QDomNode insertAfter( const QDomNode& newChild, const QDomNode& refChild );
+    virtual QDomNode replaceChild( const QDomNode& newChild, const QDomNode& oldChild );
+    virtual QDomNode removeChild( const QDomNode& oldChild );
+    virtual QDomNode appendChild( const QDomNode& newChild );
+    virtual bool hasChildNodes() const;
+    virtual QDomNode cloneNode( bool deep = TRUE ) const;
+    virtual void normalize();
+    virtual bool isSupported( const QString& feature, const QString& version ) const;
+
+    // DOM read only attributes
+    virtual QString nodeName() const;
+    virtual QDomNode::NodeType nodeType() const;
+    virtual QDomNode         parentNode() const;
+    virtual QDomNodeList     childNodes() const;
+    virtual QDomNode         firstChild() const;
+    virtual QDomNode         lastChild() const;
+    virtual QDomNode         previousSibling() const;
+    virtual QDomNode         nextSibling() const;
+    virtual QDomNamedNodeMap attributes() const;
+    virtual QDomDocument     ownerDocument() const;
+    virtual QString namespaceURI() const;
+    virtual QString localName() const;
+    virtual bool hasAttributes() const;
+
+    // DOM attributes
+    virtual QString nodeValue() const;
+    virtual void setNodeValue( const QString& );
+    virtual QString prefix() const;
+    virtual void setPrefix( const QString& pre );
+
+    // Qt extensions
+    virtual bool isAttr() const;
+    virtual bool isCDATASection() const;
+    virtual bool isDocumentFragment() const;
+    virtual bool isDocument() const;
+    virtual bool isDocumentType() const;
+    virtual bool isElement() const;
+    virtual bool isEntityReference() const;
+    virtual bool isText() const;
+    virtual bool isEntity() const;
+    virtual bool isNotation() const;
+    virtual bool isProcessingInstruction() const;
+    virtual bool isCharacterData() const;
+    virtual 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();
+    QDomCDATASection toCDATASection();
+    QDomDocumentFragment toDocumentFragment();
+    QDomDocument toDocument();
+    QDomDocumentType toDocumentType();
+    QDomElement toElement();
+    QDomEntityReference toEntityReference();
+    QDomText toText();
+    QDomEntity toEntity();
+    QDomNotation toNotation();
+    QDomProcessingInstruction toProcessingInstruction();
+    QDomCharacterData toCharacterData();
+    QDomComment toComment();
+
+    void save( QTextStream&, int ) const;
+
+protected:
+    QDomNodePrivate* impl;
+    QDomNode( QDomNodePrivate* );
+
+private:
+    friend class QDomDocument;
+    friend class QDomDocumentType;
+    friend class QDomNodeList;
+    friend class QDomNamedNodeMap;
+};
+
+class QM_EXPORT_DOM QDomNodeList
+{
+public:
+    QDomNodeList();
+    QDomNodeList( const QDomNodeList& );
+    QDomNodeList& operator= ( const QDomNodeList& );
+    bool operator== ( const QDomNodeList& ) const;
+    bool operator!= ( const QDomNodeList& ) const;
+    virtual ~QDomNodeList();
+
+    // DOM functions
+    virtual QDomNode item( int index ) const;
+
+    // DOM read only attributes
+    virtual uint length() const;
+    uint count() const { return length(); } // Qt API consitancy
+
+private:
+    QDomNodeListPrivate* impl;
+    QDomNodeList( QDomNodeListPrivate* );
+
+    friend class QDomNode;
+    friend class QDomElement;
+    friend class QDomDocument;
+};
+
+class QM_EXPORT_DOM QDomDocumentType : public QDomNode
+{
+public:
+    QDomDocumentType();
+    QDomDocumentType( const QDomDocumentType& x );
+    QDomDocumentType& operator= ( const QDomDocumentType& );
+    ~QDomDocumentType();
+
+    // DOM read only attributes
+    virtual QString name() const;
+    virtual QDomNamedNodeMap entities() const;
+    virtual QDomNamedNodeMap notations() const;
+    virtual QString publicId() const;
+    virtual QString systemId() const;
+    virtual QString internalSubset() const;
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isDocumentType() const;
+
+private:
+    QDomDocumentType( QDomDocumentTypePrivate* );
+
+    friend class QDomImplementation;
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomDocument : public QDomNode
+{
+public:
+    QDomDocument();
+    Q_EXPLICIT QDomDocument( const QString& name );
+    Q_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;
+
+    // Qt extensions
+    bool setContent( const QCString& text, bool namespaceProcessing, QString *errorMsg=0, int *errorLine=0, int *errorColumn=0  );
+    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( const QCString& text, 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  );
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isDocument() const;
+
+    // Qt extensions
+    QString toString() const; // ### Qt 4: merge the two overloads
+    QString toString( int ) const;
+    QCString toCString() const; // ### Qt 4: merge the two overloads
+    QCString toCString( int ) const;
+
+private:
+    QDomDocument( QDomDocumentPrivate* );
+
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM 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;
+    uint count() const { return length(); } // Qt API consitancy
+
+    // Qt extension
+    bool contains( const QString& name ) const;
+
+private:
+    QDomNamedNodeMapPrivate* impl;
+    QDomNamedNodeMap( QDomNamedNodeMapPrivate* );
+
+    friend class QDomNode;
+    friend class QDomDocumentType;
+    friend class QDomElement;
+};
+
+class QM_EXPORT_DOM QDomDocumentFragment : public QDomNode
+{
+public:
+    QDomDocumentFragment();
+    QDomDocumentFragment( const QDomDocumentFragment& x );
+    QDomDocumentFragment& operator= ( const QDomDocumentFragment& );
+    ~QDomDocumentFragment();
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isDocumentFragment() const;
+
+private:
+    QDomDocumentFragment( QDomDocumentFragmentPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomCharacterData : public QDomNode
+{
+public:
+    QDomCharacterData();
+    QDomCharacterData( const QDomCharacterData& x );
+    QDomCharacterData& operator= ( const QDomCharacterData& );
+    ~QDomCharacterData();
+
+    // DOM functions
+    virtual QString substringData( unsigned long offset, unsigned long count );
+    virtual void appendData( const QString& arg );
+    virtual void insertData( unsigned long offset, const QString& arg );
+    virtual void deleteData( unsigned long offset, unsigned long count );
+    virtual void replaceData( unsigned long offset, unsigned long count, const QString& arg );
+
+    // DOM read only attributes
+    virtual uint length() const;
+
+    // DOM attributes
+    virtual QString data() const;
+    virtual void setData( const QString& );
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isCharacterData() const;
+
+private:
+    QDomCharacterData( QDomCharacterDataPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomText;
+    friend class QDomComment;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomAttr : public QDomNode
+{
+public:
+    QDomAttr();
+    QDomAttr( const QDomAttr& x );
+    QDomAttr& operator= ( const QDomAttr& );
+    ~QDomAttr();
+
+    // DOM read only attributes
+    virtual QString name() const;
+    virtual bool specified() const;
+    virtual QDomElement ownerElement() const;
+
+    // DOM attributes
+    virtual QString value() const;
+    virtual void setValue( const QString& );
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isAttr() const;
+
+private:
+    QDomAttr( QDomAttrPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomElement;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomElement : public QDomNode
+{
+public:
+    QDomElement();
+    QDomElement( const QDomElement& x );
+    QDomElement& operator= ( const QDomElement& );
+    ~QDomElement();
+
+    // DOM functions
+    QString attribute( const QString& name, const QString& defValue = QString::null ) const;
+    void setAttribute( const QString& name, const QString& value );
+    void setAttribute( const QString& name, int value );
+    void setAttribute( const QString& name, uint value );
+    void setAttribute( const QString& name, long value );
+    void setAttribute( const QString& name, ulong 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 );
+    virtual QDomNodeList elementsByTagName( const QString& tagname ) const;
+    bool hasAttribute( const QString& name ) const;
+
+    QString attributeNS( const QString nsURI, const QString& localName, const QString& defValue ) const;
+    void setAttributeNS( const QString nsURI, const QString& qName, const QString& value );
+    void setAttributeNS( const QString nsURI, const QString& qName, int value );
+    void setAttributeNS( const QString nsURI, const QString& qName, uint value );
+    void setAttributeNS( const QString nsURI, const QString& qName, long value );
+    void setAttributeNS( const QString nsURI, const QString& qName, ulong 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 );
+    virtual 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
+
+    // Reimplemented from QDomNode
+    QDomNamedNodeMap attributes() const;
+    QDomNode::NodeType nodeType() const;
+    bool isElement() const;
+
+    QString text() const;
+
+private:
+    QDomElement( QDomElementPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomNode;
+    friend class QDomAttr;
+};
+
+class QM_EXPORT_DOM QDomText : public QDomCharacterData
+{
+public:
+    QDomText();
+    QDomText( const QDomText& x );
+    QDomText& operator= ( const QDomText& );
+    ~QDomText();
+
+    // DOM functions
+    QDomText splitText( int offset );
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isText() const;
+
+private:
+    QDomText( QDomTextPrivate* );
+
+    friend class QDomCDATASection;
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomComment : public QDomCharacterData
+{
+public:
+    QDomComment();
+    QDomComment( const QDomComment& x );
+    QDomComment& operator= ( const QDomComment& );
+    ~QDomComment();
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isComment() const;
+
+private:
+    QDomComment( QDomCommentPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomCDATASection : public QDomText
+{
+public:
+    QDomCDATASection();
+    QDomCDATASection( const QDomCDATASection& x );
+    QDomCDATASection& operator= ( const QDomCDATASection& );
+    ~QDomCDATASection();
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isCDATASection() const;
+
+private:
+    QDomCDATASection( QDomCDATASectionPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomNotation : public QDomNode
+{
+public:
+    QDomNotation();
+    QDomNotation( const QDomNotation& x );
+    QDomNotation& operator= ( const QDomNotation& );
+    ~QDomNotation();
+
+    // DOM read only attributes
+    QString publicId() const;
+    QString systemId() const;
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isNotation() const;
+
+private:
+    QDomNotation( QDomNotationPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomEntity : public QDomNode
+{
+public:
+    QDomEntity();
+    QDomEntity( const QDomEntity& x );
+    QDomEntity& operator= ( const QDomEntity& );
+    ~QDomEntity();
+
+    // DOM read only attributes
+    virtual QString publicId() const;
+    virtual QString systemId() const;
+    virtual QString notationName() const;
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isEntity() const;
+
+private:
+    QDomEntity( QDomEntityPrivate* );
+
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomEntityReference : public QDomNode
+{
+public:
+    QDomEntityReference();
+    QDomEntityReference( const QDomEntityReference& x );
+    QDomEntityReference& operator= ( const QDomEntityReference& );
+    ~QDomEntityReference();
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isEntityReference() const;
+
+private:
+    QDomEntityReference( QDomEntityReferencePrivate* );
+
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+class QM_EXPORT_DOM QDomProcessingInstruction : public QDomNode
+{
+public:
+    QDomProcessingInstruction();
+    QDomProcessingInstruction( const QDomProcessingInstruction& x );
+    QDomProcessingInstruction& operator= ( const QDomProcessingInstruction& );
+    ~QDomProcessingInstruction();
+
+    // DOM read only attributes
+    virtual QString target() const;
+
+    // DOM attributes
+    virtual QString data() const;
+    virtual void setData( const QString& d );
+
+    // Reimplemented from QDomNode
+    QDomNode::NodeType nodeType() const;
+    bool isProcessingInstruction() const;
+
+private:
+    QDomProcessingInstruction( QDomProcessingInstructionPrivate* );
+
+    friend class QDomDocument;
+    friend class QDomNode;
+};
+
+
+QM_EXPORT_DOM QTextStream& operator<<( QTextStream&, const QDomNode& );
+
+#endif //QT_NO_DOM
+#endif // QDOM_H
diff --git a/src/xml/qsvgdevice.cpp b/src/xml/qsvgdevice.cpp
new file mode 100644
index 0000000..1f184f1
--- /dev/null
+++ b/src/xml/qsvgdevice.cpp
@@ -0,0 +1,1591 @@
+/****************************************************************************
+**
+** Implementation of the QSvgDevice class
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+*****************************************************************************/
+
+#include <private/qsvgdevice_p.h>
+
+#ifndef QT_NO_SVG
+
+#include "qpainter.h"
+#include "qpaintdevicemetrics.h"
+#include "qfile.h"
+#include "qmap.h"
+#include "qregexp.h"
+#include "qvaluelist.h"
+#include "qtextstream.h"
+#include "qimage.h"
+#include "qpixmap.h"
+
+#include <math.h>
+
+const double deg2rad = 0.017453292519943295769;	// pi/180
+const char piData[] = "version=\"1.0\" standalone=\"no\"";
+const char publicId[] = "-//W3C//DTD SVG 20001102//EN";
+const char systemId[] = "http://www.w3.org/TR/2000/CR-SVG-20001102/DTD/svg-20001102.dtd";
+
+struct QM_EXPORT_SVG ImgElement {
+    QDomElement element;
+    QImage image;
+    Q_DUMMY_COMPARISON_OPERATOR( ImgElement )
+};
+
+struct QM_EXPORT_SVG PixElement {
+    QDomElement element;
+    QPixmap pixmap;
+    Q_DUMMY_COMPARISON_OPERATOR( PixElement )
+};
+
+struct QSvgDeviceState {
+    int textx, texty;			// current text position
+    int textalign;			// text alignment
+    Q_DUMMY_COMPARISON_OPERATOR( QSvgDeviceState )
+};
+
+typedef QValueList<ImgElement> ImageList;
+typedef QValueList<PixElement> PixmapList;
+typedef QValueList<QSvgDeviceState> StateList;
+
+class QSvgDevicePrivate {
+public:
+    ImageList images;
+    PixmapList pixmaps;
+    StateList stack;
+    int currentClip;
+
+    uint justRestored : 1;
+
+    QMap<QString, QRegion> clipPathTable;
+};
+
+enum ElementType {
+    InvalidElement = 0,
+    AnchorElement,
+    CircleElement,
+    ClipElement,
+    CommentElement,
+    DescElement,
+    EllipseElement,
+    GroupElement,
+    ImageElement,
+    LineElement,
+    PolylineElement,
+    PolygonElement,
+    PathElement,
+    RectElement,
+    SvgElement,
+    TextElement,
+    TitleElement,
+    TSpanElement
+};
+
+typedef QMap<QString,ElementType> QSvgTypeMap;
+static QSvgTypeMap *qSvgTypeMap=0; // element types
+static QMap<QString,QString> *qSvgColMap=0; // recognized color keyword names
+
+/*!
+    \class QSvgDevice qsvgdevice.h
+    \brief The QSvgDevice class provides a paint device for SVG vector graphics.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \ingroup xml-tools
+    \module XML
+    \internal
+
+    SVG is an XML vector graphics format. This class supports the
+    loading and saving of SVG files with load() and save(), and the
+    rendering of an SVG onto a QPainter using play(). Use toString()
+    to put the SVG into a string.
+
+    \sa QPaintDevice QPainter
+*/
+
+/*!
+    Creates a QSvgDevice object.
+*/
+
+QSvgDevice::QSvgDevice()
+    : QPaintDevice( QInternal::ExternalDevice ),
+      pt( 0 )
+{
+    d = new QSvgDevicePrivate;
+    d->currentClip = 0;
+    d->justRestored = FALSE;
+}
+
+/*!
+    Destroys the QSvgDevice object and frees the resources it used.
+*/
+
+QSvgDevice::~QSvgDevice()
+{
+    delete qSvgTypeMap; qSvgTypeMap = 0;	// static
+    delete qSvgColMap; qSvgColMap = 0;
+    delete d;
+}
+
+/*!
+    Loads and parses a SVG from \a dev into the device. Returns TRUE
+    on success (i.e. loaded and parsed without error); otherwise
+    returns FALSE.
+*/
+
+bool QSvgDevice::load( QIODevice *dev )
+{
+    return doc.setContent( dev );
+}
+
+/*!
+    Renders (replays) the SVG on the \a painter and returns TRUE if
+    successful (i.e. it is a valid SVG); otherwise returns FALSE.
+*/
+
+bool QSvgDevice::play( QPainter *painter )
+{
+    if ( !painter ) {
+#if defined(QT_CHECK_RANGE)
+	Q_ASSERT( painter );
+#endif
+	return FALSE;
+    }
+    pt = painter;
+    pt->setPen( Qt::NoPen ); // SVG default pen and brush
+    pt->setBrush( Qt::black );
+    if ( doc.isNull() ) {
+	qWarning( "QSvgDevice::play: No SVG data set." );
+	return FALSE;
+    }
+
+    QDomNode svg = doc.namedItem( "svg" );
+    if ( svg.isNull() || !svg.isElement() ) {
+	qWarning( "QSvgDevice::play: Couldn't find any svg element." );
+	return FALSE;
+    }
+
+    // force transform to be activated in case our sequences
+    // are replayed later with a transformed painter
+    painter->setWorldXForm( TRUE );
+
+    QDomNamedNodeMap attr = svg.attributes();
+    int x = lenToInt( attr, "x" );
+    int y = lenToInt( attr, "y" );
+    brect.setX( x );
+    brect.setY( y );
+    QString wstr = attr.contains( "width" )
+		   ? attr.namedItem( "width" ).nodeValue() : QString( "100%" );
+    QString hstr = attr.contains( "height" )
+		   ? attr.namedItem( "height" ).nodeValue() : QString( "100%" );
+    double width = parseLen( wstr, 0, TRUE );
+    double height = parseLen( hstr, 0, FALSE );
+    // SVG doesn't respect x and y. But we want a proper bounding rect.
+    brect.setWidth( int(width) - x );
+    brect.setHeight( int(height) - y );
+    painter->setClipRect( brect, QPainter::CoordPainter );
+
+    if ( attr.contains( "viewBox" ) ) {
+	QRegExp re( QString::fromLatin1("\\s*(\\S+)\\s*,?\\s*(\\S+)\\s*,?"
+					"\\s*(\\S+)\\s*,?\\s*(\\S+)\\s*") );
+	if ( re.search( attr.namedItem( "viewBox" ).nodeValue() ) < 0 ) {
+	    qWarning( "QSvgDevice::play: Invalid viewBox attribute.");
+	    return FALSE;
+	} else {
+	    double x = re.cap( 1 ).toDouble();
+	    double y = re.cap( 2 ).toDouble();
+	    double w = re.cap( 3 ).toDouble();
+	    double h = re.cap( 4 ).toDouble();
+	    if ( w < 0 || h < 0 ) {
+		qWarning( "QSvgDevice::play: Invalid viewBox dimension.");
+		return FALSE;
+	    } else if ( w == 0 || h == 0 ) {
+		return TRUE;
+	    }
+	    painter->scale( width/w, height/h );
+	    painter->translate( -x, -y );
+	}
+    }
+
+    const struct ElementTable {
+	const char *name;
+	ElementType type;
+    } etab[] = {
+	{ "a",        AnchorElement   },
+	{ "#comment", CommentElement  },
+        { "circle",   CircleElement   },
+	{ "clipPath", ClipElement     },
+	{ "desc",     DescElement     },
+        { "ellipse",  EllipseElement  },
+	{ "g",        GroupElement    },
+        { "image",    ImageElement    },
+        { "line",     LineElement     },
+        { "polyline", PolylineElement },
+        { "polygon",  PolygonElement  },
+        { "path",     PathElement     },
+        { "rect",     RectElement     },
+        { "svg",      SvgElement      },
+        { "text",     TextElement     },
+        { "tspan",    TSpanElement    },
+	{ "title",    TitleElement    },
+	{ 0,          InvalidElement  }
+    };
+    // initialize only once
+    if ( !qSvgTypeMap ) {
+	qSvgTypeMap = new QSvgTypeMap;
+	const ElementTable *t = etab;
+	while ( t->name ) {
+	    qSvgTypeMap->insert( t->name, t->type );
+	    t++;
+	}
+    }
+
+    // initial state
+    QSvgDeviceState st;
+    st.textx = st.texty = 0;
+    st.textalign = Qt::AlignLeft;
+    d->stack.append(st);
+    curr = &d->stack.last();
+    // 'play' all elements recursively starting with 'svg' as root
+    bool b = play( svg );
+    d->stack.remove( d->stack.begin() );
+    return b;
+}
+
+/*!
+    Returns the SVG as a single string of XML.
+*/
+QString QSvgDevice::toString() const
+{
+    if ( doc.isNull() )
+	return QString();
+
+    return doc.toString();
+}
+
+/*!
+    Saves the SVG to \a fileName.
+*/
+
+bool QSvgDevice::save( const QString &fileName )
+{
+    // guess svg id from fileName
+    QString svgName = fileName.endsWith( ".svg" ) ?
+		      fileName.left( fileName.length()-4 ) : fileName;
+
+    // now we have the info about name and dimensions available
+    QDomElement root = doc.documentElement();
+    root.setAttribute( "id", svgName );
+    // the standard doesn't take respect x and y. But we want a
+    // proper bounding rect. We make width and height bigger when
+    // writing out and subtract x and y when reading in.
+    root.setAttribute( "x", brect.x() );
+    root.setAttribute( "y", brect.y() );
+    root.setAttribute( "width", brect.width() + brect.x() );
+    root.setAttribute( "height", brect.height() + brect.y() );
+
+    // ... and know how to name any image files to be written out
+    int icount = 0;
+    ImageList::Iterator iit = d->images.begin();
+    for ( ; iit != d->images.end(); ++iit ) {
+	QString href = QString( "%1_%2.png" ).arg( svgName ).arg( icount );
+	(*iit).image.save( href, "PNG" );
+	(*iit).element.setAttribute( "xlink:href", href );
+	icount++;
+    }
+    PixmapList::Iterator pit = d->pixmaps.begin();
+    for ( ; pit != d->pixmaps.end(); ++pit ) {
+	QString href = QString( "%1_%2.png" ).arg( svgName ).arg( icount );
+	(*pit).pixmap.save( href, "PNG" );
+	(*pit).element.setAttribute( "xlink:href", href );
+	icount++;
+    }
+
+    QFile f( fileName );
+    if ( !f.open ( IO_WriteOnly ) )
+	return FALSE;
+    QTextStream s( &f );
+    s.setEncoding( QTextStream::UnicodeUTF8 );
+    s << doc;
+
+    return TRUE;
+}
+
+/*!
+    \overload
+
+    \a dev is the device to use for saving.
+*/
+
+bool QSvgDevice::save( QIODevice *dev )
+{
+#if defined(CHECK_RANGE)
+    if ( !d->images.isEmpty() || !d->pixmaps.isEmpty() )
+	qWarning( "QSvgDevice::save: skipping external images" );
+#endif
+
+    QTextStream s( dev );
+    s.setEncoding( QTextStream::UnicodeUTF8 );
+    s << doc;
+
+    return TRUE;
+}
+
+/*!
+    \fn QRect QSvgDevice::boundingRect() const
+
+    Returns the bounding rectangle of the SVG.
+*/
+
+/*!
+    Sets the bounding rectangle of the SVG to rectangle \a r.
+*/
+
+void QSvgDevice::setBoundingRect( const QRect &r )
+{
+    brect = r;
+}
+
+/*!
+    Internal implementation of the virtual QPaintDevice::metric()
+    function.
+
+    \warning Use the QPaintDeviceMetrics class instead.
+
+    A QSvgDevice has the following hard coded values: dpi=72,
+    numcolors=16777216 and depth=24. \a m is the metric to get.
+*/
+
+int QSvgDevice::metric( int m ) const
+{
+    int val;
+    switch ( m ) {
+    case QPaintDeviceMetrics::PdmWidth:
+	val = brect.width();
+	break;
+    case QPaintDeviceMetrics::PdmHeight:
+	val = brect.height();
+	break;
+    case QPaintDeviceMetrics::PdmWidthMM:
+	val = int(25.4/72.0*brect.width());
+	break;
+    case QPaintDeviceMetrics::PdmHeightMM:
+	val = int(25.4/72.0*brect.height());
+	break;
+    case QPaintDeviceMetrics::PdmDpiX:
+	val = 72;
+	break;
+    case QPaintDeviceMetrics::PdmDpiY:
+	val = 72;
+	break;
+    case QPaintDeviceMetrics::PdmNumColors:
+	val = 16777216;
+	break;
+    case QPaintDeviceMetrics::PdmDepth:
+	val = 24;
+	break;
+    default:
+	val = 0;
+#if defined(QT_CHECK_RANGE)
+	qWarning( "QSvgDevice::metric: Invalid metric command" );
+#endif
+    }
+    return val;
+}
+
+/*!
+    \internal
+
+    Records painter commands and stores them in the QDomDocument doc.
+*/
+
+bool QSvgDevice::cmd ( int c, QPainter *painter, QPDevCmdParam *p )
+{
+    pt = painter;
+
+    if ( c == PdcBegin ) {
+	QDomImplementation domImpl;
+	QDomDocumentType docType = domImpl.createDocumentType( "svg",
+							       publicId,
+							       systemId );
+	doc = domImpl.createDocument( "http://www.w3.org/2000/svg",
+				      "svg", docType );
+	doc.insertBefore( doc.createProcessingInstruction( "xml", piData ),
+			  doc.firstChild() );
+	current = doc.documentElement();
+	d->images.clear();
+	d->pixmaps.clear();
+	dirtyTransform = dirtyStyle = FALSE; // ###
+	return TRUE;
+    } else if ( c == PdcEnd ) {
+	return TRUE;
+    }
+
+    QDomElement e;
+    QString str;
+    QRect rect;
+    QPointArray a;
+    int i, width, height, x, y;
+    switch ( c ) {
+    case PdcNOP:
+	break;
+    case PdcMoveTo:
+	curPt = *p[0].point;
+	break;
+    case PdcLineTo:
+	e = doc.createElement( "line" );
+	e.setAttribute( "x1", curPt.x() );
+	e.setAttribute( "y1", curPt.y() );
+	e.setAttribute( "x2", p[0].point->x() );
+	e.setAttribute( "y2", p[0].point->y() );
+	break;
+    case PdcDrawPoint:
+    case PdcDrawLine:
+	e = doc.createElement( "line" );
+	e.setAttribute( "x1", p[0].point->x() );
+	e.setAttribute( "y1", p[0].point->y() );
+	i = ( c == PdcDrawLine ) ? 1 : 0;
+	e.setAttribute( "x2", p[i].point->x() );
+	e.setAttribute( "y2", p[i].point->y() );
+	break;
+    case PdcDrawRect:
+    case PdcDrawRoundRect:
+	e = doc.createElement( "rect" );
+	x = p[0].rect->x();
+	y = p[0].rect->y();
+	width = p[0].rect->width();
+	height = p[0].rect->height();
+	if ( width < 0 ) {
+	    width = -width;
+	    x -= width - 1;
+	}
+	if ( height < 0 ) {
+	    height = -height;
+	    y -= height - 1;
+	}
+	e.setAttribute( "x", x );
+	e.setAttribute( "y", y );
+	e.setAttribute( "width", width );
+	e.setAttribute( "height", height );
+	if ( c == PdcDrawRoundRect ) {
+	    e.setAttribute( "rx", (p[1].ival*p[0].rect->width())/200 );
+	    e.setAttribute( "ry", (p[2].ival*p[0].rect->height())/200 );
+	}
+	break;
+    case PdcDrawEllipse:
+	rect = *p[0].rect;
+	if ( rect.width() == rect.height() ) {
+	    e = doc.createElement( "circle" );
+	    double cx = rect.x() + (rect.width() / 2.0);
+	    double cy = rect.y() + (rect.height() / 2.0);
+	    e.setAttribute( "cx", cx );
+	    e.setAttribute( "cy", cy );
+	    e.setAttribute( "r", cx - rect.x() );
+	} else {
+	    e = doc.createElement( "ellipse" );
+    	    double cx = rect.x() + (rect.width() / 2.0);
+	    double cy = rect.y() + (rect.height() / 2.0);
+	    e.setAttribute( "cx", cx );
+	    e.setAttribute( "cy", cy );
+	    e.setAttribute( "rx", cx - rect.x() );
+	    e.setAttribute( "ry", cy - rect.y() );
+	}
+	break;
+    case PdcDrawArc:
+    case PdcDrawPie:
+    case PdcDrawChord: {
+	rect = *p[0].rect;
+	double a = (double)p[1].ival / 16.0 * deg2rad;
+	double al = (double)p[2].ival / 16.0 * deg2rad;
+	double rx = rect.width() / 2.0;
+	double ry = rect.height() / 2.0;
+	double x0 = (double)rect.x() + rx;
+	double y0 = (double)rect.y() + ry;
+	double x1 = x0 + rx*cos(a);
+	double y1 = y0 - ry*sin(a);
+	double x2 = x0 + rx*cos(a+al);
+	double y2 = y0 - ry*sin(a+al);
+	int large = QABS( al ) > ( 180.0 * deg2rad ) ? 1 : 0;
+	int sweep = al < 0.0 ? 1 : 0;
+	if ( c == PdcDrawPie )
+	    str = QString( "M %1 %2 L %3 %4 " ).arg( x0 ).arg( y0 )
+		  .arg( x1 ).arg( y1 );
+	else
+	    str = QString( "M %1 %2 " ).arg( x1 ).arg( y1 );
+	str += QString( "A %1 %2 %3 %4 %5 %6 %7" )
+	       .arg( rx ).arg( ry ).arg( a/deg2rad ). arg( large ).arg( sweep )
+	       .arg( x2 ).arg( y2 );
+	if ( c != PdcDrawArc )
+	    str += "z";
+	e = doc.createElement( "path" );
+	e.setAttribute( "d", str );
+    }
+	break;
+    case PdcDrawLineSegments:
+	{
+	    a = *p[0].ptarr;
+	    uint end = a.size() / 2;
+	    for (uint i = 0; i < end; i++) {
+		e = doc.createElement( "line" );
+		e.setAttribute( "x1", a[int(2*i)].x() );
+		e.setAttribute( "y1", a[int(2*i)].y() );
+		e.setAttribute( "x2", a[int(2*i+1)].x() );
+		e.setAttribute( "y2", a[int(2*i+1)].y() );
+		if ( i < end - 1 ) // The last one will be done at the end
+		    appendChild( e, c );
+	    }
+	}
+	break;
+    case PdcDrawPolyline:
+    case PdcDrawPolygon:
+	{
+	    a = *p[0].ptarr;
+	    e = doc.createElement( ( c == PdcDrawPolyline ) ?
+				   "polyline" : "polygon" );
+	    for (uint i = 0; i < a.size(); i++) {
+		QString tmp;
+		tmp.sprintf( "%d %d ", a[ (int)i ].x(), a[ (int)i ].y() );
+		str += tmp;
+	    }
+	    e.setAttribute( "points", str.stripWhiteSpace() );
+	}
+	break;
+#ifndef QT_NO_BEZIER
+    case PdcDrawCubicBezier:
+	a = *p[0].ptarr;
+	e = doc.createElement( "path" );
+	str.sprintf( "M %d %d C %d %d %d %d %d %d", a[0].x(), a[0].y(),
+		     a[1].x(), a[1].y(), a[2].x(), a[2].y(),
+		     a[3].x(), a[3].y() );
+	e.setAttribute( "d", str );
+	break;
+#endif
+    case PdcDrawText2:
+	e = doc.createElement( "text" );
+	if ( p[0].point->x() )
+	    e.setAttribute( "x", p[0].point->x() );
+	if ( p[0].point->y() )
+	    e.setAttribute( "y", p[0].point->y() );
+	e.appendChild( doc.createTextNode( *p[1].str ) );
+	break;
+    case PdcDrawText2Formatted: {
+	e = doc.createElement( "text" );
+	const QRect *r = p[0].rect;
+	int tf = p[1].ival;
+	int x, y;
+	// horizontal text alignment
+	if ( ( tf & Qt::AlignHCenter ) != 0 ) {
+	    x = r->x() + r->width() / 2;
+	    e.setAttribute( "text-anchor", "middle" );
+	} else if ( ( tf & Qt::AlignRight ) != 0 ) {
+	    x = r->right();
+	    e.setAttribute( "text-anchor", "end" );
+	} else {
+	    x = r->x();
+	}
+	// vertical text alignment
+	if ( ( tf & Qt::AlignVCenter ) != 0 )
+	    y = r->y() + ( r->height() + painter->fontMetrics().ascent() ) / 2;
+	else if ( ( tf & Qt::AlignBottom ) != 0 )
+	    y = r->bottom();
+	else
+	    y = r->y() + painter->fontMetrics().ascent();
+	if ( x )
+	    e.setAttribute( "x", x );
+	if ( y )
+	    e.setAttribute( "y", y );
+	e.appendChild( doc.createTextNode( *p[2].str ) );
+    }
+	break;
+    case PdcDrawPixmap:
+    case PdcDrawImage:
+	e = doc.createElement( "image" );
+	e.setAttribute( "x", p[0].rect->x() );
+	e.setAttribute( "y", p[0].rect->y() );
+	e.setAttribute( "width", p[0].rect->width() );
+	e.setAttribute( "height", p[0].rect->height() );
+	if ( c == PdcDrawImage ) {
+	    ImgElement ie;
+	    ie.element = e;
+	    ie.image = *p[1].image;
+	    d->images.append( ie );
+	} else {
+	    PixElement pe;
+	    pe.element = e;
+	    pe.pixmap = *p[1].pixmap;
+	    d->pixmaps.append( pe );
+	}
+	// saving to disk and setting the xlink:href attribute will be
+	// done later in save() once we now the svg document name.
+	break;
+    case PdcSave:
+	e = doc.createElement( "g" );
+	break;
+    case PdcRestore:
+	current = current.parentNode();
+	dirtyTransform = !pt->worldMatrix().isIdentity();
+        d->justRestored = TRUE;
+	// ### reset dirty flags
+	break;
+    case PdcSetBkColor:
+    case PdcSetBkMode:
+    case PdcSetROP:
+    case PdcSetBrushOrigin:
+    case PdcSetFont:
+    case PdcSetPen:
+    case PdcSetBrush:
+	dirtyStyle = TRUE;
+	break;
+    case PdcSetTabStops:
+	// ###
+	break;
+    case PdcSetTabArray:
+	// ###
+	break;
+    case PdcSetVXform:
+    case PdcSetWindow:
+    case PdcSetViewport:
+    case PdcSetWXform:
+    case PdcSetWMatrix:
+    case PdcSaveWMatrix:
+    case PdcRestoreWMatrix:
+	dirtyTransform = TRUE;
+	break;
+    case PdcSetClip:
+	// ###
+	break;
+    case PdcSetClipRegion:
+	{
+            // We skip the clip after restore, since restoring the clip is done automatically by
+            // the viewer as part of the tree structure. It doesn't hurt to write the region
+            // out, but it doubles the number of clipregions defined in the final svg.
+            if (d->justRestored) {
+                d->justRestored = FALSE;
+                return TRUE;
+            }
+
+            QMemArray<QRect> rects = p[0].rgn->rects();
+            if (rects.count() == 0)
+                return TRUE;
+	    d->currentClip++;
+	    e = doc.createElement( "clipPath" );
+	    e.setAttribute( "id", QString("clip%1").arg(d->currentClip) );
+            for (int i=0; i<(int)rects.count(); ++i) {
+                QDomElement ce = doc.createElement("rect");
+                ce.setAttribute( "x", rects.at(i).x() );
+                ce.setAttribute( "y", rects.at(i).y() );
+                ce.setAttribute( "width", rects.at(i).width() );
+                ce.setAttribute( "height", rects.at(i).height() );
+                e.appendChild(ce);
+	    }
+	    break;
+	}
+    default:
+#if defined(CHECK_RANGE)
+	qWarning( "QSVGDevice::cmd: Invalid command %d", c );
+#endif
+	break;
+    }
+
+    appendChild( e, c );
+
+    return TRUE;
+}
+
+/*!
+    \internal
+
+    Appends the child and applys any style and transformation.
+
+*/
+
+void QSvgDevice::appendChild( QDomElement &e, int c )
+{
+    if ( !e.isNull() ) {
+	current.appendChild( e );
+	if ( c == PdcSave )
+	    current = e;
+	// ### optimize application of attributes utilizing <g>
+	if ( c == PdcSetClipRegion ) {
+	    QDomElement ne;
+	    ne = doc.createElement( "g" );
+	    ne.setAttribute( "style", QString("clip-path:url(#clip%1)").arg(d->currentClip) );
+	    current.appendChild( ne );
+	    current = ne;
+	} else {
+	    if ( dirtyStyle )		// only reset when entering
+		applyStyle( &e, c );	// or leaving a <g> tag
+	    if ( dirtyTransform && e.tagName() != "g" ) {
+		// same as above but not for <g> tags
+		applyTransform( &e );
+		if ( c == PdcSave )
+		    dirtyTransform = FALSE;
+	    }
+	}
+    }
+}
+
+
+/*!
+    \internal
+
+    Push the current drawing attributes on a stack.
+
+    \sa restoreAttributes()
+*/
+
+void QSvgDevice::saveAttributes()
+{
+    pt->save();
+    // copy old state
+    QSvgDeviceState st( *curr );
+    d->stack.append( st );
+    curr = &d->stack.last();
+}
+
+/*!
+    \internal
+
+    Pop the current drawing attributes off the stack.
+
+    \sa saveAttributes()
+*/
+
+void QSvgDevice::restoreAttributes()
+{
+    pt->restore();
+    Q_ASSERT( d->stack.count() > 1 );
+    d->stack.remove( d->stack.fromLast() );
+    curr = &d->stack.last();
+}
+
+/*!
+    \internal
+
+    Evaluate \a node, drawing on \a p. Allows recursive calls.
+*/
+
+bool QSvgDevice::play( const QDomNode &node )
+{
+    saveAttributes();
+
+	ElementType t = (*qSvgTypeMap)[ node.nodeName() ];
+
+	if ( t == LineElement && pt->pen().style() == Qt::NoPen ) {
+	    QPen p = pt->pen();
+	    p.setStyle( Qt::SolidLine );
+	    pt->setPen( p );
+	}
+	QDomNamedNodeMap attr = node.attributes();
+	if ( attr.contains( "style" ) )
+	    setStyle( attr.namedItem( "style" ).nodeValue() );
+	// ### might have to exclude more elements from transform
+	if ( t != SvgElement && attr.contains( "transform" ) )
+	    setTransform( attr.namedItem( "transform" ).nodeValue() );
+	uint i = attr.length();
+	if ( i > 0 ) {
+	    QPen pen = pt->pen();
+	    QFont font = pt->font();
+	    while ( i-- ) {
+		QDomNode n = attr.item( i );
+		QString a = n.nodeName();
+		QString val = n.nodeValue().lower().stripWhiteSpace();
+		setStyleProperty( a, val, &pen, &font, &curr->textalign );
+	    }
+	    pt->setPen( pen );
+	    pt->setFont( font );
+	}
+
+	int x1, y1, x2, y2, rx, ry, w, h;
+	double cx1, cy1, crx, cry;
+	switch ( t ) {
+	case CommentElement:
+	    // ignore
+	    break;
+	case RectElement:
+	    rx = ry = 0;
+	    x1 = lenToInt( attr, "x" );
+	    y1 = lenToInt( attr, "y" );
+	    w = lenToInt( attr, "width" );
+	    h = lenToInt( attr, "height" );
+	    if ( w == 0 || h == 0 )	// prevent div by zero below
+		break;
+	    x2 = (int)attr.contains( "rx" ); // tiny abuse of x2 and y2
+	    y2 = (int)attr.contains( "ry" );
+	    if ( x2 )
+		rx = lenToInt( attr, "rx" );
+	    if ( y2 )
+		ry = lenToInt( attr, "ry" );
+	    if ( x2 && !y2 )
+		ry = rx;
+	    else if ( !x2 && y2 )
+		rx = ry;
+	    rx = int(200.0*double(rx)/double(w));
+	    ry = int(200.0*double(ry)/double(h));
+	    pt->drawRoundRect( x1, y1, w, h, rx, ry );
+	    break;
+	case CircleElement:
+	    cx1 = lenToDouble( attr, "cx" ) + 0.5;
+	    cy1 = lenToDouble( attr, "cy" ) + 0.5;
+	    crx = lenToDouble( attr, "r" );
+	    pt->drawEllipse( (int)(cx1-crx), (int)(cy1-crx), (int)(2*crx), (int)(2*crx) );
+	    break;
+	case EllipseElement:
+	    cx1 = lenToDouble( attr, "cx" ) + 0.5;
+	    cy1 = lenToDouble( attr, "cy" ) + 0.5;
+	    crx = lenToDouble( attr, "rx" );
+	    cry = lenToDouble( attr, "ry" );
+	    pt->drawEllipse( (int)(cx1-crx), (int)(cy1-cry), (int)(2*crx), (int)(2*cry) );
+	    break;
+	case LineElement:
+	    {
+		x1 = lenToInt( attr, "x1" );
+		x2 = lenToInt( attr, "x2" );
+		y1 = lenToInt( attr, "y1" );
+		y2 = lenToInt( attr, "y2" );
+		QPen p = pt->pen();
+		w = p.width();
+		p.setWidth( (unsigned int)(w * (QABS(pt->worldMatrix().m11()) + QABS(pt->worldMatrix().m22())) / 2) );
+		pt->setPen( p );
+		pt->drawLine( x1, y1, x2, y2 );
+		p.setWidth( w );
+		pt->setPen( p );
+	    }
+	    break;
+	case PolylineElement:
+	case PolygonElement:
+	    {
+		QString pts = attr.namedItem( "points" ).nodeValue();
+		pts = pts.simplifyWhiteSpace();
+		QStringList sl = QStringList::split( QRegExp( QString::fromLatin1("[ ,]") ), pts );
+		QPointArray ptarr( (uint)sl.count() / 2);
+		for ( int i = 0; i < (int)sl.count() / 2; i++ ) {
+		    double dx = sl[2*i].toDouble();
+		    double dy = sl[2*i+1].toDouble();
+		    ptarr.setPoint( i, int(dx), int(dy) );
+		}
+  		if ( t == PolylineElement ) {
+		    if ( pt->brush().style() != Qt::NoBrush ) {
+			QPen pn = pt->pen();
+			pt->setPen( Qt::NoPen );
+			pt->drawPolygon( ptarr );
+			pt->setPen( pn );
+		    }
+		    pt->drawPolyline( ptarr ); // ### closes when filled. bug ?
+  		} else {
+		    pt->drawPolygon( ptarr );
+		}
+	    }
+	    break;
+	case SvgElement:
+	case GroupElement:
+	case AnchorElement:
+	    {
+		QDomNode child = node.firstChild();
+		while ( !child.isNull() ) {
+		    play( child );
+		    child = child.nextSibling();
+		}
+	    }
+	    break;
+	case PathElement:
+	    drawPath( attr.namedItem( "d" ).nodeValue() );
+	    break;
+	case TSpanElement:
+	case TextElement:
+	    {
+		if ( attr.contains( "x" ) )
+		     curr->textx = lenToInt( attr, "x" );
+		if ( attr.contains( "y" ) )
+		     curr->texty = lenToInt( attr, "y" );
+		if ( t == TSpanElement ) {
+		    curr->textx += lenToInt( attr, "dx" );
+		    curr->texty += lenToInt( attr, "dy" );
+		}
+		// backup old colors
+		QPen pn = pt->pen();
+		QColor pcolor = pn.color();
+		QColor bcolor = pt->brush().color();
+		QDomNode c = node.firstChild();
+		while ( !c.isNull() ) {
+		    if ( c.isText() ) {
+			// we have pen and brush reversed for text drawing
+			pn.setColor( bcolor );
+			pt->setPen( pn );
+			QString text = c.toText().nodeValue();
+			text = text.simplifyWhiteSpace(); // ### 'preserve'
+			w = pt->fontMetrics().width( text );
+			if ( curr->textalign == Qt::AlignHCenter )
+			    curr->textx -= w / 2;
+			else if ( curr->textalign == Qt::AlignRight )
+			    curr->textx -= w;
+			pt->drawText( curr->textx, curr->texty, text );
+			// restore pen
+			pn.setColor( pcolor );
+			pt->setPen( pn );
+			curr->textx += w;
+		    } else if ( c.isElement() &&
+				c.toElement().tagName() == "tspan" ) {
+			play( c );
+
+		    }
+		    c = c.nextSibling();
+		}
+		if ( t == TSpanElement ) {
+		    // move current text position in parent text element
+		    StateList::Iterator it = --d->stack.fromLast();
+		    (*it).textx = curr->textx;
+		    (*it).texty = curr->texty;
+		}
+	    }
+	    break;
+	case ImageElement:
+	    {
+		x1 = lenToInt( attr, "x" );
+		y1 = lenToInt( attr, "y" );
+		w = lenToInt( attr, "width" );
+		h = lenToInt( attr, "height" );
+		QString href = attr.namedItem( "xlink:href" ).nodeValue();
+		// ### catch references to embedded .svg files
+		QPixmap pix;
+		if ( !pix.load( href ) ) {
+		    qWarning( "QSvgDevice::play: Couldn't load image %s", href.latin1() );
+		    break;
+		}
+		pt->drawPixmap( QRect( x1, y1, w, h ), pix );
+	    }
+	    break;
+	case DescElement:
+	case TitleElement:
+	    // ignored for now
+	    break;
+	case ClipElement:
+	    {
+		QDomNode child = node.firstChild();
+                QRegion region;
+                while (!child.isNull()) {
+                    QDomNamedNodeMap childAttr = child.attributes();
+                    if ( child.nodeName() == "rect" ) {
+                        QRect r;
+                        r.setX(lenToInt( childAttr, "x" ));
+                        r.setY(lenToInt( childAttr, "y" ));
+                        r.setWidth(lenToInt( childAttr, "width" ));
+                        r.setHeight(lenToInt( childAttr, "height" ));
+                        region |= r;
+                    } else if ( child.nodeName() == "ellipse" ) {
+                        QRect r;
+                        int x = lenToInt( childAttr, "cx" );
+                        int y = lenToInt( childAttr, "cy" );
+                        int width = lenToInt( childAttr, "rx" );
+                        int height = lenToInt( childAttr, "ry" );
+                        r.setX( x - width );
+                        r.setY( y - height );
+                        r.setWidth( width * 2 );
+                        r.setHeight( height * 2 );
+                        QRegion rgn( r, QRegion::Ellipse );
+                        region |= rgn;
+                    }
+                    child = child.nextSibling();
+                }
+                // Store the region in a named map so that it can be used when the
+                // group node is entered.
+                QString idString = attr.namedItem("id").nodeValue();
+                if (!idString.isEmpty())
+                    d->clipPathTable[idString] = region;
+                break;
+	    }
+	case InvalidElement:
+	    qWarning( "QSvgDevice::play: unknown element type %s",
+		      node.nodeName().latin1() );
+	    break;
+	};
+
+	restoreAttributes();
+
+    return TRUE;
+}
+
+/*!
+    \internal
+
+    Parses a CSS2-compatible color specification. Either a keyword or
+    a numerical RGB specification like #ff00ff or rgb(255,0,50%).
+*/
+
+QColor QSvgDevice::parseColor( const QString &col )
+{
+    static const struct ColorTable {
+	const char *name;
+	const char *rgb;
+    } coltab[] = {
+	{ "black",   "#000000" },
+	{ "silver",  "#c0c0c0" },
+	{ "gray",    "#808080" },
+	{ "white",   "#ffffff" },
+	{ "maroon",  "#800000" },
+	{ "red",     "#ff0000" },
+	{ "purple",  "#800080" },
+	{ "fuchsia", "#ff00ff" },
+	{ "green",   "#008000" },
+	{ "lime",    "#00ff00" },
+	{ "olive",   "#808000" },
+	{ "yellow",  "#ffff00" },
+	{ "navy",    "#000080" },
+	{ "blue",    "#0000ff" },
+	{ "teal",    "#008080" },
+	{ "aqua",    "#00ffff" },
+	// ### the latest spec has more
+	{ 0,         0         }
+    };
+
+    // initialize color map on first use
+    if ( !qSvgColMap ) {
+	qSvgColMap = new QMap<QString, QString>;
+	const struct ColorTable *t = coltab;
+	while ( t->name ) {
+	    qSvgColMap->insert( t->name, t->rgb );
+	    t++;
+	}
+    }
+
+    // a keyword ?
+    if ( qSvgColMap->contains ( col ) )
+	return QColor( (*qSvgColMap)[ col ] );
+    // in rgb(r,g,b) form ?
+    QString c = col;
+    c.replace( QRegExp( QString::fromLatin1("\\s*") ), "" );
+    QRegExp reg( QString::fromLatin1("^rgb\\((\\d+)(%?),(\\d+)(%?),(\\d+)(%?)\\)$") );
+    if ( reg.search( c ) >= 0 ) {
+	int comp[3];
+	for ( int i = 0; i < 3; i++ ) {
+	    comp[ i ] = reg.cap( 2*i+1 ).toInt();
+	    if ( !reg.cap( 2*i+2 ).isEmpty() )		// percentage ?
+		comp[ i ] = int((double(255*comp[ i ])/100.0));
+	}
+	return QColor( comp[ 0 ], comp[ 1 ], comp[ 2 ] );
+    }
+
+    // check for predefined Qt color objects, #RRGGBB and #RGB
+    return QColor( col );
+}
+
+/*!
+    \internal
+
+    Parse a <length> datatype consisting of a number followed by an
+    optional unit specifier. Can be used for type <coordinate> as
+    well. For relative units the value of \a horiz will determine
+    whether the horizontal or vertical dimension will be used.
+*/
+
+double QSvgDevice::parseLen( const QString &str, bool *ok, bool horiz ) const
+{
+    QRegExp reg( QString::fromLatin1("([+-]?\\d*\\.*\\d*[Ee]?[+-]?\\d*)(em|ex|px|%|pt|pc|cm|mm|in|)$") );
+    if ( reg.search( str ) == -1 ) {
+	qWarning( "QSvgDevice::parseLen: couldn't parse %s ", str.latin1() );
+	if ( ok )
+	    *ok = FALSE;
+	return 0.0;
+    }
+
+    double dbl = reg.cap( 1 ).toDouble();
+    QString u = reg.cap( 2 );
+    if ( !u.isEmpty() && u != "px" ) {
+	QPaintDeviceMetrics m( pt->device() );
+	if ( u == "em" ) {
+	    QFontInfo fi( pt->font() );
+	    dbl *= fi.pixelSize();
+	} else if ( u == "ex" ) {
+	    QFontInfo fi( pt->font() );
+	    dbl *= 0.5 * fi.pixelSize();
+	} else if ( u == "%" )
+	    dbl *= (horiz ? pt->window().width() : pt->window().height())/100.0;
+	else if ( u == "cm" )
+	    dbl *= m.logicalDpiX() / 2.54;
+	else if ( u == "mm" )
+	    dbl *= m.logicalDpiX() / 25.4;
+	else if ( u == "in" )
+	    dbl *= m.logicalDpiX();
+	else if ( u == "pt" )
+	    dbl *= m.logicalDpiX() / 72.0;
+	else if ( u == "pc" )
+	    dbl *= m.logicalDpiX() / 6.0;
+	else
+	    qWarning( "QSvgDevice::parseLen: Unknown unit %s",  u.latin1() );
+    }
+    if ( ok )
+	*ok = TRUE;
+    return dbl;
+}
+
+/*!
+    \internal
+
+    Returns the length specified in attribute \a attr in \a map. If
+    the specified attribute doesn't exist or can't be parsed \a def is
+    returned.
+*/
+
+int QSvgDevice::lenToInt( const QDomNamedNodeMap &map, const QString &attr,
+			  int def ) const
+{
+    if ( map.contains( attr ) ) {
+	bool ok;
+	double dbl = parseLen( map.namedItem( attr ).nodeValue(), &ok );
+	if ( ok )
+	    return qRound( dbl );
+    }
+    return def;
+}
+
+double QSvgDevice::lenToDouble( const QDomNamedNodeMap &map, const QString &attr,
+				int def ) const
+{
+    if ( map.contains( attr ) ) {
+	bool ok;
+	double d = parseLen( map.namedItem( attr ).nodeValue(), &ok );
+	if ( ok )
+	    return d;
+    }
+    return def;
+}
+
+void QSvgDevice::setStyleProperty( const QString &prop, const QString &val,
+				   QPen *pen, QFont *font, int *talign )
+{
+    if ( prop == "stroke" ) {
+	if ( val == "none" ) {
+	    pen->setStyle( Qt::NoPen );
+	} else {
+	    pen->setColor( parseColor( val ));
+	    if ( pen->style() == Qt::NoPen )
+		pen->setStyle( Qt::SolidLine );
+	    if ( pen->width() == 0 )
+		pen->setWidth( 1 );
+	}
+    } else if ( prop == "stroke-width" ) {
+	double w = parseLen( val );
+	if ( w > 0.0001 )
+	    pen->setWidth( int(w) );
+	else
+	    pen->setStyle( Qt::NoPen );
+    } else if ( prop == "stroke-linecap" ) {
+	if ( val == "butt" )
+	    pen->setCapStyle( Qt::FlatCap );
+	else if ( val == "round" )
+	    pen->setCapStyle( Qt::RoundCap );
+	else if ( val == "square" )
+	    pen->setCapStyle( Qt::SquareCap );
+    } else if ( prop == "stroke-linejoin" ) {
+	if ( val == "miter" )
+	    pen->setJoinStyle( Qt::MiterJoin );
+	else if ( val == "round" )
+	    pen->setJoinStyle( Qt::RoundJoin );
+	else if ( val == "bevel" )
+	    pen->setJoinStyle( Qt::BevelJoin );
+    } else if ( prop == "stroke-dasharray" ) {
+        if ( val == "18,6" )
+	    pen->setStyle( Qt::DashLine );
+	else if ( val == "3" )
+	    pen->setStyle( Qt::DotLine );
+	else if ( val == "9,6,3,6" )
+	    pen->setStyle( Qt::DashDotLine );
+	else if ( val == "9,3,3" )
+	    pen->setStyle( Qt::DashDotDotLine );
+        else
+            pen->setStyle( Qt::DotLine );
+    } else if ( prop == "fill" ) {
+	if ( val == "none" )
+	    pt->setBrush( Qt::NoBrush );
+	else
+	    pt->setBrush( parseColor( val ) );
+    } else if ( prop == "font-size" ) {
+	font->setPointSizeFloat( float(parseLen( val )) );
+    } else if ( prop == "font-family" ) {
+	font->setFamily( val );
+    } else if ( prop == "font-style" ) {
+	if ( val == "normal" )
+	    font->setItalic( FALSE );
+	else if ( val == "italic" )
+	    font->setItalic( TRUE );
+	else
+	    qWarning( "QSvgDevice::setStyleProperty: unhandled "
+		      "font-style: %s", val.latin1() );
+    } else if ( prop == "font-weight" ) {
+	int w = font->weight();
+	// no exact equivalents so we have to "round" a little bit
+	if ( val == "100" || val == "200" )
+	    w = QFont::Light;
+	if ( val == "300" || val == "400" || val == "normal" )
+	    w = QFont::Normal;
+	else if ( val == "500" || val == "600" )
+	    w = QFont::DemiBold;
+	else if ( val == "700" || val == "bold" || val == "800" )
+	    w = QFont::Bold;
+	else if ( val == "900" )
+	    w = QFont::Black;
+	font->setWeight( w );
+    } else if ( prop == "text-anchor" ) {
+	if ( val == "middle" )
+	    *talign = Qt::AlignHCenter;
+	else if ( val == "end" )
+	    *talign = Qt::AlignRight;
+	else
+	    *talign = Qt::AlignLeft;
+    } else if ( prop == "clip-path" ) {
+        if (val.startsWith("url(#")) {
+            QString clipName = val.mid(5, val.length() - 6);
+            if (!clipName.isEmpty()) {
+                QRegion clipRegion = d->clipPathTable[clipName];
+                if (!clipRegion.isEmpty())
+                    pt->setClipRegion(pt->clipRegion() & clipRegion, QPainter::CoordPainter);
+            }
+        }
+    }
+}
+
+void QSvgDevice::setStyle( const QString &s )
+{
+    QStringList rules = QStringList::split( QChar(';'), s );
+
+    QPen pen = pt->pen();
+    QFont font = pt->font();
+
+    QStringList::ConstIterator it = rules.begin();
+    for ( ; it != rules.end(); it++ ) {
+	int col = (*it).find( ':' );
+	if ( col > 0 ) {
+	    QString prop = (*it).left( col ).simplifyWhiteSpace();
+	    QString val = (*it).right( (*it).length() - col - 1 );
+	    val = val.lower().stripWhiteSpace();
+	    setStyleProperty( prop, val, &pen, &font, &curr->textalign );
+	}
+    }
+
+    pt->setPen( pen );
+    pt->setFont( font );
+}
+
+void QSvgDevice::setTransform( const QString &tr )
+{
+    QString t = tr.simplifyWhiteSpace();
+
+    QRegExp reg( QString::fromLatin1("\\s*([\\w]+)\\s*\\(([^\\(]*)\\)") );
+    int index = 0;
+    while ( (index = reg.search(t, index)) >= 0 ) {
+	QString command = reg.cap( 1 );
+	QString params = reg.cap( 2 );
+	QStringList plist = QStringList::split( QRegExp(QString::fromLatin1("[,\\s]")), params );
+	if ( command == "translate" ) {
+	    double tx = 0, ty = 0;
+	    tx = plist[0].toDouble();
+	    if ( plist.count() >= 2 )
+		ty = plist[1].toDouble();
+	    pt->translate( tx, ty );
+	} else if ( command == "rotate" ) {
+	    pt->rotate( plist[0].toDouble() );
+	} else if ( command == "scale" ) {
+	    double sx, sy;
+	    sx = sy = plist[0].toDouble();
+	    if ( plist.count() >= 2 )
+		sy = plist[1].toDouble();
+	    pt->scale( sx, sy );
+	} else if ( command == "matrix" && plist.count() >= 6 ) {
+	    double m[ 6 ];
+	    for (int i = 0; i < 6; i++)
+		m[ i ] = plist[ i ].toDouble();
+	    QWMatrix wm( m[ 0 ], m[ 1 ], m[ 2 ],
+			 m[ 3 ], m[ 4 ], m[ 5 ] );
+	    pt->setWorldMatrix( wm, TRUE );
+	} else if ( command == "skewX" ) {
+	    pt->shear( 0.0, tan( plist[0].toDouble() * deg2rad ) );
+	} else if ( command == "skewY" ) {
+	    pt->shear( tan( plist[0].toDouble() * deg2rad ), 0.0 );
+	}
+
+	// move on to next command
+	index += reg.matchedLength();
+    }
+}
+
+void QSvgDevice::drawPath( const QString &data )
+{
+    double x0 = 0, y0 = 0;		// starting point
+    double x = 0, y = 0;		// current point
+    double controlX = 0, controlY = 0;	// last control point for curves
+    QPointArray path( 500 );		// resulting path
+    QValueList<int> subIndex;		// start indices for subpaths
+    QPointArray quad( 4 ), bezier;	// for curve calculations
+    int pcount = 0;			// current point array index
+    uint idx = 0;			// current data position
+    int mode = 0, lastMode = 0;		// parser state
+    bool relative = FALSE;		// e.g. 'h' vs. 'H'
+    QString commands( "MZLHVCSQTA" );	// recognized commands
+    int cmdArgs[] = { 2, 0, 2, 1, 1, 6, 4, 4, 2, 7 };	// no of arguments
+    QRegExp reg( QString::fromLatin1("\\s*,?\\s*([+-]?\\d*\\.?\\d*)") );	// floating point
+
+    subIndex.append( 0 );
+    // detect next command
+    while ( idx < data.length() ) {
+	QChar ch = data[ (int)idx++ ];
+	if ( ch.isSpace() )
+	    continue;
+	QChar chUp = ch.upper();
+	int cmd = commands.find( chUp );
+	if ( cmd >= 0 ) {
+	    // switch to new command mode
+	    mode = cmd;
+	    relative = ( ch != chUp );		// e.g. 'm' instead of 'M'
+	} else {
+	    if ( mode && !ch.isLetter() ) {
+		cmd = mode;			// continue in previous mode
+		idx--;
+	    } else {
+		qWarning( "QSvgDevice::drawPath: Unknown command" );
+		return;
+	    }
+	}
+
+	// read in the required number of arguments
+	const int maxArgs = 7;
+	double arg[ maxArgs ];
+	int numArgs = cmdArgs[ cmd ];
+	for ( int i = 0; i < numArgs; i++ ) {
+	    int pos = reg.search( data, idx );
+	    if ( pos == -1 ) {
+		qWarning( "QSvgDevice::drawPath: Error parsing arguments" );
+		return;
+	    }
+	    arg[ i ] = reg.cap( 1 ).toDouble();
+	    idx = pos + reg.matchedLength();
+	};
+
+	// process command
+	double offsetX = relative ? x : 0;	// correction offsets
+	double offsetY = relative ? y : 0;	// for relative commands
+	switch ( mode ) {
+	case 0:					// 'M' move to
+	    if ( x != x0 || y != y0 )
+		path.setPoint( pcount++, int(x0), int(y0) );
+	    x = x0 = arg[ 0 ] + offsetX;
+	    y = y0 = arg[ 1 ] + offsetY;
+	    subIndex.append( pcount );
+	    path.setPoint( pcount++, int(x0), int(y0) );
+	    mode = 2;				// -> 'L'
+	    break;
+	case 1:					// 'Z' close path
+	    path.setPoint( pcount++, int(x0), int(y0) );
+	    x = x0;
+	    y = y0;
+	    mode = 0;
+	    break;
+	case 2:					// 'L' line to
+	    x = arg[ 0 ] + offsetX;
+	    y = arg[ 1 ] + offsetY;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+	case 3:					// 'H' horizontal line
+	    x = arg[ 0 ] + offsetX;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+	case 4:					// 'V' vertical line
+	    y = arg[ 0 ] + offsetY;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+#ifndef QT_NO_BEZIER
+	case 5:					// 'C' cubic bezier curveto
+	case 6:					// 'S' smooth shorthand
+	case 7:					// 'Q' quadratic bezier curves
+	case 8: {				// 'T' smooth shorthand
+	    quad.setPoint( 0, int(x), int(y) );
+	    // if possible, reflect last control point if smooth shorthand
+	    if ( mode == 6 || mode == 8 ) { 	// smooth 'S' and 'T'
+		bool cont = mode == lastMode ||
+		     mode == 6 && lastMode == 5 || 	// 'S' and 'C'
+		     mode == 8 && lastMode == 7;	// 'T' and 'Q'
+		x = cont ? 2*x-controlX : x;
+		y = cont ? 2*y-controlY : y;
+		quad.setPoint( 1, int(x), int(y) );
+		quad.setPoint( 2, int(x), int(y) );
+	    }
+	    for ( int j = 0; j < numArgs/2; j++ ) {
+		x = arg[ 2*j   ] + offsetX;
+		y = arg[ 2*j+1 ] + offsetY;
+		quad.setPoint( j+4-numArgs/2, int(x), int(y) );
+	    }
+	    // remember last control point for next shorthand
+	    controlX = quad[ 2 ].x();
+	    controlY = quad[ 2 ].y();
+	    // transform quadratic into cubic Bezier
+	    if ( mode == 7 || mode == 8 ) {	// cubic 'Q' and 'T'
+		int x31 = quad[0].x()+int(2.0*(quad[2].x()-quad[0].x())/3.0);
+		int y31 = quad[0].y()+int(2.0*(quad[2].y()-quad[0].y())/3.0);
+		int x32 = quad[2].x()+int(2.0*(quad[3].x()-quad[2].x())/3.0);
+		int y32 = quad[2].y()+int(2.0*(quad[3].y()-quad[2].y())/3.0);
+		quad.setPoint( 1, x31, y31 );
+		quad.setPoint( 2, x32, y32 );
+	    }
+	    // calculate points on curve
+	    bezier = quad.cubicBezier();
+	    // reserve more space if needed
+	    if ( bezier.size() > path.size() - pcount )
+		path.resize( path.size() - pcount + bezier.size() );
+	    // copy
+	    for ( int k = 0; k < (int)bezier.size(); k ++ )
+		path.setPoint( pcount++, bezier[ k ] );
+	    break;
+	}
+#endif // QT_NO_BEZIER
+	case 9:					// 'A' elliptical arc curve
+	    // ### just a straight line
+	    x = arg[ 5 ] + offsetX;
+	    y = arg[ 6 ] + offsetY;
+	    path.setPoint( pcount++, int(x), int(y) );
+	    break;
+	};
+	lastMode = mode;
+	// array almost full ? expand for next loop
+	if ( pcount >= (int)path.size() - 4 )
+	    path.resize( 2 * path.size() );
+    }
+
+    subIndex.append( pcount );			// dummy marking the end
+    if ( pt->brush().style() != Qt::NoBrush ) {
+	// fill the area without stroke first
+	if ( x != x0 || y != y0 )
+	    path.setPoint( pcount++, int(x0), int(y0) );
+	QPen pen = pt->pen();
+	pt->setPen( Qt::NoPen );
+	pt->drawPolygon( path, FALSE, 0, pcount );
+	pt->setPen( pen );
+    }
+    // draw each subpath stroke seperately
+    QValueListConstIterator<int> it = subIndex.begin();
+    int start = 0;
+    while ( it != subIndex.fromLast() ) {
+	int next = *++it;
+	// ### always joins ends if first and last point coincide.
+	// ### 'Z' can't have the desired effect
+	pt->drawPolyline( path, start, next-start );
+	start = next;
+    }
+}
+
+void QSvgDevice::applyStyle( QDomElement *e, int c ) const
+{
+    // ### do not write every attribute each time
+    QColor pcol = pt->pen().color();
+    QColor bcol = pt->brush().color();
+    QString s;
+    if ( c == PdcDrawText2 || c == PdcDrawText2Formatted ) {
+	// QPainter has a reversed understanding of pen/stroke vs.
+	// brush/fill for text
+	s += QString( "fill:rgb(%1,%2,%3);" )
+	     .arg( pcol.red() ).arg( pcol.green() ).arg( pcol.blue() );
+	s += QString( "stroke-width:0;" );
+	QFont f = pt->font();
+	QFontInfo fi( f );
+	s += QString( "font-size:%1;" ).arg( fi.pointSize() );
+	s += QString( "font-style:%1;" )
+	     .arg( f.italic() ? "italic" : "normal" );
+	// not a very scientific distribution
+	QString fw;
+	if ( f.weight() <= QFont::Light )
+	    fw = "100";
+	else if ( f.weight() <= QFont::Normal )
+	    fw = "400";
+	else if ( f.weight() <= QFont::DemiBold )
+	    fw = "600";
+	else if ( f.weight() <= QFont::Bold )
+	    fw = "700";
+	else if ( f.weight() <= QFont::Black )
+	    fw = "800";
+	else
+	    fw = "900";
+	s += QString( "font-weight:%1;" ).arg( fw );
+	s += QString( "font-family:%1;" ).arg( f.family() );
+    } else {
+	s += QString( "stroke:rgb(%1,%2,%3);" )
+	     .arg( pcol.red() ).arg( pcol.green() ).arg( pcol.blue() );
+	double pw = pt->pen().width();
+	if ( pw == 0 && pt->pen().style() != Qt::NoPen )
+	    pw = 0.9;
+	if ( c == PdcDrawLine )
+	    pw /= (QABS(pt->worldMatrix().m11()) + QABS(pt->worldMatrix().m22())) / 2.0;
+	s += QString( "stroke-width:%1;" ).arg( pw );
+	if ( pt->pen().style() == Qt::DashLine )
+	    s+= QString( "stroke-dasharray:18,6;" );
+	else if ( pt->pen().style() == Qt::DotLine )
+	    s+= QString( "stroke-dasharray:3;" );
+	else if ( pt->pen().style() == Qt::DashDotLine )
+	    s+= QString( "stroke-dasharray:9,6,3,6;" );
+	else if ( pt->pen().style() == Qt::DashDotDotLine )
+	    s+= QString( "stroke-dasharray:9,3,3;" );
+	if ( pt->brush().style() == Qt::NoBrush || c == PdcDrawPolyline ||
+	     c == PdcDrawCubicBezier )
+	    s += "fill:none;"; // Qt polylines use no brush, neither do Beziers
+	else
+	    s += QString( "fill:rgb(%1,%2,%3);" )
+		 .arg( bcol.red() ).arg( bcol.green() ).arg( bcol.blue() );
+    }
+    e->setAttribute( "style", s );
+}
+
+void QSvgDevice::applyTransform( QDomElement *e ) const
+{
+    QWMatrix m = pt->worldMatrix();
+
+    QString s;
+    bool rot = ( m.m11() != 1.0 || m.m12() != 0.0 ||
+		 m.m21() != 0.0 || m.m22() != 1.0 );
+    if ( !rot && ( m.dx() != 0.0 || m.dy() != 0.0 ) )
+	s = QString( "translate(%1,%2)" ).arg( m.dx() ).arg( m.dy() );
+    else if ( rot ) {
+	if ( m.m12() == 0.0 && m.m21() == 0.0 &&
+	     m.dx() == 0.0 && m.dy() == 0.0 )
+	    s = QString( "scale(%1,%2)" ).arg( m.m11() ).arg( m.m22() );
+	else
+	    s = QString( "matrix(%1,%2,%3,%4,%5,%6)" )
+		.arg( m.m11() ).arg( m.m12() )
+		.arg( m.m21() ).arg( m.m22() )
+		.arg( m.dx() ).arg( m.dy() );
+    }
+    else
+	return;
+
+    e->setAttribute( "transform", s );
+}
+
+#endif // QT_NO_SVG
diff --git a/src/xml/qsvgdevice_p.h b/src/xml/qsvgdevice_p.h
new file mode 100644
index 0000000..05d039e
--- /dev/null
+++ b/src/xml/qsvgdevice_p.h
@@ -0,0 +1,140 @@
+/****************************************************************************
+**
+** Definition of the QSvgDevice class
+**
+** Created : 001024
+**
+** Copyright (C) 2000-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+*****************************************************************************/
+
+#ifndef QSVGDEVICE_P_H
+#define QSVGDEVICE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QPicture class. This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#ifndef QT_H
+#include "qpaintdevice.h"
+#include "qrect.h"
+#include "qdom.h"
+#endif // QT_H
+
+#if !defined(QT_MODULE_XML) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_XML )
+#define QM_EXPORT_SVG
+#else
+#define QM_EXPORT_SVG Q_EXPORT
+#endif
+
+#ifndef QT_NO_SVG
+
+class QPainter;
+class QDomNode;
+class QDomNamedNodeMap;
+struct QSvgDeviceState;
+class QSvgDevicePrivate;
+
+class QM_EXPORT_SVG QSvgDevice : public QPaintDevice
+{
+public:
+    QSvgDevice();
+    ~QSvgDevice();
+
+    bool play( QPainter *p );
+
+    QString toString() const;
+
+    bool load( QIODevice *dev );
+    bool save( QIODevice *dev );
+    bool save( const QString &fileName );
+
+    QRect boundingRect() const;
+    void setBoundingRect( const QRect &r );
+
+protected:
+    virtual bool cmd ( int, QPainter*, QPDevCmdParam* );
+    virtual int	 metric( int ) const;
+
+private:
+    // reading
+    bool play( const QDomNode &node );
+    void saveAttributes();
+    void restoreAttributes();
+    QColor parseColor( const QString &col );
+    double parseLen( const QString &str, bool *ok=0, bool horiz=TRUE ) const;
+    int lenToInt( const QDomNamedNodeMap &map, const QString &attr,
+		  int def=0 ) const;
+    double lenToDouble( const QDomNamedNodeMap &map, const QString &attr,
+		  int def=0 ) const;
+    void setStyleProperty( const QString &prop, const QString &val,
+			   QPen *pen, QFont *font, int *talign );
+    void setStyle( const QString &s );
+    void setTransform( const QString &tr );
+    void drawPath( const QString &data );
+
+    // writing
+    void appendChild( QDomElement &e, int c );
+    void applyStyle( QDomElement *e, int c ) const;
+    void applyTransform( QDomElement *e ) const;
+
+    // reading
+    QRect brect;			// bounding rectangle
+    QDomDocument doc;			// document tree
+    QDomNode current;
+    QPoint curPt;
+    QSvgDeviceState *curr;
+    QPainter *pt;			// used by play() et al
+
+    // writing
+    bool dirtyTransform, dirtyStyle;
+
+    QSvgDevicePrivate *d;
+};
+
+inline QRect QSvgDevice::boundingRect() const
+{
+    return brect;
+}
+
+#endif // QT_NO_SVG
+
+#endif // QSVGDEVICE_P_H
diff --git a/src/xml/qt_xml.pri b/src/xml/qt_xml.pri
new file mode 100644
index 0000000..4edd51e
--- /dev/null
+++ b/src/xml/qt_xml.pri
@@ -0,0 +1,10 @@
+# Qt xml module
+
+xml {
+	HEADERS += $$XML_H/qxml.h $$XML_H/qdom.h $$XML_CPP/qsvgdevice_p.h
+	SOURCES += $$XML_CPP/qxml.cpp $$XML_CPP/qdom.cpp $$XML_CPP/qsvgdevice.cpp
+	win32-borland {
+		QMAKE_CFLAGS_WARN_ON	+= -w-use
+		QMAKE_CXXFLAGS_WARN_ON	+= -w-use
+	}
+}
diff --git a/src/xml/qxml.cpp b/src/xml/qxml.cpp
new file mode 100644
index 0000000..010389b
--- /dev/null
+++ b/src/xml/qxml.cpp
@@ -0,0 +1,7635 @@
+/****************************************************************************
+**
+** Implementation of QXmlSimpleReader and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qxml.h"
+#include "qtextcodec.h"
+#include "qbuffer.h"
+#include "qregexp.h"
+#include "qptrstack.h"
+#include "qmap.h"
+#include "qvaluestack.h"
+
+// needed for QT_TRANSLATE_NOOP:
+#include "qobject.h"
+
+#ifndef QT_NO_XML
+
+//#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" )
+
+// 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;
+
+// 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( "<?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, "" );
+	if ( strTmp.length() != str.length() )
+	    return FALSE; // external entity has wrong TextDecl
+	str = strTmp;
+    }
+    return TRUE;
+}
+
+
+class QXmlAttributesPrivate
+{
+};
+class QXmlInputSourcePrivate
+{
+};
+class QXmlParseExceptionPrivate
+{
+};
+class QXmlLocatorPrivate
+{
+};
+class QXmlDefaultHandlerPrivate
+{
+};
+
+/*!
+    \class QXmlParseException qxml.h
+    \reentrant
+    \brief The QXmlParseException class is used to report errors with
+    the QXmlErrorHandler interface.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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().
+
+    \sa QXmlErrorHandler QXmlReader
+*/
+
+/*!
+    \fn QXmlParseException::QXmlParseException( const QString& name, int c, int l, const QString& p, const QString& s )
+
+    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.
+*/
+
+/*!
+    Returns the error message.
+*/
+QString QXmlParseException::message() const
+{
+    return msg;
+}
+/*!
+    Returns the column number where the error occurred.
+*/
+int QXmlParseException::columnNumber() const
+{
+    return column;
+}
+/*!
+    Returns the line number where the error occurred.
+*/
+int QXmlParseException::lineNumber() const
+{
+    return line;
+}
+/*!
+    Returns the public identifier where the error occurred.
+*/
+QString QXmlParseException::publicId() const
+{
+    return pub;
+}
+/*!
+    Returns the system identifier where the error occurred.
+*/
+QString QXmlParseException::systemId() const
+{
+    return sys;
+}
+
+
+/*!
+    \class QXmlLocator qxml.h
+    \reentrant
+    \brief The QXmlLocator class provides the XML handler classes with
+    information about the parsing position within a file.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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()
+
+    Returns the column number (starting at 1) or -1 if there is no
+    column number available.
+*/
+
+/*!
+    \fn int QXmlLocator::lineNumber()
+
+    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()
+    {
+	return ( reader->columnNr == -1 ? -1 : reader->columnNr + 1 );
+    }
+    int lineNumber()
+    {
+	return ( reader->lineNr == -1 ? -1 : reader->lineNr + 1 );
+    }
+//    QString getPublicId()
+//    QString getSystemId()
+
+private:
+    QXmlSimpleReader *reader;
+};
+
+/*********************************************
+ *
+ * QXmlNamespaceSupport
+ *
+ *********************************************/
+
+typedef QMap<QString, QString> NamespaceMap;
+
+class QXmlNamespaceSupportPrivate
+{
+public:
+    QXmlNamespaceSupportPrivate()
+    {
+	ns.insert( "xml", "http://www.w3.org/XML/1998/namespace" ); // the XML namespace
+    }
+
+    ~QXmlNamespaceSupportPrivate()
+    {
+    }
+
+    QValueStack<NamespaceMap> nsStack;
+    NamespaceMap ns;
+};
+
+/*!
+    \class QXmlNamespaceSupport qxml.h
+    \reentrant
+    \brief The QXmlNamespaceSupport class is a helper class for XML
+    readers which want to include namespace support.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+
+/*!
+    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( "", 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.data() == uri && !itc.key().isEmpty() )
+	    return itc.key();
+    }
+    return "";
+}
+
+/*!
+    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.find(':');
+    if (pos == -1)
+        pos = qname.length();
+
+    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 QString::null if the raw name has an undeclared prefix),
+    and stores the local name (without prefix) in \a localname (which
+    will be set to QString::null 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 element name does not.
+*/
+void QXmlNamespaceSupport::processName( const QString& qname,
+	bool isAttribute,
+	QString& nsuri, QString& localname ) const
+{
+    int len = qname.length();
+    const QChar *data = qname.unicode();
+    for (int pos = 0; pos < len; ++pos) {
+        if (data[pos].unicode() == ':') {
+            nsuri = uri(qname.left(pos));
+            localname = qname.mid(pos + 1);
+            return;
+	}
+    }
+    // there was no ':'
+    nsuri = QString::null;
+    // 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.data(); // 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 "".
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \code
+    QStringList list = myXmlNamespaceSupport.prefixes();
+    QStringList::iterator it = list.begin();
+    while ( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+*/
+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, use uri() with
+    an argument of "".
+
+    Note that if you want to iterate over the list, you should iterate
+    over a copy, e.g.
+    \code
+    QStringList list = myXmlNamespaceSupport.prefixes( "" );
+    QStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+*/
+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.data() == 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 qxml.h
+    \reentrant
+    \brief The QXmlAttributes class provides XML attributes.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+int QXmlAttributes::index( const QString& qName ) const
+{
+    return qnameList.findIndex( qName );
+}
+
+/*!
+    \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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+int QXmlAttributes::index( const QString& uri, const QString& localPart ) const
+{
+    QString uriTmp;
+    if ( uri.isEmpty() )
+       uriTmp = QString::null;
+    else
+       uriTmp = uri;
+    uint count = (uint)uriList.count(); // ### size_t/int cast
+    for ( uint i=0; i<count; i++ ) {
+       if ( uriList[i] == uriTmp && localnameList[i] == localPart )
+           return i;
+    }
+    return -1;
+}
+
+/*!
+    Returns the number of attributes in the list.
+
+    \sa count()
+*/
+int QXmlAttributes::length() const
+{
+    return (int)valueList.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
+    QString::null.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+QString QXmlAttributes::localName( int index ) const
+{
+    return localnameList[index];
+}
+
+/*!
+    Looks up an attribute's XML 1.0 qualified name for the attribute
+    at position \a index.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+QString QXmlAttributes::qName( int index ) const
+{
+    return qnameList[index];
+}
+
+/*!
+    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 QString::null.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+QString QXmlAttributes::uri( int index ) const
+{
+    return uriList[index];
+}
+
+/*!
+    Looks up an attribute's type for the attribute at position \a
+    index.
+
+    Currently only "CDATA" is returned.
+*/
+QString QXmlAttributes::type( int ) const
+{
+    return "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 "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 "CDATA";
+}
+
+/*!
+    Looks up an attribute's value for the attribute at position \a
+    index.
+*/
+QString QXmlAttributes::value( int index ) const
+{
+    return valueList[index];
+}
+
+/*!
+    \overload
+
+    Looks up an attribute's value for the qualified name \a qName.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+QString QXmlAttributes::value( const QString& qName ) const
+{
+    int i = index( qName );
+    if ( i == -1 )
+	return QString::null;
+    return valueList[ i ];
+}
+
+/*!
+    \overload
+
+    Looks up 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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+*/
+QString QXmlAttributes::value( const QString& uri, const QString& localName ) const
+{
+    int i = index( uri, localName );
+    if ( i == -1 )
+	return QString::null;
+    return valueList[ i ];
+}
+
+/*!
+    Clears the list of attributes.
+
+    \sa append()
+*/
+void QXmlAttributes::clear()
+{
+    qnameList.clear();
+    uriList.clear();
+    localnameList.clear();
+    valueList.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 )
+{
+    qnameList.append( qName );
+    uriList.append( uri );
+    localnameList.append( localPart);
+    valueList.append( value );
+}
+
+
+/*********************************************
+ *
+ * QXmlInputSource
+ *
+ *********************************************/
+
+/*!
+    \class QXmlInputSource qxml.h
+    \reentrant
+    \brief The QXmlInputSource class provides the input data for the
+    QXmlReader subclasses.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 QChar QXmlInputSource::EndOfData = QChar((ushort)0xfffe);
+const QChar QXmlInputSource::EndOfDocument = QChar((ushort)0xffff);
+
+/*
+    Common part of the constructors.
+*/
+void QXmlInputSource::init()
+{
+    inputDevice = 0;
+    inputStream = 0;
+
+    setData( QString::null );
+    encMapper = 0;
+}
+
+/*!
+    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();
+    inputDevice = dev;
+    fetchData();
+}
+
+/*! \obsolete
+  Constructs an input source and gets the data from the text stream \a stream.
+*/
+QXmlInputSource::QXmlInputSource( QTextStream& stream )
+{
+    init();
+    inputStream = &stream;
+    fetchData();
+}
+
+/*! \obsolete
+  Constructs an input source and gets the data from the file \a file. If the
+  file cannot be read the input source is empty.
+*/
+QXmlInputSource::QXmlInputSource( QFile& file )
+{
+    init();
+    inputDevice = &file;
+    fetchData();
+}
+
+/*!
+    Destructor.
+*/
+QXmlInputSource::~QXmlInputSource()
+{
+    delete encMapper;
+}
+
+/*!
+    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.
+
+    \sa reset() fetchData() QXmlSimpleReader::parse() QXmlSimpleReader::parseContinue()
+*/
+QChar QXmlInputSource::next()
+{
+    if ( pos >= length ) {
+	if ( nextReturnedEndOfData ) {
+	    nextReturnedEndOfData = FALSE;
+	    fetchData();
+	    if ( pos >= length ) {
+		return EndOfDocument;
+	    }
+	    return next();
+	}
+	nextReturnedEndOfData = TRUE;
+	return EndOfData;
+    }
+    return unicode[pos++];
+}
+
+/*!
+    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.
+
+    \sa next()
+*/
+void QXmlInputSource::reset()
+{
+    nextReturnedEndOfData = FALSE;
+    pos = 0;
+}
+
+/*!
+    Returns the data the input source contains or QString::null if the
+    input source does not contain any data.
+
+    \sa setData() QXmlInputSource() fetchData()
+*/
+QString QXmlInputSource::data()
+{
+    return 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 )
+{
+    str = dat;
+    unicode = str.unicode();
+    pos = 0;
+    length = str.length();
+    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()
+{
+    QByteArray rawData;
+
+    if ( inputDevice != 0 ) {
+	if ( inputDevice->isOpen() || inputDevice->open( IO_ReadOnly )  )
+	    rawData = inputDevice->readAll();
+    } else if ( inputStream != 0 ) {
+	if ( inputStream->device()->isDirectAccess() ) {
+	    rawData = inputStream->device()->readAll();
+	} else {
+	    int nread = 0;
+	    const int bufsize = 512;
+	    while ( !inputStream->device()->atEnd() ) {
+		rawData.resize( nread + bufsize );
+		nread += inputStream->device()->readBlock( rawData.data()+nread, bufsize );
+	    }
+	    rawData.resize( nread );
+	}
+    }
+    setData( fromRawData( rawData ) );
+}
+
+/*!
+    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 )
+{
+    if ( data.size() == 0 )
+	return QString::null;
+    if ( beginning ) {
+	delete encMapper;
+	encMapper = 0;
+    }
+    if ( encMapper == 0 ) {
+	QTextCodec *codec = 0;
+	// look for byte order mark and read the first 5 characters
+	if ( data.size() >= 2 &&
+		( ((uchar)data.at(0)==(uchar)0xfe &&
+		   (uchar)data.at(1)==(uchar)0xff ) ||
+		  ((uchar)data.at(0)==(uchar)0xff &&
+		   (uchar)data.at(1)==(uchar)0xfe ) )) {
+	    codec = QTextCodec::codecForMib( 1000 ); // UTF-16
+	} else {
+	    codec = QTextCodec::codecForMib( 106 ); // UTF-8
+	}
+	if ( !codec )
+	    return QString::null;
+
+	encMapper = codec->makeDecoder();
+	QString input = encMapper->toUnicode( data.data(), data.size() );
+	// ### unexpected EOF? (for incremental parsing)
+	// starts the document with an XML declaration?
+	if ( input.find("<?xml") == 0 ) {
+	    // try to find out if there is an encoding
+	    int endPos = input.find( ">" );
+	    int pos = input.find( "encoding" );
+	    if ( pos < endPos && pos != -1 ) {
+		QString encoding;
+		do {
+		    pos++;
+		    if ( pos > endPos ) {
+			return input;
+		    }
+		} while( input[pos] != '"' && input[pos] != '\'' );
+		pos++;
+		while( input[pos] != '"' && input[pos] != '\'' ) {
+		    encoding += input[pos];
+		    pos++;
+		    if ( pos > endPos ) {
+			return input;
+		    }
+		}
+
+		codec = QTextCodec::codecForName( encoding );
+		if ( codec == 0 ) {
+		    return input;
+		}
+		delete encMapper;
+		encMapper = codec->makeDecoder();
+		return encMapper->toUnicode( data.data(), data.size() );
+	    }
+	}
+	return input;
+    }
+    return encMapper->toUnicode( data.data(), data.size() );
+}
+
+
+/*********************************************
+ *
+ * QXmlDefaultHandler
+ *
+ *********************************************/
+
+/*!
+    \class QXmlContentHandler qxml.h
+    \reentrant
+    \brief The QXmlContentHandler class provides an interface to
+    report the logical content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa QXmlDTDHandler QXmlDeclHandler QXmlEntityResolver QXmlErrorHandler
+    QXmlLexicalHandler
+*/
+
+/*!
+    \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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa endPrefixMapping()
+*/
+
+/*!
+    \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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa startPrefixMapping()
+*/
+
+/*!
+    \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
+    QString::null if the element has no namespace URI or if no
+    namespace processing is done. \a localName is the local name
+    (without prefix), or QString::null 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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa endElement()
+*/
+
+/*!
+    \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.
+
+    See also the \link xml.html#sax2Namespaces namespace description\endlink.
+
+    \sa startElement()
+*/
+
+/*!
+    \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()
+
+    The reader calls this function to get an error string, e.g. if any
+    of the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class QXmlErrorHandler qxml.h
+    \reentrant
+    \brief The QXmlErrorHandler class provides an interface to report
+    errors in XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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().
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa QXmlDTDHandler QXmlDeclHandler QXmlContentHandler QXmlEntityResolver
+    QXmlLexicalHandler
+*/
+
+/*!
+    \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()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class QXmlDTDHandler qxml.h
+    \reentrant
+    \brief The QXmlDTDHandler class provides an interface to report
+    DTD content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa QXmlDeclHandler QXmlContentHandler QXmlEntityResolver QXmlErrorHandler
+    QXmlLexicalHandler
+*/
+
+/*!
+    \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()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class QXmlEntityResolver qxml.h
+    \reentrant
+    \brief The QXmlEntityResolver class provides an interface to
+    resolve external entities contained in XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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().
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa QXmlDTDHandler QXmlDeclHandler QXmlContentHandler QXmlErrorHandler
+    QXmlLexicalHandler
+*/
+
+/*!
+    \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()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class QXmlLexicalHandler qxml.h
+    \reentrant
+    \brief The QXmlLexicalHandler class provides an interface to
+    report the lexical content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa QXmlDTDHandler QXmlDeclHandler QXmlContentHandler QXmlEntityResolver
+    QXmlErrorHandler
+*/
+
+/*!
+    \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
+    QString::null. If the system identifier is missing, \a systemId is
+    set to QString::null. 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()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class QXmlDeclHandler qxml.h
+    \reentrant
+    \brief The QXmlDeclHandler class provides an interface to report declaration
+    content of XML data.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa QXmlDTDHandler QXmlContentHandler QXmlEntityResolver QXmlErrorHandler
+    QXmlLexicalHandler
+*/
+
+/*!
+    \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 QString::null (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 QString::null.
+
+    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
+    QString::null 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()
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns FALSE.
+*/
+
+
+/*!
+    \class QXmlDefaultHandler qxml.h
+    \reentrant
+    \brief The QXmlDefaultHandler class provides a default implementation of all
+    the XML handler classes.
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+
+    Very often we are only interested in parts of the things that the
+    reader reports. This class implements a default behaviour for the
+    handler classes (i.e. most of the time do nothing). Usually this
+    is the class you subclass for implementing your own customized
+    handler.
+
+    See also the \link xml.html#sax2Intro Introduction to SAX2\endlink.
+
+    \sa QXmlDTDHandler QXmlDeclHandler QXmlContentHandler QXmlEntityResolver
+    QXmlErrorHandler QXmlLexicalHandler
+*/
+
+/*!
+    \fn QXmlDefaultHandler::QXmlDefaultHandler()
+
+    Constructor.
+*/
+/*!
+    \fn QXmlDefaultHandler::~QXmlDefaultHandler()
+
+    Destructor.
+*/
+
+/*!
+    \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()
+{
+    return QString( 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
+ *
+ *********************************************/
+
+class QXmlSimpleReaderPrivate
+{
+private:
+    // functions
+    inline QXmlSimpleReaderPrivate()
+    {
+	parseStack = 0;
+        undefEntityInAttrHack = FALSE;
+    }
+
+    inline ~QXmlSimpleReaderPrivate()
+    {
+	delete parseStack;
+    }
+
+    inline void initIncrementalParsing()
+    {
+	delete parseStack;
+	parseStack = new QValueStack<ParseState>;
+    }
+
+    // used to determine if elements are correctly nested
+    QValueStack<QString> tags;
+
+    // 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
+    QValueStack<QString> xmlRef;
+    QValueStack<QString> xmlRefName;
+
+    // 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
+    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;
+    QXmlSimpleReader::EntityRecognitionContext parseReference_context;
+    bool parseExternalID_allowPublicID;
+    QXmlSimpleReader::EntityRecognitionContext parsePEReference_context;
+    QString parseString_s;
+
+    // for incremental parsing
+    struct ParseState {
+	typedef bool (QXmlSimpleReader::*ParseFunction) ();
+	ParseFunction function;
+	int state;
+    };
+    QValueStack<ParseState> *parseStack;
+
+    // used in parseProlog()
+    bool xmldecl_possible;
+    bool doctype_read;
+
+    // used in parseDoctype()
+    bool startDTDwasReported;
+
+    // used in parseString()
+    signed char Done;
+
+    bool undefEntityInAttrHack;
+
+    int nameValueLen;
+    int refValueLen;
+    int stringValueLen;
+
+    // friend declarations
+    friend class QXmlSimpleReader;
+};
+
+
+/*********************************************
+ *
+ * QXmlSimpleReader
+ *
+ *********************************************/
+
+/*!
+    \class QXmlReader qxml.h
+    \reentrant
+    \brief The QXmlReader class provides an interface for XML readers (i.e.
+    parsers).
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \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 behaviour (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 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: \a *ok  is set to TRUE if the reader has the
+    feature called \a name; otherwise \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 \a *ok
+    is set to TRUE; otherwise \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
+*/
+
+/*!
+    \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 qxml.h
+    \reentrant
+    \brief The QXmlSimpleReader class provides an implementation of a
+    simple XML reader (parser).
+\if defined(commercial)
+    It is part of the <a href="commercialeditions.html">Qt Enterprise Edition</a>.
+\endif
+
+    \module XML
+    \ingroup xml-tools
+    \mainclass
+
+    This XML reader is sufficient for simple parsing tasks. The reader:
+    \list
+    \i provides a well-formed parser;
+    \i does not parse any external entities;
+    \i can do namespace processing.
+    \endlist
+
+    Documents are parsed with a call to parse().
+
+*/
+
+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);
+}
+
+inline void QXmlSimpleReader::nameClear()
+{
+    d->nameValueLen = 0; nameArrayPos = 0;
+}
+
+inline void QXmlSimpleReader::refClear()
+{
+    d->refValueLen = 0; refArrayPos = 0;
+}
+
+/*!
+    Constructs a simple XML reader with the following feature settings:
+    \table
+    \header \i Feature \i Setting
+    \row \i \e http://xml.org/sax/features/namespaces \i TRUE
+    \row \i \e http://xml.org/sax/features/namespace-prefixes \i FALSE
+    \row \i \e http://trolltech.com/xml/features/report-whitespace-only-CharData
+	 \i TRUE
+    \row \i \e http://trolltech.com/xml/features/report-start-end-entity \i FALSE
+    \endtable
+
+    More information about features can be found in the \link
+    xml.html#sax2Features Qt SAX2 overview. \endlink
+
+    \sa setFeature()
+*/
+
+QXmlSimpleReader::QXmlSimpleReader()
+{
+    d = new QXmlSimpleReaderPrivate();
+    d->locator = new QXmlSimpleReaderLocator( this );
+
+    entityRes  = 0;
+    dtdHnd     = 0;
+    contentHnd = 0;
+    errorHnd   = 0;
+    lexicalHnd = 0;
+    declHnd    = 0;
+
+    // default feature settings
+    d->useNamespaces = TRUE;
+    d->useNamespacePrefixes = FALSE;
+    d->reportWhitespaceCharData = TRUE;
+    d->reportEntities = FALSE;
+}
+
+/*!
+    Destroys the simple XML reader.
+*/
+QXmlSimpleReader::~QXmlSimpleReader()
+{
+    delete d->locator;
+    delete d;
+}
+
+/*!
+    \reimp
+*/
+bool QXmlSimpleReader::feature( const QString& name, bool *ok ) const
+{
+    if ( ok != 0 )
+	*ok = TRUE;
+    if        ( name == "http://xml.org/sax/features/namespaces" ) {
+	return d->useNamespaces;
+    } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) {
+	return d->useNamespacePrefixes;
+    } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) {
+	return d->reportWhitespaceCharData;
+    } else if ( name == "http://trolltech.com/xml/features/report-start-end-entity" ) {
+	return d->reportEntities;
+    } else {
+	qWarning( "Unknown feature %s", name.latin1() );
+	if ( ok != 0 )
+	    *ok = FALSE;
+    }
+    return FALSE;
+}
+
+/*!
+    Sets the state of the feature \a name to \a value:
+
+    If the feature is not recognized, it is ignored.
+
+    The following features are supported:
+    \table
+    \header \i Feature \i Notes
+    \row \i \e http://xml.org/sax/features/namespaces
+         \i If this feature is TRUE, namespace processing is
+     performed.
+    \row \i \e http://xml.org/sax/features/namespace-prefixes
+         \i If this feature is TRUE, the 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 If this feature is TRUE, CharData that only contain
+            whitespace are not ignored, but are reported via
+            QXmlContentHandler::characters().
+    \row \i \e http://trolltech.com/xml/features/report-start-end-entity
+         \i If this feature is TRUE, the parser reports
+            QXmlContentHandler::startEntity() and
+            QXmlContentHandler::endEntity() events. So character data
+            might be reported in chunks. If this feature is FALSE, the
+            parser does not report those events, but rather silently
+            substitutes the entities and reports the character data in
+            one chunk.
+    \endtable
+
+    \quotefile xml/tagreader-with-features/tagreader.cpp
+    \skipto reader
+    \printline reader
+    \skipto setFeature
+    \printline setFeature
+    \printline TRUE
+
+    (Code taken from xml/tagreader-with-features/tagreader.cpp)
+
+    \sa feature() hasFeature()
+*/
+void QXmlSimpleReader::setFeature( const QString& name, bool value )
+{
+    if        ( name == "http://xml.org/sax/features/namespaces" ) {
+	d->useNamespaces = value;
+    } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) {
+	d->useNamespacePrefixes = value;
+    } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) {
+	d->reportWhitespaceCharData = value;
+    } else if ( name == "http://trolltech.com/xml/features/report-start-end-entity" ) {
+	d->reportEntities = value;
+    } else {
+	qWarning( "Unknown feature %s", name.latin1() );
+    }
+}
+
+/*! \reimp
+*/
+bool QXmlSimpleReader::hasFeature( const QString& name ) const
+{
+    if ( name == "http://xml.org/sax/features/namespaces"
+	    || name == "http://xml.org/sax/features/namespace-prefixes"
+	    || name == "http://trolltech.com/xml/features/report-whitespace-only-CharData"
+	    || name == "http://trolltech.com/xml/features/report-start-end-entity" ) {
+	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 )
+{ entityRes = handler; }
+
+/*!
+    \reimp
+*/
+QXmlEntityResolver* QXmlSimpleReader::entityResolver() const
+{ return entityRes; }
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setDTDHandler( QXmlDTDHandler* handler )
+{ dtdHnd = handler; }
+
+/*!
+    \reimp
+*/
+QXmlDTDHandler* QXmlSimpleReader::DTDHandler() const
+{ return dtdHnd; }
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setContentHandler( QXmlContentHandler* handler )
+{ contentHnd = handler; }
+
+/*!
+    \reimp
+*/
+QXmlContentHandler* QXmlSimpleReader::contentHandler() const
+{ return contentHnd; }
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setErrorHandler( QXmlErrorHandler* handler )
+{ errorHnd = handler; }
+
+/*!
+    \reimp
+*/
+QXmlErrorHandler* QXmlSimpleReader::errorHandler() const
+{ return errorHnd; }
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setLexicalHandler( QXmlLexicalHandler* handler )
+{ lexicalHnd = handler; }
+
+/*!
+    \reimp
+*/
+QXmlLexicalHandler* QXmlSimpleReader::lexicalHandler() const
+{ return lexicalHnd; }
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setDeclHandler( QXmlDeclHandler* handler )
+{ declHnd = handler; }
+
+/*!
+    \reimp
+*/
+QXmlDeclHandler* QXmlSimpleReader::declHandler() const
+{ return declHnd; }
+
+
+
+/*!
+    \reimp
+*/
+bool QXmlSimpleReader::parse( const QXmlInputSource& input )
+{
+    return parse( &input, FALSE );
+}
+
+/*!
+    \reimp
+*/
+bool QXmlSimpleReader::parse( const QXmlInputSource* input )
+{
+    return parse( input, FALSE );
+}
+
+/*!
+    Reads an XML document from \a input and parses it. Returns FALSE
+    if the parsing detects an error; otherwise returns TRUE.
+
+    If \a incremental is TRUE, the parser does not return FALSE when
+    it reaches the end of the \a input without reaching the end of the
+    XML file. Instead it stores the state of the parser so that
+    parsing can be continued at a later stage when more data is
+    available. 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 souce. This means that you should not delete the input
+    source \a input until you've finished your calls to
+    parseContinue(). If you call this function with \a incremental
+    TRUE whilst an incremental parse is in progress a new parsing
+    session will be started and the previous session lost.
+
+    If \a incremental is FALSE, this function behaves like the normal
+    parse function, i.e. it returns FALSE when the end of input is
+    reached without reaching the end of the XML file and the parsing
+    cannot be continued.
+
+    \sa parseContinue() QSocket
+*/
+bool QXmlSimpleReader::parse( const QXmlInputSource *input, bool incremental )
+{
+    init( input );
+    if ( incremental ) {
+	d->initIncrementalParsing();
+    } else {
+	delete d->parseStack;
+	d->parseStack = 0;
+    }
+    // call the handler
+    if ( contentHnd ) {
+	contentHnd->setDocumentLocator( d->locator );
+	if ( !contentHnd->startDocument() ) {
+	    reportParseError( contentHnd->errorString() );
+	    d->tags.clear();
+	    return FALSE;
+	}
+    }
+    return parseBeginOrContinue( 0, incremental );
+}
+
+/*!
+    Continues incremental parsing; this function reads the input from
+    the QXmlInputSource that was specified with the last parse()
+    command. 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.
+
+    If the input source returns an empty string for the function
+    QXmlInputSource::data(), then this means that the end of the XML
+    file has been reached; this is quite important, especially if you
+    want to use the reader to parse more than one XML file.
+
+    The case of the end of the XML file being reached without having
+    finished parsing is not considered to be an error: you can
+    continue parsing at a later stage by calling this function again
+    when there is more data available to parse.
+
+    This function assumes that the end of the XML document is reached
+    if the QXmlInputSource::next() function returns
+    QXmlInputSource::EndOfDocument. If the parser has not finished
+    parsing when it encounters this symbol, it is an error and FALSE
+    is returned.
+
+    \sa parse() QXmlInputSource::next()
+*/
+bool QXmlSimpleReader::parseContinue()
+{
+    if ( d->parseStack == 0 || d->parseStack->isEmpty() )
+	return FALSE;
+    initData();
+    int state = d->parseStack->pop().state;
+    return parseBeginOrContinue( state, TRUE );
+}
+
+/*
+  Common part of parse() and parseContinue()
+*/
+bool QXmlSimpleReader::parseBeginOrContinue( int state, bool incremental )
+{
+    bool atEndOrig = atEnd();
+
+    if ( state==0 ) {
+	if ( !parseProlog() ) {
+	    if ( incremental && d->error.isNull() ) {
+		pushParseState( 0, 0 );
+		return TRUE;
+	    } else {
+		d->tags.clear();
+		return FALSE;
+	    }
+	}
+	state = 1;
+    }
+    if ( state==1 ) {
+	if ( !parseElement() ) {
+	    if ( incremental && d->error.isNull() ) {
+		pushParseState( 0, 1 );
+		return TRUE;
+	    } else {
+		d->tags.clear();
+		return FALSE;
+	    }
+	}
+	state = 2;
+    }
+    // parse Misc*
+    while ( !atEnd() ) {
+	if ( !parseMisc() ) {
+	    if ( incremental && d->error.isNull() ) {
+		pushParseState( 0, 2 );
+		return TRUE;
+	    } else {
+		d->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 ( !d->tags.isEmpty() && !d->error.isNull() ) {
+	reportParseError( XMLERR_UNEXPECTEDEOF );
+	d->tags.clear();
+	return FALSE;
+    }
+    // call the handler
+    if ( contentHnd ) {
+	delete d->parseStack;
+	d->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 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...() funtion. 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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->xmldecl_possible = TRUE;
+	d->doctype_read = FALSE;
+	state = Init;
+    } else {
+        state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseProlog (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+            ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseProlog, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case DocType:
+		if ( d->doctype_read ) {
+		    reportParseError( XMLERR_MORETHANONEDOCTYPE );
+		    return FALSE;
+		} else {
+		    d->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 ( d->xmldecl_possible && !d->xmlVersion.isEmpty() ) {
+			QString value( "version = '" );
+			value += d->xmlVersion;
+			value += "'";
+			if ( !d->encoding.isEmpty() ) {
+			    value += " encoding = '";
+			    value += d->encoding;
+			    value += "'";
+			}
+			if ( d->standalone == QXmlSimpleReaderPrivate::Yes ) {
+			    value += " standalone = 'yes'";
+			} else if ( d->standalone == QXmlSimpleReaderPrivate::No ) {
+			    value += " standalone = 'no'";
+			}
+			if ( !contentHnd->processingInstruction( "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
+		d->xmldecl_possible = FALSE;
+		state = PInstrR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		reportParseError( XMLERR_ERRORPARSINGELEMENT );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseProlog, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '!' ) {
+	    input = InpEm;
+	} else if ( c.unicode() == 'D' ) {
+	    input = InpD;
+	} else if ( c.unicode() == '-' ) {
+	    input = InpDash;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case EatWS:
+		// XML declaration only on first position possible
+		d->xmldecl_possible = FALSE;
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	    case Lt:
+		next();
+		break;
+	    case Em:
+		// XML declaration only on first position possible
+		d->xmldecl_possible = FALSE;
+		next();
+		break;
+	    case DocType:
+		if ( !parseDoctype() ) {
+		    parseFailed( &QXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	    case Comment:
+	    case CommentR:
+		if ( !parseComment() ) {
+		    parseFailed( &QXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	    case PInstr:
+	    case PInstrR:
+		d->parsePI_xmldecl = d->xmldecl_possible;
+		if ( !parsePI() ) {
+		    parseFailed( &QXmlSimpleReader::parseProlog, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  Parse an element [39].
+
+  Precondition: the opening '<' is already read.
+*/
+bool QXmlSimpleReader::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; // is_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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseElement (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseElement, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case ReadName:
+		// store it on the stack
+		d->tags.push( name() );
+		// empty the attributes
+		d->attList.clear();
+		if ( d->useNamespaces )
+		    d->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( XMLERR_ERRORPARSINGELEMENT );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseElement, state );
+	    return FALSE;
+	}
+
+        if (fastDetermineNameChar(c) == NameBeginning) {
+	    input = InpNameBe;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if (is_S(c)) {
+            input = InpWs;
+        } else if (c.unicode() == '/') {
+	    input = InpSlash;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case ReadName:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case STagEnd:
+		// call the handler
+		if ( contentHnd ) {
+                    const QString &tagsTop = d->tags.top();
+		    if ( d->useNamespaces ) {
+			QString uri, lname;
+                        d->namespaceSupport.processName(tagsTop, FALSE, uri, lname);
+                        if (!contentHnd->startElement(uri, lname, tagsTop, d->attList)) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE;
+			}
+		    } else {
+                        if (!contentHnd->startElement(QString::null, QString::null, tagsTop, d->attList)) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		next();
+		break;
+	    case STagEnd2:
+		if ( !parseContent() ) {
+		    parseFailed( &QXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case ETagBegin:
+		next();
+		break;
+	    case ETagBegin2:
+		// get the name of the tag
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case EmptyTag:
+		if  ( d->tags.isEmpty() ) {
+		    reportParseError( XMLERR_TAGMISMATCH );
+		    return FALSE;
+		}
+		if ( !processElementEmptyTag() )
+		    return FALSE;
+		next();
+		break;
+	    case Attrib:
+	    case AttribPro:
+		// get name and value of attribute
+		if ( !parseAttribute() ) {
+		    parseFailed( &QXmlSimpleReader::parseElement, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+/*
+  Helper to break down the size of the code in the case statement.
+  Return FALSE on error, otherwise TRUE.
+*/
+bool QXmlSimpleReader::processElementEmptyTag()
+{
+    QString uri, lname;
+    // pop the stack and call the handler
+    if ( contentHnd ) {
+	if ( d->useNamespaces ) {
+	    // report startElement first...
+	    d->namespaceSupport.processName( d->tags.top(), FALSE, uri, lname );
+	    if ( !contentHnd->startElement( uri, lname, d->tags.top(), d->attList ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	    // ... followed by endElement...
+	    if ( !contentHnd->endElement( uri, lname, d->tags.pop() ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	    // ... followed by endPrefixMapping
+	    QStringList prefixesBefore, prefixesAfter;
+	    if ( contentHnd ) {
+		prefixesBefore = d->namespaceSupport.prefixes();
+	    }
+	    d->namespaceSupport.popContext();
+	    // call the handler for prefix mapping
+	    prefixesAfter = d->namespaceSupport.prefixes();
+	    for ( QStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it ) {
+		if ( prefixesAfter.contains(*it) == 0 ) {
+		    if ( !contentHnd->endPrefixMapping( *it ) ) {
+			reportParseError( contentHnd->errorString() );
+			return FALSE;
+		    }
+		}
+	    }
+	} else {
+	    // report startElement first...
+	    if ( !contentHnd->startElement( QString::null, QString::null, d->tags.top(), d->attList ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	    // ... followed by endElement
+	    if ( !contentHnd->endElement( QString::null, QString::null, d->tags.pop() ) ) {
+		reportParseError( contentHnd->errorString() );
+		return FALSE;
+	    }
+	}
+    } else {
+	d->tags.pop_back();
+	d->namespaceSupport.popContext();
+    }
+    return TRUE;
+}
+/*
+  Helper to break down the size of the code in the case statement.
+  Return FALSE on error, otherwise TRUE.
+*/
+bool QXmlSimpleReader::processElementETagBegin2()
+{
+    const QString &name = QXmlSimpleReader::name();
+
+    // pop the stack and compare it with the name
+    if ( d->tags.pop() != name ) {
+	reportParseError( XMLERR_TAGMISMATCH );
+	return FALSE;
+    }
+    // call the handler
+    if ( contentHnd ) {
+        QString uri, lname;
+
+        if (d->useNamespaces)
+            d->namespaceSupport.processName(name, FALSE, uri, lname);
+        if (!contentHnd->endElement(uri, lname, name)) {
+            reportParseError(contentHnd->errorString());
+            return FALSE;
+	}
+    }
+    if ( d->useNamespaces ) {
+        NamespaceMap prefixesBefore, prefixesAfter;
+        if (contentHnd)
+            prefixesBefore = d->namespaceSupport.d->ns;
+
+	d->namespaceSupport.popContext();
+	// call the handler for prefix mapping
+	if ( contentHnd ) {
+            prefixesAfter = d->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 QXmlSimpleReader::processElementAttribute()
+{
+    QString uri, lname, prefix;
+    const QString &name = QXmlSimpleReader::name();
+    const QString &string = QXmlSimpleReader::string();
+
+    // add the attribute to the list
+    if ( d->useNamespaces ) {
+	// is it a namespace declaration?
+        d->namespaceSupport.splitName(name, prefix, lname);
+        if (prefix == "xmlns") {
+	    // namespace declaration
+	    d->namespaceSupport.setPrefix( lname, string );
+	    if ( d->useNamespacePrefixes ) {
+		// according to http://www.w3.org/2000/xmlns/, the "prefix"
+		// xmlns maps to the namespace name
+		// http://www.w3.org/2000/xmlns/
+		d->attList.append( name, "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
+	    d->namespaceSupport.processName( name, TRUE, uri, lname );
+	    d->attList.append( name, uri, lname, string );
+	}
+    } else {
+	// no namespace support
+	d->attList.append( name, QString::null, QString::null, 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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->contentCharDataRead = FALSE;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseContent (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseContent, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Ref:
+		if ( !d->contentCharDataRead)
+		    d->contentCharDataRead = d->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.unicode() != ']' )
+		    stringAddC( ']' );
+		break;
+	    case CDS3:
+		// test if this skipping was legal
+		if ( !atEnd() ) {
+		    if ( c.unicode() == '>' ) {
+			// 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.unicode() == ']') {
+			// three or more ']'
+			stringAddC( ']' );
+		    } else {
+			// after ']]' comes another character
+			stringAddC( ']' );
+			stringAddC( ']' );
+		    }
+		}
+		break;
+	    case Done:
+		// call the handler for CharData
+		if ( contentHnd ) {
+		    if ( d->contentCharDataRead ) {
+			if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+			    if ( !contentHnd->characters( string() ) ) {
+				reportParseError( contentHnd->errorString() );
+				return FALSE;
+			    }
+			}
+		    }
+		}
+		// Done
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGCONTENT );
+		return FALSE;
+	}
+
+	// get input (use lookup-table instead of nested ifs for performance
+	// reasons)
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::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 ( !d->contentCharDataRead ) {
+		    d->contentCharDataRead = TRUE;
+		    stringClear();
+		}
+		stringAddC();
+		if ( d->reportEntities ) {
+		    if ( !reportEndEntities() )
+			return FALSE;
+		}
+		next();
+		break;
+	    case ChD1:
+		// on first call: clear string
+		if ( !d->contentCharDataRead ) {
+		    d->contentCharDataRead = TRUE;
+		    stringClear();
+		}
+		stringAddC();
+		if ( d->reportEntities ) {
+		    if ( !reportEndEntities() )
+			return FALSE;
+		}
+		next();
+		break;
+	    case ChD2:
+		stringAddC();
+		if ( d->reportEntities ) {
+		    if ( !reportEndEntities() )
+			return FALSE;
+		}
+		next();
+		break;
+	    case Ref:
+		if ( !d->contentCharDataRead) {
+		    // reference may be CharData; so clear string to be safe
+		    stringClear();
+		    d->parseReference_context = InContent;
+		    if ( !parseReference() ) {
+			parseFailed( &QXmlSimpleReader::parseContent, state );
+			return FALSE;
+		    }
+		} else {
+		    if ( d->reportEntities ) {
+			// report character data in chunks
+			if ( contentHnd ) {
+			    if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+				if ( !contentHnd->characters( string() ) ) {
+				    reportParseError( contentHnd->errorString() );
+				    return FALSE;
+				}
+			    }
+			}
+			stringClear();
+		    }
+		    d->parseReference_context = InContent;
+		    if ( !parseReference() ) {
+			parseFailed( &QXmlSimpleReader::parseContent, state );
+			return FALSE;
+		    }
+		}
+		break;
+	    case Lt:
+		// call the handler for CharData
+		if ( contentHnd ) {
+		    if ( d->contentCharDataRead ) {
+			if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+			    if ( !contentHnd->characters( string() ) ) {
+				reportParseError( contentHnd->errorString() );
+				return FALSE;
+			    }
+			}
+		    }
+		}
+		d->contentCharDataRead = FALSE;
+		next();
+		break;
+	    case PInstr:
+	    case PInstrR:
+		d->parsePI_xmldecl = FALSE;
+		if ( !parsePI() ) {
+		    parseFailed( &QXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case Elem:
+		if ( !parseElement() ) {
+		    parseFailed( &QXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case Em:
+		next();
+		break;
+	    case Com:
+	    case ComR:
+		if ( !parseComment() ) {
+		    parseFailed( &QXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case CDS:
+		d->parseString_s = "[CDATA[";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseContent, state );
+		    return FALSE;
+		}
+		break;
+	    case CDS1:
+		stringAddC();
+		next();
+		break;
+	    case CDS2:
+		// skip ']'
+		next();
+		break;
+	    case CDS3:
+		// skip ']'...
+		next();
+		break;
+	}
+    }
+}
+bool QXmlSimpleReader::reportEndEntities()
+{
+    int count = (int)d->xmlRef.count();
+    while ( count != 0 && d->xmlRef.top().isEmpty() ) {
+	if ( contentHnd ) {
+	    if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) {
+		if ( !contentHnd->characters( string() ) ) {
+		    reportParseError( contentHnd->errorString() );
+		    return FALSE;
+		}
+	    }
+	}
+	stringClear();
+	if ( lexicalHnd ) {
+	    if ( !lexicalHnd->endEntity(d->xmlRefName.top()) ) {
+		reportParseError( lexicalHnd->errorString() );
+		return FALSE;
+	    }
+	}
+	d->xmlRef.pop_back();
+	d->xmlRefName.pop_back();
+	count--;
+    }
+    return TRUE;
+}
+
+/*
+  Parse Misc [27].
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseMisc (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::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( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseMisc, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '!' ) {
+	    input = InpEm;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case eatWS:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseMisc, state );
+		    return FALSE;
+		}
+		break;
+	    case Lt:
+		next();
+		break;
+	    case PInstr:
+		d->parsePI_xmldecl = FALSE;
+		if ( !parsePI() ) {
+		    parseFailed( &QXmlSimpleReader::parseMisc, state );
+		    return FALSE;
+		}
+		break;
+	    case Comment:
+		next();
+		break;
+	    case Comment2:
+		if ( !parseComment() ) {
+		    parseFailed( &QXmlSimpleReader::parseMisc, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parsePI (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::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().lower() == "xml" ) {
+		    if ( d->parsePI_xmldecl && name()=="xml" ) {
+			state = XMLDecl;
+		    } else {
+			reportParseError( XMLERR_INVALIDNAMEFORPI );
+			return FALSE;
+		    }
+		} else {
+		    state = PInstr;
+		    stringClear();
+		}
+		break;
+	    case Version:
+		// get version (syntax like an attribute)
+		if ( name() != "version" ) {
+		    reportParseError( XMLERR_VERSIONEXPECTED );
+		    return FALSE;
+		}
+		d->xmlVersion = string();
+		break;
+	    case EorSD:
+		// get the EDecl or SDDecl (syntax like an attribute)
+		if        ( name() == "standalone" ) {
+		    if ( string()=="yes" ) {
+			d->standalone = QXmlSimpleReaderPrivate::Yes;
+		    } else if ( string()=="no" ) {
+			d->standalone = QXmlSimpleReaderPrivate::No;
+		    } else {
+			reportParseError( XMLERR_WRONGVALUEFORSDECL );
+			return FALSE;
+		    }
+		} else if ( name() == "encoding" ) {
+		    d->encoding = string();
+		} else {
+		    reportParseError( XMLERR_EDECLORSDDECLEXPECTED );
+		    return FALSE;
+		}
+		break;
+	    case SD:
+		if ( name() != "standalone" ) {
+		    reportParseError( XMLERR_SDDECLEXPECTED );
+		    return FALSE;
+		}
+		if ( string()=="yes" ) {
+		    d->standalone = QXmlSimpleReaderPrivate::Yes;
+		} else if ( string()=="no" ) {
+		    d->standalone = QXmlSimpleReaderPrivate::No;
+		} else {
+		    reportParseError( XMLERR_WRONGVALUEFORSDECL );
+		    return FALSE;
+		}
+		break;
+	    case Qm:
+		// test if the skipping was legal
+		if ( !atEnd() && c.unicode() != '>' )
+		    stringAddC( '?' );
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parsePI, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if (determineNameChar(c) == NameBeginning) {
+	    input = InpNameBe;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case QmI:
+		next();
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+	    case Ws4:
+	    case Ws5:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case Version:
+		if ( !parseAttribute() ) {
+		    parseFailed( &QXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case EorSD:
+		if ( !parseAttribute() ) {
+		    parseFailed( &QXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case SD:
+		// get the SDDecl (syntax like an attribute)
+		if ( d->standalone != QXmlSimpleReaderPrivate::Unknown ) {
+		    // already parsed the standalone declaration
+		    reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		    return FALSE;
+		}
+		if ( !parseAttribute() ) {
+		    parseFailed( &QXmlSimpleReader::parsePI, state );
+		    return FALSE;
+		}
+		break;
+	    case ADone:
+		next();
+		break;
+	    case Char:
+		stringAddC();
+		next();
+		break;
+	    case Qm:
+		// skip the '?'
+		next();
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  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 funktion was successful, the head-position is on the first
+  character after the document type definition.
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->startDTDwasReported = FALSE;
+	d->systemId = QString::null;
+	d->publicId = QString::null;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseDoctype (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Doctype2:
+		d->doctype = name();
+		break;
+	    case MP:
+		if ( !d->startDTDwasReported && lexicalHnd  ) {
+		    d->startDTDwasReported = TRUE;
+		    if ( !lexicalHnd->startDTD( d->doctype, d->publicId, d->systemId ) ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		state = MPR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGDOCTYPE );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseDoctype, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == 'D' ) {
+	    input = InpD;
+	} else if ( c.unicode() == 'S' ) {
+	    input = InpS;
+	} else if ( c.unicode() == 'P' ) {
+	    input = InpS;
+	} else if ( c.unicode() == '[' ) {
+	    input = InpOB;
+	} else if ( c.unicode() == ']' ) {
+	    input = InpCB;
+	} else if ( c.unicode() == '%' ) {
+	    input = InpPer;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Doctype:
+		d->parseString_s = "DOCTYPE";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+	    case Ws4:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Doctype2:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Sys:
+		d->parseExternalID_allowPublicID = FALSE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case MP:
+	    case MPR:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case PER:
+		d->parsePEReference_context = InDTD;
+		if ( !parsePEReference() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Mup:
+		if ( !parseMarkupdecl() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case MPE:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseDoctype, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		if ( lexicalHnd ) {
+		    if ( !d->startDTDwasReported ) {
+			d->startDTDwasReported = TRUE;
+			if ( !lexicalHnd->startDTD( d->doctype, d->publicId, d->systemId ) ) {
+			    reportParseError( lexicalHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		    if ( !lexicalHnd->endDTD() ) {
+			reportParseError( lexicalHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a ExternalID [75].
+
+  If allowPublicID is TRUE parse ExternalID [75] or PublicID [83].
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->systemId = QString::null;
+	d->publicId = QString::null;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseExternalID (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseExternalID, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case PDone:
+		if ( d->parseExternalID_allowPublicID ) {
+		    d->publicId = string();
+		    return TRUE;
+		} else {
+		    reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		    return FALSE;
+		}
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseExternalID, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSQ;
+	} else if ( c.unicode() == '"' ) {
+	    input = InpDQ;
+	} else if ( c.unicode() == 'S' ) {
+	    input = InpS;
+	} else if ( c.unicode() == 'P' ) {
+	    input = InpP;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Sys:
+		d->parseString_s = "SYSTEM";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case SysWS:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case SysSQ:
+	    case SysDQ:
+		stringClear();
+		next();
+		break;
+	    case SysSQ2:
+	    case SysDQ2:
+		stringAddC();
+		next();
+		break;
+	    case Pub:
+		d->parseString_s = "PUBLIC";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case PubWS:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::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:
+		d->publicId = string();
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseExternalID, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		d->systemId = string();
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a markupdecl [29].
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseMarkupdecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::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( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseMarkupdecl, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '!' ) {
+	    input = InpEm;
+	} else if ( c.unicode() == '-' ) {
+	    input = InpDash;
+	} else if ( c.unicode() == 'A' ) {
+	    input = InpA;
+	} else if ( c.unicode() == 'E' ) {
+	    input = InpE;
+	} else if ( c.unicode() == 'L' ) {
+	    input = InpL;
+	} else if ( c.unicode() == '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:
+		d->parsePI_xmldecl = FALSE;
+		if ( !parsePI() ) {
+		    parseFailed( &QXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Dash:
+		if ( !parseComment() ) {
+		    parseFailed( &QXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CA:
+		if ( !parseAttlistDecl() ) {
+		    parseFailed( &QXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CEL:
+		if ( !parseElementDecl() ) {
+		    parseFailed( &QXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CEN:
+		if ( !parseEntityDecl() ) {
+		    parseFailed( &QXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	    case CN:
+		if ( !parseNotationDecl() ) {
+		    parseFailed( &QXmlSimpleReader::parseMarkupdecl, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  Parse a PEReference [69]
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parsePEReference (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parsePEReference, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Name:
+		{
+		    bool skipIt = TRUE;
+		    QString xmlRefString;
+
+		    QMap<QString,QString>::Iterator it;
+		    it = d->parameterEntities.find( ref() );
+		    if ( it != d->parameterEntities.end() ) {
+			skipIt = FALSE;
+			xmlRefString = it.data();
+		    } else if ( entityRes ) {
+			QMap<QString,QXmlSimpleReaderPrivate::ExternParameterEntity>::Iterator it2;
+			it2 = d->externParameterEntities.find( ref() );
+			QXmlInputSource *ret = 0;
+			if ( it2 != d->externParameterEntities.end() ) {
+			    if ( !entityRes->resolveEntity( it2.data().publicId, it2.data().systemId, ret ) ) {
+				delete ret;
+				reportParseError( entityRes->errorString() );
+				return FALSE;
+			    }
+			    if ( ret ) {
+				xmlRefString = ret->data();
+				delete ret;
+				if ( !stripTextDecl( xmlRefString ) ) {
+				    reportParseError( XMLERR_ERRORINTEXTDECL );
+				    return FALSE;
+				}
+				skipIt = FALSE;
+			    }
+			}
+		    }
+
+		    if ( skipIt ) {
+			if ( contentHnd ) {
+			    if ( !contentHnd->skippedEntity( QString("%") + ref() ) ) {
+				reportParseError( contentHnd->errorString() );
+				return FALSE;
+			    }
+			}
+		    } else {
+			if ( d->parsePEReference_context == InEntityValue ) {
+			    // Included in literal
+			    if ( !insertXmlRef( xmlRefString, ref(), TRUE ) )
+				return FALSE;
+			} else if ( d->parsePEReference_context == InDTD ) {
+			    // Included as PE
+			    if ( !insertXmlRef( QString(" ")+xmlRefString+QString(" "), ref(), FALSE ) )
+				return FALSE;
+			}
+		    }
+		}
+		state = NameR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parsePEReference, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == ';' ) {
+	    input = InpSemi;
+	} else if ( c.unicode() == '%' ) {
+	    input = InpPer;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Next:
+		next();
+		break;
+	    case Name:
+	    case NameR:
+		d->parseName_useRef = TRUE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parsePEReference, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a AttlistDecl [52].
+
+  Precondition: the beginning '<!' is already read and the head
+  stands on the 'A' of '<!ATTLIST'
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseAttlistDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Name:
+		d->attDeclEName = name();
+		break;
+	    case Attdef:
+		d->attDeclAName = name();
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseAttlistDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == '#' ) {
+	    input = InpHash;
+	} else if ( c.unicode() == 'A' ) {
+	    input = InpA;
+	} else if ( c.unicode() == 'I' ) {
+	    input = InpI;
+	} else if ( c.unicode() == 'F' ) {
+	    input = InpF;
+	} else if ( c.unicode() == 'R' ) {
+	    input = InpR;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Attlist:
+		d->parseString_s = "ATTLIST";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws:
+	    case Ws1:
+	    case Ws2:
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Attdef:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Atttype:
+		if ( !parseAttType() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case DDecH:
+		next();
+		break;
+	    case DefReq:
+		d->parseString_s = "REQUIRED";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case DefImp:
+		d->parseString_s = "IMPLIED";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case DefFix:
+		d->parseString_s = "FIXED";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Attval:
+		if ( !parseAttValue() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws4:
+		if ( declHnd ) {
+		    // ### not all values are computed yet...
+		    if ( !declHnd->attributeDecl( d->attDeclEName, d->attDeclAName, "", "", "" ) ) {
+			reportParseError( declHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttlistDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a AttType [54]
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseAttType (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseAttType, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case ADone:
+		return TRUE;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseAttType, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '(' ) {
+	    input = InpOp;
+	} else if ( c.unicode() == ')' ) {
+	    input = InpCp;
+	} else if ( c.unicode() == '|' ) {
+	    input = InpPipe;
+	} else if ( c.unicode() == 'C' ) {
+	    input = InpC;
+	} else if ( c.unicode() == 'E' ) {
+	    input = InpE;
+	} else if ( c.unicode() == 'I' ) {
+	    input = InpI;
+	} else if ( c.unicode() == 'M' ) {
+	    input = InpM;
+	} else if ( c.unicode() == 'N' ) {
+	    input = InpN;
+	} else if ( c.unicode() == 'O' ) {
+	    input = InpO;
+	} else if ( c.unicode() == 'R' ) {
+	    input = InpR;
+	} else if ( c.unicode() == 'S' ) {
+	    input = InpS;
+	} else if ( c.unicode() == 'Y' ) {
+	    input = InpY;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case ST:
+		d->parseString_s = "CDATA";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTI:
+		d->parseString_s = "ID";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTI2:
+		d->parseString_s = "REF";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTI3:
+		next(); // S
+		break;
+	    case TTE:
+		d->parseString_s = "ENTIT";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTEY:
+		next(); // Y
+		break;
+	    case TTEI:
+		d->parseString_s = "IES";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case N:
+		next(); // N
+		break;
+	    case TTNM:
+		d->parseString_s = "MTOKEN";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case TTNM2:
+		next(); // S
+		break;
+	    case NO:
+		d->parseString_s = "OTATION";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NO2:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NO3:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NOName:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case NO4:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case EN:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case ENNmt:
+		if ( !parseNmtoken() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case EN2:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttType, state );
+		    return FALSE;
+		}
+		break;
+	    case ADone:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseAttValue (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseAttValue, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseAttValue, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '"' ) {
+	    input = InpDq;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSq;
+	} else if ( c.unicode() == '&' ) {
+	    input = InpAmp;
+	} else if ( c.unicode() == '<' ) {
+	    input = InpLt;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Dq:
+	    case Sq:
+		stringClear();
+		next();
+		break;
+	    case DqRef:
+	    case SqRef:
+		d->parseReference_context = InAttributeValue;
+		if ( !parseReference() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttValue, state );
+		    return FALSE;
+		}
+		break;
+	    case DqC:
+	    case SqC:
+		stringAddC();
+		next();
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a elementdecl [45].
+
+  Precondition: the beginning '<!E' is already read and the head
+  stands on the 'L' of '<!ELEMENT'
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseElementDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseElementDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == '|' ) {
+	    input = InpPipe;
+	} else if ( c.unicode() == '(' ) {
+	    input = InpOp;
+	} else if ( c.unicode() == ')' ) {
+	    input = InpCp;
+	} else if ( c.unicode() == '#' ) {
+	    input = InpHash;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '*' ) {
+	    input = InpAst;
+	} else if ( c.unicode() == '+' ) {
+	    input = InpPlus;
+	} else if ( c.unicode() == 'A' ) {
+	    input = InpA;
+	} else if ( c.unicode() == 'E' ) {
+	    input = InpE;
+	} else if ( c.unicode() == 'L' ) {
+	    input = InpL;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Elem:
+		d->parseString_s = "LEMENT";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Nam:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Empty:
+		d->parseString_s = "EMPTY";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Any:
+		d->parseString_s = "ANY";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Cont:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Mix:
+		d->parseString_s = "#PCDATA";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Mix2:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Mix3:
+		next();
+		break;
+	    case MixN1:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case MixN2:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case MixN3:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case MixN4:
+		next();
+		break;
+	    case Cp:
+		if ( !parseChoiceSeq() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Cp2:
+		next();
+		break;
+	    case WsD:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseElementDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a NotationDecl [82].
+
+  Precondition: the beginning '<!' is already read and the head
+  stands on the 'N' of '<!NOTATION'
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseNotationDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseNotationDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case ExtID:
+		// call the handler
+		if ( dtdHnd ) {
+		    if ( !dtdHnd->notationDecl( name(), d->publicId, d->systemId ) ) {
+			reportParseError( dtdHnd->errorString() );
+			return FALSE;
+		    }
+		}
+		state = ExtIDR;
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseNotationDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == 'N' ) {
+	    input = InpN;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Not:
+		d->parseString_s = "NOTATION";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Nam:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case ExtID:
+	    case ExtIDR:
+		d->parseExternalID_allowPublicID = TRUE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &QXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseNotationDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  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 QXmlSimpleReader::parseChoiceSeq()
+{
+    const signed char Init             = 0;
+    const signed char Ws1              = 1; // eat whitespace
+    const signed char CorS             = 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,     CorS,  -1,    -1,    -1,     -1,      -1,      -1,      CorS  }, // Ws1
+	{ Ws2,    -1,    Done,  Ws2,   Ws2,    Ws2,     More,    More,    -1    }, // CorS
+	{ -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 CorS)
+    };
+    signed char state;
+    signed char input;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseChoiceSeq (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseChoiceSeq, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseChoiceSeq, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '(' ) {
+	    input = InpOp;
+	} else if ( c.unicode() == ')' ) {
+	    input = InpCp;
+	} else if ( c.unicode() == '?' ) {
+	    input = InpQm;
+	} else if ( c.unicode() == '*' ) {
+	    input = InpAst;
+	} else if ( c.unicode() == '+' ) {
+	    input = InpPlus;
+	} else if ( c.unicode() == '|' ) {
+	    input = InpPipe;
+	} else if ( c.unicode() == ',' ) {
+	    input = InpComm;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Ws1:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case CorS:
+		if ( !parseChoiceSeq() ) {
+		    parseFailed( &QXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case More:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseChoiceSeq, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a EntityDecl [70].
+
+  Precondition: the beginning '<!E' is already read and the head
+  stand on the 'N' of '<!ENTITY'
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseEntityDecl (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case EValue:
+		if (  !entityExist( name() ) ) {
+		    d->entities.insert( name(), string() );
+		    if ( declHnd ) {
+			if ( !declHnd->internalEntityDecl( name(), string() ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = EValueR;
+		break;
+	    case NNam:
+		if (  !entityExist( name() ) ) {
+		    d->externEntities.insert( name(), QXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, ref() ) );
+		    if ( dtdHnd ) {
+			if ( !dtdHnd->unparsedEntityDecl( name(), d->publicId, d->systemId, ref() ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = NNamR;
+		break;
+	    case PEVal:
+		if (  !entityExist( name() ) ) {
+		    d->parameterEntities.insert( name(), string() );
+		    if ( declHnd ) {
+			if ( !declHnd->internalEntityDecl( QString("%")+name(), string() ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = PEValR;
+		break;
+	    case PEEID:
+		if (  !entityExist( name() ) ) {
+		    d->externParameterEntities.insert( name(), QXmlSimpleReaderPrivate::ExternParameterEntity( d->publicId, d->systemId ) );
+		    if ( declHnd ) {
+			if ( !declHnd->externalEntityDecl( QString("%")+name(), d->publicId, d->systemId ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		state = PEEIDR;
+		break;
+	    case EDDone:
+		if (  !entityExist( name() ) ) {
+		    d->externEntities.insert( name(), QXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, QString::null ) );
+		    if ( declHnd ) {
+			if ( !declHnd->externalEntityDecl( name(), d->publicId, d->systemId ) ) {
+			    reportParseError( declHnd->errorString() );
+			    return FALSE;
+			}
+		    }
+		}
+		return TRUE;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseEntityDecl, state );
+	    return FALSE;
+	}
+	if        ( is_S(c) ) {
+	    input = InpWs;
+	} else if ( c.unicode() == '%' ) {
+	    input = InpPer;
+	} else if ( c.unicode() == '"' || c.unicode() == '\'' ) {
+	    input = InpQuot;
+	} else if ( c.unicode() == '>' ) {
+	    input = InpGt;
+	} else if ( c.unicode() == 'N' ) {
+	    input = InpN;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case Ent:
+		d->parseString_s = "NTITY";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws1:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Name:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws2:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case EValue:
+	    case EValueR:
+		if ( !parseEntityValue() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case ExtID:
+		d->parseExternalID_allowPublicID = FALSE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws3:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ndata:
+		d->parseString_s = "NDATA";
+		if ( !parseString() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws4:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case NNam:
+	    case NNamR:
+		d->parseName_useRef = TRUE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PEDec:
+		next();
+		break;
+	    case Ws6:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PENam:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws7:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PEVal:
+	    case PEValR:
+		if ( !parseEntityValue() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case PEEID:
+	    case PEEIDR:
+		d->parseExternalID_allowPublicID = FALSE;
+		if ( !parseExternalID() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case WsE:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityDecl, state );
+		    return FALSE;
+		}
+		break;
+	    case EDDone:
+		next();
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a EntityValue [9]
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseEntityValue (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseEntityValue, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseEntityValue, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '"' ) {
+	    input = InpDq;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSq;
+	} else if ( c.unicode() == '&' ) {
+	    input = InpAmp;
+	} else if ( c.unicode() == '%' ) {
+	    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:
+		d->parsePEReference_context = InEntityValue;
+		if ( !parsePEReference() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityValue, state );
+		    return FALSE;
+		}
+		break;
+	    case DqRef:
+	    case SqRef:
+		d->parseReference_context = InEntityValue;
+		if ( !parseReference() ) {
+		    parseFailed( &QXmlSimpleReader::parseEntityValue, state );
+		    return FALSE;
+		}
+		break;
+	    case Done:
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseComment (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::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.unicode() != '-' )
+		    stringAddC( '-' );
+		break;
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGCOMMENT );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseComment, state );
+	    return FALSE;
+	}
+	if        ( c.unicode() == '-' ) {
+	    input = InpDash;
+	} else if ( c.unicode() == '>' ) {
+	    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;
+	}
+    }
+}
+
+/*
+    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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseAttribute (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseAttribute, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Quotes:
+		// Done
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseAttribute, state );
+	    return FALSE;
+	}
+	if        ( determineNameChar(c) == NameBeginning ) {
+	    input = InpNameBe;
+	} else if ( c.unicode() == '=' ) {
+	    input = InpEq;
+	} else if ( c.unicode() == '"' ) {
+	    input = InpDq;
+	} else if ( c.unicode() == '\'' ) {
+	    input = InpSq;
+	} else {
+	    input = InpUnknown;
+	}
+	state = table[state][input];
+
+	switch ( state ) {
+	    case PName:
+		d->parseName_useRef = FALSE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	    case Ws:
+		if ( !eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	    case Eq:
+		if ( !next_eat_ws() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	    case Quotes:
+		if ( !parseAttValue() ) {
+		    parseFailed( &QXmlSimpleReader::parseAttribute, state );
+		    return FALSE;
+		}
+		break;
+	}
+    }
+}
+
+/*
+  Parse a Name [5] and store the name in name or ref (if useRef is TRUE).
+*/
+bool QXmlSimpleReader::parseName()
+{
+    const int Init             = 0;
+    const int Name1            = 1; // parse first signed character of the name
+    const int Name             = 2; // parse name
+    const int Done             = 3;
+
+    const int InpNameBe        = 0; // name beginning signed characters
+    const int InpNameCh        = 1; // NameChar without InpNameBe
+    const int InpUnknown       = 2;
+
+    Q_ASSERT(InpNameBe == (int)NameBeginning);
+    Q_ASSERT(InpNameCh == (int)NameNotBeginning);
+    Q_ASSERT(InpUnknown == (int)NotName);
+
+    static const int table[3][3] = {
+     /*  InpNameBe  InpNameCh  InpUnknown */
+	{ Name1,     -1,        -1    }, // Init
+	{ Name,      Name,      Done  }, // Name1
+	{ Name,      Name,      Done  }  // Name
+    };
+    int state;
+
+    if ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseName (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseName, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::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 ( d->parseName_useRef ) {
+		    refClear();
+		    refAddC();
+		} else {
+		    nameClear();
+		    nameAddC();
+		}
+		next();
+		break;
+	    case Name:
+		if ( d->parseName_useRef ) {
+		    refAddC();
+		} else {
+		    nameAddC();
+		}
+		next();
+		break;
+	}
+    }
+}
+
+/*
+  Parse a Nmtoken [7] and store the name in name.
+*/
+bool QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseNmtoken (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseNmtoken, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case Done:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_LETTEREXPECTED );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::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;
+	}
+    }
+}
+
+/*
+  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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->parseReference_charDataRead = FALSE;
+	state = Init;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseReference (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseReference, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	switch ( state ) {
+	    case DoneD:
+		return TRUE;
+	    case DoneH:
+		return TRUE;
+	    case DoneN:
+		return TRUE;
+	    case -1:
+		// Error
+		reportParseError( XMLERR_ERRORPARSINGREFERENCE );
+		return FALSE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::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
+		d->parseName_useRef = TRUE;
+		if ( !parseName() ) {
+		    parseFailed( &QXmlSimpleReader::parseReference, state );
+		    return FALSE;
+		}
+		break;
+	    case DoneD:
+		tmp = ref().toUInt( &ok, 10 );
+		if ( ok ) {
+		    stringAddC( QChar(tmp) );
+		} else {
+		    reportParseError( XMLERR_ERRORPARSINGREFERENCE );
+		    return FALSE;
+		}
+		d->parseReference_charDataRead = TRUE;
+		next();
+		break;
+	    case DoneH:
+		tmp = ref().toUInt( &ok, 16 );
+		if ( ok ) {
+		    stringAddC( QChar(tmp) );
+		} else {
+		    reportParseError( XMLERR_ERRORPARSINGREFERENCE );
+		    return FALSE;
+		}
+		d->parseReference_charDataRead = TRUE;
+		next();
+		break;
+	    case DoneN:
+		if ( !processReference() )
+		    return FALSE;
+		next();
+		break;
+	}
+    }
+}
+
+/* This private function is only called by QDom. It avoids a data corruption bug
+   whereby undefined entities in attribute values would be appended after the
+   element that contained them.
+
+   The solution is not perfect - the undefined entity reference is replaced by
+   an empty string. The propper fix will come in Qt4, when SAX will be extended
+   so that attribute values can be made up of multiple children, rather than just
+   a single string value.
+*/
+void QXmlSimpleReader::setUndefEntityInAttrHack(bool b)
+{
+    d->undefEntityInAttrHack = b;
+}
+
+/*
+  Helper function for parseReference()
+*/
+bool QXmlSimpleReader::processReference()
+{
+    QString reference = ref();
+    if ( reference == "amp" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'm' ); stringAddC( 'p' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '&' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "lt" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'l' ); stringAddC( 't' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '<' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "gt" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'g' ); stringAddC( 't' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '>' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "apos" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'p' ); stringAddC( 'o' ); stringAddC( 's' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '\'' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else if ( reference == "quot" ) {
+	if ( d->parseReference_context == InEntityValue ) {
+	    // Bypassed
+	    stringAddC( '&' ); stringAddC( 'q' ); stringAddC( 'u' ); stringAddC( 'o' ); stringAddC( 't' ); stringAddC( ';' );
+	} else {
+	    // Included or Included in literal
+	    stringAddC( '"' );
+	}
+	d->parseReference_charDataRead = TRUE;
+    } else {
+	QMap<QString,QString>::Iterator it;
+	it = d->entities.find( reference );
+	if ( it != d->entities.end() ) {
+	    // "Internal General"
+	    switch ( d->parseReference_context ) {
+		case InContent:
+		    // Included
+		    if ( !insertXmlRef( it.data(), reference, FALSE ) )
+			return FALSE;
+		    d->parseReference_charDataRead = FALSE;
+		    break;
+		case InAttributeValue:
+		    // Included in literal
+		    if ( !insertXmlRef( it.data(), reference, TRUE ) )
+			return FALSE;
+		    d->parseReference_charDataRead = FALSE;
+		    break;
+		case InEntityValue:
+		    {
+			// Bypassed
+			stringAddC( '&' );
+			for ( int i=0; i<(int)reference.length(); i++ ) {
+			    stringAddC( reference[i] );
+			}
+			stringAddC( ';');
+			d->parseReference_charDataRead = TRUE;
+		    }
+		    break;
+		case InDTD:
+		    // Forbidden
+		    d->parseReference_charDataRead = FALSE;
+		    reportParseError( XMLERR_INTERNALGENERALENTITYINDTD );
+		    return FALSE;
+	    }
+	} else {
+	    QMap<QString,QXmlSimpleReaderPrivate::ExternEntity>::Iterator itExtern;
+	    itExtern = d->externEntities.find( reference );
+	    if ( itExtern == d->externEntities.end() ) {
+		// entity not declared
+		// ### check this case for conformance
+		if ( d->parseReference_context == InEntityValue ) {
+		    // Bypassed
+		    stringAddC( '&' );
+		    for ( int i=0; i<(int)reference.length(); i++ ) {
+			stringAddC( reference[i] );
+		    }
+		    stringAddC( ';');
+		    d->parseReference_charDataRead = TRUE;
+		} else {
+		    if ( contentHnd && !(d->parseReference_context == InAttributeValue
+                             && d->undefEntityInAttrHack)) {
+			if ( !contentHnd->skippedEntity( reference ) ) {
+			    reportParseError( contentHnd->errorString() );
+			    return FALSE; // error
+			}
+		    }
+		}
+	    } else if ( (*itExtern).notation.isNull() ) {
+		// "External Parsed General"
+		switch ( d->parseReference_context ) {
+		    case InContent:
+			{
+			    // Included if validating
+			    bool skipIt = TRUE;
+			    if ( entityRes ) {
+				QXmlInputSource *ret = 0;
+				if ( !entityRes->resolveEntity( itExtern.data().publicId, itExtern.data().systemId, ret ) ) {
+				    delete ret;
+				    reportParseError( entityRes->errorString() );
+				    return FALSE;
+				}
+				if ( ret ) {
+				    QString xmlRefString = ret->data();
+				    delete ret;
+				    if ( !stripTextDecl( xmlRefString ) ) {
+					reportParseError( XMLERR_ERRORINTEXTDECL );
+					return FALSE;
+				    }
+				    if ( !insertXmlRef( xmlRefString, reference, FALSE ) )
+					return FALSE;
+				    skipIt = FALSE;
+				}
+			    }
+			    if ( skipIt && contentHnd ) {
+				if ( !contentHnd->skippedEntity( reference ) ) {
+				    reportParseError( contentHnd->errorString() );
+				    return FALSE; // error
+				}
+			    }
+			    d->parseReference_charDataRead = FALSE;
+			} break;
+		    case InAttributeValue:
+			// Forbidden
+			d->parseReference_charDataRead = FALSE;
+			reportParseError( XMLERR_EXTERNALGENERALENTITYINAV );
+			return FALSE;
+		    case InEntityValue:
+			{
+			    // Bypassed
+			    stringAddC( '&' );
+			    for ( int i=0; i<(int)reference.length(); i++ ) {
+				stringAddC( reference[i] );
+			    }
+			    stringAddC( ';');
+			    d->parseReference_charDataRead = TRUE;
+			}
+			break;
+		    case InDTD:
+			// Forbidden
+			d->parseReference_charDataRead = FALSE;
+			reportParseError( XMLERR_EXTERNALGENERALENTITYINDTD );
+			return FALSE;
+		}
+	    } else {
+		// "Unparsed"
+		// ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway)
+		// Forbidden
+		d->parseReference_charDataRead = FALSE;
+		reportParseError( 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 QXmlSimpleReader::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 ( d->parseStack==0 || d->parseStack->isEmpty() ) {
+	d->Done = d->parseString_s.length();
+	state = 0;
+    } else {
+	state = d->parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+	qDebug( "QXmlSimpleReader: parseString (cont) in state %d", state );
+#endif
+	if ( !d->parseStack->isEmpty() ) {
+	    ParseFunction function = d->parseStack->top().function;
+	    if ( function == &QXmlSimpleReader::eat_ws ) {
+		d->parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+		qDebug( "QXmlSimpleReader: eat_ws (cont)" );
+#endif
+	    }
+	    if ( !(this->*function)() ) {
+		parseFailed( &QXmlSimpleReader::parseString, state );
+		return FALSE;
+	    }
+	}
+    }
+
+    for (;;) {
+	if ( state == d->Done ) {
+	    return TRUE;
+	}
+
+	if ( atEnd() ) {
+	    unexpectedEof( &QXmlSimpleReader::parseString, state );
+	    return FALSE;
+	}
+	if ( c == d->parseString_s[(int)state] ) {
+	    input = InpCharExpected;
+	} else {
+	    input = InpUnknown;
+	}
+	if ( input == InpCharExpected ) {
+	    state++;
+	} else {
+	    // Error
+	    reportParseError( XMLERR_UNEXPECTEDCHARACTER );
+	    return FALSE;
+	}
+
+	next();
+    }
+}
+
+/*
+  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 QXmlSimpleReader::insertXmlRef( const QString &data, const QString &name, bool inLiteral )
+{
+    if ( inLiteral ) {
+	QString tmp = data;
+	d->xmlRef.push( tmp.replace( "\"", "&quot;" ).replace( "'", "&apos;" ) );
+    } else {
+	d->xmlRef.push( data );
+    }
+    d->xmlRefName.push( name );
+    uint n = (uint)QMAX( d->parameterEntities.count(), d->entities.count() );
+    if ( d->xmlRefName.count() > n+1 ) {
+	// recursive entities
+	reportParseError( XMLERR_RECURSIVEENTITIES );
+	return FALSE;
+    }
+    if ( d->reportEntities && lexicalHnd ) {
+	if ( !lexicalHnd->startEntity( name ) ) {
+	    reportParseError( lexicalHnd->errorString() );
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+/*
+  This private function moves the cursor to the next character.
+*/
+void QXmlSimpleReader::next()
+{
+    int count = (int)d->xmlRef.count();
+    while ( count != 0 ) {
+	if ( d->xmlRef.top().isEmpty() ) {
+	    d->xmlRef.pop_back();
+	    d->xmlRefName.pop_back();
+	    count--;
+	} else {
+	    c = d->xmlRef.top().constref( 0 );
+	    d->xmlRef.top().remove( (uint)0, 1 );
+	    return;
+	}
+    }
+    // the following could be written nicer, but since it is a time-critical
+    // function, rather optimize for speed
+    ushort uc = c.unicode();
+    if (uc == '\n') {
+	c = inputSource->next();
+	lineNr++;
+	columnNr = -1;
+    } else if ( uc == '\r' ) {
+	c = inputSource->next();
+	if ( c.unicode() != '\n' ) {
+	    lineNr++;
+	    columnNr = -1;
+	}
+    } else {
+	c = inputSource->next();
+    }
+    ++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 QXmlSimpleReader::eat_ws()
+{
+    while ( !atEnd() ) {
+	if ( !is_S(c) ) {
+	    return TRUE;
+	}
+	next();
+    }
+    if ( d->parseStack != 0 ) {
+	unexpectedEof( &QXmlSimpleReader::eat_ws, 0 );
+	return FALSE;
+    }
+    return TRUE;
+}
+
+bool QXmlSimpleReader::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 QXmlSimpleReader::init( const QXmlInputSource *i )
+{
+    lineNr = 0;
+    columnNr = -1;
+    inputSource = (QXmlInputSource *)i;
+    initData();
+
+    d->externParameterEntities.clear();
+    d->parameterEntities.clear();
+    d->externEntities.clear();
+    d->entities.clear();
+
+    d->tags.clear();
+
+    d->doctype = "";
+    d->xmlVersion = "";
+    d->encoding = "";
+    d->standalone = QXmlSimpleReaderPrivate::Unknown;
+    d->error = QString::null;
+}
+
+/*
+  This private function initializes the XML data related variables. Especially,
+  it reads the data from the input source.
+*/
+void QXmlSimpleReader::initData()
+{
+    c = QXmlInputSource::EndOfData;
+    d->xmlRef.clear();
+    next();
+}
+
+/*
+  Returns TRUE if a entity with the name \a e exists,
+  otherwise returns FALSE.
+*/
+bool QXmlSimpleReader::entityExist( const QString& e ) const
+{
+    if (  d->parameterEntities.find(e) == d->parameterEntities.end() &&
+	  d->externParameterEntities.find(e) == d->externParameterEntities.end() &&
+	  d->externEntities.find(e) == d->externEntities.end() &&
+	  d->entities.find(e) == d->entities.end() ) {
+	return FALSE;
+    } else {
+	return TRUE;
+    }
+}
+
+void QXmlSimpleReader::reportParseError( const QString& error )
+{
+    d->error = error;
+    if ( errorHnd ) {
+	if ( d->error.isNull() ) {
+	    errorHnd->fatalError( QXmlParseException( XMLERR_OK, columnNr+1, lineNr+1 ) );
+	} else {
+	    errorHnd->fatalError( QXmlParseException( d->error, columnNr+1, lineNr+1 ) );
+	}
+    }
+}
+
+/*
+  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 QXmlSimpleReader::unexpectedEof( ParseFunction where, int state )
+{
+    if ( d->parseStack == 0 ) {
+	reportParseError( XMLERR_UNEXPECTEDEOF );
+    } else {
+	if ( c == QXmlInputSource::EndOfDocument ) {
+	    reportParseError( 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 QXmlSimpleReader::parseFailed( ParseFunction where, int state )
+{
+    if ( d->parseStack!=0 && d->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 QXmlSimpleReader::pushParseState( ParseFunction function, int state )
+{
+    QXmlSimpleReaderPrivate::ParseState ps;
+    ps.function = function;
+    ps.state = state;
+    d->parseStack->push( ps );
+}
+
+inline static void updateValue(QString &value, const QChar *array, int &arrayPos, int &valueLen)
+{
+    value.setLength(valueLen + arrayPos);
+    memcpy(const_cast<QChar*>(value.unicode()) + valueLen, array, arrayPos * sizeof(QChar));
+    valueLen += arrayPos;
+    arrayPos = 0;
+}
+
+// use buffers instead of QString::operator+= when single characters are read
+const QString& QXmlSimpleReader::string()
+{
+    updateValue(stringValue, stringArray, stringArrayPos, d->stringValueLen);
+    return stringValue;
+}
+
+const QString& QXmlSimpleReader::name()
+{
+    updateValue(nameValue, nameArray, nameArrayPos, d->nameValueLen);
+    return nameValue;
+}
+
+const QString& QXmlSimpleReader::ref()
+{
+    updateValue(refValue, refArray, refArrayPos, d->refValueLen);
+    return refValue;
+}
+
+void QXmlSimpleReader::stringAddC(const QChar &ch)
+{
+    if (stringArrayPos == 256)
+        updateValue(stringValue, stringArray, stringArrayPos, d->stringValueLen);
+    stringArray[stringArrayPos++] = ch;
+}
+void QXmlSimpleReader::nameAddC(const QChar &ch)
+{
+    if (nameArrayPos == 256)
+        updateValue(nameValue, nameArray, nameArrayPos, d->nameValueLen);
+    nameArray[nameArrayPos++] = ch;
+}
+
+void QXmlSimpleReader::refAddC(const QChar &ch)
+{
+    if (refArrayPos == 256)
+        updateValue(refValue, refArray, refArrayPos, d->refValueLen);
+    refArray[refArrayPos++] = ch;
+}
+
+void QXmlSimpleReader::stringClear()
+{
+    d->stringValueLen = 0; stringArrayPos = 0;
+}
+
+
+#endif //QT_NO_XML
diff --git a/src/xml/qxml.h b/src/xml/qxml.h
new file mode 100644
index 0000000..11fbbdb
--- /dev/null
+++ b/src/xml/qxml.h
@@ -0,0 +1,531 @@
+/****************************************************************************
+**
+** Definition of QXmlSimpleReader and related classes.
+**
+** Created : 000518
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the xml module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#ifndef QXML_H
+#define QXML_H
+
+#ifndef QT_H
+#include "qtextstream.h"
+#include "qfile.h"
+#include "qstring.h"
+#include "qstringlist.h"
+#include "qvaluevector.h"
+#endif // QT_H
+
+#if !defined(QT_MODULE_XML) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_XML )
+#define QM_EXPORT_XML
+#else
+#define QM_EXPORT_XML Q_EXPORT
+#endif
+
+#ifndef QT_NO_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 QM_EXPORT_XML 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 QXmlSimpleReader;
+};
+
+
+//
+// SAX Attributes
+//
+
+class QM_EXPORT_XML QXmlAttributes
+{
+public:
+    QXmlAttributes() {}
+    virtual ~QXmlAttributes() {}
+
+    int index( const QString& 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 QString& uri, const QString& localName ) const;
+
+    void clear();
+    void append( const QString &qName, const QString &uri, const QString &localPart, const QString &value );
+
+private:
+    QStringList qnameList;
+    QStringList uriList;
+    QStringList localnameList;
+    QStringList valueList;
+
+    QXmlAttributesPrivate *d;
+};
+
+//
+// SAX Input Source
+//
+
+class QM_EXPORT_XML QXmlInputSource
+{
+public:
+    QXmlInputSource();
+    QXmlInputSource( QIODevice *dev );
+    QXmlInputSource( QFile& file ); // obsolete
+    QXmlInputSource( QTextStream& stream ); // obsolete
+    virtual ~QXmlInputSource();
+
+    virtual void setData( const QString& dat );
+    virtual void setData( const QByteArray& dat );
+    virtual void fetchData();
+    virtual QString data();
+    virtual QChar next();
+    virtual void reset();
+
+    static const QChar EndOfData;
+    static const QChar EndOfDocument;
+
+protected:
+    virtual QString fromRawData( const QByteArray &data, bool beginning = FALSE );
+
+private:
+    void init();
+
+    QIODevice *inputDevice;
+    QTextStream *inputStream;
+
+    QString str;
+    const QChar *unicode;
+    int pos;
+    int length;
+    bool nextReturnedEndOfData;
+    QTextDecoder *encMapper;
+
+    QXmlInputSourcePrivate *d;
+};
+
+//
+// SAX Exception Classes
+//
+
+class QM_EXPORT_XML QXmlParseException
+{
+public:
+    QXmlParseException( const QString& name="", int c=-1, int l=-1, const QString& p="", const QString& s="" )
+	: msg( name ), column( c ), line( l ), pub( p ), sys( s )
+    { }
+
+    int columnNumber() const;
+    int lineNumber() const;
+    QString publicId() const;
+    QString systemId() const;
+    QString message() const;
+
+private:
+    QString msg;
+    int column;
+    int line;
+    QString pub;
+    QString sys;
+
+    QXmlParseExceptionPrivate *d;
+};
+
+
+//
+// XML Reader
+//
+
+class QM_EXPORT_XML QXmlReader
+{
+public:
+    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 QM_EXPORT_XML 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:
+    // 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
+
+    int     nameArrayPos;
+    QChar   nameArray[256]; // only used for names
+    QString nameValue; // only used for names
+    int     refArrayPos;
+    QChar   refArray[256]; // only used for references
+    QString refValue; // only used for references
+    int     stringArrayPos;
+    QChar   stringArray[256]; // used for any other strings that are parsed
+    QString stringValue; // used for any other strings that are parsed
+
+    QXmlSimpleReaderPrivate* d;
+
+    const QString &string();
+    void stringClear();
+    inline void stringAddC() { stringAddC(c); }
+    void stringAddC(const QChar&);
+    const QString& name();
+    void nameClear();
+    inline void nameAddC() { nameAddC(c); }
+    void nameAddC(const QChar&);
+    const QString& ref();
+    void refClear();
+    inline void refAddC() { refAddC(c); }
+    void refAddC(const QChar&);
+
+    // used by parseReference() and parsePEReference()
+    enum EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD };
+
+    // private functions
+    bool eat_ws();
+    bool next_eat_ws();
+
+    void 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 (QXmlSimpleReader::*ParseFunction) ();
+    void unexpectedEof( ParseFunction where, int state );
+    void parseFailed( ParseFunction where, int state );
+    void pushParseState( ParseFunction function, int state );
+
+    void setUndefEntityInAttrHack(bool b);
+
+    friend class QXmlSimpleReaderPrivate;
+    friend class QXmlSimpleReaderLocator;
+    friend class QDomDocumentPrivate;
+};
+
+//
+// SAX Locator
+//
+
+class QM_EXPORT_XML QXmlLocator
+{
+public:
+    QXmlLocator();
+    virtual ~QXmlLocator();
+
+    virtual int columnNumber() = 0;
+    virtual int lineNumber() = 0;
+//    QString getPublicId()
+//    QString getSystemId()
+};
+
+//
+// SAX handler classes
+//
+
+class QM_EXPORT_XML QXmlContentHandler
+{
+public:
+    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() = 0;
+};
+
+class QM_EXPORT_XML QXmlErrorHandler
+{
+public:
+    virtual bool warning( const QXmlParseException& exception ) = 0;
+    virtual bool error( const QXmlParseException& exception ) = 0;
+    virtual bool fatalError( const QXmlParseException& exception ) = 0;
+    virtual QString errorString() = 0;
+};
+
+class QM_EXPORT_XML QXmlDTDHandler
+{
+public:
+    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() = 0;
+};
+
+class QM_EXPORT_XML QXmlEntityResolver
+{
+public:
+    virtual bool resolveEntity( const QString& publicId, const QString& systemId, QXmlInputSource*& ret ) = 0;
+    virtual QString errorString() = 0;
+};
+
+class QM_EXPORT_XML QXmlLexicalHandler
+{
+public:
+    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() = 0;
+};
+
+class QM_EXPORT_XML QXmlDeclHandler
+{
+public:
+    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() = 0;
+};
+
+
+class QM_EXPORT_XML 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();
+
+private:
+    QXmlDefaultHandlerPrivate *d;
+};
+
+
+//
+// inlines
+//
+
+inline bool QXmlSimpleReader::atEnd()
+{ return (c.unicode()|0x0001) == 0xffff; }
+inline int QXmlAttributes::count() const
+{ return length(); }
+
+
+#endif //QT_NO_XML
+
+#endif