Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

3 files changed, 8561 insertions, 0 deletions

diff --git a/src/xml/sax/qxml.cpp b/src/xml/sax/qxml.cpp
new file mode 100644
index 0000000000..f3296145ab
--- /dev/null
+++ b/src/xml/sax/qxml.cpp
@@ -0,0 +1,8132 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtXml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qxml.h"
+#include "qtextcodec.h"
+#include "qbuffer.h"
+#include "qregexp.h"
+#include "qmap.h"
+#include "qstack.h"
+#include <qdebug.h>
+
+
+#ifdef Q_CC_BOR // borland 6 finds bogus warnings when building this file in uic3
+#    pragma warn -8080
+#endif
+
+//#define QT_QXML_DEBUG
+
+// Error strings for the XML reader
+#define XMLERR_OK                         QT_TRANSLATE_NOOP("QXml", "no error occurred")
+#define XMLERR_ERRORBYCONSUMER            QT_TRANSLATE_NOOP("QXml", "error triggered by consumer")
+#define XMLERR_UNEXPECTEDEOF              QT_TRANSLATE_NOOP("QXml", "unexpected end of file")
+#define XMLERR_MORETHANONEDOCTYPE         QT_TRANSLATE_NOOP("QXml", "more than one document type definition")
+#define XMLERR_ERRORPARSINGELEMENT        QT_TRANSLATE_NOOP("QXml", "error occurred while parsing element")
+#define XMLERR_TAGMISMATCH                QT_TRANSLATE_NOOP("QXml", "tag mismatch")
+#define XMLERR_ERRORPARSINGCONTENT        QT_TRANSLATE_NOOP("QXml", "error occurred while parsing content")
+#define XMLERR_UNEXPECTEDCHARACTER        QT_TRANSLATE_NOOP("QXml", "unexpected character")
+#define XMLERR_INVALIDNAMEFORPI           QT_TRANSLATE_NOOP("QXml", "invalid name for processing instruction")
+#define XMLERR_VERSIONEXPECTED            QT_TRANSLATE_NOOP("QXml", "version expected while reading the XML declaration")
+#define XMLERR_WRONGVALUEFORSDECL         QT_TRANSLATE_NOOP("QXml", "wrong value for standalone declaration")
+#define XMLERR_EDECLORSDDECLEXPECTED      QT_TRANSLATE_NOOP("QXml", "encoding declaration or standalone declaration expected while reading the XML declaration")
+#define XMLERR_SDDECLEXPECTED             QT_TRANSLATE_NOOP("QXml", "standalone declaration expected while reading the XML declaration")
+#define XMLERR_ERRORPARSINGDOCTYPE        QT_TRANSLATE_NOOP("QXml", "error occurred while parsing document type definition")
+#define XMLERR_LETTEREXPECTED             QT_TRANSLATE_NOOP("QXml", "letter is expected")
+#define XMLERR_ERRORPARSINGCOMMENT        QT_TRANSLATE_NOOP("QXml", "error occurred while parsing comment")
+#define XMLERR_ERRORPARSINGREFERENCE      QT_TRANSLATE_NOOP("QXml", "error occurred while parsing reference")
+#define XMLERR_INTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP("QXml", "internal general entity reference not allowed in DTD")
+#define XMLERR_EXTERNALGENERALENTITYINAV  QT_TRANSLATE_NOOP("QXml", "external parsed general entity reference not allowed in attribute value")
+#define XMLERR_EXTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP("QXml", "external parsed general entity reference not allowed in DTD")
+#define XMLERR_UNPARSEDENTITYREFERENCE    QT_TRANSLATE_NOOP("QXml", "unparsed entity reference in wrong context")
+#define XMLERR_RECURSIVEENTITIES          QT_TRANSLATE_NOOP("QXml", "recursive entities")
+#define XMLERR_ERRORINTEXTDECL            QT_TRANSLATE_NOOP("QXml", "error in the text declaration of an external entity")
+
+QT_BEGIN_NAMESPACE
+
+// the constants for the lookup table
+static const signed char cltWS      =  0; // white space
+static const signed char cltPer     =  1; // %
+static const signed char cltAmp     =  2; // &
+static const signed char cltGt      =  3; // >
+static const signed char cltLt      =  4; // <
+static const signed char cltSlash   =  5; // /
+static const signed char cltQm      =  6; // ?
+static const signed char cltEm      =  7; // !
+static const signed char cltDash    =  8; // -
+static const signed char cltCB      =  9; // ]
+static const signed char cltOB      = 10; // [
+static const signed char cltEq      = 11; // =
+static const signed char cltDq      = 12; // "
+static const signed char cltSq      = 13; // '
+static const signed char cltUnknown = 14;
+
+// Hack for letting QDom know where the skipped entity occurred
+// ### Qt5: the use of this variable means the code isn't reentrant.
+bool qt_xml_skipped_entity_in_content;
+
+// character lookup table
+static const signed char charLookupTable[256]={
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x00 - 0x07
+    cltUnknown, // 0x08
+    cltWS,      // 0x09 \t
+    cltWS,      // 0x0A \n
+    cltUnknown, // 0x0B
+    cltUnknown, // 0x0C
+    cltWS,      // 0x0D \r
+    cltUnknown, // 0x0E
+    cltUnknown, // 0x0F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x17 - 0x16
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x18 - 0x1F
+    cltWS,      // 0x20 Space
+    cltEm,      // 0x21 !
+    cltDq,      // 0x22 "
+    cltUnknown, // 0x23
+    cltUnknown, // 0x24
+    cltPer,     // 0x25 %
+    cltAmp,     // 0x26 &
+    cltSq,      // 0x27 '
+    cltUnknown, // 0x28
+    cltUnknown, // 0x29
+    cltUnknown, // 0x2A
+    cltUnknown, // 0x2B
+    cltUnknown, // 0x2C
+    cltDash,    // 0x2D -
+    cltUnknown, // 0x2E
+    cltSlash,   // 0x2F /
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x30 - 0x37
+    cltUnknown, // 0x38
+    cltUnknown, // 0x39
+    cltUnknown, // 0x3A
+    cltUnknown, // 0x3B
+    cltLt,      // 0x3C <
+    cltEq,      // 0x3D =
+    cltGt,      // 0x3E >
+    cltQm,      // 0x3F ?
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x40 - 0x47
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x48 - 0x4F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x50 - 0x57
+    cltUnknown, // 0x58
+    cltUnknown, // 0x59
+    cltUnknown, // 0x5A
+    cltOB,      // 0x5B [
+    cltUnknown, // 0x5C
+    cltCB,      // 0x5D]
+    cltUnknown, // 0x5E
+    cltUnknown, // 0x5F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x60 - 0x67
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x68 - 0x6F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x70 - 0x77
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x78 - 0x7F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x80 - 0x87
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x88 - 0x8F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x90 - 0x97
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x98 - 0x9F
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA0 - 0xA7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA8 - 0xAF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB0 - 0xB7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB8 - 0xBF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC0 - 0xC7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC8 - 0xCF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD0 - 0xD7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD8 - 0xDF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE0 - 0xE7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE8 - 0xEF
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xF0 - 0xF7
+    cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown  // 0xF8 - 0xFF
+};
+
+//
+// local helper functions
+//
+
+/*
+  This function strips the TextDecl [77] ("<?xml ...?>") from the string \a
+  str. The stripped version is stored in \a str. If this function finds an
+  invalid TextDecl, it returns false, otherwise true.
+
+  This function is used for external entities since those can include an
+  TextDecl that must be stripped before inserting the entity.
+*/
+static bool stripTextDecl(QString& str)
+{
+    QString textDeclStart(QLatin1String("<?xml"));
+    if (str.startsWith(textDeclStart)) {
+        QRegExp textDecl(QString::fromLatin1(
+            "^<\\?xml\\s+"
+            "(version\\s*=\\s*((['\"])[-a-zA-Z0-9_.:]+\\3))?"
+            "\\s*"
+            "(encoding\\s*=\\s*((['\"])[A-Za-z][-a-zA-Z0-9_.]*\\6))?"
+            "\\s*\\?>"
+       ));
+        QString strTmp = str.replace(textDecl, QLatin1String(""));
+        if (strTmp.length() != str.length())
+            return false; // external entity has wrong TextDecl
+        str = strTmp;
+    }
+    return true;
+}
+
+
+class QXmlAttributesPrivate
+{
+};
+
+/* \class QXmlInputSourcePrivate
+    \internal
+
+  There's a slight misdesign in this class that can
+  be worth to keep in mind: the `str' member is
+  a buffer which QXmlInputSource::next() returns from,
+  and which is populated from the input device or input
+  stream. However, when the input is a QString(the user called
+  QXmlInputSource::setData()), `str' has two roles: it's the
+  buffer, but also the source. This /seems/ to be no problem
+  because in the case of having no device or stream, the QString
+  is read in one go.
+ */
+class QXmlInputSourcePrivate
+{
+public:
+    QIODevice *inputDevice;
+    QTextStream *inputStream;
+
+    QString str;
+    const QChar *unicode;
+    int pos;
+    int length;
+    bool nextReturnedEndOfData;
+#ifndef QT_NO_TEXTCODEC
+    QTextDecoder *encMapper;
+#endif
+
+    QByteArray encodingDeclBytes;
+    QString encodingDeclChars;
+    bool lookingForEncodingDecl;
+};
+class QXmlParseExceptionPrivate
+{
+public:
+    QXmlParseExceptionPrivate()
+        : column(-1), line(-1)
+    {
+    }
+    QXmlParseExceptionPrivate(const QXmlParseExceptionPrivate &other)
+        : msg(other.msg), column(other.column), line(other.line),
+          pub(other.pub), sys(other.sys)
+    {
+    }
+
+    QString msg;
+    int column;
+    int line;
+    QString pub;
+    QString sys;
+
+};
+
+class QXmlLocatorPrivate
+{
+};
+
+class QXmlDefaultHandlerPrivate
+{
+};
+
+class QXmlSimpleReaderPrivate
+{
+public:
+    ~QXmlSimpleReaderPrivate();
+private:
+    // functions
+    QXmlSimpleReaderPrivate(QXmlSimpleReader *reader);
+    void initIncrementalParsing();
+
+    // used to determine if elements are correctly nested
+    QStack<QString> tags;
+
+    // used by parseReference() and parsePEReference()
+    enum EntityRecognitionContext { InContent, InAttributeValue, InEntityValue, InDTD };
+
+    // used for entity declarations
+    struct ExternParameterEntity
+    {
+        ExternParameterEntity() {}
+        ExternParameterEntity(const QString &p, const QString &s)
+            : publicId(p), systemId(s) {}
+        QString publicId;
+        QString systemId;
+
+        Q_DUMMY_COMPARISON_OPERATOR(ExternParameterEntity)
+    };
+    struct ExternEntity
+    {
+        ExternEntity() {}
+        ExternEntity(const QString &p, const QString &s, const QString &n)
+            : publicId(p), systemId(s), notation(n) {}
+        QString publicId;
+        QString systemId;
+        QString notation;
+        Q_DUMMY_COMPARISON_OPERATOR(ExternEntity)
+    };
+    QMap<QString,ExternParameterEntity> externParameterEntities;
+    QMap<QString,QString> parameterEntities;
+    QMap<QString,ExternEntity> externEntities;
+    QMap<QString,QString> entities;
+
+    // used for parsing of entity references
+    struct XmlRef {
+        XmlRef()
+            : index(0) {}
+        XmlRef(const QString &_name, const QString &_value)
+            : name(_name), value(_value), index(0) {}
+        bool isEmpty() const { return index == value.length(); }
+        QChar next() { return value.at(index++); }
+        QString name;
+        QString value;
+        int index;
+    };
+    QStack<XmlRef> xmlRefStack;
+
+    // used for standalone declaration
+    enum Standalone { Yes, No, Unknown };
+
+    QString doctype; // only used for the doctype
+    QString xmlVersion; // only used to store the version information
+    QString encoding; // only used to store the encoding
+    Standalone standalone; // used to store the value of the standalone declaration
+
+    QString publicId; // used by parseExternalID() to store the public ID
+    QString systemId; // used by parseExternalID() to store the system ID
+
+    // Since publicId/systemId is used as temporary variables by parseExternalID(), it
+    // might overwrite the PUBLIC/SYSTEM for the document we're parsing. In effect, we would
+    // possibly send off an QXmlParseException that has the PUBLIC/SYSTEM of a entity declaration
+    // instead of those of the current document.
+    // Hence we have these two variables for storing the document's data.
+    QString thisPublicId;
+    QString thisSystemId;
+
+    QString attDeclEName; // use by parseAttlistDecl()
+    QString attDeclAName; // use by parseAttlistDecl()
+
+    // flags for some features support
+    bool useNamespaces;
+    bool useNamespacePrefixes;
+    bool reportWhitespaceCharData;
+    bool reportEntities;
+
+    // used to build the attribute list
+    QXmlAttributes attList;
+
+    // used in QXmlSimpleReader::parseContent() to decide whether character
+    // data was read
+    bool contentCharDataRead;
+
+    // helper classes
+    QScopedPointer<QXmlLocator> locator;
+    QXmlNamespaceSupport namespaceSupport;
+
+    // error string
+    QString error;
+
+    // arguments for parse functions (this is needed to allow incremental
+    // parsing)
+    bool parsePI_xmldecl;
+    bool parseName_useRef;
+    bool parseReference_charDataRead;
+    EntityRecognitionContext parseReference_context;
+    bool parseExternalID_allowPublicID;
+    EntityRecognitionContext parsePEReference_context;
+    QString parseString_s;
+
+    // for incremental parsing
+    struct ParseState {
+        typedef bool (QXmlSimpleReaderPrivate::*ParseFunction)();
+        ParseFunction function;
+        int state;
+    };
+    QStack<ParseState> *parseStack;
+
+    // used in parseProlog()
+    bool xmldecl_possible;
+    bool doctype_read;
+
+    // used in parseDoctype()
+    bool startDTDwasReported;
+
+    // used in parseString()
+    signed char Done;
+
+
+    // variables
+    QXmlContentHandler *contentHnd;
+    QXmlErrorHandler   *errorHnd;
+    QXmlDTDHandler     *dtdHnd;
+    QXmlEntityResolver *entityRes;
+    QXmlLexicalHandler *lexicalHnd;
+    QXmlDeclHandler    *declHnd;
+
+    QXmlInputSource *inputSource;
+
+    QChar c; // the character at reading position
+    int   lineNr; // number of line
+    int   columnNr; // position in line
+
+    QChar   nameArray[256]; // only used for names
+    QString nameValue; // only used for names
+    int     nameArrayPos;
+    int     nameValueLen;
+    QChar   refArray[256]; // only used for references
+    QString refValue; // only used for references
+    int     refArrayPos;
+    int     refValueLen;
+    QChar   stringArray[256]; // used for any other strings that are parsed
+    QString stringValue; // used for any other strings that are parsed
+    int     stringArrayPos;
+    int     stringValueLen;
+    QString emptyStr;
+
+    const QString &string();
+    void stringClear();
+    void stringAddC(QChar);
+    inline void stringAddC() { stringAddC(c); }
+    const QString &name();
+    void nameClear();
+    void nameAddC(QChar);
+    inline void nameAddC() { nameAddC(c); }
+    const QString &ref();
+    void refClear();
+    void refAddC(QChar);
+    inline void refAddC() { refAddC(c); }
+
+    // private functions
+    bool eat_ws();
+    bool next_eat_ws();
+
+    void QT_FASTCALL next();
+    bool atEnd();
+
+    void init(const QXmlInputSource* i);
+    void initData();
+
+    bool entityExist(const QString&) const;
+
+    bool parseBeginOrContinue(int state, bool incremental);
+
+    bool parseProlog();
+    bool parseElement();
+    bool processElementEmptyTag();
+    bool processElementETagBegin2();
+    bool processElementAttribute();
+    bool parseMisc();
+    bool parseContent();
+
+    bool parsePI();
+    bool parseDoctype();
+    bool parseComment();
+
+    bool parseName();
+    bool parseNmtoken();
+    bool parseAttribute();
+    bool parseReference();
+    bool processReference();
+
+    bool parseExternalID();
+    bool parsePEReference();
+    bool parseMarkupdecl();
+    bool parseAttlistDecl();
+    bool parseAttType();
+    bool parseAttValue();
+    bool parseElementDecl();
+    bool parseNotationDecl();
+    bool parseChoiceSeq();
+    bool parseEntityDecl();
+    bool parseEntityValue();
+
+    bool parseString();
+
+    bool insertXmlRef(const QString&, const QString&, bool);
+
+    bool reportEndEntities();
+    void reportParseError(const QString& error);
+
+    typedef bool (QXmlSimpleReaderPrivate::*ParseFunction) ();
+    void unexpectedEof(ParseFunction where, int state);
+    void parseFailed(ParseFunction where, int state);
+    void pushParseState(ParseFunction function, int state);
+
+    Q_DECLARE_PUBLIC(QXmlSimpleReader)
+    QXmlSimpleReader *q_ptr;
+
+    friend class QXmlSimpleReaderLocator;
+};
+
+/*!
+    \class QXmlParseException
+    \reentrant
+    \brief The QXmlParseException class is used to report errors with
+    the QXmlErrorHandler interface.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    The XML subsystem constructs an instance of this class when it
+    detects an error. You can retrieve the place where the error
+    occurred using systemId(), publicId(), lineNumber() and
+    columnNumber(), along with the error message(). The possible error
+    messages are:
+
+
+    \list
+        \o "no error occurred"
+        \o "error triggered by consumer"
+        \o "unexpected end of file"
+        \o "more than one document type definition"
+        \o "error occurred while parsing element"
+        \o "tag mismatch"
+        \o "error occurred while parsing content"
+        \o "unexpected character"
+        \o "invalid name for processing instruction"
+        \o "version expected while reading the XML declaration"
+        \o "wrong value for standalone declaration"
+        \o "encoding declaration or standalone declaration expected while reading the XML declaration"
+        \o "standalone declaration expected while reading the XML declaration"
+        \o "error occurred while parsing document type definition"
+        \o "letter is expected"
+        \o "error occurred while parsing comment"
+        \o "error occurred while parsing reference"
+        \o "internal general entity reference not allowed in DTD"
+        \o "external parsed general entity reference not allowed in attribute value"
+        \o "external parsed general entity reference not allowed in DTD"
+        \o "unparsed entity reference n wrong context"
+        \o "recursive entities"
+        \o "error in the text declaration of an external entity"
+    \endlist
+
+    Note that, if you want to display these error messages to your
+    application's users, they will be displayed in English unless
+    they are explicitly translated.
+
+    \sa QXmlErrorHandler, QXmlReader
+*/
+
+/*!
+    Constructs a parse exception with the error string \a name for
+    column \a c and line \a l for the public identifier \a p and the
+    system identifier \a s.
+*/
+
+QXmlParseException::QXmlParseException(const QString& name, int c, int l,
+                                       const QString& p, const QString& s)
+    : d(new QXmlParseExceptionPrivate)
+{
+    d->msg = name;
+    d->column = c;
+    d->line = l;
+    d->pub = p;
+    d->sys = s;
+}
+
+/*!
+    Creates a copy of \a other.
+*/
+QXmlParseException::QXmlParseException(const QXmlParseException& other) :
+     d(new QXmlParseExceptionPrivate(*other.d))
+{
+
+}
+
+/*!
+    Destroys the QXmlParseException.
+*/
+QXmlParseException::~QXmlParseException()
+{
+}
+
+/*!
+    Returns the error message.
+*/
+QString QXmlParseException::message() const
+{
+    return d->msg;
+}
+/*!
+    Returns the column number where the error occurred.
+*/
+int QXmlParseException::columnNumber() const
+{
+    return d->column;
+}
+/*!
+    Returns the line number where the error occurred.
+*/
+int QXmlParseException::lineNumber() const
+{
+    return d->line;
+}
+/*!
+    Returns the public identifier where the error occurred.
+*/
+QString QXmlParseException::publicId() const
+{
+    return d->pub;
+}
+/*!
+    Returns the system identifier where the error occurred.
+*/
+QString QXmlParseException::systemId() const
+{
+    return d->sys;
+}
+
+
+/*!
+    \class QXmlLocator
+    \reentrant
+    \brief The QXmlLocator class provides the XML handler classes with
+    information about the parsing position within a file.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    The reader reports a QXmlLocator to the content handler before it
+    starts to parse the document. This is done with the
+    QXmlContentHandler::setDocumentLocator() function. The handler
+    classes can now use this locator to get the position (lineNumber()
+    and columnNumber()) that the reader has reached.
+*/
+
+/*!
+    Constructor.
+*/
+QXmlLocator::QXmlLocator()
+{
+}
+
+/*!
+    Destructor.
+*/
+QXmlLocator::~QXmlLocator()
+{
+}
+
+/*!
+    \fn int QXmlLocator::columnNumber() const
+
+    Returns the column number (starting at 1) or -1 if there is no
+    column number available.
+*/
+
+/*!
+    \fn int QXmlLocator::lineNumber() const
+
+    Returns the line number (starting at 1) or -1 if there is no line
+    number available.
+*/
+
+class QXmlSimpleReaderLocator : public QXmlLocator
+{
+public:
+    QXmlSimpleReaderLocator(QXmlSimpleReader* parent)
+    {
+        reader = parent;
+    }
+    ~QXmlSimpleReaderLocator()
+    {
+    }
+
+    int columnNumber() const
+    {
+        return (reader->d_ptr->columnNr == -1 ? -1 : reader->d_ptr->columnNr + 1);
+    }
+    int lineNumber() const
+    {
+        return (reader->d_ptr->lineNr == -1 ? -1 : reader->d_ptr->lineNr + 1);
+    }
+//    QString getPublicId()
+//    QString getSystemId()
+
+private:
+    QXmlSimpleReader *reader;
+};
+
+/*********************************************
+ *
+ * QXmlNamespaceSupport
+ *
+ *********************************************/
+
+typedef QMap<QString, QString> NamespaceMap;
+
+class QXmlNamespaceSupportPrivate
+{
+public:
+    QXmlNamespaceSupportPrivate()
+    {
+        ns.insert(QLatin1String("xml"), QLatin1String("http://www.w3.org/XML/1998/namespace")); // the XML namespace
+    }
+
+    ~QXmlNamespaceSupportPrivate()
+    {
+    }
+
+    QStack<NamespaceMap> nsStack;
+    NamespaceMap ns;
+};
+
+/*!
+    \class QXmlNamespaceSupport
+    \since 4.4
+    \reentrant
+    \brief The QXmlNamespaceSupport class is a helper class for XML
+    readers which want to include namespace support.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    You can set the prefix for the current namespace with setPrefix(),
+    and get the list of current prefixes (or those for a given URI)
+    with prefixes(). The namespace URI is available from uri(). Use
+    pushContext() to start a new namespace context, and popContext()
+    to return to the previous namespace context. Use splitName() or
+    processName() to split a name into its prefix and local name.
+
+    \sa {Namespace Support via Features}
+*/
+
+/*!
+    Constructs a QXmlNamespaceSupport.
+*/
+QXmlNamespaceSupport::QXmlNamespaceSupport()
+{
+    d = new QXmlNamespaceSupportPrivate;
+}
+
+/*!
+    Destroys a QXmlNamespaceSupport.
+*/
+QXmlNamespaceSupport::~QXmlNamespaceSupport()
+{
+    delete d;
+}
+
+/*!
+    This function declares a prefix \a pre in the current namespace
+    context to be the namespace URI \a uri. The prefix remains in
+    force until this context is popped, unless it is shadowed in a
+    descendant context.
+
+    Note that there is an asymmetry in this library. prefix() does not
+    return the default "" prefix, even if you have declared one; to
+    check for a default prefix, you must look it up explicitly using
+    uri(). This asymmetry exists to make it easier to look up prefixes
+    for attribute names, where the default prefix is not allowed.
+*/
+void QXmlNamespaceSupport::setPrefix(const QString& pre, const QString& uri)
+{
+    if(pre.isNull()) {
+        d->ns.insert(QLatin1String(""), uri);
+    } else {
+        d->ns.insert(pre, uri);
+    }
+}
+
+/*!
+    Returns one of the prefixes mapped to the namespace URI \a uri.
+
+    If more than one prefix is currently mapped to the same URI, this
+    function makes an arbitrary selection; if you want all of the
+    prefixes, use prefixes() instead.
+
+    Note: to check for a default prefix, use the uri() function with
+    an argument of "".
+*/
+QString QXmlNamespaceSupport::prefix(const QString& uri) const
+{
+    NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+    while ((itc=it) != d->ns.constEnd()) {
+        ++it;
+        if (*itc == uri && !itc.key().isEmpty())
+            return itc.key();
+    }
+    return QLatin1String("");
+}
+
+/*!
+    Looks up the prefix \a prefix in the current context and returns
+    the currently-mapped namespace URI. Use the empty string ("") for
+    the default namespace.
+*/
+QString QXmlNamespaceSupport::uri(const QString& prefix) const
+{
+    return d->ns[prefix];
+}
+
+/*!
+    Splits the name \a qname at the ':' and returns the prefix in \a
+    prefix and the local name in \a localname.
+
+    \sa processName()
+*/
+void QXmlNamespaceSupport::splitName(const QString& qname, QString& prefix,
+                                     QString& localname) const
+{
+    int pos = qname.indexOf(QLatin1Char(':'));
+    if (pos == -1)
+        pos = qname.size();
+
+    prefix = qname.left(pos);
+    localname = qname.mid(pos+1);
+}
+
+/*!
+    Processes a raw XML 1.0 name in the current context by removing
+    the prefix and looking it up among the prefixes currently
+    declared.
+
+    \a qname is the raw XML 1.0 name to be processed. \a isAttribute
+    is true if the name is an attribute name.
+
+    This function stores the namespace URI in \a nsuri (which will be
+    set to an empty string if the raw name has an undeclared prefix),
+    and stores the local name (without prefix) in \a localname (which
+    will be set to an empty string if no namespace is in use).
+
+    Note that attribute names are processed differently than element
+    names: an unprefixed element name gets the default namespace (if
+    any), while an unprefixed attribute name does not.
+*/
+void QXmlNamespaceSupport::processName(const QString& qname,
+        bool isAttribute,
+        QString& nsuri, QString& localname) const
+{
+    int len = qname.size();
+    const QChar *data = qname.constData();
+    for (int pos = 0; pos < len; ++pos) {
+        if (data[pos] == QLatin1Char(':')) {
+            nsuri = uri(qname.left(pos));
+            localname = qname.mid(pos + 1);
+            return;
+        }
+    }
+
+    // there was no ':'
+    nsuri.clear();
+    // attributes don't take default namespace
+    if (!isAttribute && !d->ns.isEmpty()) {
+	/*
+	    We want to access d->ns.value(""), but as an optimization
+	    we use the fact that "" compares less than any other
+	    string, so it's either first in the map or not there.
+	*/
+        NamespaceMap::const_iterator first = d->ns.constBegin();
+        if (first.key().isEmpty())
+            nsuri = first.value(); // get default namespace
+    }
+    localname = qname;
+}
+
+/*!
+    Returns a list of all the prefixes currently declared.
+
+    If there is a default prefix, this function does not return it in
+    the list; check for the default prefix using uri() with an
+    argument of "".
+*/
+QStringList QXmlNamespaceSupport::prefixes() const
+{
+    QStringList list;
+
+    NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+    while ((itc=it) != d->ns.constEnd()) {
+        ++it;
+        if (!itc.key().isEmpty())
+            list.append(itc.key());
+    }
+    return list;
+}
+
+/*!
+    \overload
+
+    Returns a list of all prefixes currently declared for the
+    namespace URI \a uri.
+
+    The "xml:" prefix is included. If you only want one prefix that is
+    mapped to the namespace URI, and you don't care which one you get,
+    use the prefix() function instead.
+
+    Note: The empty (default) prefix is never included in this list;
+    to check for the presence of a default namespace, call uri() with
+    "" as the argument.
+*/
+QStringList QXmlNamespaceSupport::prefixes(const QString& uri) const
+{
+    QStringList list;
+
+    NamespaceMap::const_iterator itc, it = d->ns.constBegin();
+    while ((itc=it) != d->ns.constEnd()) {
+        ++it;
+        if (*itc == uri && !itc.key().isEmpty())
+            list.append(itc.key());
+    }
+    return list;
+}
+
+/*!
+    Starts a new namespace context.
+
+    Normally, you should push a new context at the beginning of each
+    XML element: the new context automatically inherits the
+    declarations of its parent context, and it also keeps track of
+    which declarations were made within this context.
+
+    \sa popContext()
+*/
+void QXmlNamespaceSupport::pushContext()
+{
+    d->nsStack.push(d->ns);
+}
+
+/*!
+    Reverts to the previous namespace context.
+
+    Normally, you should pop the context at the end of each XML
+    element. After popping the context, all namespace prefix mappings
+    that were previously in force are restored.
+
+    \sa pushContext()
+*/
+void QXmlNamespaceSupport::popContext()
+{
+    d->ns.clear();
+    if(!d->nsStack.isEmpty())
+        d->ns = d->nsStack.pop();
+}
+
+/*!
+    Resets this namespace support object ready for reuse.
+*/
+void QXmlNamespaceSupport::reset()
+{
+    QXmlNamespaceSupportPrivate *newD = new QXmlNamespaceSupportPrivate;
+    delete d;
+    d = newD;
+}
+
+
+
+/*********************************************
+ *
+ * QXmlAttributes
+ *
+ *********************************************/
+
+/*!
+    \class QXmlAttributes
+    \reentrant
+    \brief The QXmlAttributes class provides XML attributes.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    If attributes are reported by QXmlContentHandler::startElement()
+    this class is used to pass the attribute values.
+
+    Use index() to locate the position of an attribute in the list,
+    count() to retrieve the number of attributes, and clear() to
+    remove the attributes. New attributes can be added with append().
+    Use type() to get an attribute's type and value() to get its
+    value. The attribute's name is available from localName() or
+    qName(), and its namespace URI from uri().
+
+*/
+
+/*!
+    \fn QXmlAttributes::QXmlAttributes()
+
+    Constructs an empty attribute list.
+*/
+
+/*!
+    \fn QXmlAttributes::~QXmlAttributes()
+
+    Destroys the attributes object.
+*/
+
+/*!
+    Looks up the index of an attribute by the qualified name \a qName.
+
+    Returns the index of the attribute or -1 if it wasn't found.
+
+    \sa {Namespace Support via Features}
+*/
+int QXmlAttributes::index(const QString& qName) const
+{
+    for (int i = 0; i < attList.size(); ++i) {
+        if (attList.at(i).qname == qName)
+            return i;
+    }
+    return -1;
+}
+
+/*! \overload
+  */
+int QXmlAttributes::index(const QLatin1String& qName) const
+{
+    for (int i = 0; i < attList.size(); ++i) {
+        if (attList.at(i).qname == qName)
+            return i;
+    }
+    return -1;
+}
+
+/*!
+    \overload
+
+    Looks up the index of an attribute by a namespace name.
+
+    \a uri specifies the namespace URI, or an empty string if the name
+    has no namespace URI. \a localPart specifies the attribute's local
+    name.
+
+    Returns the index of the attribute, or -1 if it wasn't found.
+
+    \sa {Namespace Support via Features}
+*/
+int QXmlAttributes::index(const QString& uri, const QString& localPart) const
+{
+    for (int i = 0; i < attList.size(); ++i) {
+        const Attribute &att = attList.at(i);
+        if (att.uri == uri && att.localname == localPart)
+            return i;
+    }
+    return -1;
+}
+
+/*!
+    Returns the number of attributes in the list.
+
+    \sa count()
+*/
+int QXmlAttributes::length() const
+{
+    return attList.count();
+}
+
+/*!
+    \fn int QXmlAttributes::count() const
+
+    Returns the number of attributes in the list. This function is
+    equivalent to length().
+*/
+
+/*!
+    Looks up an attribute's local name for the attribute at position
+    \a index. If no namespace processing is done, the local name is
+    an empty string.
+
+    \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::localName(int index) const
+{
+    return attList.at(index).localname;
+}
+
+/*!
+    Looks up an attribute's XML 1.0 qualified name for the attribute
+    at position \a index.
+
+    \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::qName(int index) const
+{
+    return attList.at(index).qname;
+}
+
+/*!
+    Looks up an attribute's namespace URI for the attribute at
+    position \a index. If no namespace processing is done or if the
+    attribute has no namespace, the namespace URI is an empty string.
+
+    \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::uri(int index) const
+{
+    return attList.at(index).uri;
+}
+
+/*!
+    Looks up an attribute's type for the attribute at position \a
+    index.
+
+    Currently only "CDATA" is returned.
+*/
+QString QXmlAttributes::type(int) const
+{
+    return QLatin1String("CDATA");
+}
+
+/*!
+    \overload
+
+    Looks up an attribute's type for the qualified name \a qName.
+
+    Currently only "CDATA" is returned.
+*/
+QString QXmlAttributes::type(const QString&) const
+{
+    return QLatin1String("CDATA");
+}
+
+/*!
+    \overload
+
+    Looks up an attribute's type by namespace name.
+
+    \a uri specifies the namespace URI and \a localName specifies the
+    local name. If the name has no namespace URI, use an empty string
+    for \a uri.
+
+    Currently only "CDATA" is returned.
+*/
+QString QXmlAttributes::type(const QString&, const QString&) const
+{
+    return QLatin1String("CDATA");
+}
+
+/*!
+    Returns an attribute's value for the attribute at position \a
+    index. The index must be a valid position
+    (i.e., 0 <= \a index < count()).
+*/
+QString QXmlAttributes::value(int index) const
+{
+    return attList.at(index).value;
+}
+
+/*!
+    \overload
+
+    Returns an attribute's value for the qualified name \a qName, or an
+    empty string if no attribute exists for the name given.
+
+    \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::value(const QString& qName) const
+{
+    int i = index(qName);
+    if (i == -1)
+        return QString();
+    return attList.at(i).value;
+}
+
+/*!
+    \overload
+
+    Returns an attribute's value for the qualified name \a qName, or an
+    empty string if no attribute exists for the name given.
+
+    \sa {Namespace Support via Features}
+*/
+QString QXmlAttributes::value(const QLatin1String& qName) const
+{
+    int i = index(qName);
+    if (i == -1)
+        return QString();
+    return attList.at(i).value;
+}
+
+/*!
+    \overload
+
+    Returns an attribute's value by namespace name.
+
+    \a uri specifies the namespace URI, or an empty string if the name
+    has no namespace URI. \a localName specifies the attribute's local
+    name.
+*/
+QString QXmlAttributes::value(const QString& uri, const QString& localName) const
+{
+    int i = index(uri, localName);
+    if (i == -1)
+        return QString();
+    return attList.at(i).value;
+}
+
+/*!
+    Clears the list of attributes.
+
+    \sa append()
+*/
+void QXmlAttributes::clear()
+{
+    attList.clear();
+}
+
+/*!
+    Appends a new attribute entry to the list of attributes. The
+    qualified name of the attribute is \a qName, the namespace URI is
+    \a uri and the local name is \a localPart. The value of the
+    attribute is \a value.
+
+    \sa qName() uri() localName() value()
+*/
+void QXmlAttributes::append(const QString &qName, const QString &uri, const QString &localPart, const QString &value)
+{
+    Attribute att;
+    att.qname = qName;
+    att.uri = uri;
+    att.localname = localPart;
+    att.value = value;
+
+    attList.append(att);
+}
+
+
+/*********************************************
+ *
+ * QXmlInputSource
+ *
+ *********************************************/
+
+/*!
+    \class QXmlInputSource
+    \reentrant
+    \brief The QXmlInputSource class provides the input data for the
+    QXmlReader subclasses.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    All subclasses of QXmlReader read the input XML document from this
+    class.
+
+    This class recognizes the encoding of the data by reading the
+    encoding declaration in the XML file if it finds one, and reading
+    the data using the corresponding encoding. If it does not find an
+    encoding declaration, then it assumes that the data is either in
+    UTF-8 or UTF-16, depending on whether it can find a byte-order
+    mark.
+
+    There are two ways to populate the input source with data: you can
+    construct it with a QIODevice* so that the input source reads the
+    data from that device. Or you can set the data explicitly with one
+    of the setData() functions.
+
+    Usually you either construct a QXmlInputSource that works on a
+    QIODevice* or you construct an empty QXmlInputSource and set the
+    data with setData(). There are only rare occasions where you would
+    want to mix both methods.
+
+    The QXmlReader subclasses use the next() function to read the
+    input character by character. If you want to start from the
+    beginning again, use reset().
+
+    The functions data() and fetchData() are useful if you want to do
+    something with the data other than parsing, e.g. displaying the
+    raw XML file. The benefit of using the QXmlInputClass in such
+    cases is that it tries to use the correct encoding.
+
+    \sa QXmlReader QXmlSimpleReader
+*/
+
+// the following two are guaranteed not to be a character
+const ushort QXmlInputSource::EndOfData = 0xfffe;
+const ushort QXmlInputSource::EndOfDocument = 0xffff;
+
+/*
+    Common part of the constructors.
+*/
+void QXmlInputSource::init()
+{
+    d = new QXmlInputSourcePrivate;
+
+    QT_TRY {
+        d->inputDevice = 0;
+        d->inputStream = 0;
+
+        setData(QString());
+#ifndef QT_NO_TEXTCODEC
+        d->encMapper = 0;
+#endif
+        d->nextReturnedEndOfData = true; // first call to next() will call fetchData()
+
+        d->encodingDeclBytes.clear();
+        d->encodingDeclChars.clear();
+        d->lookingForEncodingDecl = true;
+    } QT_CATCH(...) {
+        delete(d);
+        QT_RETHROW;
+    }
+}
+
+/*!
+    Constructs an input source which contains no data.
+
+    \sa setData()
+*/
+QXmlInputSource::QXmlInputSource()
+{
+    init();
+}
+
+/*!
+    Constructs an input source and gets the data from device \a dev.
+    If \a dev is not open, it is opened in read-only mode. If \a dev
+    is 0 or it is not possible to read from the device, the input
+    source will contain no data.
+
+    \sa setData() fetchData() QIODevice
+*/
+QXmlInputSource::QXmlInputSource(QIODevice *dev)
+{
+    init();
+    d->inputDevice = dev;
+    d->inputDevice->setTextModeEnabled(false);
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    Use the QXmlInputSource(QIODevice *) constructor instead, with
+    the device used by \a stream.
+
+    \sa QTextStream::device()
+*/
+QXmlInputSource::QXmlInputSource(QTextStream& stream)
+{
+    init();
+    d->inputStream = &stream;
+}
+
+/*!
+    Use QXmlInputSource(&\a file) instead.
+*/
+QXmlInputSource::QXmlInputSource(QFile& file)
+{
+    init();
+    d->inputDevice = &file;
+}
+#endif
+
+/*!
+    Destructor.
+*/
+QXmlInputSource::~QXmlInputSource()
+{
+    // ### Qt 5: close the input device. See task 153111
+#ifndef QT_NO_TEXTCODEC
+    delete d->encMapper;
+#endif
+    delete d;
+}
+
+/*!
+Returns the next character of the input source. If this function
+reaches the end of available data, it returns
+QXmlInputSource::EndOfData. If you call next() after that, it
+tries to fetch more data by calling fetchData(). If the
+fetchData() call results in new data, this function returns the
+first character of that data; otherwise it returns
+QXmlInputSource::EndOfDocument.
+
+Readers, such as QXmlSimpleReader, will assume that the end of
+the XML document has been reached if the this function returns
+QXmlInputSource::EndOfDocument, and will check that the
+supplied input is well-formed. Therefore, when reimplementing
+this function, it is important to ensure that this behavior is
+duplicated.
+
+\sa reset() fetchData() QXmlSimpleReader::parse() QXmlSimpleReader::parseContinue()
+*/
+QChar QXmlInputSource::next()
+{
+    if (d->pos >= d->length) {
+        if (d->nextReturnedEndOfData) {
+            d->nextReturnedEndOfData = false;
+            fetchData();
+            if (d->pos >= d->length) {
+                return EndOfDocument;
+            }
+            return next();
+        }
+        d->nextReturnedEndOfData = true;
+        return EndOfData;
+    }
+
+    // QXmlInputSource has no way to signal encoding errors. The best we can do
+    // is return EndOfDocument. We do *not* return EndOfData, because the reader
+    // will then just call this function again to get the next char.
+    QChar c = d->unicode[d->pos++];
+    if (c.unicode() == EndOfData)
+        c = EndOfDocument;
+    return c;
+}
+
+/*!
+    This function sets the position used by next() to the beginning of
+    the data returned by data(). This is useful if you want to use the
+    input source for more than one parse.
+
+    \note In the case that the underlying data source is a QIODevice,
+    the current position in the device is not automatically set to the
+    start of input. Call QIODevice::seek(0) on the device to do this.
+
+    \sa next()
+*/
+void QXmlInputSource::reset()
+{
+    d->nextReturnedEndOfData = false;
+    d->pos = 0;
+}
+
+/*!
+    Returns the data the input source contains or an empty string if the
+    input source does not contain any data.
+
+    \sa setData() QXmlInputSource() fetchData()
+*/
+QString QXmlInputSource::data() const
+{
+    if (d->nextReturnedEndOfData) {
+        QXmlInputSource *that = const_cast<QXmlInputSource*>(this);
+        that->d->nextReturnedEndOfData = false;
+        that->fetchData();
+    }
+    return d->str;
+}
+
+/*!
+    Sets the data of the input source to \a dat.
+
+    If the input source already contains data, this function deletes
+    that data first.
+
+    \sa data()
+*/
+void QXmlInputSource::setData(const QString& dat)
+{
+    d->str = dat;
+    d->unicode = dat.unicode();
+    d->pos = 0;
+    d->length = d->str.length();
+    d->nextReturnedEndOfData = false;
+}
+
+/*!
+    \overload
+
+    The data \a dat is passed through the correct text-codec, before
+    it is set.
+*/
+void QXmlInputSource::setData(const QByteArray& dat)
+{
+    setData(fromRawData(dat));
+}
+
+/*!
+    This function reads more data from the device that was set during
+    construction. If the input source already contained data, this
+    function deletes that data first.
+
+    This object contains no data after a call to this function if the
+    object was constructed without a device to read data from or if
+    this function was not able to get more data from the device.
+
+    There are two occasions where a fetch is done implicitly by
+    another function call: during construction (so that the object
+    starts out with some initial data where available), and during a
+    call to next() (if the data had run out).
+
+    You don't normally need to use this function if you use next().
+
+    \sa data() next() QXmlInputSource()
+*/
+
+void QXmlInputSource::fetchData()
+{
+    enum
+    {
+        BufferSize = 1024
+    };
+
+    QByteArray rawData;
+
+    if (d->inputDevice || d->inputStream) {
+        QIODevice *device = d->inputDevice ? d->inputDevice : d->inputStream->device();
+
+        if (!device) {
+            if (d->inputStream && d->inputStream->string()) {
+                QString *s = d->inputStream->string();
+                rawData = QByteArray((const char *) s->constData(), s->size() * sizeof(QChar));
+            }
+        } else if (device->isOpen() || device->open(QIODevice::ReadOnly)) {
+            rawData.resize(BufferSize);
+            qint64 size = device->read(rawData.data(), BufferSize);
+
+            if (size != -1) {
+                // We don't want to give fromRawData() less than four bytes if we can avoid it.
+                while (size < 4) {
+                    if (!device->waitForReadyRead(-1))
+                        break;
+                    int ret = device->read(rawData.data() + size, BufferSize - size);
+                    if (ret <= 0)
+                        break;
+                    size += ret;
+                }
+            }
+
+            rawData.resize(qMax(qint64(0), size));
+        }
+
+        /* We do this inside the "if (d->inputDevice ..." scope
+         * because if we're not using a stream or device, that is,
+         * the user set a QString manually, we don't want to set
+         * d->str. */
+        setData(fromRawData(rawData));
+    }
+}
+
+#ifndef QT_NO_TEXTCODEC
+static QString extractEncodingDecl(const QString &text, bool *needMoreText)
+{
+    *needMoreText = false;
+
+    int l = text.length();
+    QString snip = QString::fromLatin1("<?xml").left(l);
+    if (l > 0 && !text.startsWith(snip))
+        return QString();
+
+    int endPos = text.indexOf(QLatin1Char('>'));
+    if (endPos == -1) {
+        *needMoreText = l < 255; // we won't look forever
+        return QString();
+    }
+
+    int pos = text.indexOf(QLatin1String("encoding"));
+    if (pos == -1 || pos >= endPos)
+        return QString();
+
+    while (pos < endPos) {
+        ushort uc = text.at(pos).unicode();
+        if (uc == '\'' || uc == '"')
+            break;
+        ++pos;
+    }
+
+    if (pos == endPos)
+        return QString();
+
+    QString encoding;
+    ++pos;
+    while (pos < endPos) {
+        ushort uc = text.at(pos).unicode();
+        if (uc == '\'' || uc == '"')
+            break;
+        encoding.append(uc);
+        ++pos;
+    }
+
+    return encoding;
+}
+#endif // QT_NO_TEXTCODEC
+
+/*!
+    This function reads the XML file from \a data and tries to
+    recognize the encoding. It converts the raw data \a data into a
+    QString and returns it. It tries its best to get the correct
+    encoding for the XML file.
+
+    If \a beginning is true, this function assumes that the data
+    starts at the beginning of a new XML document and looks for an
+    encoding declaration. If \a beginning is false, it converts the
+    raw data using the encoding determined from prior calls.
+*/
+QString QXmlInputSource::fromRawData(const QByteArray &data, bool beginning)
+{
+#ifdef QT_NO_TEXTCODEC
+    Q_UNUSED(beginning);
+    return QString::fromAscii(data.constData(), data.size());
+#else
+    if (data.size() == 0)
+        return QString();
+    if (beginning) {
+        delete d->encMapper;
+        d->encMapper = 0;
+    }
+
+    int mib = 106; // UTF-8
+
+    // This is the initial UTF codec we will read the encoding declaration with
+    if (d->encMapper == 0) {
+        d->encodingDeclBytes.clear();
+        d->encodingDeclChars.clear();
+        d->lookingForEncodingDecl = true;
+
+        // look for byte order mark and read the first 5 characters
+        if (data.size() >= 4) {
+            uchar ch1 = data.at(0);
+            uchar ch2 = data.at(1);
+            uchar ch3 = data.at(2);
+            uchar ch4 = data.at(3);
+
+            if ((ch1 == 0 && ch2 == 0 && ch3 == 0xfe && ch4 == 0xff) ||
+                (ch1 == 0xff && ch2 == 0xfe && ch3 == 0 && ch4 == 0))
+                mib = 1017; // UTF-32 with byte order mark
+            else if (ch1 == 0x3c && ch2 == 0x00 && ch3 == 0x00 && ch4 == 0x00)
+                mib = 1019; // UTF-32LE
+            else if (ch1 == 0x00 && ch2 == 0x00 && ch3 == 0x00 && ch4 == 0x3c)
+                mib = 1018; // UTF-32BE
+        }
+        if (mib == 106 && data.size() >= 2) {
+            uchar ch1 = data.at(0);
+            uchar ch2 = data.at(1);
+
+            if ((ch1 == 0xfe && ch2 == 0xff) || (ch1 == 0xff && ch2 == 0xfe))
+                mib = 1015; // UTF-16 with byte order mark
+            else if (ch1 == 0x3c && ch2 == 0x00)
+                mib = 1014; // UTF-16LE
+            else if (ch1 == 0x00 && ch2 == 0x3c)
+                mib = 1013; // UTF-16BE
+        }
+
+        QTextCodec *codec = QTextCodec::codecForMib(mib);
+        Q_ASSERT(codec);
+
+        d->encMapper = codec->makeDecoder();
+    }
+
+    QString input = d->encMapper->toUnicode(data, data.size());
+
+    if (d->lookingForEncodingDecl) {
+        d->encodingDeclChars += input;
+
+        bool needMoreText;
+        QString encoding = extractEncodingDecl(d->encodingDeclChars, &needMoreText);
+
+        if (!encoding.isEmpty()) {
+            if (QTextCodec *codec = QTextCodec::codecForName(encoding.toLatin1())) {
+                /* If the encoding is the same, we don't have to do toUnicode() all over again. */
+                if(codec->mibEnum() != mib) {
+                    delete d->encMapper;
+                    d->encMapper = codec->makeDecoder();
+
+                    /* The variable input can potentially be large, so we deallocate
+                     * it before calling toUnicode() in order to avoid having two
+                     * large QStrings in memory simultaneously. */
+                    input.clear();
+
+                    // prime the decoder with the data so far
+                    d->encMapper->toUnicode(d->encodingDeclBytes, d->encodingDeclBytes.size());
+                    // now feed it the new data
+                    input = d->encMapper->toUnicode(data, data.size());
+                }
+            }
+        }
+
+        d->encodingDeclBytes += data;
+        d->lookingForEncodingDecl = needMoreText;
+    }
+
+    return input;
+#endif
+}
+
+
+/*********************************************
+ *
+ * QXmlDefaultHandler
+ *
+ *********************************************/
+
+/*!
+    \class QXmlContentHandler
+    \reentrant
+    \brief The QXmlContentHandler class provides an interface to
+    report the logical content of XML data.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    If the application needs to be informed of basic parsing events,
+    it can implement this interface and activate it using
+    QXmlReader::setContentHandler(). The reader can then report basic
+    document-related events like the start and end of elements and
+    character data through this interface.
+
+    The order of events in this interface is very important, and
+    mirrors the order of information in the document itself. For
+    example, all of an element's content (character data, processing
+    instructions, and sub-elements) appears, in order, between the
+    startElement() event and the corresponding endElement() event.
+
+    The class QXmlDefaultHandler provides a default implementation for
+    this interface; subclassing from the QXmlDefaultHandler class is
+    very convenient if you only want to be informed of some parsing
+    events.
+
+    The startDocument() function is called at the start of the
+    document, and endDocument() is called at the end. Before parsing
+    begins setDocumentLocator() is called. For each element
+    startElement() is called, with endElement() being called at the
+    end of each element. The characters() function is called with
+    chunks of character data; ignorableWhitespace() is called with
+    chunks of whitespace and processingInstruction() is called with
+    processing instructions. If an entity is skipped skippedEntity()
+    is called. At the beginning of prefix-URI scopes
+    startPrefixMapping() is called.
+
+    \sa QXmlDTDHandler, QXmlDeclHandler, QXmlEntityResolver, QXmlErrorHandler,
+        QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+    \fn QXmlContentHandler::~QXmlContentHandler()
+
+    Destroys the content handler.
+*/
+
+/*!
+    \fn void QXmlContentHandler::setDocumentLocator(QXmlLocator* locator)
+
+    The reader calls this function before it starts parsing the
+    document. The argument \a locator is a pointer to a QXmlLocator
+    which allows the application to get the parsing position within
+    the document.
+
+    Do not destroy the \a locator; it is destroyed when the reader is
+    destroyed. (Do not use the \a locator after the reader is
+    destroyed).
+*/
+
+/*!
+    \fn bool QXmlContentHandler::startDocument()
+
+    The reader calls this function when it starts parsing the
+    document. The reader calls this function just once, after the call
+    to setDocumentLocator(), and before any other functions in this
+    class or in the QXmlDTDHandler class are called.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endDocument()
+*/
+
+/*!
+    \fn bool QXmlContentHandler::endDocument()
+
+    The reader calls this function after it has finished parsing. It
+    is called just once, and is the last handler function called. It
+    is called after the reader has read all input or has abandoned
+    parsing because of a fatal error.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startDocument()
+*/
+
+/*!
+    \fn bool QXmlContentHandler::startPrefixMapping(const QString& prefix, const QString& uri)
+
+    The reader calls this function to signal the begin of a prefix-URI
+    namespace mapping scope. This information is not necessary for
+    normal namespace processing since the reader automatically
+    replaces prefixes for element and attribute names.
+
+    Note that startPrefixMapping() and endPrefixMapping() calls are
+    not guaranteed to be properly nested relative to each other: all
+    startPrefixMapping() events occur before the corresponding
+    startElement() event, and all endPrefixMapping() events occur
+    after the corresponding endElement() event, but their order is not
+    otherwise guaranteed.
+
+    The argument \a prefix is the namespace prefix being declared and
+    the argument \a uri is the namespace URI the prefix is mapped to.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endPrefixMapping(), {Namespace Support via Features}
+*/
+
+/*!
+    \fn bool QXmlContentHandler::endPrefixMapping(const QString& prefix)
+
+    The reader calls this function to signal the end of a prefix
+    mapping for the prefix \a prefix.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startPrefixMapping(), {Namespace Support via Features}
+*/
+
+/*!
+    \fn bool QXmlContentHandler::startElement(const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts)
+
+    The reader calls this function when it has parsed a start element
+    tag.
+
+    There is a corresponding endElement() call when the corresponding
+    end element tag is read. The startElement() and endElement() calls
+    are always nested correctly. Empty element tags (e.g. \c{<x/>})
+    cause a startElement() call to be immediately followed by an
+    endElement() call.
+
+    The attribute list provided only contains attributes with explicit
+    values. The attribute list contains attributes used for namespace
+    declaration (i.e. attributes starting with xmlns) only if the
+    namespace-prefix property of the reader is true.
+
+    The argument \a namespaceURI is the namespace URI, or
+    an empty string if the element has no namespace URI or if no
+    namespace processing is done. \a localName is the local name
+    (without prefix), or an empty string if no namespace processing is
+    done, \a qName is the qualified name (with prefix) and \a atts are
+    the attributes attached to the element. If there are no
+    attributes, \a atts is an empty attributes object.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endElement(), {Namespace Support via Features}
+*/
+
+/*!
+    \fn bool QXmlContentHandler::endElement(const QString& namespaceURI, const QString& localName, const QString& qName)
+
+    The reader calls this function when it has parsed an end element
+    tag with the qualified name \a qName, the local name \a localName
+    and the namespace URI \a namespaceURI.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startElement(), {Namespace Support via Features}
+*/
+
+/*!
+    \fn bool QXmlContentHandler::characters(const QString& ch)
+
+    The reader calls this function when it has parsed a chunk of
+    character data (either normal character data or character data
+    inside a CDATA section; if you need to distinguish between those
+    two types you must use QXmlLexicalHandler::startCDATA() and
+    QXmlLexicalHandler::endCDATA()). The character data is reported in
+    \a ch.
+
+    Some readers report whitespace in element content using the
+    ignorableWhitespace() function rather than using this one.
+
+    A reader may report the character data of an element in more than
+    one chunk; e.g. a reader might want to report "a\<b" in three
+    characters() events ("a ", "\<" and " b").
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool QXmlContentHandler::ignorableWhitespace(const QString& ch)
+
+    Some readers may use this function to report each chunk of
+    whitespace in element content. The whitespace is reported in \a ch.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool QXmlContentHandler::processingInstruction(const QString& target, const QString& data)
+
+    The reader calls this function when it has parsed a processing
+    instruction.
+
+    \a target is the target name of the processing instruction and \a
+    data is the data in the processing instruction.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool QXmlContentHandler::skippedEntity(const QString& name)
+
+    Some readers may skip entities if they have not seen the
+    declarations (e.g. because they are in an external DTD). If they
+    do so they report that they skipped the entity called \a name by
+    calling this function.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn QString QXmlContentHandler::errorString() const
+
+    The reader calls this function to get an error string, e.g. if any
+    of the handler functions returns false.
+*/
+
+
+/*!
+    \class QXmlErrorHandler
+    \reentrant
+    \brief The QXmlErrorHandler class provides an interface to report
+    errors in XML data.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    If you want your application to report errors to the user or to
+    perform customized error handling, you should subclass this class.
+
+    You can set the error handler with QXmlReader::setErrorHandler().
+
+    Errors can be reported using warning(), error() and fatalError(),
+    with the error text being reported with errorString().
+
+    \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver,
+        QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+    \fn QXmlErrorHandler::~QXmlErrorHandler()
+
+    Destroys the error handler.
+*/
+
+/*!
+    \fn bool QXmlErrorHandler::warning(const QXmlParseException& exception)
+
+    A reader might use this function to report a warning. Warnings are
+    conditions that are not errors or fatal errors as defined by the
+    XML 1.0 specification. Details of the warning are stored in \a
+    exception.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool QXmlErrorHandler::error(const QXmlParseException& exception)
+
+    A reader might use this function to report a recoverable error. A
+    recoverable error corresponds to the definiton of "error" in
+    section 1.2 of the XML 1.0 specification. Details of the error are
+    stored in \a exception.
+
+    The reader must continue to provide normal parsing events after
+    invoking this function.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+\fn bool QXmlErrorHandler::fatalError(const QXmlParseException& exception)
+
+A reader must use this function to report a non-recoverable error.
+Details of the error are stored in \a exception.
+
+If this function returns true the reader might try to go on
+parsing and reporting further errors, but no regular parsing
+events are reported.
+*/
+
+/*!
+    \fn QString QXmlErrorHandler::errorString() const
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns false.
+*/
+
+
+/*!
+    \class QXmlDTDHandler
+    \reentrant
+    \brief The QXmlDTDHandler class provides an interface to report
+    DTD content of XML data.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    If an application needs information about notations and unparsed
+    entities, it can implement this interface and register an instance
+    with QXmlReader::setDTDHandler().
+
+    Note that this interface includes only those DTD events that the
+    XML recommendation requires processors to report, i.e. notation
+    and unparsed entity declarations using notationDecl() and
+    unparsedEntityDecl() respectively.
+
+    \sa QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver, QXmlErrorHandler,
+        QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+    \fn QXmlDTDHandler::~QXmlDTDHandler()
+
+    Destroys the DTD handler.
+*/
+
+/*!
+    \fn bool QXmlDTDHandler::notationDecl(const QString& name, const QString& publicId, const QString& systemId)
+
+    The reader calls this function when it has parsed a notation
+    declaration.
+
+    The argument \a name is the notation name, \a publicId is the
+    notation's public identifier and \a systemId is the notation's
+    system identifier.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool QXmlDTDHandler::unparsedEntityDecl(const QString& name, const QString& publicId, const QString& systemId, const QString& notationName)
+
+    The reader calls this function when it finds an unparsed entity
+    declaration.
+
+    The argument \a name is the unparsed entity's name, \a publicId is
+    the entity's public identifier, \a systemId is the entity's system
+    identifier and \a notationName is the name of the associated
+    notation.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn QString QXmlDTDHandler::errorString() const
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns false.
+*/
+
+
+/*!
+    \class QXmlEntityResolver
+    \reentrant
+    \brief The QXmlEntityResolver class provides an interface to
+    resolve external entities contained in XML data.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    If an application needs to implement customized handling for
+    external entities, it must implement this interface, i.e.
+    resolveEntity(), and register it with
+    QXmlReader::setEntityResolver().
+
+    \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlErrorHandler,
+        QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+    \fn QXmlEntityResolver::~QXmlEntityResolver()
+
+    Destroys the entity resolver.
+*/
+
+/*!
+    \fn bool QXmlEntityResolver::resolveEntity(const QString& publicId, const QString& systemId, QXmlInputSource*& ret)
+
+    The reader calls this function before it opens any external
+    entity, except the top-level document entity. The application may
+    request the reader to resolve the entity itself (\a ret is 0) or
+    to use an entirely different input source (\a ret points to the
+    input source).
+
+    The reader deletes the input source \a ret when it no longer needs
+    it, so you should allocate it on the heap with \c new.
+
+    The argument \a publicId is the public identifier of the external
+    entity, \a systemId is the system identifier of the external
+    entity and \a ret is the return value of this function. If \a ret
+    is 0 the reader should resolve the entity itself, if it is
+    non-zero it must point to an input source which the reader uses
+    instead.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn QString QXmlEntityResolver::errorString() const
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns false.
+*/
+
+
+/*!
+    \class QXmlLexicalHandler
+    \reentrant
+    \brief The QXmlLexicalHandler class provides an interface to
+    report the lexical content of XML data.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    The events in the lexical handler apply to the entire document,
+    not just to the document element, and all lexical handler events
+    appear between the content handler's startDocument and endDocument
+    events.
+
+    You can set the lexical handler with
+    QXmlReader::setLexicalHandler().
+
+    This interface's design is based on the SAX2 extension
+    LexicalHandler.
+
+    The interface provides the startDTD(), endDTD(), startEntity(),
+    endEntity(), startCDATA(), endCDATA() and comment() functions.
+
+    \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver,
+        QXmlErrorHandler, {Introduction to SAX2}
+*/
+
+/*!
+    \fn QXmlLexicalHandler::~QXmlLexicalHandler()
+
+    Destroys the lexical handler.
+*/
+
+/*!
+    \fn bool QXmlLexicalHandler::startDTD(const QString& name, const QString& publicId, const QString& systemId)
+
+    The reader calls this function to report the start of a DTD
+    declaration, if any. It reports the name of the document type in
+    \a name, the public identifier in \a publicId and the system
+    identifier in \a systemId.
+
+    If the public identifier is missing, \a publicId is set to
+    an empty string. If the system identifier is missing, \a systemId is
+    set to an empty string. Note that it is not valid XML to have a
+    public identifier but no system identifier; in such cases a parse
+    error will occur.
+
+    All declarations reported through QXmlDTDHandler or
+    QXmlDeclHandler appear between the startDTD() and endDTD() calls.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endDTD()
+*/
+
+/*!
+    \fn bool QXmlLexicalHandler::endDTD()
+
+    The reader calls this function to report the end of a DTD
+    declaration, if any.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startDTD()
+*/
+
+/*!
+    \fn bool QXmlLexicalHandler::startEntity(const QString& name)
+
+    The reader calls this function to report the start of an entity
+    called \a name.
+
+    Note that if the entity is unknown, the reader reports it through
+    QXmlContentHandler::skippedEntity() and not through this
+    function.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endEntity(), QXmlSimpleReader::setFeature()
+*/
+
+/*!
+    \fn bool QXmlLexicalHandler::endEntity(const QString& name)
+
+    The reader calls this function to report the end of an entity
+    called \a name.
+
+    For every startEntity() call, there is a corresponding endEntity()
+    call. The calls to startEntity() and endEntity() are properly
+    nested.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa startEntity(), QXmlContentHandler::skippedEntity(), QXmlSimpleReader::setFeature()
+*/
+
+/*!
+    \fn bool QXmlLexicalHandler::startCDATA()
+
+    The reader calls this function to report the start of a CDATA
+    section. The content of the CDATA section is reported through the
+    QXmlContentHandler::characters() function. This function is
+    intended only to report the boundary.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+
+    \sa endCDATA()
+*/
+
+/*!
+    \fn bool QXmlLexicalHandler::endCDATA()
+
+    The reader calls this function to report the end of a CDATA
+    section.
+
+    If this function returns false the reader stops parsing and reports
+    an error. The reader uses the function errorString() to get the error
+    message.
+
+    \sa startCDATA(), QXmlContentHandler::characters()
+*/
+
+/*!
+    \fn bool QXmlLexicalHandler::comment(const QString& ch)
+
+    The reader calls this function to report an XML comment anywhere
+    in the document. It reports the text of the comment in \a ch.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn QString QXmlLexicalHandler::errorString() const
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns false.
+*/
+
+
+/*!
+    \class QXmlDeclHandler
+    \reentrant
+    \brief The QXmlDeclHandler class provides an interface to report declaration
+    content of XML data.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    You can set the declaration handler with
+    QXmlReader::setDeclHandler().
+
+    This interface is based on the SAX2 extension DeclHandler.
+
+    The interface provides attributeDecl(), internalEntityDecl() and
+    externalEntityDecl() functions.
+
+    \sa QXmlDTDHandler, QXmlContentHandler, QXmlEntityResolver, QXmlErrorHandler,
+        QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+    \fn QXmlDeclHandler::~QXmlDeclHandler()
+
+    Destroys the declaration handler.
+*/
+
+/*!
+    \fn bool QXmlDeclHandler::attributeDecl(const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value)
+
+    The reader calls this function to report an attribute type
+    declaration. Only the effective (first) declaration for an
+    attribute is reported.
+
+    The reader passes the name of the associated element in \a eName
+    and the name of the attribute in \a aName. It passes a string that
+    represents the attribute type in \a type and a string that
+    represents the attribute default in \a valueDefault. This string
+    is one of "#IMPLIED", "#REQUIRED", "#FIXED" or an empty string (if
+    none of the others applies). The reader passes the attribute's
+    default value in \a value. If no default value is specified in the
+    XML file, \a value is an empty string.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool QXmlDeclHandler::internalEntityDecl(const QString& name, const QString& value)
+
+    The reader calls this function to report an internal entity
+    declaration. Only the effective (first) declaration is reported.
+
+    The reader passes the name of the entity in \a name and the value
+    of the entity in \a value.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn bool QXmlDeclHandler::externalEntityDecl(const QString& name, const QString& publicId, const QString& systemId)
+
+    The reader calls this function to report a parsed external entity
+    declaration. Only the effective (first) declaration for each
+    entity is reported.
+
+    The reader passes the name of the entity in \a name, the public
+    identifier in \a publicId and the system identifier in \a
+    systemId. If there is no public identifier specified, it passes
+    an empty string in \a publicId.
+
+    If this function returns false the reader stops parsing and
+    reports an error. The reader uses the function errorString() to
+    get the error message.
+*/
+
+/*!
+    \fn QString QXmlDeclHandler::errorString() const
+
+    The reader calls this function to get an error string if any of
+    the handler functions returns false.
+*/
+
+
+/*!
+    \class QXmlDefaultHandler
+    \reentrant
+    \brief The QXmlDefaultHandler class provides a default implementation of all
+    the XML handler classes.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    This class gathers together the features of
+    the specialized handler classes, making it a convenient
+    starting point when implementing custom handlers for
+    subclasses of QXmlReader, particularly QXmlSimpleReader.
+    The virtual functions from each of the base classes are
+    reimplemented in this class, providing sensible default behavior
+    for many common cases. By subclassing this class, and
+    overriding these functions, you can concentrate
+    on implementing the parts of the handler relevant to your
+    application.
+
+    The XML reader must be told which handler to use for different
+    kinds of events during parsing. This means that, although
+    QXmlDefaultHandler provides default implementations of functions
+    inherited from all its base classes, we can still use specialized
+    handlers for particular kinds of events.
+
+    For example, QXmlDefaultHandler subclasses both
+    QXmlContentHandler and QXmlErrorHandler, so by subclassing
+    it we can use the same handler for both of the following
+    reader functions:
+
+    \snippet doc/src/snippets/xml/rsslisting/rsslisting.cpp 0
+
+    Since the reader will inform the handler of parsing errors, it is
+    necessary to reimplement QXmlErrorHandler::fatalError() if, for
+    example, we want to stop parsing when such an error occurs:
+
+    \snippet doc/src/snippets/xml/rsslisting/handler.cpp 0
+
+    The above function returns false, which tells the reader to stop
+    parsing. To continue to use the same reader,
+    it is necessary to create a new handler instance, and set up the
+    reader to use it in the manner described above.
+
+    It is useful to examine some of the functions inherited by
+    QXmlDefaultHandler, and consider why they might be
+    reimplemented in a custom handler.
+    Custom handlers will typically reimplement
+    QXmlContentHandler::startDocument() to prepare the handler for
+    new content. Document elements and the text within them can be
+    processed by reimplementing QXmlContentHandler::startElement(),
+    QXmlContentHandler::endElement(), and
+    QXmlContentHandler::characters().
+    You may want to reimplement QXmlContentHandler::endDocument()
+    to perform some finalization or validation on the content once the
+    document has been read completely.
+
+    \sa QXmlDTDHandler, QXmlDeclHandler, QXmlContentHandler, QXmlEntityResolver,
+        QXmlErrorHandler, QXmlLexicalHandler, {Introduction to SAX2}
+*/
+
+/*!
+    \fn QXmlDefaultHandler::QXmlDefaultHandler()
+
+    Constructs a handler for use with subclasses of QXmlReader.
+*/
+/*!
+    \fn QXmlDefaultHandler::~QXmlDefaultHandler()
+
+    Destroys the handler.
+*/
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+void QXmlDefaultHandler::setDocumentLocator(QXmlLocator*)
+{
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::startDocument()
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::endDocument()
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::startPrefixMapping(const QString&, const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::endPrefixMapping(const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::startElement(const QString&, const QString&,
+        const QString&, const QXmlAttributes&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::endElement(const QString&, const QString&,
+        const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::characters(const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::ignorableWhitespace(const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::processingInstruction(const QString&,
+        const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::skippedEntity(const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::warning(const QXmlParseException&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::error(const QXmlParseException&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::fatalError(const QXmlParseException&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::notationDecl(const QString&, const QString&,
+        const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::unparsedEntityDecl(const QString&, const QString&,
+        const QString&, const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    Sets \a ret to 0, so that the reader uses the system identifier
+    provided in the XML document.
+*/
+bool QXmlDefaultHandler::resolveEntity(const QString&, const QString&,
+        QXmlInputSource*& ret)
+{
+    ret = 0;
+    return true;
+}
+
+/*!
+    \reimp
+
+    Returns the default error string.
+*/
+QString QXmlDefaultHandler::errorString() const
+{
+    return QString::fromLatin1(XMLERR_ERRORBYCONSUMER);
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::startDTD(const QString&, const QString&, const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::endDTD()
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::startEntity(const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::endEntity(const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::startCDATA()
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::endCDATA()
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::comment(const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::attributeDecl(const QString&, const QString&, const QString&, const QString&, const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::internalEntityDecl(const QString&, const QString&)
+{
+    return true;
+}
+
+/*!
+    \reimp
+
+    This reimplementation does nothing.
+*/
+bool QXmlDefaultHandler::externalEntityDecl(const QString&, const QString&, const QString&)
+{
+    return true;
+}
+
+
+/*********************************************
+ *
+ * QXmlSimpleReaderPrivate
+ *
+ *********************************************/
+
+inline bool QXmlSimpleReaderPrivate::atEnd()
+{
+    return (c.unicode()|0x0001) == 0xffff;
+}
+
+inline void QXmlSimpleReaderPrivate::stringClear()
+{
+    stringValueLen = 0; stringArrayPos = 0;
+}
+inline void QXmlSimpleReaderPrivate::nameClear()
+{
+    nameValueLen = 0; nameArrayPos = 0;
+}
+
+inline void QXmlSimpleReaderPrivate::refClear()
+{
+    refValueLen = 0; refArrayPos = 0;
+}
+
+QXmlSimpleReaderPrivate::QXmlSimpleReaderPrivate(QXmlSimpleReader *reader)
+{
+    q_ptr = reader;
+    parseStack = 0;
+
+    locator.reset(new QXmlSimpleReaderLocator(reader));
+    entityRes  = 0;
+    dtdHnd     = 0;
+    contentHnd = 0;
+    errorHnd   = 0;
+    lexicalHnd = 0;
+    declHnd    = 0;
+
+    // default feature settings
+    useNamespaces = true;
+    useNamespacePrefixes = false;
+    reportWhitespaceCharData = true;
+    reportEntities = false;
+}
+
+QXmlSimpleReaderPrivate::~QXmlSimpleReaderPrivate()
+{
+    delete parseStack;
+}
+
+void QXmlSimpleReaderPrivate::initIncrementalParsing()
+{
+    if(parseStack)
+        parseStack->clear();
+    else
+        parseStack = new QStack<ParseState>;
+}
+
+/*********************************************
+ *
+ * QXmlSimpleReader
+ *
+ *********************************************/
+
+/*!
+    \class QXmlReader
+    \reentrant
+    \brief The QXmlReader class provides an interface for XML readers (i.e.
+    parsers).
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+    This abstract class provides an interface for all of Qt's XML
+    readers. Currently there is only one implementation of a reader
+    included in Qt's XML module: QXmlSimpleReader. In future releases
+    there might be more readers with different properties available
+    (e.g. a validating parser).
+
+    The design of the XML classes follows the \link
+    http://www.saxproject.org/ SAX2 Java interface\endlink, with
+    the names adapted to fit Qt naming conventions. It should be very
+    easy for anybody who has worked with SAX2 to get started with the
+    Qt XML classes.
+
+    All readers use the class QXmlInputSource to read the input
+    document. Since you are normally interested in particular content
+    in the XML document, the reader reports the content through
+    special handler classes (QXmlDTDHandler, QXmlDeclHandler,
+    QXmlContentHandler, QXmlEntityResolver, QXmlErrorHandler and
+    QXmlLexicalHandler), which you must subclass, if you want to
+    process the contents.
+
+    Since the handler classes only describe interfaces you must
+    implement all the functions. We provide the QXmlDefaultHandler
+    class to make this easier: it implements a default behavior (do
+    nothing) for all functions, so you can subclass it and just
+    implement the functions you are interested in.
+
+    Features and properties of the reader can be set with setFeature()
+    and setProperty() respectively. You can set the reader to use your
+    own subclasses with setEntityResolver(), setDTDHandler(),
+    setContentHandler(), setErrorHandler(), setLexicalHandler() and
+    setDeclHandler(). The parse itself is started with a call to
+    parse().
+
+    \sa QXmlSimpleReader
+*/
+
+/*!
+    \fn QXmlReader::~QXmlReader()
+
+    Destroys the reader.
+*/
+
+/*!
+    \fn bool QXmlReader::feature(const QString& name, bool *ok) const
+
+    If the reader has the feature called \a name, the feature's value
+    is returned. If no such feature exists the return value is
+    undefined.
+
+    If \a ok is not 0: \c{*}\a{ok}  is set to true if the reader has the
+    feature called \a name; otherwise \c{*}\a{ok} is set to false.
+
+    \sa setFeature(), hasFeature()
+*/
+
+/*!
+    \fn void QXmlReader::setFeature(const QString& name, bool value)
+
+    Sets the feature called \a name to the given \a value. If the
+    reader doesn't have the feature nothing happens.
+
+    \sa feature(), hasFeature()
+*/
+
+/*!
+    \fn bool QXmlReader::hasFeature(const QString& name) const
+
+    Returns \c true if the reader has the feature called \a name;
+    otherwise returns false.
+
+    \sa feature(), setFeature()
+*/
+
+/*!
+    \fn void* QXmlReader::property(const QString& name, bool *ok) const
+
+    If the reader has the property \a name, this function returns the
+    value of the property; otherwise the return value is undefined.
+
+    If \a ok is not 0: if the reader has the \a name property
+    \c{*}\a{ok} is set to true; otherwise \c{*}\a{ok} is set to false.
+
+    \sa setProperty(), hasProperty()
+*/
+
+/*!
+    \fn void QXmlReader::setProperty(const QString& name, void* value)
+
+    Sets the property \a name to \a value. If the reader doesn't have
+    the property nothing happens.
+
+    \sa property(), hasProperty()
+*/
+
+/*!
+    \fn bool QXmlReader::hasProperty(const QString& name) const
+
+    Returns true if the reader has the property \a name; otherwise
+    returns false.
+
+    \sa property(), setProperty()
+*/
+
+/*!
+    \fn void QXmlReader::setEntityResolver(QXmlEntityResolver* handler)
+
+    Sets the entity resolver to \a handler.
+
+    \sa entityResolver()
+*/
+
+/*!
+    \fn QXmlEntityResolver* QXmlReader::entityResolver() const
+
+    Returns the entity resolver or 0 if none was set.
+
+    \sa setEntityResolver()
+*/
+
+/*!
+    \fn void QXmlReader::setDTDHandler(QXmlDTDHandler* handler)
+
+    Sets the DTD handler to \a handler.
+
+    \sa DTDHandler()
+*/
+
+/*!
+    \fn QXmlDTDHandler* QXmlReader::DTDHandler() const
+
+    Returns the DTD handler or 0 if none was set.
+
+    \sa setDTDHandler()
+*/
+
+/*!
+    \fn void QXmlReader::setContentHandler(QXmlContentHandler* handler)
+
+    Sets the content handler to \a handler.
+
+    \sa contentHandler()
+*/
+
+/*!
+    \fn QXmlContentHandler* QXmlReader::contentHandler() const
+
+    Returns the content handler or 0 if none was set.
+
+    \sa setContentHandler()
+*/
+
+/*!
+    \fn void QXmlReader::setErrorHandler(QXmlErrorHandler* handler)
+
+    Sets the error handler to \a handler. Clears the error handler if
+    \a handler is 0.
+
+    \sa errorHandler()
+*/
+
+/*!
+    \fn QXmlErrorHandler* QXmlReader::errorHandler() const
+
+    Returns the error handler or 0 if none is set.
+
+    \sa setErrorHandler()
+*/
+
+/*!
+    \fn void QXmlReader::setLexicalHandler(QXmlLexicalHandler* handler)
+
+    Sets the lexical handler to \a handler.
+
+    \sa lexicalHandler()
+*/
+
+/*!
+    \fn QXmlLexicalHandler* QXmlReader::lexicalHandler() const
+
+    Returns the lexical handler or 0 if none was set.
+
+    \sa setLexicalHandler()
+*/
+
+/*!
+    \fn void QXmlReader::setDeclHandler(QXmlDeclHandler* handler)
+
+    Sets the declaration handler to \a handler.
+
+    \sa declHandler()
+*/
+
+/*!
+    \fn QXmlDeclHandler* QXmlReader::declHandler() const
+
+    Returns the declaration handler or 0 if none was set.
+
+    \sa setDeclHandler()
+*/
+
+/*!
+  \fn bool QXmlReader::parse(const QXmlInputSource &input)
+
+  \obsolete
+
+  Parses the given \a input.
+*/
+
+/*!
+    \fn bool QXmlReader::parse(const QXmlInputSource *input)
+
+    Reads an XML document from \a input and parses it. Returns true if
+    the parsing was successful; otherwise returns false.
+*/
+
+
+/*!
+    \class QXmlSimpleReader
+    \nonreentrant
+    \brief The QXmlSimpleReader class provides an implementation of a
+    simple XML parser.
+
+    \inmodule QtXml
+    \ingroup xml-tools
+
+
+    This XML reader is suitable for a wide range of applications. It
+    is able to parse well-formed XML and can report the namespaces of
+    elements to a content handler; however, it does not parse any
+    external entities. For historical reasons, Attribute Value
+    Normalization and End-of-Line Handling as described in the XML 1.0
+    specification is not performed.
+
+    The easiest pattern of use for this class is to create a reader
+    instance, define an input source, specify the handlers to be used
+    by the reader, and parse the data.
+
+    For example, we could use a QFile to supply the input. Here, we
+    create a reader, and define an input source to be used by the
+    reader:
+
+    \snippet doc/src/snippets/xml/simpleparse/main.cpp 0
+
+    A handler lets us perform actions when the reader encounters
+    certain types of content, or if errors in the input are found. The
+    reader must be told which handler to use for each type of
+    event. For many common applications, we can create a custom
+    handler by subclassing QXmlDefaultHandler, and use this to handle
+    both error and content events:
+
+    \snippet doc/src/snippets/xml/simpleparse/main.cpp 1
+
+    If you don't set at least the content and error handlers, the
+    parser will fall back on its default behavior---and will do
+    nothing.
+
+    The most convenient way to handle the input is to read it in a
+    single pass using the parse() function with an argument that
+    specifies the input source:
+
+    \snippet doc/src/snippets/xml/simpleparse/main.cpp 2
+
+    If you can't parse the entire input in one go (for example, it is
+    huge, or is being delivered over a network connection), data can
+    be fed to the parser in pieces. This is achieved by telling
+    parse() to work incrementally, and making subsequent calls to the
+    parseContinue() function, until all the data has been processed.
+
+    A common way to perform incremental parsing is to connect the \c
+    readyRead() signal of a \l{QNetworkReply} {network reply} a slot,
+    and handle the incoming data there. See QNetworkAccessManager.
+    
+    Aspects of the parsing behavior can be adapted using setFeature()
+    and setProperty().
+    
+    \snippet doc/src/snippets/code/src_xml_sax_qxml.cpp 0
+
+    QXmlSimpleReader is not reentrant. If you want to use the class
+    in threaded code, lock the code using QXmlSimpleReader with a
+    locking mechanism, such as a QMutex.
+*/
+
+static inline bool is_S(QChar ch)
+{
+    ushort uc = ch.unicode();
+    return (uc == ' ' || uc == '\t' || uc == '\n' || uc == '\r');
+}
+
+enum NameChar { NameBeginning, NameNotBeginning, NotName };
+
+static const char Begi = (char)NameBeginning;
+static const char NtBg = (char)NameNotBeginning;
+static const char NotN = (char)NotName;
+
+static const char nameCharTable[128] =
+{
+// 0x00
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+// 0x10
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+// 0x20 (0x2D is '-', 0x2E is '.')
+    NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN,
+    NotN, NotN, NotN, NotN, NotN, NtBg, NtBg, NotN,
+// 0x30 (0x30..0x39 are '0'..'9', 0x3A is ':')
+    NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg,
+    NtBg, NtBg, Begi, NotN, NotN, NotN, NotN, NotN,
+// 0x40 (0x41..0x5A are 'A'..'Z')
+    NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+// 0x50 (0x5F is '_')
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, NotN, NotN, NotN, NotN, Begi,
+// 0x60 (0x61..0x7A are 'a'..'z')
+    NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+// 0x70
+    Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi,
+    Begi, Begi, Begi, NotN, NotN, NotN, NotN, NotN
+};
+
+static inline NameChar fastDetermineNameChar(QChar ch)
+{
+    ushort uc = ch.unicode();
+    if (!(uc & ~0x7f)) // uc < 128
+        return (NameChar)nameCharTable[uc];
+
+    QChar::Category cat = ch.category();
+    // ### some these categories might be slightly wrong
+    if ((cat >= QChar::Letter_Uppercase && cat <= QChar::Letter_Other)
+        || cat == QChar::Number_Letter)
+        return NameBeginning;
+    if ((cat >= QChar::Number_DecimalDigit && cat <= QChar::Number_Other)
+                || (cat >= QChar::Mark_NonSpacing && cat <= QChar::Mark_Enclosing))
+        return NameNotBeginning;
+    return NotName;
+}
+
+static NameChar determineNameChar(QChar ch)
+{
+    return fastDetermineNameChar(ch);
+}
+
+/*!
+    Constructs a simple XML reader.
+
+*/
+QXmlSimpleReader::QXmlSimpleReader()
+    : d_ptr(new QXmlSimpleReaderPrivate(this))
+{
+}
+
+/*!
+    Destroys the simple XML reader.
+*/
+QXmlSimpleReader::~QXmlSimpleReader()
+{
+}
+
+/*!
+    \reimp
+*/
+bool QXmlSimpleReader::feature(const QString& name, bool *ok) const
+{
+    const QXmlSimpleReaderPrivate *d = d_func();
+
+    // Qt5 ###: Change these strings to qt.nokia.com
+    if (ok != 0)
+        *ok = true;
+    if (name == QLatin1String("http://xml.org/sax/features/namespaces")) {
+        return d->useNamespaces;
+    } else if (name == QLatin1String("http://xml.org/sax/features/namespace-prefixes")) {
+        return d->useNamespacePrefixes;
+    } else if (name == QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData")) { // Shouldn't change in Qt 4
+        return d->reportWhitespaceCharData;
+    } else if (name == QLatin1String("http://trolltech.com/xml/features/report-start-end-entity")) { // Shouldn't change in Qt 4
+        return d->reportEntities;
+    } else {
+        qWarning("Unknown feature %s", name.toLatin1().data());
+        if (ok != 0)
+            *ok = false;
+    }
+    return false;
+}
+
+/*!
+    Turns on the feature \a name if \a enable is true; otherwise turns it off.
+
+    The \a name parameter must be one of the following strings:
+    \table
+    \header \i Feature \i Default \i Notes
+    \row \i \e http://xml.org/sax/features/namespaces
+         \i true
+         \i If enabled, namespaces are reported to the content handler.
+    \row \i \e http://xml.org/sax/features/namespace-prefixes
+         \i false
+         \i If enabled, the original prefixed names
+            and attributes used for namespace declarations are
+            reported.
+    \row \i \e http://trolltech.com/xml/features/report-whitespace-only-CharData
+         \i true
+         \i If enabled, CharData that consist of
+            only whitespace characters are reported
+            using QXmlContentHandler::characters(). If disabled, whitespace is silently
+            discarded.
+    \row \i \e http://trolltech.com/xml/features/report-start-end-entity
+         \i false
+         \i If enabled, the parser reports
+            QXmlContentHandler::startEntity() and
+            QXmlContentHandler::endEntity() events, so character data
+            might be reported in chunks.
+            If disabled, the parser does not report these events, but
+            silently substitutes the entities, and reports the character
+            data in one chunk.
+    \endtable
+
+    \sa feature(), hasFeature(), {SAX2 Features}
+*/
+void QXmlSimpleReader::setFeature(const QString& name, bool enable)
+{
+    Q_D(QXmlSimpleReader);
+    // Qt5 ###: Change these strings to qt.nokia.com
+    if (name == QLatin1String("http://xml.org/sax/features/namespaces")) {
+        d->useNamespaces = enable;
+    } else if (name == QLatin1String("http://xml.org/sax/features/namespace-prefixes")) {
+        d->useNamespacePrefixes = enable;
+    } else if (name == QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData")) { // Shouldn't change in Qt 4
+        d->reportWhitespaceCharData = enable;
+    } else if (name == QLatin1String("http://trolltech.com/xml/features/report-start-end-entity")) { // Shouldn't change in Qt 4
+        d->reportEntities = enable;
+    } else {
+        qWarning("Unknown feature %s", name.toLatin1().data());
+    }
+}
+
+/*! \reimp
+*/
+bool QXmlSimpleReader::hasFeature(const QString& name) const
+{
+    // Qt5 ###: Change these strings to qt.nokia.com
+    if (name == QLatin1String("http://xml.org/sax/features/namespaces")
+        || name == QLatin1String("http://xml.org/sax/features/namespace-prefixes")
+        || name == QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData") // Shouldn't change in Qt 4
+        || name == QLatin1String("http://trolltech.com/xml/features/report-start-end-entity")) { // Shouldn't change in Qt 4
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/*! \reimp
+*/
+void* QXmlSimpleReader::property(const QString&, bool *ok) const
+{
+    if (ok != 0)
+        *ok = false;
+    return 0;
+}
+
+/*! \reimp
+*/
+void QXmlSimpleReader::setProperty(const QString&, void*)
+{
+}
+
+/*!
+    \reimp
+*/
+bool QXmlSimpleReader::hasProperty(const QString&) const
+{
+    return false;
+}
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setEntityResolver(QXmlEntityResolver* handler)
+{
+    Q_D(QXmlSimpleReader);
+    d->entityRes = handler;
+}
+
+/*!
+    \reimp
+*/
+QXmlEntityResolver* QXmlSimpleReader::entityResolver() const
+{
+    const QXmlSimpleReaderPrivate *d = d_func();
+    return d->entityRes;
+}
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setDTDHandler(QXmlDTDHandler* handler)
+{
+    Q_D(QXmlSimpleReader);
+    d->dtdHnd = handler;
+}
+
+/*!
+    \reimp
+*/
+QXmlDTDHandler* QXmlSimpleReader::DTDHandler() const
+{
+    const QXmlSimpleReaderPrivate *d = d_func();
+    return d->dtdHnd;
+}
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setContentHandler(QXmlContentHandler* handler)
+{
+    Q_D(QXmlSimpleReader);
+    d->contentHnd = handler;
+}
+
+/*!
+    \reimp
+*/
+QXmlContentHandler* QXmlSimpleReader::contentHandler() const
+{
+    const QXmlSimpleReaderPrivate *d = d_func();
+    return d->contentHnd;
+}
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setErrorHandler(QXmlErrorHandler* handler)
+{
+    Q_D(QXmlSimpleReader);
+    d->errorHnd = handler;
+}
+
+/*!
+    \reimp
+*/
+QXmlErrorHandler* QXmlSimpleReader::errorHandler() const
+{
+    const QXmlSimpleReaderPrivate *d = d_func();
+    return d->errorHnd;
+}
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setLexicalHandler(QXmlLexicalHandler* handler)
+{
+    Q_D(QXmlSimpleReader);
+    d->lexicalHnd = handler;
+}
+
+/*!
+    \reimp
+*/
+QXmlLexicalHandler* QXmlSimpleReader::lexicalHandler() const
+{
+    const QXmlSimpleReaderPrivate *d = d_func();
+    return d->lexicalHnd;
+}
+
+/*!
+    \reimp
+*/
+void QXmlSimpleReader::setDeclHandler(QXmlDeclHandler* handler)
+{
+    Q_D(QXmlSimpleReader);
+    d->declHnd = handler;
+}
+
+/*!
+    \reimp
+*/
+QXmlDeclHandler* QXmlSimpleReader::declHandler() const
+{
+    const QXmlSimpleReaderPrivate *d = d_func();
+    return d->declHnd;
+}
+
+
+
+/*!
+    \reimp
+*/
+bool QXmlSimpleReader::parse(const QXmlInputSource& input)
+{
+    return parse(&input, false);
+}
+
+/*!
+    Reads an XML document from \a input and parses it in one pass (non-incrementally).
+    Returns true if the parsing was successful; otherwise returns false.
+*/
+bool QXmlSimpleReader::parse(const QXmlInputSource* input)
+{
+    return parse(input, false);
+}
+
+/*!
+    Reads an XML document from \a input and parses it. Returns true
+    if the parsing is completed successfully; otherwise returns false,
+    indicating that an error occurred.
+
+    If \a incremental is false, this function will return false if the XML
+    file is not read completely. The parsing cannot be continued in this
+    case.
+
+    If \a incremental is true, the parser does not return false if
+    it reaches the end of the \a input before reaching the end
+    of the XML file. Instead, it stores the state of the parser so that
+    parsing can be continued later when more data is available.
+    In such a case, you can use the function parseContinue() to
+    continue with parsing. This class stores a pointer to the input
+    source \a input and the parseContinue() function tries to read from
+    that input source. Therefore, you should not delete the input
+    source \a input until you no longer need to call parseContinue().
+
+    If this function is called with \a incremental set to true
+    while an incremental parse is in progress, a new parsing
+    session will be started, and the previous session will be lost.
+
+    \sa parseContinue(), QTcpSocket
+*/
+bool QXmlSimpleReader::parse(const QXmlInputSource *input, bool incremental)
+{
+    Q_D(QXmlSimpleReader);
+
+    if (incremental) {
+        d->initIncrementalParsing();
+    } else {
+        delete d->parseStack;
+        d->parseStack = 0;
+    }
+    d->init(input);
+
+    // call the handler
+    if (d->contentHnd) {
+        d->contentHnd->setDocumentLocator(d->locator.data());
+        if (!d->contentHnd->startDocument()) {
+            d->reportParseError(d->contentHnd->errorString());
+            d->tags.clear();
+            return false;
+        }
+    }
+    qt_xml_skipped_entity_in_content = false;
+    return d->parseBeginOrContinue(0, incremental);
+}
+
+/*!
+    Continues incremental parsing, taking input from the
+    QXmlInputSource that was specified with the most recent
+    call to parse(). To use this function, you \e must have called
+    parse() with the incremental argument set to true.
+
+    Returns false if a parsing error occurs; otherwise returns true,
+    even if the end of the XML file has not been reached. You can
+    continue parsing at a later stage by calling this function again
+    when there is more data available to parse.
+
+    Calling this function when there is no data available in the input
+    source indicates to the reader that the end of the XML file has
+    been reached. If the input supplied up to this point was
+    not well-formed then a parsing error occurs, and false is returned.
+    If the input supplied was well-formed, true is returned.
+    It is important to end the input in this way because it allows you
+    to reuse the reader to parse other XML files.
+
+    Calling this function after the end of file has been reached, but
+    without available data will cause false to be returned whether the
+    previous input was well-formed or not.
+
+    \sa parse(), QXmlInputSource::data(), QXmlInputSource::next()
+*/
+bool QXmlSimpleReader::parseContinue()
+{
+    Q_D(QXmlSimpleReader);
+    if (d->parseStack == 0 || d->parseStack->isEmpty())
+        return false;
+    d->initData();
+    int state = d->parseStack->pop().state;
+    return d->parseBeginOrContinue(state, true);
+}
+
+/*
+  Common part of parse() and parseContinue()
+*/
+bool QXmlSimpleReaderPrivate::parseBeginOrContinue(int state, bool incremental)
+{
+    bool atEndOrig = atEnd();
+
+    if (state==0) {
+        if (!parseProlog()) {
+            if (incremental && error.isNull()) {
+                pushParseState(0, 0);
+                return true;
+            } else {
+                tags.clear();
+                return false;
+            }
+        }
+        state = 1;
+    }
+    if (state==1) {
+        if (!parseElement()) {
+            if (incremental && error.isNull()) {
+                pushParseState(0, 1);
+                return true;
+            } else {
+                tags.clear();
+                return false;
+            }
+        }
+        state = 2;
+    }
+    // parse Misc*
+    while (!atEnd()) {
+        if (!parseMisc()) {
+            if (incremental && error.isNull()) {
+                pushParseState(0, 2);
+                return true;
+            } else {
+                tags.clear();
+                return false;
+            }
+        }
+    }
+    if (!atEndOrig && incremental) {
+        // we parsed something at all, so be prepared to come back later
+        pushParseState(0, 2);
+        return true;
+    }
+    // is stack empty?
+    if (!tags.isEmpty() && !error.isNull()) {
+        reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
+        tags.clear();
+        return false;
+    }
+    // call the handler
+    if (contentHnd) {
+        delete parseStack;
+        parseStack = 0;
+        if (!contentHnd->endDocument()) {
+            reportParseError(contentHnd->errorString());
+            return false;
+        }
+    }
+    return true;
+}
+
+//
+// The following private parse functions have another semantics for the return
+// value: They return true iff parsing has finished successfully (i.e. the end
+// of the XML file must be reached!). If one of these functions return false,
+// there is only an error when d->error.isNULL() is also false.
+//
+
+/*
+  For the incremental parsing, it is very important that the parse...()
+  functions have a certain structure. Since it might be hard to understand how
+  they work, here is a description of the layout of these functions:
+
+    bool QXmlSimpleReader::parse...()
+    {
+(1)        const signed char Init             = 0;
+        ...
+
+(2)        const signed char Inp...           = 0;
+        ...
+
+(3)        static const signed char table[3][2] = {
+        ...
+        };
+        signed char state;
+        signed char input;
+
+(4)        if (d->parseStack == 0 || d->parseStack->isEmpty()) {
+(4a)        ...
+        } else {
+(4b)        ...
+        }
+
+        for (; ;) {
+(5)            switch (state) {
+            ...
+            }
+
+(6)
+(6a)            if (atEnd()) {
+                unexpectedEof(&QXmlSimpleReader::parseNmtoken, state);
+                return false;
+            }
+(6b)            if (determineNameChar(c) != NotName) {
+            ...
+            }
+(7)            state = table[state][input];
+
+(8)            switch (state) {
+            ...
+            }
+        }
+    }
+
+  Explanation:
+  ad 1: constants for the states (used in the transition table)
+  ad 2: constants for the input (used in the transition table)
+  ad 3: the transition table for the state machine
+  ad 4: test if we are in a parseContinue() step
+        a) if no, do inititalizations
+        b) if yes, restore the state and call parse functions recursively
+  ad 5: Do some actions according to the state; from the logical execution
+        order, this code belongs after 8 (see there for an explanation)
+  ad 6: Check the character that is at the actual "cursor" position:
+        a) If we reached the EOF, report either error or push the state (in the
+           case of incremental parsing).
+        b) Otherwise, set the input character constant for the transition
+           table.
+  ad 7: Get the new state according to the input that was read.
+  ad 8: Do some actions according to the state. The last line in every case
+        statement reads new data (i.e. it move the cursor). This can also be
+        done by calling another parse...() function. If you need processing for
+        this state after that, you have to put it into the switch statement 5.
+        This ensures that you have a well defined re-entry point, when you ran
+        out of data.
+*/
+
+/*
+  Parses the prolog [22].
+*/
+
+bool QXmlSimpleReaderPrivate::parseProlog()
+{
+    const signed char Init             = 0;
+    const signed char EatWS            = 1; // eat white spaces
+    const signed char Lt               = 2; // '<' read
+    const signed char Em               = 3; // '!' read
+    const signed char DocType          = 4; // read doctype
+    const signed char Comment          = 5; // read comment
+    const signed char CommentR         = 6; // same as Comment, but already reported
+    const signed char PInstr           = 7; // read PI
+    const signed char PInstrR          = 8; // same as PInstr, but already reported
+    const signed char Done             = 9;
+
+    const signed char InpWs            = 0;
+    const signed char InpLt            = 1; // <
+    const signed char InpQm            = 2; // ?
+    const signed char InpEm            = 3; // !
+    const signed char InpD             = 4; // D
+    const signed char InpDash          = 5; // -
+    const signed char InpUnknown       = 6;
+
+    static const signed char table[9][7] = {
+     /*  InpWs   InpLt  InpQm  InpEm  InpD      InpDash  InpUnknown */
+        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // Init
+        { -1,     Lt,    -1,    -1,    -1,       -1,       -1      }, // EatWS
+        { -1,     -1,    PInstr,Em,    Done,     -1,       Done    }, // Lt
+        { -1,     -1,    -1,    -1,    DocType,  Comment,  -1      }, // Em
+        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // DocType
+        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // Comment
+        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // CommentR
+        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }, // PInstr
+        { EatWS,  Lt,    -1,    -1,    -1,       -1,       -1      }  // PInstrR
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack == 0 || parseStack->isEmpty()) {
+        xmldecl_possible = true;
+        doctype_read = false;
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseProlog (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case DocType:
+                if (doctype_read) {
+                    reportParseError(QLatin1String(XMLERR_MORETHANONEDOCTYPE));
+                    return false;
+                } else {
+                    doctype_read = false;
+                }
+                break;
+            case Comment:
+                if (lexicalHnd) {
+                    if (!lexicalHnd->comment(string())) {
+                        reportParseError(lexicalHnd->errorString());
+                        return false;
+                    }
+                }
+                state = CommentR;
+                break;
+            case PInstr:
+                // call the handler
+                if (contentHnd) {
+                    if (xmldecl_possible && !xmlVersion.isEmpty()) {
+                        QString value(QLatin1String("version='"));
+                        value += xmlVersion;
+                        value += QLatin1Char('\'');
+                        if (!encoding.isEmpty()) {
+                            value += QLatin1String(" encoding='");
+                            value += encoding;
+                            value += QLatin1Char('\'');
+                        }
+                        if (standalone == QXmlSimpleReaderPrivate::Yes) {
+                            value += QLatin1String(" standalone='yes'");
+                        } else if (standalone == QXmlSimpleReaderPrivate::No) {
+                            value += QLatin1String(" standalone='no'");
+                        }
+                        if (!contentHnd->processingInstruction(QLatin1String("xml"), value)) {
+                            reportParseError(contentHnd->errorString());
+                            return false;
+                        }
+                    } else {
+                        if (!contentHnd->processingInstruction(name(), string())) {
+                            reportParseError(contentHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+                // XML declaration only on first position possible
+                xmldecl_possible = false;
+                state = PInstrR;
+                break;
+            case Done:
+                return true;
+            case -1:
+                reportParseError(QLatin1String(XMLERR_ERRORPARSINGELEMENT));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseProlog, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('<')) {
+            input = InpLt;
+        } else if (c == QLatin1Char('?')) {
+            input = InpQm;
+        } else if (c == QLatin1Char('!')) {
+            input = InpEm;
+        } else if (c == QLatin1Char('D')) {
+            input = InpD;
+        } else if (c == QLatin1Char('-')) {
+            input = InpDash;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case EatWS:
+                // XML declaration only on first position possible
+                xmldecl_possible = false;
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+                    return false;
+                }
+                break;
+            case Lt:
+                next();
+                break;
+            case Em:
+                // XML declaration only on first position possible
+                xmldecl_possible = false;
+                next();
+                break;
+            case DocType:
+                if (!parseDoctype()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+                    return false;
+                }
+                break;
+            case Comment:
+            case CommentR:
+                if (!parseComment()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+                    return false;
+                }
+                break;
+            case PInstr:
+            case PInstrR:
+                parsePI_xmldecl = xmldecl_possible;
+                if (!parsePI()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseProlog, state);
+                    return false;
+                }
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse an element [39].
+
+  Precondition: the opening '<' is already read.
+*/
+bool QXmlSimpleReaderPrivate::parseElement()
+{
+    const int Init             =  0;
+    const int ReadName         =  1;
+    const int Ws1              =  2;
+    const int STagEnd          =  3;
+    const int STagEnd2         =  4;
+    const int ETagBegin        =  5;
+    const int ETagBegin2       =  6;
+    const int Ws2              =  7;
+    const int EmptyTag         =  8;
+    const int Attrib           =  9;
+    const int AttribPro        = 10; // like Attrib, but processAttribute was already called
+    const int Ws3              = 11;
+    const int Done             = 12;
+
+    const int InpWs            = 0; // whitespace
+    const int InpNameBe        = 1; // NameBeginning
+    const int InpGt            = 2; // >
+    const int InpSlash         = 3; // /
+    const int InpUnknown       = 4;
+
+    static const int table[12][5] = {
+     /*  InpWs      InpNameBe    InpGt        InpSlash     InpUnknown */
+        { -1,        ReadName,    -1,          -1,          -1        }, // Init
+        { Ws1,       Attrib,      STagEnd,     EmptyTag,    -1        }, // ReadName
+        { -1,        Attrib,      STagEnd,     EmptyTag,    -1        }, // Ws1
+        { STagEnd2,  STagEnd2,    STagEnd2,    STagEnd2,    STagEnd2  }, // STagEnd
+        { -1,        -1,          -1,          ETagBegin,   -1        }, // STagEnd2
+        { -1,        ETagBegin2,  -1,          -1,          -1        }, // ETagBegin
+        { Ws2,       -1,          Done,        -1,          -1        }, // ETagBegin2
+        { -1,        -1,          Done,        -1,          -1        }, // Ws2
+        { -1,        -1,          Done,        -1,          -1        }, // EmptyTag
+        { Ws3,       Attrib,      STagEnd,     EmptyTag,    -1        }, // Attrib
+        { Ws3,       Attrib,      STagEnd,     EmptyTag,    -1        }, // AttribPro
+        { -1,        Attrib,      STagEnd,     EmptyTag,    -1        }  // Ws3
+    };
+    int state;
+    int input;
+
+    if (parseStack == 0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseElement (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case ReadName:
+                // store it on the stack
+                tags.push(name());
+                // empty the attributes
+                attList.clear();
+                if (useNamespaces)
+                    namespaceSupport.pushContext();
+                break;
+            case ETagBegin2:
+                if (!processElementETagBegin2())
+                    return false;
+                break;
+            case Attrib:
+                if (!processElementAttribute())
+                    return false;
+                state = AttribPro;
+                break;
+            case Done:
+                return true;
+            case -1:
+                reportParseError(QLatin1String(XMLERR_ERRORPARSINGELEMENT));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseElement, state);
+            return false;
+        }
+        if (fastDetermineNameChar(c) == NameBeginning) {
+            input = InpNameBe;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('/')) {
+            input = InpSlash;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case ReadName:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+                    return false;
+                }
+                break;
+            case Ws1:
+            case Ws2:
+            case Ws3:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+                    return false;
+                }
+                break;
+            case STagEnd:
+                // call the handler
+                if (contentHnd) {
+                    const QString &tagsTop = tags.top();
+                    if (useNamespaces) {
+                        QString uri, lname;
+                        namespaceSupport.processName(tagsTop, false, uri, lname);
+                        if (!contentHnd->startElement(uri, lname, tagsTop, attList)) {
+                            reportParseError(contentHnd->errorString());
+                            return false;
+                        }
+                    } else {
+                        if (!contentHnd->startElement(QString(), QString(), tagsTop, attList)) {
+                            reportParseError(contentHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+                next();
+                break;
+            case STagEnd2:
+                if (!parseContent()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+                    return false;
+                }
+                break;
+            case ETagBegin:
+                next();
+                break;
+            case ETagBegin2:
+                // get the name of the tag
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+                    return false;
+                }
+                break;
+            case EmptyTag:
+                if  (tags.isEmpty()) {
+                    reportParseError(QLatin1String(XMLERR_TAGMISMATCH));
+                    return false;
+                }
+                if (!processElementEmptyTag())
+                    return false;
+                next();
+                break;
+            case Attrib:
+            case AttribPro:
+                // get name and value of attribute
+                if (!parseAttribute()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElement, state);
+                    return false;
+                }
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Helper to break down the size of the code in the case statement.
+  Return false on error, otherwise true.
+*/
+bool QXmlSimpleReaderPrivate::processElementEmptyTag()
+{
+    QString uri, lname;
+    // pop the stack and call the handler
+    if (contentHnd) {
+        if (useNamespaces) {
+            // report startElement first...
+            namespaceSupport.processName(tags.top(), false, uri, lname);
+            if (!contentHnd->startElement(uri, lname, tags.top(), attList)) {
+                reportParseError(contentHnd->errorString());
+                return false;
+            }
+            // ... followed by endElement...
+            if (!contentHnd->endElement(uri, lname, tags.pop())) {
+                reportParseError(contentHnd->errorString());
+                return false;
+            }
+            // ... followed by endPrefixMapping
+            QStringList prefixesBefore, prefixesAfter;
+            if (contentHnd) {
+                prefixesBefore = namespaceSupport.prefixes();
+            }
+            namespaceSupport.popContext();
+            // call the handler for prefix mapping
+            prefixesAfter = namespaceSupport.prefixes();
+            for (QStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it) {
+                if (!prefixesAfter.contains(*it)) {
+                    if (!contentHnd->endPrefixMapping(*it)) {
+                        reportParseError(contentHnd->errorString());
+                        return false;
+                    }
+                }
+            }
+        } else {
+            // report startElement first...
+            if (!contentHnd->startElement(QString(), QString(), tags.top(), attList)) {
+                reportParseError(contentHnd->errorString());
+                return false;
+            }
+            // ... followed by endElement
+            if (!contentHnd->endElement(QString(), QString(), tags.pop())) {
+                reportParseError(contentHnd->errorString());
+                return false;
+            }
+        }
+    } else {
+        tags.pop_back();
+        namespaceSupport.popContext();
+    }
+    return true;
+}
+/*
+  Helper to break down the size of the code in the case statement.
+  Return false on error, otherwise true.
+*/
+bool QXmlSimpleReaderPrivate::processElementETagBegin2()
+{
+    const QString &name = QXmlSimpleReaderPrivate::name();
+
+    // pop the stack and compare it with the name
+    if (tags.pop() != name) {
+        reportParseError(QLatin1String(XMLERR_TAGMISMATCH));
+        return false;
+    }
+    // call the handler
+    if (contentHnd) {
+        QString uri, lname;
+
+        if (useNamespaces)
+            namespaceSupport.processName(name, false, uri, lname);
+        if (!contentHnd->endElement(uri, lname, name)) {
+            reportParseError(contentHnd->errorString());
+            return false;
+        }
+    }
+    if (useNamespaces) {
+        NamespaceMap prefixesBefore, prefixesAfter;
+        if (contentHnd)
+            prefixesBefore = namespaceSupport.d->ns;
+
+        namespaceSupport.popContext();
+        // call the handler for prefix mapping
+        if (contentHnd) {
+            prefixesAfter = namespaceSupport.d->ns;
+            if (prefixesBefore.size() != prefixesAfter.size()) {
+                for (NamespaceMap::const_iterator it = prefixesBefore.constBegin(); it != prefixesBefore.constEnd(); ++it) {
+                    if (!it.key().isEmpty() && !prefixesAfter.contains(it.key())) {
+                        if (!contentHnd->endPrefixMapping(it.key())) {
+                            reportParseError(contentHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return true;
+}
+/*
+  Helper to break down the size of the code in the case statement.
+  Return false on error, otherwise true.
+*/
+bool QXmlSimpleReaderPrivate::processElementAttribute()
+{
+    QString uri, lname, prefix;
+    const QString &name = QXmlSimpleReaderPrivate::name();
+    const QString &string = QXmlSimpleReaderPrivate::string();
+
+    // add the attribute to the list
+    if (useNamespaces) {
+        // is it a namespace declaration?
+        namespaceSupport.splitName(name, prefix, lname);
+        if (prefix == QLatin1String("xmlns")) {
+            // namespace declaration
+            namespaceSupport.setPrefix(lname, string);
+            if (useNamespacePrefixes) {
+                // according to http://www.w3.org/2000/xmlns/, the "prefix"
+                // xmlns maps to the namespace name
+                // http://www.w3.org/2000/xmlns/
+                attList.append(name, QLatin1String("http://www.w3.org/2000/xmlns/"), lname, string);
+            }
+            // call the handler for prefix mapping
+            if (contentHnd) {
+                if (!contentHnd->startPrefixMapping(lname, string)) {
+                    reportParseError(contentHnd->errorString());
+                    return false;
+                }
+            }
+        } else {
+            // no namespace delcaration
+            namespaceSupport.processName(name, true, uri, lname);
+            attList.append(name, uri, lname, string);
+        }
+    } else {
+        // no namespace support
+        attList.append(name, uri, lname, string);
+    }
+    return true;
+}
+
+/*
+  Parse a content [43].
+
+  A content is only used between tags. If a end tag is found the < is already
+  read and the head stand on the '/' of the end tag '</name>'.
+*/
+bool QXmlSimpleReaderPrivate::parseContent()
+{
+    const signed char Init             =  0;
+    const signed char ChD              =  1; // CharData
+    const signed char ChD1             =  2; // CharData help state
+    const signed char ChD2             =  3; // CharData help state
+    const signed char Ref              =  4; // Reference
+    const signed char Lt               =  5; // '<' read
+    const signed char PInstr           =  6; // PI
+    const signed char PInstrR          =  7; // same as PInstr, but already reported
+    const signed char Elem             =  8; // Element
+    const signed char Em               =  9; // '!' read
+    const signed char Com              = 10; // Comment
+    const signed char ComR             = 11; // same as Com, but already reported
+    const signed char CDS              = 12; // CDSect
+    const signed char CDS1             = 13; // read a CDSect
+    const signed char CDS2             = 14; // read a CDSect (help state)
+    const signed char CDS3             = 15; // read a CDSect (help state)
+    const signed char Done             = 16; // finished reading content
+
+    const signed char InpLt            = 0; // <
+    const signed char InpGt            = 1; // >
+    const signed char InpSlash         = 2; // /
+    const signed char InpQMark         = 3; // ?
+    const signed char InpEMark         = 4; // !
+    const signed char InpAmp           = 5; // &
+    const signed char InpDash          = 6; // -
+    const signed char InpOpenB         = 7; // [
+    const signed char InpCloseB        = 8; //]
+    const signed char InpUnknown       = 9;
+
+    static const signed char mapCLT2FSMChar[] = {
+        InpUnknown, // white space
+        InpUnknown, // %
+        InpAmp,     // &
+        InpGt,      // >
+        InpLt,      // <
+        InpSlash,   // /
+        InpQMark,   // ?
+        InpEMark,   // !
+        InpDash,    // -
+        InpCloseB,  //]
+        InpOpenB,   // [
+        InpUnknown, // =
+        InpUnknown, // "
+        InpUnknown, // '
+        InpUnknown  // unknown
+    };
+
+    static const signed char table[16][10] = {
+     /*  InpLt  InpGt  InpSlash  InpQMark  InpEMark  InpAmp  InpDash  InpOpenB  InpCloseB  InpUnknown */
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD1,      ChD  }, // Init
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD1,      ChD  }, // ChD
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD2,      ChD  }, // ChD1
+        { Lt,    -1,    ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD2,      ChD  }, // ChD2
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Ref (same as Init)
+        { -1,    -1,    Done,     PInstr,   Em,       -1,     -1,      -1,       -1,        Elem }, // Lt
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // PInstr (same as Init)
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // PInstrR
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Elem (same as Init)
+        { -1,    -1,    -1,       -1,       -1,       -1,     Com,     CDS,      -1,        -1   }, // Em
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // Com (same as Init)
+        { Lt,    ChD,   ChD,      ChD,      ChD,      Ref,    ChD,     ChD,      ChD,       ChD  }, // ComR
+        { CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS2,      CDS1 }, // CDS
+        { CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS2,      CDS1 }, // CDS1
+        { CDS1,  CDS1,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS3,      CDS1 }, // CDS2
+        { CDS1,  Init,  CDS1,     CDS1,     CDS1,     CDS1,   CDS1,    CDS1,     CDS3,      CDS1 }  // CDS3
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack == 0 || parseStack->isEmpty()) {
+        contentCharDataRead = false;
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseContent (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Ref:
+                if (!contentCharDataRead)
+                    contentCharDataRead = parseReference_charDataRead;
+                break;
+            case PInstr:
+                if (contentHnd) {
+                    if (!contentHnd->processingInstruction(name(),string())) {
+                        reportParseError(contentHnd->errorString());
+                        return false;
+                    }
+                }
+                state = PInstrR;
+                break;
+            case Com:
+                if (lexicalHnd) {
+                    if (!lexicalHnd->comment(string())) {
+                        reportParseError(lexicalHnd->errorString());
+                        return false;
+                    }
+                }
+                state = ComR;
+                break;
+            case CDS:
+                stringClear();
+                break;
+            case CDS2:
+                if (!atEnd() && c != QLatin1Char(']'))
+                    stringAddC(QLatin1Char(']'));
+                break;
+            case CDS3:
+                // test if this skipping was legal
+                if (!atEnd()) {
+                    if (c == QLatin1Char('>')) {
+                        // the end of the CDSect
+                        if (lexicalHnd) {
+                            if (!lexicalHnd->startCDATA()) {
+                                reportParseError(lexicalHnd->errorString());
+                                return false;
+                            }
+                        }
+                        if (contentHnd) {
+                            if (!contentHnd->characters(string())) {
+                                reportParseError(contentHnd->errorString());
+                                return false;
+                            }
+                        }
+                        if (lexicalHnd) {
+                            if (!lexicalHnd->endCDATA()) {
+                                reportParseError(lexicalHnd->errorString());
+                                return false;
+                            }
+                        }
+                    } else if (c == QLatin1Char(']')) {
+                        // three or more ']'
+                        stringAddC(QLatin1Char(']'));
+                    } else {
+                        // after ']]' comes another character
+                        stringAddC(QLatin1Char(']'));
+                        stringAddC(QLatin1Char(']'));
+                    }
+                }
+                break;
+            case Done:
+                // call the handler for CharData
+                if (contentHnd) {
+                    if (contentCharDataRead) {
+                        if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+                            if (!contentHnd->characters(string())) {
+                                reportParseError(contentHnd->errorString());
+                                return false;
+                            }
+                        }
+                    }
+                }
+                // Done
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_ERRORPARSINGCONTENT));
+                return false;
+        }
+
+        // get input (use lookup-table instead of nested ifs for performance
+        // reasons)
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseContent, state);
+            return false;
+        }
+        if (c.row()) {
+            input = InpUnknown;
+        } else {
+            input = mapCLT2FSMChar[charLookupTable[c.cell()]];
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Init:
+                // skip the ending '>' of a CDATASection
+                next();
+                break;
+            case ChD:
+                // on first call: clear string
+                if (!contentCharDataRead) {
+                    contentCharDataRead = true;
+                    stringClear();
+                }
+                stringAddC();
+                if (reportEntities) {
+                    if (!reportEndEntities())
+                        return false;
+                }
+                next();
+                break;
+            case ChD1:
+                // on first call: clear string
+                if (!contentCharDataRead) {
+                    contentCharDataRead = true;
+                    stringClear();
+                }
+                stringAddC();
+                if (reportEntities) {
+                    if (!reportEndEntities())
+                        return false;
+                }
+                next();
+                break;
+            case ChD2:
+                stringAddC();
+                if (reportEntities) {
+                    if (!reportEndEntities())
+                        return false;
+                }
+                next();
+                break;
+            case Ref:
+                if (!contentCharDataRead) {
+                    // reference may be CharData; so clear string to be safe
+                    stringClear();
+                    parseReference_context = InContent;
+                    if (!parseReference()) {
+                        parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+                        return false;
+                    }
+                } else {
+                    if (reportEntities) {
+                        // report character data in chunks
+                        if (contentHnd) {
+                            if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+                                if (!contentHnd->characters(string())) {
+                                    reportParseError(contentHnd->errorString());
+                                    return false;
+                                }
+                            }
+                        }
+                        stringClear();
+                    }
+                    parseReference_context = InContent;
+                    if (!parseReference()) {
+                        parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+                        return false;
+                    }
+                }
+                break;
+            case Lt:
+                // call the handler for CharData
+                if (contentHnd) {
+                    if (contentCharDataRead) {
+                        if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+                            if (!contentHnd->characters(string())) {
+                                reportParseError(contentHnd->errorString());
+                                return false;
+                            }
+                        }
+                    }
+                }
+                contentCharDataRead = false;
+                next();
+                break;
+            case PInstr:
+            case PInstrR:
+                parsePI_xmldecl = false;
+                if (!parsePI()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+                    return false;
+                }
+                break;
+            case Elem:
+                if (!parseElement()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+                    return false;
+                }
+                break;
+            case Em:
+                next();
+                break;
+            case Com:
+            case ComR:
+                if (!parseComment()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+                    return false;
+                }
+                break;
+            case CDS:
+                parseString_s = QLatin1String("[CDATA[");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseContent, state);
+                    return false;
+                }
+                break;
+            case CDS1:
+                stringAddC();
+                next();
+                break;
+            case CDS2:
+                // skip ']'
+                next();
+                break;
+            case CDS3:
+                // skip ']'...
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+bool QXmlSimpleReaderPrivate::reportEndEntities()
+{
+    int count = (int)xmlRefStack.count();
+    while (count != 0 && xmlRefStack.top().isEmpty()) {
+        if (contentHnd) {
+            if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+                if (!contentHnd->characters(string())) {
+                    reportParseError(contentHnd->errorString());
+                    return false;
+                }
+            }
+        }
+        stringClear();
+        if (lexicalHnd) {
+            if (!lexicalHnd->endEntity(xmlRefStack.top().name)) {
+                reportParseError(lexicalHnd->errorString());
+                return false;
+            }
+        }
+        xmlRefStack.pop_back();
+        count--;
+    }
+    return true;
+}
+
+/*
+  Parse Misc [27].
+*/
+bool QXmlSimpleReaderPrivate::parseMisc()
+{
+    const signed char Init             = 0;
+    const signed char Lt               = 1; // '<' was read
+    const signed char Comment          = 2; // read comment
+    const signed char eatWS            = 3; // eat whitespaces
+    const signed char PInstr           = 4; // read PI
+    const signed char Comment2         = 5; // read comment
+
+    const signed char InpWs            = 0; // S
+    const signed char InpLt            = 1; // <
+    const signed char InpQm            = 2; // ?
+    const signed char InpEm            = 3; // !
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[3][5] = {
+     /*  InpWs   InpLt  InpQm  InpEm     InpUnknown */
+        { eatWS,  Lt,    -1,    -1,       -1        }, // Init
+        { -1,     -1,    PInstr,Comment,  -1        }, // Lt
+        { -1,     -1,    -1,    -1,       Comment2  }  // Comment
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseMisc (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case eatWS:
+                return true;
+            case PInstr:
+                if (contentHnd) {
+                    if (!contentHnd->processingInstruction(name(),string())) {
+                        reportParseError(contentHnd->errorString());
+                        return false;
+                    }
+                }
+                return true;
+            case Comment2:
+                if (lexicalHnd) {
+                    if (!lexicalHnd->comment(string())) {
+                        reportParseError(lexicalHnd->errorString());
+                        return false;
+                    }
+                }
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseMisc, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('<')) {
+            input = InpLt;
+        } else if (c == QLatin1Char('?')) {
+            input = InpQm;
+        } else if (c == QLatin1Char('!')) {
+            input = InpEm;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case eatWS:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+                    return false;
+                }
+                break;
+            case Lt:
+                next();
+                break;
+            case PInstr:
+                parsePI_xmldecl = false;
+                if (!parsePI()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+                    return false;
+                }
+                break;
+            case Comment:
+                next();
+                break;
+            case Comment2:
+                if (!parseComment()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMisc, state);
+                    return false;
+                }
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a processing instruction [16].
+
+  If xmldec is true, it tries to parse a PI or a XML declaration [23].
+
+  Precondition: the beginning '<' of the PI is already read and the head stand
+  on the '?' of '<?'.
+
+  If this funktion was successful, the head-position is on the first
+  character after the PI.
+*/
+bool QXmlSimpleReaderPrivate::parsePI()
+{
+    const signed char Init             =  0;
+    const signed char QmI              =  1; // ? was read
+    const signed char Name             =  2; // read Name
+    const signed char XMLDecl          =  3; // read XMLDecl
+    const signed char Ws1              =  4; // eat ws after "xml" of XMLDecl
+    const signed char PInstr           =  5; // read PI
+    const signed char Ws2              =  6; // eat ws after Name of PI
+    const signed char Version          =  7; // read versionInfo
+    const signed char Ws3              =  8; // eat ws after versionInfo
+    const signed char EorSD            =  9; // read EDecl or SDDecl
+    const signed char Ws4              = 10; // eat ws after EDecl or SDDecl
+    const signed char SD               = 11; // read SDDecl
+    const signed char Ws5              = 12; // eat ws after SDDecl
+    const signed char ADone            = 13; // almost done
+    const signed char Char             = 14; // Char was read
+    const signed char Qm               = 15; // Qm was read
+    const signed char Done             = 16; // finished reading content
+
+    const signed char InpWs            = 0; // whitespace
+    const signed char InpNameBe        = 1; // NameBeginning
+    const signed char InpGt            = 2; // >
+    const signed char InpQm            = 3; // ?
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[16][5] = {
+     /*  InpWs,  InpNameBe  InpGt  InpQm   InpUnknown  */
+        { -1,     -1,        -1,    QmI,    -1     }, // Init
+        { -1,     Name,      -1,    -1,     -1     }, // QmI
+        { -1,     -1,        -1,    -1,     -1     }, // Name (this state is left not through input)
+        { Ws1,    -1,        -1,    -1,     -1     }, // XMLDecl
+        { -1,     Version,   -1,    -1,     -1     }, // Ws1
+        { Ws2,    -1,        -1,    Qm,     -1     }, // PInstr
+        { Char,   Char,      Char,  Qm,     Char   }, // Ws2
+        { Ws3,    -1,        -1,    ADone,  -1     }, // Version
+        { -1,     EorSD,     -1,    ADone,  -1     }, // Ws3
+        { Ws4,    -1,        -1,    ADone,  -1     }, // EorSD
+        { -1,     SD,        -1,    ADone,  -1     }, // Ws4
+        { Ws5,    -1,        -1,    ADone,  -1     }, // SD
+        { -1,     -1,        -1,    ADone,  -1     }, // Ws5
+        { -1,     -1,        Done,  -1,     -1     }, // ADone
+        { Char,   Char,      Char,  Qm,     Char   }, // Char
+        { Char,   Char,      Done,  Qm,     Char   }, // Qm
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parsePI (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Name:
+                // test what name was read and determine the next state
+                // (not very beautiful, I admit)
+                if (name().toLower() == QLatin1String("xml")) {
+                    if (parsePI_xmldecl && name() == QLatin1String("xml")) {
+                        state = XMLDecl;
+                    } else {
+                        reportParseError(QLatin1String(XMLERR_INVALIDNAMEFORPI));
+                        return false;
+                    }
+                } else {
+                    state = PInstr;
+                    stringClear();
+                }
+                break;
+            case Version:
+                // get version (syntax like an attribute)
+                if (name() != QLatin1String("version")) {
+                    reportParseError(QLatin1String(XMLERR_VERSIONEXPECTED));
+                    return false;
+                }
+                xmlVersion = string();
+                break;
+            case EorSD:
+                // get the EDecl or SDDecl (syntax like an attribute)
+                if (name() == QLatin1String("standalone")) {
+                    if (string()== QLatin1String("yes")) {
+                        standalone = QXmlSimpleReaderPrivate::Yes;
+                    } else if (string() == QLatin1String("no")) {
+                        standalone = QXmlSimpleReaderPrivate::No;
+                    } else {
+                        reportParseError(QLatin1String(XMLERR_WRONGVALUEFORSDECL));
+                        return false;
+                    }
+                } else if (name() == QLatin1String("encoding")) {
+                    encoding = string();
+                } else {
+                    reportParseError(QLatin1String(XMLERR_EDECLORSDDECLEXPECTED));
+                    return false;
+                }
+                break;
+            case SD:
+                if (name() != QLatin1String("standalone")) {
+                    reportParseError(QLatin1String(XMLERR_SDDECLEXPECTED));
+                    return false;
+                }
+                if (string() == QLatin1String("yes")) {
+                    standalone = QXmlSimpleReaderPrivate::Yes;
+                } else if (string() == QLatin1String("no")) {
+                    standalone = QXmlSimpleReaderPrivate::No;
+                } else {
+                    reportParseError(QLatin1String(XMLERR_WRONGVALUEFORSDECL));
+                    return false;
+                }
+                break;
+            case Qm:
+                // test if the skipping was legal
+                if (!atEnd() && c != QLatin1Char('>'))
+                    stringAddC(QLatin1Char('?'));
+                break;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parsePI, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (determineNameChar(c) == NameBeginning) {
+            input = InpNameBe;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else if (c == QLatin1Char('?')) {
+            input = InpQm;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case QmI:
+                next();
+                break;
+            case Name:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+                    return false;
+                }
+                break;
+            case Ws1:
+            case Ws2:
+            case Ws3:
+            case Ws4:
+            case Ws5:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+                    return false;
+                }
+                break;
+            case Version:
+                if (!parseAttribute()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+                    return false;
+                }
+                break;
+            case EorSD:
+                if (!parseAttribute()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+                    return false;
+                }
+                break;
+            case SD:
+                // get the SDDecl (syntax like an attribute)
+                if (standalone != QXmlSimpleReaderPrivate::Unknown) {
+                    // already parsed the standalone declaration
+                    reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                    return false;
+                }
+                if (!parseAttribute()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parsePI, state);
+                    return false;
+                }
+                break;
+            case ADone:
+                next();
+                break;
+            case Char:
+                stringAddC();
+                next();
+                break;
+            case Qm:
+                // skip the '?'
+                next();
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a document type definition (doctypedecl [28]).
+
+  Precondition: the beginning '<!' of the doctype is already read the head
+  stands on the 'D' of '<!DOCTYPE'.
+
+  If this function was successful, the head-position is on the first
+  character after the document type definition.
+*/
+bool QXmlSimpleReaderPrivate::parseDoctype()
+{
+    const signed char Init             =  0;
+    const signed char Doctype          =  1; // read the doctype
+    const signed char Ws1              =  2; // eat_ws
+    const signed char Doctype2         =  3; // read the doctype, part 2
+    const signed char Ws2              =  4; // eat_ws
+    const signed char Sys              =  5; // read SYSTEM or PUBLIC
+    const signed char Ws3              =  6; // eat_ws
+    const signed char MP               =  7; // markupdecl or PEReference
+    const signed char MPR              =  8; // same as MP, but already reported
+    const signed char PER              =  9; // PERReference
+    const signed char Mup              = 10; // markupdecl
+    const signed char Ws4              = 11; // eat_ws
+    const signed char MPE              = 12; // end of markupdecl or PEReference
+    const signed char Done             = 13;
+
+    const signed char InpWs            = 0;
+    const signed char InpD             = 1; // 'D'
+    const signed char InpS             = 2; // 'S' or 'P'
+    const signed char InpOB            = 3; // [
+    const signed char InpCB            = 4; //]
+    const signed char InpPer           = 5; // %
+    const signed char InpGt            = 6; // >
+    const signed char InpUnknown       = 7;
+
+    static const signed char table[13][8] = {
+     /*  InpWs,  InpD       InpS       InpOB  InpCB  InpPer InpGt  InpUnknown */
+        { -1,     Doctype,   -1,        -1,    -1,    -1,    -1,    -1        }, // Init
+        { Ws1,    -1,        -1,        -1,    -1,    -1,    -1,    -1        }, // Doctype
+        { -1,     Doctype2,  Doctype2,  -1,    -1,    -1,    -1,    Doctype2  }, // Ws1
+        { Ws2,    -1,        Sys,       MP,    -1,    -1,    Done,  -1        }, // Doctype2
+        { -1,     -1,        Sys,       MP,    -1,    -1,    Done,  -1        }, // Ws2
+        { Ws3,    -1,        -1,        MP,    -1,    -1,    Done,  -1        }, // Sys
+        { -1,     -1,        -1,        MP,    -1,    -1,    Done,  -1        }, // Ws3
+        { -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // MP
+        { -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // MPR
+        { Ws4,    -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // PER
+        { Ws4,    -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // Mup
+        { -1,     -1,        -1,        -1,    MPE,   PER,   -1,    Mup       }, // Ws4
+        { -1,     -1,        -1,        -1,    -1,    -1,    Done,  -1        }  // MPE
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        startDTDwasReported = false;
+        systemId.clear();
+        publicId.clear();
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseDoctype (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Doctype2:
+                doctype = name();
+                break;
+            case MP:
+                if (!startDTDwasReported && lexicalHnd ) {
+                    startDTDwasReported = true;
+                    if (!lexicalHnd->startDTD(doctype, publicId, systemId)) {
+                        reportParseError(lexicalHnd->errorString());
+                        return false;
+                    }
+                }
+                state = MPR;
+                break;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_ERRORPARSINGDOCTYPE));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseDoctype, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('D')) {
+            input = InpD;
+        } else if (c == QLatin1Char('S')) {
+            input = InpS;
+        } else if (c == QLatin1Char('P')) {
+            input = InpS;
+        } else if (c == QLatin1Char('[')) {
+            input = InpOB;
+        } else if (c == QLatin1Char(']')) {
+            input = InpCB;
+        } else if (c == QLatin1Char('%')) {
+            input = InpPer;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Doctype:
+                parseString_s = QLatin1String("DOCTYPE");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                break;
+            case Ws1:
+            case Ws2:
+            case Ws3:
+            case Ws4:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                break;
+            case Doctype2:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                break;
+            case Sys:
+                parseExternalID_allowPublicID = false;
+                if (!parseExternalID()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                thisPublicId = publicId;
+                thisSystemId = systemId;
+                break;
+            case MP:
+            case MPR:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                break;
+            case PER:
+                parsePEReference_context = InDTD;
+                if (!parsePEReference()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                break;
+            case Mup:
+                if (!parseMarkupdecl()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                break;
+            case MPE:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state);
+                    return false;
+                }
+                break;
+            case Done:
+                if (lexicalHnd) {
+                    if (!startDTDwasReported) {
+                        startDTDwasReported = true;
+                        if (!lexicalHnd->startDTD(doctype, publicId, systemId)) {
+                            reportParseError(lexicalHnd->errorString());
+                            return false;
+                        }
+                    }
+                    if (!lexicalHnd->endDTD()) {
+                        reportParseError(lexicalHnd->errorString());
+                        return false;
+                    }
+                }
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a ExternalID [75].
+
+  If allowPublicID is true parse ExternalID [75] or PublicID [83].
+*/
+bool QXmlSimpleReaderPrivate::parseExternalID()
+{
+    const signed char Init             =  0;
+    const signed char Sys              =  1; // parse 'SYSTEM'
+    const signed char SysWS            =  2; // parse the whitespace after 'SYSTEM'
+    const signed char SysSQ            =  3; // parse SystemLiteral with '
+    const signed char SysSQ2           =  4; // parse SystemLiteral with '
+    const signed char SysDQ            =  5; // parse SystemLiteral with "
+    const signed char SysDQ2           =  6; // parse SystemLiteral with "
+    const signed char Pub              =  7; // parse 'PUBLIC'
+    const signed char PubWS            =  8; // parse the whitespace after 'PUBLIC'
+    const signed char PubSQ            =  9; // parse PubidLiteral with '
+    const signed char PubSQ2           = 10; // parse PubidLiteral with '
+    const signed char PubDQ            = 11; // parse PubidLiteral with "
+    const signed char PubDQ2           = 12; // parse PubidLiteral with "
+    const signed char PubE             = 13; // finished parsing the PubidLiteral
+    const signed char PubWS2           = 14; // parse the whitespace after the PubidLiteral
+    const signed char PDone            = 15; // done if allowPublicID is true
+    const signed char Done             = 16;
+
+    const signed char InpSQ            = 0; // '
+    const signed char InpDQ            = 1; // "
+    const signed char InpS             = 2; // S
+    const signed char InpP             = 3; // P
+    const signed char InpWs            = 4; // white space
+    const signed char InpUnknown       = 5;
+
+    static const signed char table[15][6] = {
+     /*  InpSQ    InpDQ    InpS     InpP     InpWs     InpUnknown */
+        { -1,      -1,      Sys,     Pub,     -1,       -1      }, // Init
+        { -1,      -1,      -1,      -1,      SysWS,    -1      }, // Sys
+        { SysSQ,   SysDQ,   -1,      -1,      -1,       -1      }, // SysWS
+        { Done,    SysSQ2,  SysSQ2,  SysSQ2,  SysSQ2,   SysSQ2  }, // SysSQ
+        { Done,    SysSQ2,  SysSQ2,  SysSQ2,  SysSQ2,   SysSQ2  }, // SysSQ2
+        { SysDQ2,  Done,    SysDQ2,  SysDQ2,  SysDQ2,   SysDQ2  }, // SysDQ
+        { SysDQ2,  Done,    SysDQ2,  SysDQ2,  SysDQ2,   SysDQ2  }, // SysDQ2
+        { -1,      -1,      -1,      -1,      PubWS,    -1      }, // Pub
+        { PubSQ,   PubDQ,   -1,      -1,      -1,       -1      }, // PubWS
+        { PubE,    -1,      PubSQ2,  PubSQ2,  PubSQ2,   PubSQ2  }, // PubSQ
+        { PubE,    -1,      PubSQ2,  PubSQ2,  PubSQ2,   PubSQ2  }, // PubSQ2
+        { -1,      PubE,    PubDQ2,  PubDQ2,  PubDQ2,   PubDQ2  }, // PubDQ
+        { -1,      PubE,    PubDQ2,  PubDQ2,  PubDQ2,   PubDQ2  }, // PubDQ2
+        { PDone,   PDone,   PDone,   PDone,   PubWS2,   PDone   }, // PubE
+        { SysSQ,   SysDQ,   PDone,   PDone,   PDone,    PDone   }  // PubWS2
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        systemId.clear();
+        publicId.clear();
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseExternalID (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case PDone:
+                if (parseExternalID_allowPublicID) {
+                    publicId = string();
+                    return true;
+                } else {
+                    reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                    return false;
+                }
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseExternalID, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('\'')) {
+            input = InpSQ;
+        } else if (c == QLatin1Char('"')) {
+            input = InpDQ;
+        } else if (c == QLatin1Char('S')) {
+            input = InpS;
+        } else if (c == QLatin1Char('P')) {
+            input = InpP;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Sys:
+                parseString_s = QLatin1String("SYSTEM");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+                    return false;
+                }
+                break;
+            case SysWS:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+                    return false;
+                }
+                break;
+            case SysSQ:
+            case SysDQ:
+                stringClear();
+                next();
+                break;
+            case SysSQ2:
+            case SysDQ2:
+                stringAddC();
+                next();
+                break;
+            case Pub:
+                parseString_s = QLatin1String("PUBLIC");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+                    return false;
+                }
+                break;
+            case PubWS:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+                    return false;
+                }
+                break;
+            case PubSQ:
+            case PubDQ:
+                stringClear();
+                next();
+                break;
+            case PubSQ2:
+            case PubDQ2:
+                stringAddC();
+                next();
+                break;
+            case PubE:
+                next();
+                break;
+            case PubWS2:
+                publicId = string();
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseExternalID, state);
+                    return false;
+                }
+                break;
+            case Done:
+                systemId = string();
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a markupdecl [29].
+*/
+bool QXmlSimpleReaderPrivate::parseMarkupdecl()
+{
+    const signed char Init             = 0;
+    const signed char Lt               = 1; // < was read
+    const signed char Em               = 2; // ! was read
+    const signed char CE               = 3; // E was read
+    const signed char Qm               = 4; // ? was read
+    const signed char Dash             = 5; // - was read
+    const signed char CA               = 6; // A was read
+    const signed char CEL              = 7; // EL was read
+    const signed char CEN              = 8; // EN was read
+    const signed char CN               = 9; // N was read
+    const signed char Done             = 10;
+
+    const signed char InpLt            = 0; // <
+    const signed char InpQm            = 1; // ?
+    const signed char InpEm            = 2; // !
+    const signed char InpDash          = 3; // -
+    const signed char InpA             = 4; // A
+    const signed char InpE             = 5; // E
+    const signed char InpL             = 6; // L
+    const signed char InpN             = 7; // N
+    const signed char InpUnknown       = 8;
+
+    static const signed char table[4][9] = {
+     /*  InpLt  InpQm  InpEm  InpDash  InpA   InpE   InpL   InpN   InpUnknown */
+        { Lt,    -1,    -1,    -1,      -1,    -1,    -1,    -1,    -1     }, // Init
+        { -1,    Qm,    Em,    -1,      -1,    -1,    -1,    -1,    -1     }, // Lt
+        { -1,    -1,    -1,    Dash,    CA,    CE,    -1,    CN,    -1     }, // Em
+        { -1,    -1,    -1,    -1,      -1,    -1,    CEL,   CEN,   -1     }  // CE
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseMarkupdecl (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Qm:
+                if (contentHnd) {
+                    if (!contentHnd->processingInstruction(name(),string())) {
+                        reportParseError(contentHnd->errorString());
+                        return false;
+                    }
+                }
+                return true;
+            case Dash:
+                if (lexicalHnd) {
+                    if (!lexicalHnd->comment(string())) {
+                        reportParseError(lexicalHnd->errorString());
+                        return false;
+                    }
+                }
+                return true;
+            case CA:
+                return true;
+            case CEL:
+                return true;
+            case CEN:
+                return true;
+            case CN:
+                return true;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+            return false;
+        }
+        if        (c == QLatin1Char('<')) {
+            input = InpLt;
+        } else if (c == QLatin1Char('?')) {
+            input = InpQm;
+        } else if (c == QLatin1Char('!')) {
+            input = InpEm;
+        } else if (c == QLatin1Char('-')) {
+            input = InpDash;
+        } else if (c == QLatin1Char('A')) {
+            input = InpA;
+        } else if (c == QLatin1Char('E')) {
+            input = InpE;
+        } else if (c == QLatin1Char('L')) {
+            input = InpL;
+        } else if (c == QLatin1Char('N')) {
+            input = InpN;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Lt:
+                next();
+                break;
+            case Em:
+                next();
+                break;
+            case CE:
+                next();
+                break;
+            case Qm:
+                parsePI_xmldecl = false;
+                if (!parsePI()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+                    return false;
+                }
+                break;
+            case Dash:
+                if (!parseComment()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+                    return false;
+                }
+                break;
+            case CA:
+                if (!parseAttlistDecl()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+                    return false;
+                }
+                break;
+            case CEL:
+                if (!parseElementDecl()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+                    return false;
+                }
+                break;
+            case CEN:
+                if (!parseEntityDecl()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+                    return false;
+                }
+                break;
+            case CN:
+                if (!parseNotationDecl()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseMarkupdecl, state);
+                    return false;
+                }
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a PEReference [69]
+*/
+bool QXmlSimpleReaderPrivate::parsePEReference()
+{
+    const signed char Init             = 0;
+    const signed char Next             = 1;
+    const signed char Name             = 2;
+    const signed char NameR            = 3; // same as Name, but already reported
+    const signed char Done             = 4;
+
+    const signed char InpSemi          = 0; // ;
+    const signed char InpPer           = 1; // %
+    const signed char InpUnknown       = 2;
+
+    static const signed char table[4][3] = {
+     /*  InpSemi  InpPer  InpUnknown */
+        { -1,      Next,   -1    }, // Init
+        { -1,      -1,     Name  }, // Next
+        { Done,    -1,     -1    }, // Name
+        { Done,    -1,     -1    }  // NameR
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parsePEReference (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parsePEReference, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Name:
+                {
+                    bool skipIt = true;
+                    QString xmlRefString;
+
+                    QMap<QString,QString>::Iterator it;
+                    it = parameterEntities.find(ref());
+                    if (it != parameterEntities.end()) {
+                        skipIt = false;
+                        xmlRefString = *it;
+                    } else if (entityRes) {
+                        QMap<QString,QXmlSimpleReaderPrivate::ExternParameterEntity>::Iterator it2;
+                        it2 = externParameterEntities.find(ref());
+                        QXmlInputSource *ret = 0;
+                        if (it2 != externParameterEntities.end()) {
+                            if (!entityRes->resolveEntity((*it2).publicId, (*it2).systemId, ret)) {
+                                delete ret;
+                                reportParseError(entityRes->errorString());
+                                return false;
+                            }
+                            if (ret) {
+                                xmlRefString = ret->data();
+                                delete ret;
+                                if (!stripTextDecl(xmlRefString)) {
+                                    reportParseError(QLatin1String(XMLERR_ERRORINTEXTDECL));
+                                    return false;
+                                }
+                                skipIt = false;
+                            }
+                        }
+                    }
+
+                    if (skipIt) {
+                        if (contentHnd) {
+                            if (!contentHnd->skippedEntity(QLatin1Char('%') + ref())) {
+                                reportParseError(contentHnd->errorString());
+                                return false;
+                            }
+                        }
+                    } else {
+                        if (parsePEReference_context == InEntityValue) {
+                            // Included in literal
+                            if (!insertXmlRef(xmlRefString, ref(), true))
+                                return false;
+                        } else if (parsePEReference_context == InDTD) {
+                            // Included as PE
+                            if (!insertXmlRef(QLatin1Char(' ') + xmlRefString + QLatin1Char(' '), ref(), false))
+                                return false;
+                        }
+                    }
+                }
+                state = NameR;
+                break;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parsePEReference, state);
+            return false;
+        }
+        if        (c == QLatin1Char(';')) {
+            input = InpSemi;
+        } else if (c == QLatin1Char('%')) {
+            input = InpPer;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Next:
+                next();
+                break;
+            case Name:
+            case NameR:
+                parseName_useRef = true;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parsePEReference, state);
+                    return false;
+                }
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a AttlistDecl [52].
+
+  Precondition: the beginning '<!' is already read and the head
+  stands on the 'A' of '<!ATTLIST'
+*/
+bool QXmlSimpleReaderPrivate::parseAttlistDecl()
+{
+    const signed char Init             =  0;
+    const signed char Attlist          =  1; // parse the string "ATTLIST"
+    const signed char Ws               =  2; // whitespace read
+    const signed char Name             =  3; // parse name
+    const signed char Ws1              =  4; // whitespace read
+    const signed char Attdef           =  5; // parse the AttDef
+    const signed char Ws2              =  6; // whitespace read
+    const signed char Atttype          =  7; // parse the AttType
+    const signed char Ws3              =  8; // whitespace read
+    const signed char DDecH            =  9; // DefaultDecl with #
+    const signed char DefReq           = 10; // parse the string "REQUIRED"
+    const signed char DefImp           = 11; // parse the string "IMPLIED"
+    const signed char DefFix           = 12; // parse the string "FIXED"
+    const signed char Attval           = 13; // parse the AttValue
+    const signed char Ws4              = 14; // whitespace read
+    const signed char Done             = 15;
+
+    const signed char InpWs            = 0; // white space
+    const signed char InpGt            = 1; // >
+    const signed char InpHash          = 2; // #
+    const signed char InpA             = 3; // A
+    const signed char InpI             = 4; // I
+    const signed char InpF             = 5; // F
+    const signed char InpR             = 6; // R
+    const signed char InpUnknown       = 7;
+
+    static const signed char table[15][8] = {
+     /*  InpWs    InpGt    InpHash  InpA      InpI     InpF     InpR     InpUnknown */
+        { -1,      -1,      -1,      Attlist,  -1,      -1,      -1,      -1      }, // Init
+        { Ws,      -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attlist
+        { -1,      -1,      -1,      Name,     Name,    Name,    Name,    Name    }, // Ws
+        { Ws1,     Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }, // Name
+        { -1,      Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }, // Ws1
+        { Ws2,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attdef
+        { -1,      Atttype, Atttype, Atttype,  Atttype, Atttype, Atttype, Atttype }, // Ws2
+        { Ws3,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // Attype
+        { -1,      Attval,  DDecH,   Attval,   Attval,  Attval,  Attval,  Attval  }, // Ws3
+        { -1,      -1,      -1,      -1,       DefImp,  DefFix,  DefReq,  -1      }, // DDecH
+        { Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // DefReq
+        { Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // DefImp
+        { Ws3,     -1,      -1,      -1,       -1,      -1,      -1,      -1      }, // DefFix
+        { Ws4,     Ws4,     -1,      -1,       -1,      -1,      -1,      -1      }, // Attval
+        { -1,      Done,    Attdef,  Attdef,   Attdef,  Attdef,  Attdef,  Attdef  }  // Ws4
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseAttlistDecl (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Name:
+                attDeclEName = name();
+                break;
+            case Attdef:
+                attDeclAName = name();
+                break;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else if (c == QLatin1Char('#')) {
+            input = InpHash;
+        } else if (c == QLatin1Char('A')) {
+            input = InpA;
+        } else if (c == QLatin1Char('I')) {
+            input = InpI;
+        } else if (c == QLatin1Char('F')) {
+            input = InpF;
+        } else if (c == QLatin1Char('R')) {
+            input = InpR;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Attlist:
+                parseString_s = QLatin1String("ATTLIST");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case Ws:
+            case Ws1:
+            case Ws2:
+            case Ws3:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case Name:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case Attdef:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case Atttype:
+                if (!parseAttType()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case DDecH:
+                next();
+                break;
+            case DefReq:
+                parseString_s = QLatin1String("REQUIRED");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case DefImp:
+                parseString_s = QLatin1String("IMPLIED");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case DefFix:
+                parseString_s = QLatin1String("FIXED");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case Attval:
+                if (!parseAttValue()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case Ws4:
+                if (declHnd) {
+                    // ### not all values are computed yet...
+                    if (!declHnd->attributeDecl(attDeclEName, attDeclAName, QLatin1String(""), QLatin1String(""), QLatin1String(""))) {
+                        reportParseError(declHnd->errorString());
+                        return false;
+                    }
+                }
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttlistDecl, state);
+                    return false;
+                }
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a AttType [54]
+*/
+bool QXmlSimpleReaderPrivate::parseAttType()
+{
+    const signed char Init             =  0;
+    const signed char ST               =  1; // StringType
+    const signed char TTI              =  2; // TokenizedType starting with 'I'
+    const signed char TTI2             =  3; // TokenizedType helpstate
+    const signed char TTI3             =  4; // TokenizedType helpstate
+    const signed char TTE              =  5; // TokenizedType starting with 'E'
+    const signed char TTEY             =  6; // TokenizedType starting with 'ENTITY'
+    const signed char TTEI             =  7; // TokenizedType starting with 'ENTITI'
+    const signed char N                =  8; // N read (TokenizedType or Notation)
+    const signed char TTNM             =  9; // TokenizedType starting with 'NM'
+    const signed char TTNM2            = 10; // TokenizedType helpstate
+    const signed char NO               = 11; // Notation
+    const signed char NO2              = 12; // Notation helpstate
+    const signed char NO3              = 13; // Notation helpstate
+    const signed char NOName           = 14; // Notation, read name
+    const signed char NO4              = 15; // Notation helpstate
+    const signed char EN               = 16; // Enumeration
+    const signed char ENNmt            = 17; // Enumeration, read Nmtoken
+    const signed char EN2              = 18; // Enumeration helpstate
+    const signed char ADone            = 19; // almost done (make next and accept)
+    const signed char Done             = 20;
+
+    const signed char InpWs            =  0; // whitespace
+    const signed char InpOp            =  1; // (
+    const signed char InpCp            =  2; //)
+    const signed char InpPipe          =  3; // |
+    const signed char InpC             =  4; // C
+    const signed char InpE             =  5; // E
+    const signed char InpI             =  6; // I
+    const signed char InpM             =  7; // M
+    const signed char InpN             =  8; // N
+    const signed char InpO             =  9; // O
+    const signed char InpR             = 10; // R
+    const signed char InpS             = 11; // S
+    const signed char InpY             = 12; // Y
+    const signed char InpUnknown       = 13;
+
+    static const signed char table[19][14] = {
+     /*  InpWs    InpOp    InpCp    InpPipe  InpC     InpE     InpI     InpM     InpN     InpO     InpR     InpS     InpY     InpUnknown */
+        { -1,      EN,      -1,      -1,      ST,      TTE,     TTI,     -1,      N,       -1,      -1,      -1,      -1,      -1     }, // Init
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // ST
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTI2,    Done,    Done,    Done   }, // TTI
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTI3,    Done,    Done   }, // TTI2
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTI3
+        { -1,      -1,      -1,      -1,      -1,      -1,      TTEI,    -1,      -1,      -1,      -1,      -1,      TTEY,    -1     }, // TTE
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTEY
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTEI
+        { -1,      -1,      -1,      -1,      -1,      -1,      -1,      TTNM,    -1,      NO,      -1,      -1,      -1,      -1     }, // N
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    TTNM2,   Done,    Done   }, // TTNM
+        { Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done,    Done   }, // TTNM2
+        { NO2,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO
+        { -1,      NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO2
+        { NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName,  NOName }, // NO3
+        { NO4,     -1,      ADone,   NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NOName
+        { -1,      -1,      ADone,   NO3,     -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // NO4
+        { -1,      -1,      ENNmt,   -1,      ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt,   ENNmt  }, // EN
+        { EN2,     -1,      ADone,   EN,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }, // ENNmt
+        { -1,      -1,      ADone,   EN,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1,      -1     }  // EN2
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseAttType (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case ADone:
+                return true;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttType, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('(')) {
+            input = InpOp;
+        } else if (c == QLatin1Char(')')) {
+            input = InpCp;
+        } else if (c == QLatin1Char('|')) {
+            input = InpPipe;
+        } else if (c == QLatin1Char('C')) {
+            input = InpC;
+        } else if (c == QLatin1Char('E')) {
+            input = InpE;
+        } else if (c == QLatin1Char('I')) {
+            input = InpI;
+        } else if (c == QLatin1Char('M')) {
+            input = InpM;
+        } else if (c == QLatin1Char('N')) {
+            input = InpN;
+        } else if (c == QLatin1Char('O')) {
+            input = InpO;
+        } else if (c == QLatin1Char('R')) {
+            input = InpR;
+        } else if (c == QLatin1Char('S')) {
+            input = InpS;
+        } else if (c == QLatin1Char('Y')) {
+            input = InpY;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case ST:
+                parseString_s = QLatin1String("CDATA");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case TTI:
+                parseString_s = QLatin1String("ID");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case TTI2:
+                parseString_s = QLatin1String("REF");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case TTI3:
+                next(); // S
+                break;
+            case TTE:
+                parseString_s = QLatin1String("ENTIT");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case TTEY:
+                next(); // Y
+                break;
+            case TTEI:
+                parseString_s = QLatin1String("IES");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case N:
+                next(); // N
+                break;
+            case TTNM:
+                parseString_s = QLatin1String("MTOKEN");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case TTNM2:
+                next(); // S
+                break;
+            case NO:
+                parseString_s = QLatin1String("OTATION");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case NO2:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case NO3:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case NOName:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case NO4:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case EN:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case ENNmt:
+                if (!parseNmtoken()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case EN2:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttType, state);
+                    return false;
+                }
+                break;
+            case ADone:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a AttValue [10]
+
+  Precondition: the head stands on the beginning " or '
+
+  If this function was successful, the head stands on the first
+  character after the closing " or ' and the value of the attribute
+  is in string().
+*/
+bool QXmlSimpleReaderPrivate::parseAttValue()
+{
+    const signed char Init             = 0;
+    const signed char Dq               = 1; // double quotes were read
+    const signed char DqRef            = 2; // read references in double quotes
+    const signed char DqC              = 3; // signed character read in double quotes
+    const signed char Sq               = 4; // single quotes were read
+    const signed char SqRef            = 5; // read references in single quotes
+    const signed char SqC              = 6; // signed character read in single quotes
+    const signed char Done             = 7;
+
+    const signed char InpDq            = 0; // "
+    const signed char InpSq            = 1; // '
+    const signed char InpAmp           = 2; // &
+    const signed char InpLt            = 3; // <
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[7][5] = {
+     /*  InpDq  InpSq  InpAmp  InpLt InpUnknown */
+        { Dq,    Sq,    -1,     -1,   -1    }, // Init
+        { Done,  DqC,   DqRef,  -1,   DqC   }, // Dq
+        { Done,  DqC,   DqRef,  -1,   DqC   }, // DqRef
+        { Done,  DqC,   DqRef,  -1,   DqC   }, // DqC
+        { SqC,   Done,  SqRef,  -1,   SqC   }, // Sq
+        { SqC,   Done,  SqRef,  -1,   SqC   }, // SqRef
+        { SqC,   Done,  SqRef,  -1,   SqC   }  // SqRef
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseAttValue (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseAttValue, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttValue, state);
+            return false;
+        }
+        if        (c == QLatin1Char('"')) {
+            input = InpDq;
+        } else if (c == QLatin1Char('\'')) {
+            input = InpSq;
+        } else if (c == QLatin1Char('&')) {
+            input = InpAmp;
+        } else if (c == QLatin1Char('<')) {
+            input = InpLt;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Dq:
+            case Sq:
+                stringClear();
+                next();
+                break;
+            case DqRef:
+            case SqRef:
+                parseReference_context = InAttributeValue;
+                if (!parseReference()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttValue, state);
+                    return false;
+                }
+                break;
+            case DqC:
+            case SqC:
+                stringAddC();
+                next();
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a elementdecl [45].
+
+  Precondition: the beginning '<!E' is already read and the head
+  stands on the 'L' of '<!ELEMENT'
+*/
+bool QXmlSimpleReaderPrivate::parseElementDecl()
+{
+    const signed char Init             =  0;
+    const signed char Elem             =  1; // parse the beginning string
+    const signed char Ws1              =  2; // whitespace required
+    const signed char Nam              =  3; // parse Name
+    const signed char Ws2              =  4; // whitespace required
+    const signed char Empty            =  5; // read EMPTY
+    const signed char Any              =  6; // read ANY
+    const signed char Cont             =  7; // read contentspec (except ANY or EMPTY)
+    const signed char Mix              =  8; // read Mixed
+    const signed char Mix2             =  9; //
+    const signed char Mix3             = 10; //
+    const signed char MixN1            = 11; //
+    const signed char MixN2            = 12; //
+    const signed char MixN3            = 13; //
+    const signed char MixN4            = 14; //
+    const signed char Cp               = 15; // parse cp
+    const signed char Cp2              = 16; //
+    const signed char WsD              = 17; // eat whitespace before Done
+    const signed char Done             = 18;
+
+    const signed char InpWs            =  0;
+    const signed char InpGt            =  1; // >
+    const signed char InpPipe          =  2; // |
+    const signed char InpOp            =  3; // (
+    const signed char InpCp            =  4; //)
+    const signed char InpHash          =  5; // #
+    const signed char InpQm            =  6; // ?
+    const signed char InpAst           =  7; // *
+    const signed char InpPlus          =  8; // +
+    const signed char InpA             =  9; // A
+    const signed char InpE             = 10; // E
+    const signed char InpL             = 11; // L
+    const signed char InpUnknown       = 12;
+
+    static const signed char table[18][13] = {
+     /*  InpWs   InpGt  InpPipe  InpOp  InpCp   InpHash  InpQm  InpAst  InpPlus  InpA    InpE    InpL    InpUnknown */
+        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     Elem,   -1     }, // Init
+        { Ws1,    -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Elem
+        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      Nam,    Nam,    Nam,    Nam    }, // Ws1
+        { Ws2,    -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Nam
+        { -1,     -1,    -1,      Cont,  -1,     -1,      -1,    -1,     -1,      Any,    Empty,  -1,     -1     }, // Ws2
+        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Empty
+        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Any
+        { -1,     -1,    -1,      Cp,    Cp,     Mix,     -1,    -1,     -1,      Cp,     Cp,     Cp,     Cp     }, // Cont
+        { Mix2,   -1,    MixN1,   -1,    Mix3,   -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Mix
+        { -1,     -1,    MixN1,   -1,    Mix3,   -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Mix2
+        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    WsD,    -1,      -1,     -1,     -1,     -1     }, // Mix3
+        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    -1,     -1,      MixN2,  MixN2,  MixN2,  MixN2  }, // MixN1
+        { MixN3,  -1,    MixN1,   -1,    MixN4,  -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // MixN2
+        { -1,     -1,    MixN1,   -1,    MixN4,  -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // MixN3
+        { -1,     -1,    -1,      -1,    -1,     -1,      -1,    WsD,    -1,      -1,     -1,     -1,     -1     }, // MixN4
+        { WsD,    Done,  -1,      -1,    -1,     -1,      Cp2,   Cp2,    Cp2,     -1,     -1,     -1,     -1     }, // Cp
+        { WsD,    Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }, // Cp2
+        { -1,     Done,  -1,      -1,    -1,     -1,      -1,    -1,     -1,      -1,     -1,     -1,     -1     }  // WsD
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseElementDecl (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Done:
+                return true;
+            case -1:
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else if (c == QLatin1Char('|')) {
+            input = InpPipe;
+        } else if (c == QLatin1Char('(')) {
+            input = InpOp;
+        } else if (c == QLatin1Char(')')) {
+            input = InpCp;
+        } else if (c == QLatin1Char('#')) {
+            input = InpHash;
+        } else if (c == QLatin1Char('?')) {
+            input = InpQm;
+        } else if (c == QLatin1Char('*')) {
+            input = InpAst;
+        } else if (c == QLatin1Char('+')) {
+            input = InpPlus;
+        } else if (c == QLatin1Char('A')) {
+            input = InpA;
+        } else if (c == QLatin1Char('E')) {
+            input = InpE;
+        } else if (c == QLatin1Char('L')) {
+            input = InpL;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Elem:
+                parseString_s = QLatin1String("LEMENT");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Ws1:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Nam:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Ws2:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Empty:
+                parseString_s = QLatin1String("EMPTY");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Any:
+                parseString_s = QLatin1String("ANY");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Cont:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Mix:
+                parseString_s = QLatin1String("#PCDATA");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Mix2:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Mix3:
+                next();
+                break;
+            case MixN1:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case MixN2:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case MixN3:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case MixN4:
+                next();
+                break;
+            case Cp:
+                if (!parseChoiceSeq()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Cp2:
+                next();
+                break;
+            case WsD:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseElementDecl, state);
+                    return false;
+                }
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a NotationDecl [82].
+
+  Precondition: the beginning '<!' is already read and the head
+  stands on the 'N' of '<!NOTATION'
+*/
+bool QXmlSimpleReaderPrivate::parseNotationDecl()
+{
+    const signed char Init             = 0;
+    const signed char Not              = 1; // read NOTATION
+    const signed char Ws1              = 2; // eat whitespaces
+    const signed char Nam              = 3; // read Name
+    const signed char Ws2              = 4; // eat whitespaces
+    const signed char ExtID            = 5; // parse ExternalID
+    const signed char ExtIDR           = 6; // same as ExtID, but already reported
+    const signed char Ws3              = 7; // eat whitespaces
+    const signed char Done             = 8;
+
+    const signed char InpWs            = 0;
+    const signed char InpGt            = 1; // >
+    const signed char InpN             = 2; // N
+    const signed char InpUnknown       = 3;
+
+    static const signed char table[8][4] = {
+     /*  InpWs   InpGt  InpN    InpUnknown */
+        { -1,     -1,    Not,    -1     }, // Init
+        { Ws1,    -1,    -1,     -1     }, // Not
+        { -1,     -1,    Nam,    Nam    }, // Ws1
+        { Ws2,    Done,  -1,     -1     }, // Nam
+        { -1,     Done,  ExtID,  ExtID  }, // Ws2
+        { Ws3,    Done,  -1,     -1     }, // ExtID
+        { Ws3,    Done,  -1,     -1     }, // ExtIDR
+        { -1,     Done,  -1,     -1     }  // Ws3
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseNotationDecl (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case ExtID:
+                // call the handler
+                if (dtdHnd) {
+                    if (!dtdHnd->notationDecl(name(), publicId, systemId)) {
+                        reportParseError(dtdHnd->errorString());
+                        return false;
+                    }
+                }
+                state = ExtIDR;
+                break;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else if (c == QLatin1Char('N')) {
+            input = InpN;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Not:
+                parseString_s = QLatin1String("NOTATION");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+                    return false;
+                }
+                break;
+            case Ws1:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+                    return false;
+                }
+                break;
+            case Nam:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+                    return false;
+                }
+                break;
+            case Ws2:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+                    return false;
+                }
+                break;
+            case ExtID:
+            case ExtIDR:
+                parseExternalID_allowPublicID = true;
+                if (!parseExternalID()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+                    return false;
+                }
+                break;
+            case Ws3:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseNotationDecl, state);
+                    return false;
+                }
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse choice [49] or seq [50].
+
+  Precondition: the beginning '('S? is already read and the head
+  stands on the first non-whitespace character after it.
+*/
+bool QXmlSimpleReaderPrivate::parseChoiceSeq()
+{
+    const signed char Init             = 0;
+    const signed char Ws1              = 1; // eat whitespace
+    const signed char CoS              = 2; // choice or set
+    const signed char Ws2              = 3; // eat whitespace
+    const signed char More             = 4; // more cp to read
+    const signed char Name             = 5; // read name
+    const signed char Done             = 6; //
+
+    const signed char InpWs            = 0; // S
+    const signed char InpOp            = 1; // (
+    const signed char InpCp            = 2; //)
+    const signed char InpQm            = 3; // ?
+    const signed char InpAst           = 4; // *
+    const signed char InpPlus          = 5; // +
+    const signed char InpPipe          = 6; // |
+    const signed char InpComm          = 7; // ,
+    const signed char InpUnknown       = 8;
+
+    static const signed char table[6][9] = {
+     /*  InpWs   InpOp  InpCp  InpQm  InpAst  InpPlus  InpPipe  InpComm  InpUnknown */
+        { -1,     Ws1,   -1,    -1,    -1,     -1,      -1,      -1,      Name  }, // Init
+        { -1,     CoS,   -1,    -1,    -1,     -1,      -1,      -1,      CoS   }, // Ws1
+        { Ws2,    -1,    Done,  Ws2,   Ws2,    Ws2,     More,    More,    -1    }, // CS
+        { -1,     -1,    Done,  -1,    -1,     -1,      More,    More,    -1    }, // Ws2
+        { -1,     Ws1,   -1,    -1,    -1,     -1,      -1,      -1,      Name  }, // More (same as Init)
+        { Ws2,    -1,    Done,  Ws2,   Ws2,    Ws2,     More,    More,    -1    }  // Name (same as CS)
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseChoiceSeq (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('(')) {
+            input = InpOp;
+        } else if (c == QLatin1Char(')')) {
+            input = InpCp;
+        } else if (c == QLatin1Char('?')) {
+            input = InpQm;
+        } else if (c == QLatin1Char('*')) {
+            input = InpAst;
+        } else if (c == QLatin1Char('+')) {
+            input = InpPlus;
+        } else if (c == QLatin1Char('|')) {
+            input = InpPipe;
+        } else if (c == QLatin1Char(',')) {
+            input = InpComm;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Ws1:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+                    return false;
+                }
+                break;
+            case CoS:
+                if (!parseChoiceSeq()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+                    return false;
+                }
+                break;
+            case Ws2:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+                    return false;
+                }
+                break;
+            case More:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+                    return false;
+                }
+                break;
+            case Name:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseChoiceSeq, state);
+                    return false;
+                }
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a EntityDecl [70].
+
+  Precondition: the beginning '<!E' is already read and the head
+  stand on the 'N' of '<!ENTITY'
+*/
+bool QXmlSimpleReaderPrivate::parseEntityDecl()
+{
+    const signed char Init             =  0;
+    const signed char Ent              =  1; // parse "ENTITY"
+    const signed char Ws1              =  2; // white space read
+    const signed char Name             =  3; // parse name
+    const signed char Ws2              =  4; // white space read
+    const signed char EValue           =  5; // parse entity value
+    const signed char EValueR          =  6; // same as EValue, but already reported
+    const signed char ExtID            =  7; // parse ExternalID
+    const signed char Ws3              =  8; // white space read
+    const signed char Ndata            =  9; // parse "NDATA"
+    const signed char Ws4              = 10; // white space read
+    const signed char NNam             = 11; // parse name
+    const signed char NNamR            = 12; // same as NNam, but already reported
+    const signed char PEDec            = 13; // parse PEDecl
+    const signed char Ws6              = 14; // white space read
+    const signed char PENam            = 15; // parse name
+    const signed char Ws7              = 16; // white space read
+    const signed char PEVal            = 17; // parse entity value
+    const signed char PEValR           = 18; // same as PEVal, but already reported
+    const signed char PEEID            = 19; // parse ExternalID
+    const signed char PEEIDR           = 20; // same as PEEID, but already reported
+    const signed char WsE              = 21; // white space read
+    const signed char Done             = 22;
+    const signed char EDDone           = 23; // done, but also report an external, unparsed entity decl
+
+    const signed char InpWs            = 0; // white space
+    const signed char InpPer           = 1; // %
+    const signed char InpQuot          = 2; // " or '
+    const signed char InpGt            = 3; // >
+    const signed char InpN             = 4; // N
+    const signed char InpUnknown       = 5;
+
+    static const signed char table[22][6] = {
+     /*  InpWs  InpPer  InpQuot  InpGt  InpN    InpUnknown */
+        { -1,    -1,     -1,      -1,    Ent,    -1      }, // Init
+        { Ws1,   -1,     -1,      -1,    -1,     -1      }, // Ent
+        { -1,    PEDec,  -1,      -1,    Name,   Name    }, // Ws1
+        { Ws2,   -1,     -1,      -1,    -1,     -1      }, // Name
+        { -1,    -1,     EValue,  -1,    -1,     ExtID   }, // Ws2
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // EValue
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // EValueR
+        { Ws3,   -1,     -1,      EDDone,-1,     -1      }, // ExtID
+        { -1,    -1,     -1,      EDDone,Ndata,  -1      }, // Ws3
+        { Ws4,   -1,     -1,      -1,    -1,     -1      }, // Ndata
+        { -1,    -1,     -1,      -1,    NNam,   NNam    }, // Ws4
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // NNam
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // NNamR
+        { Ws6,   -1,     -1,      -1,    -1,     -1      }, // PEDec
+        { -1,    -1,     -1,      -1,    PENam,  PENam   }, // Ws6
+        { Ws7,   -1,     -1,      -1,    -1,     -1      }, // PENam
+        { -1,    -1,     PEVal,   -1,    -1,     PEEID   }, // Ws7
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEVal
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEValR
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEEID
+        { WsE,   -1,     -1,      Done,  -1,     -1      }, // PEEIDR
+        { -1,    -1,     -1,      Done,  -1,     -1      }  // WsE
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseEntityDecl (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case EValue:
+                if ( !entityExist(name())) {
+                    entities.insert(name(), string());
+                    if (declHnd) {
+                        if (!declHnd->internalEntityDecl(name(), string())) {
+                            reportParseError(declHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+                state = EValueR;
+                break;
+            case NNam:
+                if ( !entityExist(name())) {
+                    externEntities.insert(name(), QXmlSimpleReaderPrivate::ExternEntity(publicId, systemId, ref()));
+                    if (dtdHnd) {
+                        if (!dtdHnd->unparsedEntityDecl(name(), publicId, systemId, ref())) {
+                            reportParseError(declHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+                state = NNamR;
+                break;
+            case PEVal:
+                if ( !entityExist(name())) {
+                    parameterEntities.insert(name(), string());
+                    if (declHnd) {
+                        if (!declHnd->internalEntityDecl(QLatin1Char('%') + name(), string())) {
+                            reportParseError(declHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+                state = PEValR;
+                break;
+            case PEEID:
+                if ( !entityExist(name())) {
+                    externParameterEntities.insert(name(), QXmlSimpleReaderPrivate::ExternParameterEntity(publicId, systemId));
+                    if (declHnd) {
+                        if (!declHnd->externalEntityDecl(QLatin1Char('%') + name(), publicId, systemId)) {
+                            reportParseError(declHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+                state = PEEIDR;
+                break;
+            case EDDone:
+                if ( !entityExist(name())) {
+                    externEntities.insert(name(), QXmlSimpleReaderPrivate::ExternEntity(publicId, systemId, QString()));
+                    if (declHnd) {
+                        if (!declHnd->externalEntityDecl(name(), publicId, systemId)) {
+                            reportParseError(declHnd->errorString());
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+            return false;
+        }
+        if (is_S(c)) {
+            input = InpWs;
+        } else if (c == QLatin1Char('%')) {
+            input = InpPer;
+        } else if (c == QLatin1Char('"') || c == QLatin1Char('\'')) {
+            input = InpQuot;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else if (c == QLatin1Char('N')) {
+            input = InpN;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Ent:
+                parseString_s = QLatin1String("NTITY");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case Ws1:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case Name:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case Ws2:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case EValue:
+            case EValueR:
+                if (!parseEntityValue()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case ExtID:
+                parseExternalID_allowPublicID = false;
+                if (!parseExternalID()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case Ws3:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case Ndata:
+                parseString_s = QLatin1String("NDATA");
+                if (!parseString()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case Ws4:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case NNam:
+            case NNamR:
+                parseName_useRef = true;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case PEDec:
+                next();
+                break;
+            case Ws6:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case PENam:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case Ws7:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case PEVal:
+            case PEValR:
+                if (!parseEntityValue()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case PEEID:
+            case PEEIDR:
+                parseExternalID_allowPublicID = false;
+                if (!parseExternalID()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case WsE:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityDecl, state);
+                    return false;
+                }
+                break;
+            case EDDone:
+                next();
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a EntityValue [9]
+*/
+bool QXmlSimpleReaderPrivate::parseEntityValue()
+{
+    const signed char Init             = 0;
+    const signed char Dq               = 1; // EntityValue is double quoted
+    const signed char DqC              = 2; // signed character
+    const signed char DqPER            = 3; // PERefence
+    const signed char DqRef            = 4; // Reference
+    const signed char Sq               = 5; // EntityValue is double quoted
+    const signed char SqC              = 6; // signed character
+    const signed char SqPER            = 7; // PERefence
+    const signed char SqRef            = 8; // Reference
+    const signed char Done             = 9;
+
+    const signed char InpDq            = 0; // "
+    const signed char InpSq            = 1; // '
+    const signed char InpAmp           = 2; // &
+    const signed char InpPer           = 3; // %
+    const signed char InpUnknown       = 4;
+
+    static const signed char table[9][5] = {
+     /*  InpDq  InpSq  InpAmp  InpPer  InpUnknown */
+        { Dq,    Sq,    -1,     -1,     -1    }, // Init
+        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // Dq
+        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqC
+        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqPER
+        { Done,  DqC,   DqRef,  DqPER,  DqC   }, // DqRef
+        { SqC,   Done,  SqRef,  SqPER,  SqC   }, // Sq
+        { SqC,   Done,  SqRef,  SqPER,  SqC   }, // SqC
+        { SqC,   Done,  SqRef,  SqPER,  SqC   }, // SqPER
+        { SqC,   Done,  SqRef,  SqPER,  SqC   }  // SqRef
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseEntityValue (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+            return false;
+        }
+        if        (c == QLatin1Char('"')) {
+            input = InpDq;
+        } else if (c == QLatin1Char('\'')) {
+            input = InpSq;
+        } else if (c == QLatin1Char('&')) {
+            input = InpAmp;
+        } else if (c == QLatin1Char('%')) {
+            input = InpPer;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Dq:
+            case Sq:
+                stringClear();
+                next();
+                break;
+            case DqC:
+            case SqC:
+                stringAddC();
+                next();
+                break;
+            case DqPER:
+            case SqPER:
+                parsePEReference_context = InEntityValue;
+                if (!parsePEReference()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+                    return false;
+                }
+                break;
+            case DqRef:
+            case SqRef:
+                parseReference_context = InEntityValue;
+                if (!parseReference()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseEntityValue, state);
+                    return false;
+                }
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a comment [15].
+
+  Precondition: the beginning '<!' of the comment is already read and the head
+  stands on the first '-' of '<!--'.
+
+  If this funktion was successful, the head-position is on the first
+  character after the comment.
+*/
+bool QXmlSimpleReaderPrivate::parseComment()
+{
+    const signed char Init             = 0;
+    const signed char Dash1            = 1; // the first dash was read
+    const signed char Dash2            = 2; // the second dash was read
+    const signed char Com              = 3; // read comment
+    const signed char Com2             = 4; // read comment (help state)
+    const signed char ComE             = 5; // finished reading comment
+    const signed char Done             = 6;
+
+    const signed char InpDash          = 0; // -
+    const signed char InpGt            = 1; // >
+    const signed char InpUnknown       = 2;
+
+    static const signed char table[6][3] = {
+     /*  InpDash  InpGt  InpUnknown */
+        { Dash1,   -1,    -1  }, // Init
+        { Dash2,   -1,    -1  }, // Dash1
+        { Com2,    Com,   Com }, // Dash2
+        { Com2,    Com,   Com }, // Com
+        { ComE,    Com,   Com }, // Com2
+        { -1,      Done,  -1  }  // ComE
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseComment (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseComment, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Dash2:
+                stringClear();
+                break;
+            case Com2:
+                // if next character is not a dash than don't skip it
+                if (!atEnd() && c != QLatin1Char('-'))
+                    stringAddC(QLatin1Char('-'));
+                break;
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_ERRORPARSINGCOMMENT));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseComment, state);
+            return false;
+        }
+        if (c == QLatin1Char('-')) {
+            input = InpDash;
+        } else if (c == QLatin1Char('>')) {
+            input = InpGt;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case Dash1:
+                next();
+                break;
+            case Dash2:
+                next();
+                break;
+            case Com:
+                stringAddC();
+                next();
+                break;
+            case Com2:
+                next();
+                break;
+            case ComE:
+                next();
+                break;
+            case Done:
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+    Parse an Attribute [41].
+
+    Precondition: the head stands on the first character of the name
+    of the attribute (i.e. all whitespaces are already parsed).
+
+    The head stand on the next character after the end quotes. The
+    variable name contains the name of the attribute and the variable
+    string contains the value of the attribute.
+*/
+bool QXmlSimpleReaderPrivate::parseAttribute()
+{
+    const int Init             = 0;
+    const int PName            = 1; // parse name
+    const int Ws               = 2; // eat ws
+    const int Eq               = 3; // the '=' was read
+    const int Quotes           = 4; // " or ' were read
+
+    const int InpNameBe        = 0;
+    const int InpEq            = 1; // =
+    const int InpDq            = 2; // "
+    const int InpSq            = 3; // '
+    const int InpUnknown       = 4;
+
+    static const int table[4][5] = {
+     /*  InpNameBe  InpEq  InpDq    InpSq    InpUnknown */
+        { PName,     -1,    -1,      -1,      -1    }, // Init
+        { -1,        Eq,    -1,      -1,      Ws    }, // PName
+        { -1,        Eq,    -1,      -1,      -1    }, // Ws
+        { -1,        -1,    Quotes,  Quotes,  -1    }  // Eq
+    };
+    int state;
+    int input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseAttribute (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Quotes:
+                // Done
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseAttribute, state);
+            return false;
+        }
+        if (determineNameChar(c) == NameBeginning) {
+            input = InpNameBe;
+        } else if (c == QLatin1Char('=')) {
+            input = InpEq;
+        } else if (c == QLatin1Char('"')) {
+            input = InpDq;
+        } else if (c == QLatin1Char('\'')) {
+            input = InpSq;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case PName:
+                parseName_useRef = false;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+                    return false;
+                }
+                break;
+            case Ws:
+                if (!eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+                    return false;
+                }
+                break;
+            case Eq:
+                if (!next_eat_ws()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+                    return false;
+                }
+                break;
+            case Quotes:
+                if (!parseAttValue()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseAttribute, state);
+                    return false;
+                }
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a Name [5] and store the name in name or ref (if useRef is true).
+*/
+bool QXmlSimpleReaderPrivate::parseName()
+{
+    const int Init             = 0;
+    const int Name1            = 1; // parse first character of the name
+    const int Name             = 2; // parse name
+    const int Done             = 3;
+
+    static const int table[3][3] = {
+     /*  InpNameBe  InpNameCh  InpUnknown */
+        { Name1,     -1,        -1    }, // Init
+        { Name,      Name,      Done  }, // Name1
+        { Name,      Name,      Done  }  // Name
+    };
+    int state;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseName (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseName, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseName, state);
+            return false;
+        }
+
+        // we can safely do the (int) cast thanks to the Q_ASSERTs earlier in this function
+        state = table[state][(int)fastDetermineNameChar(c)];
+
+        switch (state) {
+            case Name1:
+                if (parseName_useRef) {
+                    refClear();
+                    refAddC();
+                } else {
+                    nameClear();
+                    nameAddC();
+                }
+                next();
+                break;
+            case Name:
+                if (parseName_useRef) {
+                    refAddC();
+                } else {
+                    nameAddC();
+                }
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a Nmtoken [7] and store the name in name.
+*/
+bool QXmlSimpleReaderPrivate::parseNmtoken()
+{
+    const signed char Init             = 0;
+    const signed char NameF            = 1;
+    const signed char Name             = 2;
+    const signed char Done             = 3;
+
+    const signed char InpNameCh        = 0; // NameChar without InpNameBe
+    const signed char InpUnknown       = 1;
+
+    static const signed char table[3][2] = {
+     /*  InpNameCh  InpUnknown */
+        { NameF,     -1    }, // Init
+        { Name,      Done  }, // NameF
+        { Name,      Done  }  // Name
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseNmtoken (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseNmtoken, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case Done:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_LETTEREXPECTED));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseNmtoken, state);
+            return false;
+        }
+        if (determineNameChar(c) == NotName) {
+            input = InpUnknown;
+        } else {
+            input = InpNameCh;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case NameF:
+                nameClear();
+                nameAddC();
+                next();
+                break;
+            case Name:
+                nameAddC();
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Parse a Reference [67].
+
+  parseReference_charDataRead is set to true if the reference must not be
+  parsed. The character(s) which the reference mapped to are appended to
+  string. The head stands on the first character after the reference.
+
+  parseReference_charDataRead is set to false if the reference must be parsed.
+  The charachter(s) which the reference mapped to are inserted at the reference
+  position. The head stands on the first character of the replacement).
+*/
+bool QXmlSimpleReaderPrivate::parseReference()
+{
+    // temporary variables (only used in very local context, so they don't
+    // interfere with incremental parsing)
+    uint tmp;
+    bool ok;
+
+    const signed char Init             =  0;
+    const signed char SRef             =  1; // start of a reference
+    const signed char ChRef            =  2; // parse CharRef
+    const signed char ChDec            =  3; // parse CharRef decimal
+    const signed char ChHexS           =  4; // start CharRef hexadecimal
+    const signed char ChHex            =  5; // parse CharRef hexadecimal
+    const signed char Name             =  6; // parse name
+    const signed char DoneD            =  7; // done CharRef decimal
+    const signed char DoneH            =  8; // done CharRef hexadecimal
+    const signed char DoneN            =  9; // done EntityRef
+
+    const signed char InpAmp           = 0; // &
+    const signed char InpSemi          = 1; // ;
+    const signed char InpHash          = 2; // #
+    const signed char InpX             = 3; // x
+    const signed char InpNum           = 4; // 0-9
+    const signed char InpHex           = 5; // a-f A-F
+    const signed char InpUnknown       = 6;
+
+    static const signed char table[8][7] = {
+     /*  InpAmp  InpSemi  InpHash  InpX     InpNum  InpHex  InpUnknown */
+        { SRef,   -1,      -1,      -1,      -1,     -1,     -1    }, // Init
+        { -1,     -1,      ChRef,   Name,    Name,   Name,   Name  }, // SRef
+        { -1,     -1,      -1,      ChHexS,  ChDec,  -1,     -1    }, // ChRef
+        { -1,     DoneD,   -1,      -1,      ChDec,  -1,     -1    }, // ChDec
+        { -1,     -1,      -1,      -1,      ChHex,  ChHex,  -1    }, // ChHexS
+        { -1,     DoneH,   -1,      -1,      ChHex,  ChHex,  -1    }, // ChHex
+        { -1,     DoneN,   -1,      -1,      -1,     -1,     -1    }  // Name
+    };
+    signed char state;
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        parseReference_charDataRead = false;
+        state = Init;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseReference (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseReference, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        switch (state) {
+            case DoneD:
+                return true;
+            case DoneH:
+                return true;
+            case DoneN:
+                return true;
+            case -1:
+                // Error
+                reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
+                return false;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseReference, state);
+            return false;
+        }
+        if        (c.row()) {
+            input = InpUnknown;
+        } else if (c.cell() == '&') {
+            input = InpAmp;
+        } else if (c.cell() == ';') {
+            input = InpSemi;
+        } else if (c.cell() == '#') {
+            input = InpHash;
+        } else if (c.cell() == 'x') {
+            input = InpX;
+        } else if ('0' <= c.cell() && c.cell() <= '9') {
+            input = InpNum;
+        } else if ('a' <= c.cell() && c.cell() <= 'f') {
+            input = InpHex;
+        } else if ('A' <= c.cell() && c.cell() <= 'F') {
+            input = InpHex;
+        } else {
+            input = InpUnknown;
+        }
+        state = table[state][input];
+
+        switch (state) {
+            case SRef:
+                refClear();
+                next();
+                break;
+            case ChRef:
+                next();
+                break;
+            case ChDec:
+                refAddC();
+                next();
+                break;
+            case ChHexS:
+                next();
+                break;
+            case ChHex:
+                refAddC();
+                next();
+                break;
+            case Name:
+                // read the name into the ref
+                parseName_useRef = true;
+                if (!parseName()) {
+                    parseFailed(&QXmlSimpleReaderPrivate::parseReference, state);
+                    return false;
+                }
+                break;
+            case DoneD:
+                tmp = ref().toUInt(&ok, 10);
+                if (ok) {
+                    stringAddC(QChar(tmp));
+                } else {
+                    reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
+                    return false;
+                }
+                parseReference_charDataRead = true;
+                next();
+                break;
+            case DoneH:
+                tmp = ref().toUInt(&ok, 16);
+                if (ok) {
+                    stringAddC(QChar(tmp));
+                } else {
+                    reportParseError(QLatin1String(XMLERR_ERRORPARSINGREFERENCE));
+                    return false;
+                }
+                parseReference_charDataRead = true;
+                next();
+                break;
+            case DoneN:
+                if (!processReference())
+                    return false;
+                next();
+                break;
+        }
+    }
+    return false;
+}
+
+/*
+  Helper function for parseReference()
+*/
+bool QXmlSimpleReaderPrivate::processReference()
+{
+    QString reference = ref();
+    if (reference == QLatin1String("amp")) {
+        if (parseReference_context == InEntityValue) {
+            // Bypassed
+            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('a')); stringAddC(QLatin1Char('m')); stringAddC(QLatin1Char('p')); stringAddC(QLatin1Char(';'));
+        } else {
+            // Included or Included in literal
+            stringAddC(QLatin1Char('&'));
+        }
+        parseReference_charDataRead = true;
+    } else if (reference == QLatin1String("lt")) {
+        if (parseReference_context == InEntityValue) {
+            // Bypassed
+            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('l')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
+        } else {
+            // Included or Included in literal
+            stringAddC(QLatin1Char('<'));
+        }
+        parseReference_charDataRead = true;
+    } else if (reference == QLatin1String("gt")) {
+        if (parseReference_context == InEntityValue) {
+            // Bypassed
+            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('g')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
+        } else {
+            // Included or Included in literal
+            stringAddC(QLatin1Char('>'));
+        }
+        parseReference_charDataRead = true;
+    } else if (reference == QLatin1String("apos")) {
+        if (parseReference_context == InEntityValue) {
+            // Bypassed
+            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('a')); stringAddC(QLatin1Char('p')); stringAddC(QLatin1Char('o')); stringAddC(QLatin1Char('s')); stringAddC(QLatin1Char(';'));
+        } else {
+            // Included or Included in literal
+            stringAddC(QLatin1Char('\''));
+        }
+        parseReference_charDataRead = true;
+    } else if (reference == QLatin1String("quot")) {
+        if (parseReference_context == InEntityValue) {
+            // Bypassed
+            stringAddC(QLatin1Char('&')); stringAddC(QLatin1Char('q')); stringAddC(QLatin1Char('u')); stringAddC(QLatin1Char('o')); stringAddC(QLatin1Char('t')); stringAddC(QLatin1Char(';'));
+        } else {
+            // Included or Included in literal
+            stringAddC(QLatin1Char('"'));
+        }
+        parseReference_charDataRead = true;
+    } else {
+        QMap<QString,QString>::Iterator it;
+        it = entities.find(reference);
+        if (it != entities.end()) {
+            // "Internal General"
+            switch (parseReference_context) {
+                case InContent:
+                    // Included
+                    if (!insertXmlRef(*it, reference, false))
+                        return false;
+                    parseReference_charDataRead = false;
+                    break;
+                case InAttributeValue:
+                    // Included in literal
+                    if (!insertXmlRef(*it, reference, true))
+                        return false;
+                    parseReference_charDataRead = false;
+                    break;
+                case InEntityValue:
+                    {
+                        // Bypassed
+                        stringAddC(QLatin1Char('&'));
+                        for (int i=0; i<(int)reference.length(); i++) {
+                            stringAddC(reference[i]);
+                        }
+                        stringAddC(QLatin1Char(';'));
+                        parseReference_charDataRead = true;
+                    }
+                    break;
+                case InDTD:
+                    // Forbidden
+                    parseReference_charDataRead = false;
+                    reportParseError(QLatin1String(XMLERR_INTERNALGENERALENTITYINDTD));
+                    return false;
+            }
+        } else {
+            QMap<QString,QXmlSimpleReaderPrivate::ExternEntity>::Iterator itExtern;
+            itExtern = externEntities.find(reference);
+            if (itExtern == externEntities.end()) {
+                // entity not declared
+                // ### check this case for conformance
+                if (parseReference_context == InEntityValue) {
+                    // Bypassed
+                    stringAddC(QLatin1Char('&'));
+                    for (int i=0; i<(int)reference.length(); i++) {
+                        stringAddC(reference[i]);
+                    }
+                    stringAddC(QLatin1Char(';'));
+                    parseReference_charDataRead = true;
+                } else {
+                    // if we have some char data read, report it now
+                    if (parseReference_context == InContent) {
+                        if (contentCharDataRead) {
+                            if (reportWhitespaceCharData || !string().simplified().isEmpty()) {
+                                if (contentHnd != 0 && !contentHnd->characters(string())) {
+                                    reportParseError(contentHnd->errorString());
+                                    return false;
+                                }
+                            }
+                            stringClear();
+                            contentCharDataRead = false;
+                        }
+                    }
+
+                    if (contentHnd) {
+                        qt_xml_skipped_entity_in_content = parseReference_context == InContent;
+                        if (!contentHnd->skippedEntity(reference)) {
+                            qt_xml_skipped_entity_in_content = false;
+                            reportParseError(contentHnd->errorString());
+                            return false; // error
+                        }
+                        qt_xml_skipped_entity_in_content = false;
+                    }
+                }
+            } else if ((*itExtern).notation.isNull()) {
+                // "External Parsed General"
+                switch (parseReference_context) {
+                    case InContent:
+                        {
+                            // Included if validating
+                            bool skipIt = true;
+                            if (entityRes) {
+                                QXmlInputSource *ret = 0;
+                                if (!entityRes->resolveEntity((*itExtern).publicId, (*itExtern).systemId, ret)) {
+                                    delete ret;
+                                    reportParseError(entityRes->errorString());
+                                    return false;
+                                }
+                                if (ret) {
+                                    QString xmlRefString = ret->data();
+                                    delete ret;
+                                    if (!stripTextDecl(xmlRefString)) {
+                                        reportParseError(QLatin1String(XMLERR_ERRORINTEXTDECL));
+                                        return false;
+                                    }
+                                    if (!insertXmlRef(xmlRefString, reference, false))
+                                        return false;
+                                    skipIt = false;
+                                }
+                            }
+                            if (skipIt && contentHnd) {
+                                qt_xml_skipped_entity_in_content = true;
+                                if (!contentHnd->skippedEntity(reference)) {
+                                    qt_xml_skipped_entity_in_content = false;
+                                    reportParseError(contentHnd->errorString());
+                                    return false; // error
+                                }
+                                qt_xml_skipped_entity_in_content = false;
+                            }
+                            parseReference_charDataRead = false;
+                        } break;
+                    case InAttributeValue:
+                        // Forbidden
+                        parseReference_charDataRead = false;
+                        reportParseError(QLatin1String(XMLERR_EXTERNALGENERALENTITYINAV));
+                        return false;
+                    case InEntityValue:
+                        {
+                            // Bypassed
+                            stringAddC(QLatin1Char('&'));
+                            for (int i=0; i<(int)reference.length(); i++) {
+                                stringAddC(reference[i]);
+                            }
+                            stringAddC(QLatin1Char(';'));
+                            parseReference_charDataRead = true;
+                        }
+                        break;
+                    case InDTD:
+                        // Forbidden
+                        parseReference_charDataRead = false;
+                        reportParseError(QLatin1String(XMLERR_EXTERNALGENERALENTITYINDTD));
+                        return false;
+                }
+            } else {
+                // "Unparsed"
+                // ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway)
+                // Forbidden
+                parseReference_charDataRead = false;
+                reportParseError(QLatin1String(XMLERR_UNPARSEDENTITYREFERENCE));
+                return false; // error
+            }
+        }
+    }
+    return true; // no error
+}
+
+
+/*
+  Parses over a simple string.
+
+  After the string was successfully parsed, the head is on the first
+  character after the string.
+*/
+bool QXmlSimpleReaderPrivate::parseString()
+{
+    const signed char InpCharExpected  = 0; // the character that was expected
+    const signed char InpUnknown       = 1;
+
+    signed char state; // state in this function is the position in the string s
+    signed char input;
+
+    if (parseStack==0 || parseStack->isEmpty()) {
+        Done = parseString_s.length();
+        state = 0;
+    } else {
+        state = parseStack->pop().state;
+#if defined(QT_QXML_DEBUG)
+        qDebug("QXmlSimpleReader: parseString (cont) in state %d", state);
+#endif
+        if (!parseStack->isEmpty()) {
+            ParseFunction function = parseStack->top().function;
+            if (function == &QXmlSimpleReaderPrivate::eat_ws) {
+                parseStack->pop();
+#if defined(QT_QXML_DEBUG)
+                qDebug("QXmlSimpleReader: eat_ws (cont)");
+#endif
+            }
+            if (!(this->*function)()) {
+                parseFailed(&QXmlSimpleReaderPrivate::parseString, state);
+                return false;
+            }
+        }
+    }
+
+    for (;;) {
+        if (state == Done) {
+            return true;
+        }
+
+        if (atEnd()) {
+            unexpectedEof(&QXmlSimpleReaderPrivate::parseString, state);
+            return false;
+        }
+        if (c == parseString_s[(int)state]) {
+            input = InpCharExpected;
+        } else {
+            input = InpUnknown;
+        }
+        if (input == InpCharExpected) {
+            state++;
+        } else {
+            // Error
+            reportParseError(QLatin1String(XMLERR_UNEXPECTEDCHARACTER));
+            return false;
+        }
+
+        next();
+    }
+    return false;
+}
+
+/*
+  This private function inserts and reports an entity substitution. The
+  substituted string is \a data and the name of the entity reference is \a
+  name. If \a inLiteral is true, the entity is IncludedInLiteral (i.e., " and '
+  must be quoted. Otherwise they are not quoted.
+
+  This function returns false on error.
+*/
+bool QXmlSimpleReaderPrivate::insertXmlRef(const QString &data, const QString &name, bool inLiteral)
+{
+    if (inLiteral) {
+        QString tmp = data;
+        xmlRefStack.push(XmlRef(name, tmp.replace(QLatin1Char('\"'),
+                            QLatin1String("&quot;")).replace(QLatin1Char('\''), QLatin1String("&apos;"))));
+    } else {
+        xmlRefStack.push(XmlRef(name, data));
+    }
+    int n = qMax(parameterEntities.count(), entities.count());
+    if (xmlRefStack.count() > n+1) {
+        // recursive entities
+        reportParseError(QLatin1String(XMLERR_RECURSIVEENTITIES));
+        return false;
+    }
+    if (reportEntities && lexicalHnd) {
+        if (!lexicalHnd->startEntity(name)) {
+            reportParseError(lexicalHnd->errorString());
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+  This private function moves the cursor to the next character.
+*/
+void QXmlSimpleReaderPrivate::next()
+{
+    int count = xmlRefStack.size();
+    while (count != 0) {
+        if (xmlRefStack.top().isEmpty()) {
+            xmlRefStack.pop_back();
+            count--;
+        } else {
+            c = xmlRefStack.top().next();
+            return;
+        }
+    }
+
+    // the following could be written nicer, but since it is a time-critical
+    // function, rather optimize for speed
+    ushort uc = c.unicode();
+    c = inputSource->next();
+    // If we are not incremental parsing, we just skip over EndOfData chars to give the
+    // parser an uninterrupted stream of document chars.
+    if (c == QXmlInputSource::EndOfData && parseStack == 0)
+        c = inputSource->next();
+    if (uc == '\n') {
+        lineNr++;
+        columnNr = -1;
+    } else if (uc == '\r') {
+        if (c != QLatin1Char('\n')) {
+            lineNr++;
+            columnNr = -1;
+        }
+    }
+    ++columnNr;
+}
+
+/*
+  This private function moves the cursor to the next non-whitespace character.
+  This function does not move the cursor if the actual cursor position is a
+  non-whitespace charcter.
+
+  Returns false when you use incremental parsing and this function reaches EOF
+  with reading only whitespace characters. In this case it also poplulates the
+  parseStack with useful information. In all other cases, this function returns
+  true.
+*/
+bool QXmlSimpleReaderPrivate::eat_ws()
+{
+    while (!atEnd()) {
+        if (!is_S(c)) {
+            return true;
+        }
+        next();
+    }
+    if (parseStack != 0) {
+        unexpectedEof(&QXmlSimpleReaderPrivate::eat_ws, 0);
+        return false;
+    }
+    return true;
+}
+
+bool QXmlSimpleReaderPrivate::next_eat_ws()
+{
+    next();
+    return eat_ws();
+}
+
+
+/*
+  This private function initializes the reader. \a i is the input source to
+  read the data from.
+*/
+void QXmlSimpleReaderPrivate::init(const QXmlInputSource *i)
+{
+    lineNr = 0;
+    columnNr = -1;
+    inputSource = const_cast<QXmlInputSource *>(i);
+    initData();
+
+    externParameterEntities.clear();
+    parameterEntities.clear();
+    externEntities.clear();
+    entities.clear();
+
+    tags.clear();
+
+    doctype.clear();
+    xmlVersion.clear();
+    encoding.clear();
+    standalone = QXmlSimpleReaderPrivate::Unknown;
+    error.clear();
+}
+
+/*
+  This private function initializes the XML data related variables. Especially,
+  it reads the data from the input source.
+*/
+void QXmlSimpleReaderPrivate::initData()
+{
+    c = QXmlInputSource::EndOfData;
+    xmlRefStack.clear();
+    next();
+}
+
+/*
+  Returns true if a entity with the name \a e exists,
+  otherwise returns false.
+*/
+bool QXmlSimpleReaderPrivate::entityExist(const QString& e) const
+{
+    if ( parameterEntities.find(e) == parameterEntities.end() &&
+          externParameterEntities.find(e) == externParameterEntities.end() &&
+          externEntities.find(e) == externEntities.end() &&
+          entities.find(e) == entities.end()) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+void QXmlSimpleReaderPrivate::reportParseError(const QString& error)
+{
+    this->error = error;
+    if (errorHnd) {
+        if (this->error.isNull()) {
+            const QXmlParseException ex(QLatin1String(XMLERR_OK), columnNr+1, lineNr+1,
+                                        thisPublicId, thisSystemId);
+            errorHnd->fatalError(ex);
+        } else {
+            const QXmlParseException ex(this->error, columnNr+1, lineNr+1,
+                                        thisPublicId, thisSystemId);
+            errorHnd->fatalError(ex);
+        }
+    }
+}
+
+/*
+  This private function is called when a parsing function encounters an
+  unexpected EOF. It decides what to do (depending on incremental parsing or
+  not). \a where is a pointer to the function where the error occurred and \a
+  state is the parsing state in this function.
+*/
+void QXmlSimpleReaderPrivate::unexpectedEof(ParseFunction where, int state)
+{
+    if (parseStack == 0) {
+        reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
+    } else {
+        if (c == QXmlInputSource::EndOfDocument) {
+            reportParseError(QLatin1String(XMLERR_UNEXPECTEDEOF));
+        } else {
+            pushParseState(where, state);
+        }
+    }
+}
+
+/*
+  This private function is called when a parse...() function returned false. It
+  determines if there was an error or if incremental parsing simply went out of
+  data and does the right thing for the case. \a where is a pointer to the
+  function where the error occurred and \a state is the parsing state in this
+  function.
+*/
+void QXmlSimpleReaderPrivate::parseFailed(ParseFunction where, int state)
+{
+    if (parseStack!=0 && error.isNull()) {
+        pushParseState(where, state);
+    }
+}
+
+/*
+  This private function pushes the function pointer \a function and state \a
+  state to the parse stack. This is used when you are doing an incremental
+  parsing and reach the end of file too early.
+
+  Only call this function when d->parseStack!=0.
+*/
+void QXmlSimpleReaderPrivate::pushParseState(ParseFunction function, int state)
+{
+    QXmlSimpleReaderPrivate::ParseState ps;
+    ps.function = function;
+    ps.state = state;
+    parseStack->push(ps);
+}
+
+inline static void updateValue(QString &value, const QChar *array, int &arrayPos, int &valueLen)
+{
+    value.resize(valueLen + arrayPos);
+    memcpy(value.data() + valueLen, array, arrayPos * sizeof(QChar));
+    valueLen += arrayPos;
+    arrayPos = 0;
+}
+
+// use buffers instead of QString::operator+= when single characters are read
+const QString& QXmlSimpleReaderPrivate::string()
+{
+    updateValue(stringValue, stringArray, stringArrayPos, stringValueLen);
+    return stringValue;
+}
+const QString& QXmlSimpleReaderPrivate::name()
+{
+    updateValue(nameValue, nameArray, nameArrayPos, nameValueLen);
+    return nameValue;
+}
+const QString& QXmlSimpleReaderPrivate::ref()
+{
+    updateValue(refValue, refArray, refArrayPos, refValueLen);
+    return refValue;
+}
+
+void QXmlSimpleReaderPrivate::stringAddC(QChar ch)
+{
+    if (stringArrayPos == 256)
+        updateValue(stringValue, stringArray, stringArrayPos, stringValueLen);
+    stringArray[stringArrayPos++] = ch;
+}
+void QXmlSimpleReaderPrivate::nameAddC(QChar ch)
+{
+    if (nameArrayPos == 256)
+        updateValue(nameValue, nameArray, nameArrayPos, nameValueLen);
+    nameArray[nameArrayPos++] = ch;
+}
+void QXmlSimpleReaderPrivate::refAddC(QChar ch)
+{
+    if (refArrayPos == 256)
+        updateValue(refValue, refArray, refArrayPos, refValueLen);
+    refArray[refArrayPos++] = ch;
+}
+QT_END_NAMESPACE
diff --git a/src/xml/sax/qxml.h b/src/xml/sax/qxml.h
new file mode 100644
index 0000000000..1cd04353a3
--- /dev/null
+++ b/src/xml/sax/qxml.h
@@ -0,0 +1,427 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtXml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QXML_H
+#define QXML_H
+
+#include <QtCore/qtextstream.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qscopedpointer.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Xml)
+
+class QXmlNamespaceSupport;
+class QXmlAttributes;
+class QXmlContentHandler;
+class QXmlDefaultHandler;
+class QXmlDTDHandler;
+class QXmlEntityResolver;
+class QXmlErrorHandler;
+class QXmlLexicalHandler;
+class QXmlDeclHandler;
+class QXmlInputSource;
+class QXmlLocator;
+class QXmlNamespaceSupport;
+class QXmlParseException;
+
+class QXmlReader;
+class QXmlSimpleReader;
+
+class QXmlSimpleReaderPrivate;
+class QXmlNamespaceSupportPrivate;
+class QXmlAttributesPrivate;
+class QXmlInputSourcePrivate;
+class QXmlParseExceptionPrivate;
+class QXmlLocatorPrivate;
+class QXmlDefaultHandlerPrivate;
+
+
+//
+// SAX Namespace Support
+//
+
+class Q_XML_EXPORT QXmlNamespaceSupport
+{
+public:
+    QXmlNamespaceSupport();
+    ~QXmlNamespaceSupport();
+
+    void setPrefix(const QString&, const QString&);
+
+    QString prefix(const QString&) const;
+    QString uri(const QString&) const;
+    void splitName(const QString&, QString&, QString&) const;
+    void processName(const QString&, bool, QString&, QString&) const;
+    QStringList prefixes() const;
+    QStringList prefixes(const QString&) const;
+
+    void pushContext();
+    void popContext();
+    void reset();
+
+private:
+    QXmlNamespaceSupportPrivate *d;
+
+    friend class QXmlSimpleReaderPrivate;
+    Q_DISABLE_COPY(QXmlNamespaceSupport)
+};
+
+
+//
+// SAX Attributes
+//
+
+class Q_XML_EXPORT QXmlAttributes
+{
+public:
+    QXmlAttributes() {}
+    virtual ~QXmlAttributes() {}
+
+    int index(const QString& qName) const;
+    int index(const QLatin1String& qName) const;
+    int index(const QString& uri, const QString& localPart) const;
+    int length() const;
+    int count() const;
+    QString localName(int index) const;
+    QString qName(int index) const;
+    QString uri(int index) const;
+    QString type(int index) const;
+    QString type(const QString& qName) const;
+    QString type(const QString& uri, const QString& localName) const;
+    QString value(int index) const;
+    QString value(const QString& qName) const;
+    QString value(const QLatin1String& qName) const;
+    QString value(const QString& uri, const QString& localName) const;
+
+    void clear();
+    void append(const QString &qName, const QString &uri, const QString &localPart, const QString &value);
+
+private:
+    struct Attribute {
+        QString qname, uri, localname, value;
+    };
+    typedef QList<Attribute> AttributeList;
+    AttributeList attList;
+
+    QXmlAttributesPrivate *d;
+};
+
+//
+// SAX Input Source
+//
+
+class Q_XML_EXPORT QXmlInputSource
+{
+public:
+    QXmlInputSource();
+    QXmlInputSource(QIODevice *dev);
+    virtual ~QXmlInputSource();
+
+    virtual void setData(const QString& dat);
+    virtual void setData(const QByteArray& dat);
+    virtual void fetchData();
+    virtual QString data() const;
+    virtual QChar next();
+    virtual void reset();
+
+    static const ushort EndOfData;
+    static const ushort EndOfDocument;
+
+#ifdef QT3_SUPPORT
+    QT3_SUPPORT_CONSTRUCTOR QXmlInputSource(QFile& file);
+    QT3_SUPPORT_CONSTRUCTOR QXmlInputSource(QTextStream& stream);
+#endif
+
+protected:
+    virtual QString fromRawData(const QByteArray &data, bool beginning = false);
+
+private:
+    void init();
+    QXmlInputSourcePrivate *d;
+};
+
+//
+// SAX Exception Classes
+//
+
+class Q_XML_EXPORT QXmlParseException
+{
+public:
+    explicit QXmlParseException(const QString &name = QString(), int c = -1, int l = -1,
+                                const QString &p = QString(), const QString &s = QString());
+    QXmlParseException(const QXmlParseException &other);
+    ~QXmlParseException();
+
+    int columnNumber() const;
+    int lineNumber() const;
+    QString publicId() const;
+    QString systemId() const;
+    QString message() const;
+
+private:
+    QScopedPointer<QXmlParseExceptionPrivate> d;
+};
+
+
+//
+// XML Reader
+//
+
+class Q_XML_EXPORT QXmlReader
+{
+public:
+    virtual ~QXmlReader() {}
+    virtual bool feature(const QString& name, bool *ok = 0) const = 0;
+    virtual void setFeature(const QString& name, bool value) = 0;
+    virtual bool hasFeature(const QString& name) const = 0;
+    virtual void* property(const QString& name, bool *ok = 0) const = 0;
+    virtual void setProperty(const QString& name, void* value) = 0;
+    virtual bool hasProperty(const QString& name) const = 0;
+    virtual void setEntityResolver(QXmlEntityResolver* handler) = 0;
+    virtual QXmlEntityResolver* entityResolver() const = 0;
+    virtual void setDTDHandler(QXmlDTDHandler* handler) = 0;
+    virtual QXmlDTDHandler* DTDHandler() const = 0;
+    virtual void setContentHandler(QXmlContentHandler* handler) = 0;
+    virtual QXmlContentHandler* contentHandler() const = 0;
+    virtual void setErrorHandler(QXmlErrorHandler* handler) = 0;
+    virtual QXmlErrorHandler* errorHandler() const = 0;
+    virtual void setLexicalHandler(QXmlLexicalHandler* handler) = 0;
+    virtual QXmlLexicalHandler* lexicalHandler() const = 0;
+    virtual void setDeclHandler(QXmlDeclHandler* handler) = 0;
+    virtual QXmlDeclHandler* declHandler() const = 0;
+    virtual bool parse(const QXmlInputSource& input) = 0;
+    virtual bool parse(const QXmlInputSource* input) = 0;
+};
+
+class Q_XML_EXPORT QXmlSimpleReader : public QXmlReader
+{
+public:
+    QXmlSimpleReader();
+    virtual ~QXmlSimpleReader();
+
+    bool feature(const QString& name, bool *ok = 0) const;
+    void setFeature(const QString& name, bool value);
+    bool hasFeature(const QString& name) const;
+
+    void* property(const QString& name, bool *ok = 0) const;
+    void setProperty(const QString& name, void* value);
+    bool hasProperty(const QString& name) const;
+
+    void setEntityResolver(QXmlEntityResolver* handler);
+    QXmlEntityResolver* entityResolver() const;
+    void setDTDHandler(QXmlDTDHandler* handler);
+    QXmlDTDHandler* DTDHandler() const;
+    void setContentHandler(QXmlContentHandler* handler);
+    QXmlContentHandler* contentHandler() const;
+    void setErrorHandler(QXmlErrorHandler* handler);
+    QXmlErrorHandler* errorHandler() const;
+    void setLexicalHandler(QXmlLexicalHandler* handler);
+    QXmlLexicalHandler* lexicalHandler() const;
+    void setDeclHandler(QXmlDeclHandler* handler);
+    QXmlDeclHandler* declHandler() const;
+
+    bool parse(const QXmlInputSource& input);
+    bool parse(const QXmlInputSource* input);
+    virtual bool parse(const QXmlInputSource* input, bool incremental);
+    virtual bool parseContinue();
+
+private:
+    Q_DISABLE_COPY(QXmlSimpleReader)
+    Q_DECLARE_PRIVATE(QXmlSimpleReader)
+    QScopedPointer<QXmlSimpleReaderPrivate> d_ptr;
+
+    friend class QXmlSimpleReaderLocator;
+};
+
+//
+// SAX Locator
+//
+
+class Q_XML_EXPORT QXmlLocator
+{
+public:
+    QXmlLocator();
+    virtual ~QXmlLocator();
+
+    virtual int columnNumber() const = 0;
+    virtual int lineNumber() const = 0;
+//    QString getPublicId() const
+//    QString getSystemId() const
+};
+
+//
+// SAX handler classes
+//
+
+class Q_XML_EXPORT QXmlContentHandler
+{
+public:
+    virtual ~QXmlContentHandler() {}
+    virtual void setDocumentLocator(QXmlLocator* locator) = 0;
+    virtual bool startDocument() = 0;
+    virtual bool endDocument() = 0;
+    virtual bool startPrefixMapping(const QString& prefix, const QString& uri) = 0;
+    virtual bool endPrefixMapping(const QString& prefix) = 0;
+    virtual bool startElement(const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts) = 0;
+    virtual bool endElement(const QString& namespaceURI, const QString& localName, const QString& qName) = 0;
+    virtual bool characters(const QString& ch) = 0;
+    virtual bool ignorableWhitespace(const QString& ch) = 0;
+    virtual bool processingInstruction(const QString& target, const QString& data) = 0;
+    virtual bool skippedEntity(const QString& name) = 0;
+    virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlErrorHandler
+{
+public:
+    virtual ~QXmlErrorHandler() {}
+    virtual bool warning(const QXmlParseException& exception) = 0;
+    virtual bool error(const QXmlParseException& exception) = 0;
+    virtual bool fatalError(const QXmlParseException& exception) = 0;
+    virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlDTDHandler
+{
+public:
+    virtual ~QXmlDTDHandler() {}
+    virtual bool notationDecl(const QString& name, const QString& publicId, const QString& systemId) = 0;
+    virtual bool unparsedEntityDecl(const QString& name, const QString& publicId, const QString& systemId, const QString& notationName) = 0;
+    virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlEntityResolver
+{
+public:
+    virtual ~QXmlEntityResolver() {}
+    virtual bool resolveEntity(const QString& publicId, const QString& systemId, QXmlInputSource*& ret) = 0;
+    virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlLexicalHandler
+{
+public:
+    virtual ~QXmlLexicalHandler() {}
+    virtual bool startDTD(const QString& name, const QString& publicId, const QString& systemId) = 0;
+    virtual bool endDTD() = 0;
+    virtual bool startEntity(const QString& name) = 0;
+    virtual bool endEntity(const QString& name) = 0;
+    virtual bool startCDATA() = 0;
+    virtual bool endCDATA() = 0;
+    virtual bool comment(const QString& ch) = 0;
+    virtual QString errorString() const = 0;
+};
+
+class Q_XML_EXPORT QXmlDeclHandler
+{
+public:
+    virtual ~QXmlDeclHandler() {}
+    virtual bool attributeDecl(const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value) = 0;
+    virtual bool internalEntityDecl(const QString& name, const QString& value) = 0;
+    virtual bool externalEntityDecl(const QString& name, const QString& publicId, const QString& systemId) = 0;
+    virtual QString errorString() const = 0;
+    // ### Qt 5: Conform to SAX by adding elementDecl
+};
+
+
+class Q_XML_EXPORT QXmlDefaultHandler : public QXmlContentHandler, public QXmlErrorHandler, public QXmlDTDHandler, public QXmlEntityResolver, public QXmlLexicalHandler, public QXmlDeclHandler
+{
+public:
+    QXmlDefaultHandler() { }
+    virtual ~QXmlDefaultHandler() { }
+
+    void setDocumentLocator(QXmlLocator* locator);
+    bool startDocument();
+    bool endDocument();
+    bool startPrefixMapping(const QString& prefix, const QString& uri);
+    bool endPrefixMapping(const QString& prefix);
+    bool startElement(const QString& namespaceURI, const QString& localName, const QString& qName, const QXmlAttributes& atts);
+    bool endElement(const QString& namespaceURI, const QString& localName, const QString& qName);
+    bool characters(const QString& ch);
+    bool ignorableWhitespace(const QString& ch);
+    bool processingInstruction(const QString& target, const QString& data);
+    bool skippedEntity(const QString& name);
+
+    bool warning(const QXmlParseException& exception);
+    bool error(const QXmlParseException& exception);
+    bool fatalError(const QXmlParseException& exception);
+
+    bool notationDecl(const QString& name, const QString& publicId, const QString& systemId);
+    bool unparsedEntityDecl(const QString& name, const QString& publicId, const QString& systemId, const QString& notationName);
+
+    bool resolveEntity(const QString& publicId, const QString& systemId, QXmlInputSource*& ret);
+
+    bool startDTD(const QString& name, const QString& publicId, const QString& systemId);
+    bool endDTD();
+    bool startEntity(const QString& name);
+    bool endEntity(const QString& name);
+    bool startCDATA();
+    bool endCDATA();
+    bool comment(const QString& ch);
+
+    bool attributeDecl(const QString& eName, const QString& aName, const QString& type, const QString& valueDefault, const QString& value);
+    bool internalEntityDecl(const QString& name, const QString& value);
+    bool externalEntityDecl(const QString& name, const QString& publicId, const QString& systemId);
+
+    QString errorString() const;
+
+private:
+    QXmlDefaultHandlerPrivate *d;
+    Q_DISABLE_COPY(QXmlDefaultHandler)
+};
+
+// inlines
+
+inline int QXmlAttributes::count() const
+{ return length(); }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QXML_H
diff --git a/src/xml/sax/sax.pri b/src/xml/sax/sax.pri
new file mode 100644
index 0000000000..65916271bd
--- /dev/null
+++ b/src/xml/sax/sax.pri
@@ -0,0 +1,2 @@
+SOURCES += $$PWD/qxml.cpp
+HEADERS += $$PWD/qxml.h