Long live Qt!

11 files changed, 3319 insertions, 0 deletions

diff --git a/src/xmlpatterns/acceltree/acceltree.pri b/src/xmlpatterns/acceltree/acceltree.pri
new file mode 100644
index 0000000..284371a
--- /dev/null
+++ b/src/xmlpatterns/acceltree/acceltree.pri
@@ -0,0 +1,10 @@
+SOURCES += $$PWD/qacceltree.cpp                  \
+           $$PWD/qacceltreeresourceloader.cpp    \
+           $$PWD/qacceliterators.cpp             \
+           $$PWD/qcompressedwhitespace.cpp
+
+HEADERS += $$PWD/qacceltreebuilder_p.h             \
+           $$PWD/qacceltree_p.h                    \
+           $$PWD/qacceltreeresourceloader_p.h      \
+           $$PWD/qacceliterators_p.h               \
+           $$PWD/qcompressedwhitespace_p.h
diff --git a/src/xmlpatterns/acceltree/qacceliterators.cpp b/src/xmlpatterns/acceltree/qacceliterators.cpp
new file mode 100644
index 0000000..152c5d8
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceliterators.cpp
@@ -0,0 +1,181 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtDebug>
+
+#include "qacceliterators_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+xsInteger AccelIterator::position() const
+{
+    return m_position;
+}
+
+QXmlNodeModelIndex AccelIterator::current() const
+{
+    return m_current;
+}
+
+QXmlNodeModelIndex FollowingIterator::next()
+{
+    /* "the following axis contains all nodes that are descendants
+     *  of the root of the tree in which the context node is found,
+     *  are not descendants of the context node, and occur after
+     *  the context node in document order." */
+
+    if(m_position == 0)
+    {
+        /* Skip the descendants. */
+        m_currentPre += m_document->size(m_preNumber) + 1;
+    }
+
+    if(m_currentPre > m_document->maximumPreNumber())
+        return closedExit();
+
+    while(m_document->kind(m_currentPre) == QXmlNodeModelIndex::Attribute)
+    {
+        ++m_currentPre;
+        if(m_currentPre > m_document->maximumPreNumber())
+            return closedExit();
+    }
+
+    m_current = m_document->createIndex(m_currentPre);
+    ++m_position;
+    ++m_currentPre;
+    return m_current;
+}
+
+QXmlNodeModelIndex PrecedingIterator::next()
+{
+    if(m_currentPre == -1)
+        return closedExit();
+
+    /* We skip ancestors and attributes and take into account that they can be intermixed. If one
+     * skips them in two separate loops, one can end up with skipping all the attributes to then
+     * be positioned at an ancestor(which will be accepted because the ancestor loop was before the
+     * attributes loop).  */
+    while(m_document->kind(m_currentPre) == QXmlNodeModelIndex::Attribute ||
+          m_document->postNumber(m_currentPre) > m_postNumber)
+    {
+        --m_currentPre;
+        if(m_currentPre == -1)
+            return closedExit();
+    }
+
+    if(m_currentPre == -1)
+    {
+        m_currentPre = -1;
+        return closedExit();
+    }
+
+    /* Phew, m_currentPre is now 1) not an ancestor; and
+     * 2) not an attribute; and 3) preceds the context node. */
+
+    m_current = m_document->createIndex(m_currentPre);
+    ++m_position;
+    --m_currentPre;
+
+    return m_current;
+}
+
+QXmlNodeModelIndex::Iterator::Ptr PrecedingIterator::copy() const
+{
+    return QXmlNodeModelIndex::Iterator::Ptr(new PrecedingIterator(m_document, m_preNumber));
+}
+
+QXmlNodeModelIndex::Iterator::Ptr FollowingIterator::copy() const
+{
+    return QXmlNodeModelIndex::Iterator::Ptr(new FollowingIterator(m_document, m_preNumber));
+}
+
+QXmlNodeModelIndex ChildIterator::next()
+{
+    if(m_currentPre == -1)
+        return closedExit();
+
+    ++m_position;
+    m_current = m_document->createIndex(m_currentPre);
+
+    /* We get the count of the descendants, and increment m_currentPre. After
+     * this, m_currentPre is the node after the descendants. */
+    m_currentPre += m_document->size(m_currentPre);
+    ++m_currentPre;
+
+    if(m_currentPre > m_document->maximumPreNumber() || m_document->depth(m_currentPre) != m_depth)
+        m_currentPre = -1;
+
+    return m_current;
+}
+
+QXmlNodeModelIndex::Iterator::Ptr ChildIterator::copy() const
+{
+    return QXmlNodeModelIndex::Iterator::Ptr(new ChildIterator(m_document, m_preNumber));
+}
+
+QXmlNodeModelIndex AttributeIterator::next()
+{
+    if(m_currentPre == -1)
+        return closedExit();
+    else
+    {
+        m_current = m_document->createIndex(m_currentPre);
+        ++m_position;
+
+        ++m_currentPre;
+
+        if(m_currentPre > m_document->maximumPreNumber() ||
+           m_document->kind(m_currentPre) != QXmlNodeModelIndex::Attribute)
+            m_currentPre = -1;
+
+        return m_current;
+    }
+}
+
+QXmlNodeModelIndex::Iterator::Ptr AttributeIterator::copy() const
+{
+    return QXmlNodeModelIndex::Iterator::Ptr(new AttributeIterator(m_document, m_preNumber));
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/acceltree/qacceliterators_p.h b/src/xmlpatterns/acceltree/qacceliterators_p.h
new file mode 100644
index 0000000..545ff73
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceliterators_p.h
@@ -0,0 +1,413 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+
+#ifndef Patternist_AccelIterators_H
+#define Patternist_AccelIterators_H
+
+#include "qacceltree_p.h"
+#include "qitem_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+    /**
+     * @short Abstract base class for Iterators for the AccelTree, that
+     * contains common functions and members.
+     *
+     * @author Frans Englich<fenglich@trolltech.com>
+     */
+    class AccelIterator : public QXmlNodeModelIndex::Iterator
+    {
+    public:
+        virtual xsInteger position() const;
+        virtual QXmlNodeModelIndex current() const;
+
+    protected:
+        inline AccelIterator(const AccelTree *const doc,
+                             const AccelTree::PreNumber pre,
+                             const AccelTree::PreNumber currentPre) : m_document(doc)
+                                                                    , m_preNumber(pre)
+                                                                    , m_currentPre(currentPre)
+                                                                    , m_position(0)
+
+        {
+            Q_ASSERT(m_document);
+            Q_ASSERT(m_preNumber >= 0);
+        }
+
+        inline QXmlNodeModelIndex closedExit()
+        {
+            m_position = -1;
+            m_current.reset();
+            return QXmlNodeModelIndex();
+        }
+
+        /**
+         * We do not own it.
+         */
+        const AccelTree *const      m_document;
+
+        /**
+         * The pre number of the node that should be navigated from.
+         */
+        const AccelTree::PreNumber  m_preNumber;
+        AccelTree::PreNumber        m_currentPre;
+        xsInteger                   m_position;
+        QXmlNodeModelIndex          m_current;
+    };
+
+    /**
+     * @short Iterates along the @c ancestor or @c ancestor-or-self axis in an AccelTree.
+     *
+     * @author Frans Englich<fenglich@trolltech.com>
+     */
+    template<const bool IncludeSelf>
+    class AncestorIterator : public AccelIterator
+    {
+    public:
+        /**
+         * @p pre is the node from which iteration starts
+         * from. In the @c ancestor axis it is excluded,
+         * while in @c ancestor-or-self it is included. @p pre
+         * must have at least one ancestor.
+         */
+        inline AncestorIterator(const AccelTree *const doc,
+                                const AccelTree::PreNumber pre) : AccelIterator(doc, pre, IncludeSelf ? pre : doc->basicData.at(pre).parent())
+        {
+            Q_ASSERT(IncludeSelf || m_document->hasParent(pre));
+        }
+
+        virtual QXmlNodeModelIndex next()
+        {
+            if(m_currentPre == -1)
+                return closedExit();
+            else
+            {
+                ++m_position;
+                m_current = m_document->createIndex(m_currentPre);
+                m_currentPre = m_document->basicData.at(m_currentPre).parent();
+
+                return m_current;
+            }
+        }
+
+        virtual QXmlNodeModelIndex::Iterator::Ptr copy() const
+        {
+            return QXmlNodeModelIndex::Iterator::Ptr(new AncestorIterator<IncludeSelf>(m_document, m_preNumber));
+        }
+    };
+
+    /**
+     * @short Iterates along the @c child axis in an AccelTree.
+     *
+     * @author Frans Englich<fenglich@trolltech.com>
+     */
+    class ChildIterator : public AccelIterator
+    {
+    public:
+        /**
+         * @p pre must have at least one child.
+         */
+        inline ChildIterator(const AccelTree *const doc,
+                             const AccelTree::PreNumber pre) : AccelIterator(doc, pre, pre + 1),
+                                                               m_depth(m_document->depth(m_currentPre))
+        {
+            Q_ASSERT(m_document->hasChildren(pre));
+
+            /* Skip the attributes, that are children in the pre/post plane, of
+             * the node we're applying the child axis to. */
+            while(m_document->kind(m_currentPre) == QXmlNodeModelIndex::Attribute)
+            {
+                ++m_currentPre;
+                /* We check the depth here because we would otherwise include
+                 * following siblings. */
+                if(m_currentPre > m_document->maximumPreNumber() || m_document->depth(m_currentPre) != m_depth)
+                {
+                    m_currentPre = -1;
+                    break;
+                }
+            }
+        }
+
+        virtual QXmlNodeModelIndex next();
+        virtual QXmlNodeModelIndex::Iterator::Ptr copy() const;
+
+    private:
+        const AccelTree::Depth m_depth;
+    };
+
+    /**
+     * @short Iterates along the sibling axes in an AccelTree.
+     *
+     * @author Frans Englich<fenglich@trolltech.com>
+     */
+    template<const bool IsFollowing>
+    class SiblingIterator : public AccelIterator
+    {
+    public:
+        inline SiblingIterator(const AccelTree *const doc,
+                               const AccelTree::PreNumber pre) : AccelIterator(doc, pre, pre + (IsFollowing ? 0 : -1)),
+                                                                 m_depth(doc->depth(pre))
+        {
+            Q_ASSERT_X(IsFollowing || pre != 0, "",
+                       "When being preceding-sibling, the context node cannot be the first node in the document.");
+            Q_ASSERT_X(!IsFollowing || pre != m_document->maximumPreNumber(), "",
+                       "When being following-sibling, the context node cannot be the last node in the document.");
+        }
+
+        virtual QXmlNodeModelIndex next()
+        {
+            if(m_currentPre == -1)
+                return QXmlNodeModelIndex();
+
+            if(IsFollowing)
+            {
+                /* Skip the descendants, and jump to the next node. */
+                m_currentPre += m_document->size(m_currentPre) + 1;
+
+                if(m_currentPre > m_document->maximumPreNumber() || m_document->depth(m_currentPre) != m_depth)
+                    return closedExit();
+                else
+                {
+                    ++m_position;
+                    m_current = m_document->createIndex(m_currentPre);
+                    return m_current;
+                }
+            }
+            else
+            {
+                while(m_document->depth(m_currentPre) > m_depth)
+                    --m_currentPre;
+
+                while(m_document->kind(m_currentPre) == QXmlNodeModelIndex::Attribute)
+                    --m_currentPre;
+
+                if(m_document->depth(m_currentPre) == m_depth &&
+                   m_document->kind(m_currentPre) != QXmlNodeModelIndex::Attribute)
+                {
+                    m_current = m_document->createIndex(m_currentPre);
+                    ++m_position;
+                    --m_currentPre;
+                    return m_current;
+                }
+                else
+                {
+                    m_currentPre = -1;
+                    return closedExit();
+                }
+            }
+        }
+
+        virtual QXmlNodeModelIndex::Iterator::Ptr copy() const
+        {
+            return QXmlNodeModelIndex::Iterator::Ptr(new SiblingIterator<IsFollowing>(m_document, m_preNumber));
+        }
+
+    private:
+        const AccelTree::Depth m_depth;
+    };
+
+    /**
+     * @short Implements axis @c descendant and @c descendant-or-self for the
+     * AccelTree.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    template<const bool IncludeSelf>
+    class DescendantIterator : public AccelIterator
+    {
+    public:
+        /**
+         * @p pre must have at least one child.
+         */
+        inline DescendantIterator(const AccelTree *const doc,
+                                  const AccelTree::PreNumber pre) : AccelIterator(doc, pre, pre + (IncludeSelf ? 0 : 1)),
+                                                                    m_postNumber(doc->postNumber(pre))
+        {
+            Q_ASSERT(IncludeSelf || m_document->hasChildren(pre));
+
+            /* Make sure that m_currentPre is the first node part of this axis.
+             * Since we're not including ourself, advance to the node after our
+             * attributes, if any. */
+            if(!IncludeSelf)
+            {
+                while(m_document->kind(m_currentPre) == QXmlNodeModelIndex::Attribute)
+                {
+                    ++m_currentPre;
+                    /* We check the depth here because we would otherwise include
+                     * following siblings. */
+                    if(m_currentPre > m_document->maximumPreNumber() || m_document->postNumber(m_currentPre) > m_postNumber)
+                    {
+                        m_currentPre = -1;
+                        break;
+                    }
+                }
+            }
+        }
+
+        virtual QXmlNodeModelIndex next()
+        {
+            if(m_currentPre == -1)
+                return closedExit();
+
+            ++m_position;
+            m_current = m_document->createIndex(m_currentPre);
+
+            ++m_currentPre;
+
+            if(m_currentPre > m_document->maximumPreNumber())
+            {
+                m_currentPre = -1;
+                return m_current;
+            }
+
+            if(m_document->postNumber(m_currentPre) < m_postNumber)
+            {
+                while(m_document->kind(m_currentPre) == QXmlNodeModelIndex::Attribute)
+                {
+                    ++m_currentPre;
+                    if(m_currentPre > m_document->maximumPreNumber())
+                    {
+                        m_currentPre = -1;
+                        break;
+                    }
+                }
+            }
+            else
+                m_currentPre = -1;
+
+            return m_current;
+        }
+
+        virtual QXmlNodeModelIndex::Iterator::Ptr copy() const
+        {
+            return QXmlNodeModelIndex::Iterator::Ptr(new DescendantIterator<IncludeSelf>(m_document, m_preNumber));
+        }
+
+    private:
+        const AccelTree::PreNumber m_postNumber;
+    };
+
+    /**
+     * @short Implements axis @c following for the AccelTree.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    class FollowingIterator : public AccelIterator
+    {
+    public:
+        /**
+         * @ pre must have at least one child.
+         */
+        inline FollowingIterator(const AccelTree *const doc,
+                                 const AccelTree::PreNumber pre) : AccelIterator(doc, pre, pre)
+        {
+        }
+
+        virtual QXmlNodeModelIndex next();
+        virtual QXmlNodeModelIndex::Iterator::Ptr copy() const;
+    };
+
+    /**
+     * @short Implements axis @c preceding for the AccelTree.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    class PrecedingIterator : public AccelIterator
+    {
+    public:
+        /**
+         * @ pre must have at least one child.
+         */
+        inline PrecedingIterator(const AccelTree *const doc,
+                                 const AccelTree::PreNumber pre) : AccelIterator(doc, pre,
+                                                                                 pre - 1 /* currentPre */)
+                                                                 , m_postNumber(m_document->postNumber(m_preNumber))
+        {
+        }
+
+        virtual QXmlNodeModelIndex next();
+        virtual QXmlNodeModelIndex::Iterator::Ptr copy() const;
+
+    private:
+        const AccelTree::PreNumber  m_postNumber;
+    };
+
+    /**
+     * @short Implements axis @c attribute for the AccelTree.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    class AttributeIterator : public AccelIterator
+    {
+    public:
+        /**
+         * @p pre must have at least one child.
+         */
+        inline AttributeIterator(const AccelTree *const doc, const AccelTree::PreNumber pre) : AccelIterator(doc, pre, pre + 1)
+        {
+            Q_ASSERT(m_document->hasChildren(pre));
+            Q_ASSERT(m_document->kind(m_currentPre) == QXmlNodeModelIndex::Attribute);
+        }
+
+        virtual QXmlNodeModelIndex next();
+        virtual QXmlNodeModelIndex::Iterator::Ptr copy() const;
+    };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/acceltree/qacceltree.cpp b/src/xmlpatterns/acceltree/qacceltree.cpp
new file mode 100644
index 0000000..60e6e27
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceltree.cpp
@@ -0,0 +1,706 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QStack>
+
+#include "qabstractxmlreceiver.h"
+#include "qacceliterators_p.h"
+#include "qacceltree_p.h"
+#include "qatomicstring_p.h"
+#include "qcommonvalues_p.h"
+#include "qcompressedwhitespace_p.h"
+#include "qdebug_p.h"
+#include "quntypedatomic_p.h"
+#include "qxpathhelper_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+void AccelTree::printStats(const NamePool::Ptr &np) const
+{
+    Q_ASSERT(np);
+#ifdef QT_NO_DEBUG
+    Q_UNUSED(np); /* Needed when compiling in release mode. */
+#else
+    const int len = basicData.count();
+
+    pDebug() << "AccelTree stats for" << (m_documentURI.isEmpty() ? QString::fromLatin1("<empty URI>") : m_documentURI.toString());
+    pDebug() << "Maximum pre number:" << maximumPreNumber();
+    pDebug() << "+---------------+-------+-------+---------------+-------+--------------+-------+";
+    pDebug() << "| Pre number    | Depth | Size  | Post Number   | Kind  | Name         | Value |";
+    pDebug() << "+---------------+-------+-------+---------------+-------+--------------+-------+";
+    for(int i = 0; i < len; ++i)
+    {
+        const BasicNodeData &v = basicData.at(i);
+        pDebug() << "|" << i
+                 << "\t\t|" << v.depth()
+                 << "\t|" << v.size()
+                 << "\t|" << postNumber(i)
+                 << "\t|" << v.kind()
+                 << "\t\t|" << (v.name().isNull() ? QString::fromLatin1("(none)") : np->displayName(v.name()))
+                 << "\t\t|" << ((v.kind() == QXmlNodeModelIndex::Text && isCompressed(i)) ? CompressedWhitespace::decompress(data.value(i))
+                                                                                          : data.value(i))
+                 << "\t|";
+        /*
+        pDebug() << "|" << QString().arg(i, 14)
+                 << "|" << QString().arg(v.depth(), 6)
+                 << "|" << QString().arg(v.size(), 6)
+                 << "|" << QString().arg(postNumber(i), 14)
+                 << "|" << QString().arg(v.kind(), 6)
+                 << "|";
+                 */
+    }
+    pDebug() << "+---------------+-------+-------+---------------+-------+--------------+";
+    pDebug() << "Namespaces(" << namespaces.count() << "):";
+
+    QHashIterator<PreNumber, QVector<QXmlName> > it(namespaces);
+    while(it.hasNext())
+    {
+        it.next();
+
+        pDebug() << "PreNumber: " << QString::number(it.key());
+        for(int i = 0; i < it.value().count(); ++i)
+            pDebug() << "\t\t" << np->stringForPrefix(it.value().at(i).prefix()) << " = " << np->stringForNamespace(it.value().at(i).namespaceURI());
+    }
+
+#endif
+}
+
+QUrl AccelTree::baseUri(const QXmlNodeModelIndex &ni) const
+{
+    switch(kind(toPreNumber(ni)))
+    {
+        case QXmlNodeModelIndex::Document:
+            return baseUri();
+        case QXmlNodeModelIndex::Element:
+        {
+            const QXmlNodeModelIndex::Iterator::Ptr it(iterate(ni, QXmlNodeModelIndex::AxisAttribute));
+            QXmlNodeModelIndex next(it->next());
+
+            while(!next.isNull())
+            {
+                if(next.name() == QXmlName(StandardNamespaces::xml, StandardLocalNames::base))
+                {
+                    const QUrl candidate(next.stringValue());
+                    //  TODO. The xml:base spec says to do URI escaping here.
+
+                    if(!candidate.isValid())
+                        return QUrl();
+                    else if(candidate.isRelative())
+                    {
+                        const QXmlNodeModelIndex par(parent(ni));
+
+                        if(par.isNull())
+                            return baseUri().resolved(candidate);
+                        else
+                            return par.baseUri().resolved(candidate);
+                    }
+                    else
+                        return candidate;
+                }
+
+                next = it->next();
+            }
+
+            /* We have no xml:base-attribute. Can any parent supply us a base URI? */
+            const QXmlNodeModelIndex par(parent(ni));
+
+            if(par.isNull())
+                return baseUri();
+            else
+                return par.baseUri();
+        }
+        case QXmlNodeModelIndex::ProcessingInstruction:
+        /* Fallthrough. */
+        case QXmlNodeModelIndex::Comment:
+        /* Fallthrough. */
+        case QXmlNodeModelIndex::Attribute:
+        /* Fallthrough. */
+        case QXmlNodeModelIndex::Text:
+        {
+            const QXmlNodeModelIndex par(ni.iterate(QXmlNodeModelIndex::AxisParent)->next());
+            if(par.isNull())
+                return QUrl();
+            else
+                return par.baseUri();
+        }
+        case QXmlNodeModelIndex::Namespace:
+            return QUrl();
+    }
+
+    Q_ASSERT_X(false, Q_FUNC_INFO, "This line is never supposed to be reached.");
+    return QUrl();
+}
+
+QUrl AccelTree::documentUri(const QXmlNodeModelIndex &ni) const
+{
+    if(kind(toPreNumber(ni)) == QXmlNodeModelIndex::Document)
+        return documentUri();
+    else
+        return QUrl();
+}
+
+QXmlNodeModelIndex::NodeKind AccelTree::kind(const QXmlNodeModelIndex &ni) const
+{
+    return kind(toPreNumber(ni));
+}
+
+QXmlNodeModelIndex::DocumentOrder AccelTree::compareOrder(const QXmlNodeModelIndex &ni1,
+                                                          const QXmlNodeModelIndex &ni2) const
+{
+    Q_ASSERT_X(ni1.model() == ni2.model(), Q_FUNC_INFO,
+               "The API docs guarantees the two nodes are from the same model");
+
+    const PreNumber p1 = ni1.data();
+    const PreNumber p2 = ni2.data();
+
+    if(p1 == p2)
+        return QXmlNodeModelIndex::Is;
+    else if(p1 < p2)
+        return QXmlNodeModelIndex::Precedes;
+    else
+        return QXmlNodeModelIndex::Follows;
+}
+
+QXmlNodeModelIndex AccelTree::root(const QXmlNodeModelIndex &) const
+{
+    return createIndex(qint64(0));
+}
+
+QXmlNodeModelIndex AccelTree::parent(const QXmlNodeModelIndex &ni) const
+{
+    const AccelTree::PreNumber p = basicData.at(toPreNumber(ni)).parent();
+
+    if(p == -1)
+        return QXmlNodeModelIndex();
+    else
+        return createIndex(p);
+}
+
+QXmlNodeModelIndex::Iterator::Ptr AccelTree::iterate(const QXmlNodeModelIndex &ni,
+                                                     QXmlNodeModelIndex::Axis axis) const
+{
+    const PreNumber preNumber = toPreNumber(ni);
+
+    switch(axis)
+    {
+        case QXmlNodeModelIndex::AxisChildOrTop:
+        {
+            if(!hasParent(preNumber))
+            {
+                switch(kind(preNumber))
+                {
+                    case QXmlNodeModelIndex::Comment:
+                    /* Fallthrough. */
+                    case QXmlNodeModelIndex::ProcessingInstruction:
+                    /* Fallthrough. */
+                    case QXmlNodeModelIndex::Element:
+                    /* Fallthrough. */
+                    case QXmlNodeModelIndex::Text:
+                        return makeSingletonIterator(ni);
+                    case QXmlNodeModelIndex::Attribute:
+                    /* Fallthrough. */
+                    case QXmlNodeModelIndex::Document:
+                    /* Fallthrough. */
+                    case QXmlNodeModelIndex::Namespace:
+                        /* Do nothing. */;
+                }
+            }
+            /* Else, fallthrough to AxisChild. */
+        }
+        case QXmlNodeModelIndex::AxisChild:
+        {
+            if(hasChildren(preNumber))
+                return QXmlNodeModelIndex::Iterator::Ptr(new ChildIterator(this, preNumber));
+            else
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+        }
+        case QXmlNodeModelIndex::AxisAncestor:
+        {
+            if(hasParent(preNumber))
+                return QXmlNodeModelIndex::Iterator::Ptr(new AncestorIterator<false>(this, preNumber));
+            else
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+        }
+        case QXmlNodeModelIndex::AxisAncestorOrSelf:
+            return QXmlNodeModelIndex::Iterator::Ptr(new AncestorIterator<true>(this, preNumber));
+        case QXmlNodeModelIndex::AxisParent:
+        {
+            if(hasParent(preNumber))
+                return makeSingletonIterator(createIndex(parent(preNumber)));
+            else
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+        }
+        case QXmlNodeModelIndex::AxisDescendant:
+        {
+            if(hasChildren(preNumber))
+                return QXmlNodeModelIndex::Iterator::Ptr(new DescendantIterator<false>(this, preNumber));
+            else
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+        }
+        case QXmlNodeModelIndex::AxisDescendantOrSelf:
+            return QXmlNodeModelIndex::Iterator::Ptr(new DescendantIterator<true>(this, preNumber));
+        case QXmlNodeModelIndex::AxisFollowing:
+        {
+            if(preNumber == maximumPreNumber())
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+            else
+                return QXmlNodeModelIndex::Iterator::Ptr(new FollowingIterator(this, preNumber));
+        }
+        case QXmlNodeModelIndex::AxisAttributeOrTop:
+        {
+            if(!hasParent(preNumber) && kind(preNumber) == QXmlNodeModelIndex::Attribute)
+                return makeSingletonIterator(ni);
+            /* Else, falthrough to AxisAttribute. */
+        }
+        case QXmlNodeModelIndex::AxisAttribute:
+        {
+            if(hasChildren(preNumber) && kind(preNumber + 1) == QXmlNodeModelIndex::Attribute)
+                return QXmlNodeModelIndex::Iterator::Ptr(new AttributeIterator(this, preNumber));
+            else
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+        }
+        case QXmlNodeModelIndex::AxisPreceding:
+        {
+            if(preNumber == 0)
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+            else
+                return QXmlNodeModelIndex::Iterator::Ptr(new PrecedingIterator(this, preNumber));
+        }
+        case QXmlNodeModelIndex::AxisSelf:
+            return makeSingletonIterator(createIndex(toPreNumber(ni)));
+        case QXmlNodeModelIndex::AxisFollowingSibling:
+        {
+            if(preNumber == maximumPreNumber())
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+            else
+                return QXmlNodeModelIndex::Iterator::Ptr(new SiblingIterator<true>(this, preNumber));
+        }
+        case QXmlNodeModelIndex::AxisPrecedingSibling:
+        {
+            if(preNumber == 0)
+                return makeEmptyIterator<QXmlNodeModelIndex>();
+            else
+                return QXmlNodeModelIndex::Iterator::Ptr(new SiblingIterator<false>(this, preNumber));
+        }
+        case QXmlNodeModelIndex::AxisNamespace:
+            return makeEmptyIterator<QXmlNodeModelIndex>();
+    }
+
+    Q_ASSERT(false);
+    return QXmlNodeModelIndex::Iterator::Ptr();
+}
+
+QXmlNodeModelIndex AccelTree::nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis,
+                                                 const QXmlNodeModelIndex&) const
+{
+    Q_ASSERT_X(false, Q_FUNC_INFO, "This function is not supposed to be called.");
+    return QXmlNodeModelIndex();
+}
+
+QVector<QXmlNodeModelIndex> AccelTree::attributes(const QXmlNodeModelIndex &element) const
+{
+    Q_ASSERT_X(false, Q_FUNC_INFO, "This function is not supposed to be called.");
+    Q_UNUSED(element);
+    return QVector<QXmlNodeModelIndex>();
+}
+
+QXmlName AccelTree::name(const QXmlNodeModelIndex &ni) const
+{
+    /* If this node type does not have a name(for instance, it's a comment)
+     * we will return the default constructed value, which is conformant with
+     * this function's contract. */
+    return name(toPreNumber(ni));
+}
+
+QVector<QXmlName> AccelTree::namespaceBindings(const QXmlNodeModelIndex &ni) const
+{
+    /* We get a hold of the ancestor, and loop them in reverse document
+     * order(first the parent, then the parent's parent, etc). As soon
+     * we find a binding that hasn't already been added, we add it to the
+     * result list. In that way, declarations appearing further down override
+     * those further up. */
+
+    const PreNumber preNumber = toPreNumber(ni);
+
+    const QXmlNodeModelIndex::Iterator::Ptr it(new AncestorIterator<true>(this, preNumber));
+    QVector<QXmlName> result;
+    QXmlNodeModelIndex n(it->next());
+
+    /* Whether xmlns="" has been encountered. */
+    bool hasUndeclaration = false;
+
+    while(!n.isNull())
+    {
+        const QVector<QXmlName> &forNode = namespaces.value(toPreNumber(n));
+        const int len = forNode.size();
+        bool stopInheritance = false;
+
+        for(int i = 0; i < len; ++i)
+        {
+            const QXmlName &nsb = forNode.at(i);
+
+            if(nsb.namespaceURI() == StandardNamespaces::StopNamespaceInheritance)
+            {
+                stopInheritance = true;
+                continue;
+            }
+
+            if(nsb.prefix() == StandardPrefixes::empty &&
+               nsb.namespaceURI() == StandardNamespaces::empty)
+            {
+                hasUndeclaration = true;
+                continue;
+            }
+
+            if(!hasPrefix(result, nsb.prefix()))
+            {
+                /* We've already encountered an undeclaration, so we're supposed to skip
+                 * them. */
+                if(hasUndeclaration && nsb.prefix() == StandardPrefixes::empty)
+                    continue;
+                else
+                    result.append(nsb);
+            }
+        }
+
+        if(stopInheritance)
+            break;
+        else
+            n = it->next();
+    }
+
+    result.append(QXmlName(StandardNamespaces::xml, StandardLocalNames::empty, StandardPrefixes::xml));
+
+    return result;
+}
+
+void AccelTree::sendNamespaces(const QXmlNodeModelIndex &n,
+                               QAbstractXmlReceiver *const receiver) const
+{
+    Q_ASSERT(n.kind() == QXmlNodeModelIndex::Element);
+
+    const QXmlNodeModelIndex::Iterator::Ptr it(iterate(n, QXmlNodeModelIndex::AxisAncestorOrSelf));
+    QXmlNodeModelIndex next(it->next());
+    QVector<QXmlName::PrefixCode> alreadySent;
+
+    while(!next.isNull())
+    {
+        const PreNumber preNumber = toPreNumber(next);
+
+        const QVector<QXmlName> &nss = namespaces.value(preNumber);
+
+        /* This is by far the most common case. */
+        if(nss.isEmpty())
+        {
+            next = it->next();
+            continue;
+        }
+
+        const int len = nss.count();
+        bool stopInheritance = false;
+
+        for(int i = 0; i < len; ++i)
+        {
+            const QXmlName &name = nss.at(i);
+
+            if(name.namespaceURI() == StandardNamespaces::StopNamespaceInheritance)
+            {
+                stopInheritance = true;
+                continue;
+            }
+
+            if(!alreadySent.contains(name.prefix()))
+            {
+                alreadySent.append(name.prefix());
+                receiver->namespaceBinding(name);
+            }
+        }
+
+        if(stopInheritance)
+            break;
+        else
+            next = it->next();
+    }
+}
+
+QString AccelTree::stringValue(const QXmlNodeModelIndex &ni) const
+{
+    const PreNumber preNumber = toPreNumber(ni);
+
+    switch(kind(preNumber))
+    {
+        case QXmlNodeModelIndex::Element:
+        {
+            /* Concatenate all text nodes that are descendants of this node. */
+            if(!hasChildren(preNumber))
+                return QString();
+
+            const AccelTree::PreNumber stop = preNumber + size(preNumber);
+            AccelTree::PreNumber pn = preNumber + 1; /* Jump over ourselves. */
+            QString result;
+
+            for(; pn <= stop; ++pn)
+            {
+                if(kind(pn) == QXmlNodeModelIndex::Text)
+                {
+                    if(isCompressed(pn))
+                        result += CompressedWhitespace::decompress(data.value(pn));
+                    else
+                        result += data.value(pn);
+                }
+            }
+
+            return result;
+        }
+        case QXmlNodeModelIndex::Text:
+        {
+            if(isCompressed(preNumber))
+                return CompressedWhitespace::decompress(data.value(preNumber));
+            /* Else, fallthrough. It's not compressed so use it as it is. */
+        }
+        case QXmlNodeModelIndex::Attribute:
+        /* Fallthrough */
+        case QXmlNodeModelIndex::ProcessingInstruction:
+        /* Fallthrough */
+        case QXmlNodeModelIndex::Comment:
+            return data.value(preNumber);
+        case QXmlNodeModelIndex::Document:
+        {
+            /* Concatenate all text nodes in the whole document. */
+
+            QString result;
+            // Perhaps we can QString::reserve() the result based on the size?
+            const AccelTree::PreNumber max = maximumPreNumber();
+
+            for(AccelTree::PreNumber i = 0; i <= max; ++i)
+            {
+                if(kind(i) == QXmlNodeModelIndex::Text)
+                {
+                    if(isCompressed(i))
+                        result += CompressedWhitespace::decompress(data.value(i));
+                    else
+                        result += data.value(i);
+                }
+            }
+
+            return result;
+        }
+        default:
+        {
+            Q_ASSERT_X(false, Q_FUNC_INFO,
+                       "A node type that doesn't exist in the XPath Data Model was encountered.");
+            return QString(); /* Dummy, silence compiler warning. */
+        }
+    }
+}
+
+QVariant AccelTree::typedValue(const QXmlNodeModelIndex &n) const
+{
+    return stringValue(n);
+}
+
+bool AccelTree::hasPrefix(const QVector<QXmlName> &nbs, const QXmlName::PrefixCode prefix)
+{
+    const int size = nbs.size();
+
+    for(int i = 0; i < size; ++i)
+    {
+        if(nbs.at(i).prefix() == prefix)
+            return true;
+    }
+
+    return false;
+}
+
+ItemType::Ptr AccelTree::type(const QXmlNodeModelIndex &ni) const
+{
+    /* kind() is manually inlined here to avoid a virtual call. */
+    return XPathHelper::typeFromKind(basicData.at(toPreNumber(ni)).kind());
+}
+
+Item::Iterator::Ptr AccelTree::sequencedTypedValue(const QXmlNodeModelIndex &n) const
+{
+    const PreNumber preNumber = toPreNumber(n);
+
+    switch(kind(preNumber))
+    {
+        case QXmlNodeModelIndex::Element:
+        /* Fallthrough. */
+        case QXmlNodeModelIndex::Document:
+        /* Fallthrough. */
+        case QXmlNodeModelIndex::Attribute:
+            return makeSingletonIterator(Item(UntypedAtomic::fromValue(stringValue(n))));
+
+        case QXmlNodeModelIndex::Text:
+        /* Fallthrough. */
+        case QXmlNodeModelIndex::ProcessingInstruction:
+        /* Fallthrough. */
+        case QXmlNodeModelIndex::Comment:
+            return makeSingletonIterator(Item(AtomicString::fromValue(stringValue(n))));
+        default:
+        {
+            Q_ASSERT_X(false, Q_FUNC_INFO,
+                       qPrintable(QString::fromLatin1("A node type that doesn't exist "
+                                                      "in the XPath Data Model was encountered.").arg(kind(preNumber))));
+            return Item::Iterator::Ptr(); /* Dummy, silence compiler warning. */
+        }
+    }
+}
+
+void AccelTree::copyNodeTo(const QXmlNodeModelIndex &node,
+                           QAbstractXmlReceiver *const receiver,
+                           const NodeCopySettings &settings) const
+{
+    /* This code piece can be seen as a customized version of
+     * QAbstractXmlReceiver::item/sendAsNode(). */
+    Q_ASSERT(receiver);
+    Q_ASSERT(!node.isNull());
+
+    typedef QHash<QXmlName::PrefixCode, QXmlName::NamespaceCode> Binding;
+    QStack<Binding> outputted;
+
+    switch(node.kind())
+    {
+        case QXmlNodeModelIndex::Element:
+        {
+            outputted.push(Binding());
+
+            /* Add the namespace for our element name. */
+            const QXmlName elementName(node.name());
+
+            receiver->startElement(elementName);
+
+            if(!settings.testFlag(InheritNamespaces))
+                receiver->namespaceBinding(QXmlName(StandardNamespaces::StopNamespaceInheritance, 0,
+                                                    StandardPrefixes::StopNamespaceInheritance));
+
+            if(settings.testFlag(PreserveNamespaces))
+                node.sendNamespaces(receiver);
+            else
+            {
+                /* Find the namespaces that we actually use and add them to outputted. These are drawn
+                 * from the element name, and the node's attributes. */
+                outputted.top().insert(elementName.prefix(), elementName.namespaceURI());
+
+                const QXmlNodeModelIndex::Iterator::Ptr attributes(iterate(node, QXmlNodeModelIndex::AxisAttribute));
+                QXmlNodeModelIndex attr(attributes->next());
+
+                while(!attr.isNull())
+                {
+                    const QXmlName &attrName = attr.name();
+                    outputted.top().insert(attrName.prefix(), attrName.namespaceURI());
+                    attr = attributes->next();
+                }
+
+                Binding::const_iterator it(outputted.top().constBegin());
+                const Binding::const_iterator end(outputted.top().constEnd());
+
+                for(; it != end; ++it)
+                    receiver->namespaceBinding(QXmlName(it.value(), 0, it.key()));
+            }
+
+            /* Send the attributes of the element. */
+            {
+                QXmlNodeModelIndex::Iterator::Ptr attributes(node.iterate(QXmlNodeModelIndex::AxisAttribute));
+                QXmlNodeModelIndex attribute(attributes->next());
+
+                while(!attribute.isNull())
+                {
+                    const QString &v = attribute.stringValue();
+                    receiver->attribute(attribute.name(), QStringRef(&v));
+                    attribute = attributes->next();
+                }
+            }
+
+            /* Send the children of the element. */
+            copyChildren(node, receiver, settings);
+
+            receiver->endElement();
+            outputted.pop();
+            break;
+        }
+        case QXmlNodeModelIndex::Document:
+        {
+            /* We need to intercept and grab the elements of the document node, such
+             * that we preserve/inherit preference applies to them. */
+            receiver->startDocument();
+            copyChildren(node, receiver, settings);
+            receiver->endDocument();
+            break;
+        }
+        default:
+            receiver->item(node);
+    }
+
+}
+
+void AccelTree::copyChildren(const QXmlNodeModelIndex &node,
+                             QAbstractXmlReceiver *const receiver,
+                             const NodeCopySettings &settings) const
+{
+    QXmlNodeModelIndex::Iterator::Ptr children(node.iterate(QXmlNodeModelIndex::AxisChild));
+    QXmlNodeModelIndex child(children->next());
+
+    while(!child.isNull())
+    {
+        copyNodeTo(child, receiver, settings);
+        child = children->next();
+    }
+}
+
+QXmlNodeModelIndex AccelTree::elementById(const QXmlName &id) const
+{
+    const PreNumber pre = m_IDs.value(id.localName(), -1);
+    if(pre == -1)
+        return QXmlNodeModelIndex();
+    else
+        return createIndex(pre);
+}
+
+QVector<QXmlNodeModelIndex> AccelTree::nodesByIdref(const QXmlName &) const
+{
+    return QVector<QXmlNodeModelIndex>();
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/acceltree/qacceltree_p.h b/src/xmlpatterns/acceltree/qacceltree_p.h
new file mode 100644
index 0000000..10320ba
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceltree_p.h
@@ -0,0 +1,404 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+
+#ifndef Patternist_AccelTree_H
+#define Patternist_AccelTree_H
+
+#include <QHash>
+#include <QUrl>
+#include <QVector>
+#include <QXmlName>
+
+#include "qitem_p.h"
+#include "qnamepool_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+    template<bool> class AccelTreeBuilder;
+
+    /**
+     * @short Stores an XML document using the XPath Accelerator scheme, also
+     * known as pre/post numbering.
+     *
+     * Working on this code will be destructive without a proper understanding of
+     * the Accelerator scheme, so do check out the links. We don't implement any form
+     * of staircase join, although that is only due to time constraints.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     * @see <a href="http://www.pathfinder-xquery.org/?q=research/xpath-accel">XPath
+     * Accelerator</a>
+     * @see <a href="http://www.pathfinder-xquery.org/files/xpath-accel.pdf">Accelerating
+     * XPath Location Steps, Torsten Grust</a>
+     * @see <a href="http://citeseer.ist.psu.edu/cache/papers/cs/29367/http:zSzzSzwww.informatik.uni-konstanz.dezSz~grustzSzfileszSzstaircase-join.pdf/grust03staircase.pdf">Staircase Join:
+     * Teach a Relational DBMS to Watch its (Axis) Steps</a>
+     * @see <a href="http://ftp.cwi.nl/CWIreports/INS/INS-E0510.pdf">Loop-lifted
+     * staircase join: from XPath to XQuery, Torsten Grust</a>
+     * @see <a href="http://englich.wordpress.com/2007/01/09/xmlstat/">xmlstat, Frans Englich</a>
+     * @see <a href"http://www.inf.uni-konstanz.de/dbis/publications/download/accelerating-locsteps.pdf">Accelerating
+     * XPath Evaluation in Any RDBMS, Torsten Grust</a>
+     */
+    class AccelTree : public QAbstractXmlNodeModel
+    {
+    public:
+        using QAbstractXmlNodeModel::createIndex;
+
+        typedef QExplicitlySharedDataPointer<AccelTree> Ptr;
+        typedef qint32 PreNumber;
+        typedef PreNumber PostNumber;
+        typedef qint8 Depth;
+
+        inline AccelTree(const QUrl &docURI,
+                         const QUrl &bURI) : m_documentURI(docURI),
+                                             m_baseURI(bURI)
+        {
+            /* Pre-allocate at least a little bit. */
+            // TODO. Do it according to what an average 4 KB doc contains.
+            basicData.reserve(100);
+            data.reserve(30);
+        }
+
+        /**
+         * @short Houses data for a node, and that all node kinds have.
+         *
+         * BasicNodeData is internal to the Accel tree implementation, and is
+         * only used by those classes.
+         *
+         * @author Frans Englich <fenglich@trolltech.com>
+         * @todo Can't m_kind be coded somewhere else? If m_name is invalid,
+         * its bits can be used to distinguish the node types that doesn't have
+         * names, and for elements, attributes and processing instructions, we need
+         * two bits, somewhere. Attributes and processing instructions can't have a
+         * size, is that of help? There's also certain rules for the names. For instance,
+         * a processing instruction will never have a prefix nor namespace. Neither
+         * will an attribute node have a default, non-empty namespace, right?
+         * @todo Compress text nodes, add general support for it in Patternist.
+         */
+        class BasicNodeData
+        {
+        public:
+            inline BasicNodeData()
+            {
+            }
+
+            inline BasicNodeData(const PreNumber aDepth,
+                                 const PreNumber aParent,
+                                 const QXmlNodeModelIndex::NodeKind k,
+                                 const PreNumber s,
+                                 const QXmlName n = QXmlName()) : m_parent(aParent)
+                                                                , m_size(s)
+                                                                , m_name(n)
+                                                                , m_depth(aDepth)
+                                                                , m_kind(k)
+            {
+            }
+
+            inline Depth depth() const
+            {
+                return m_depth;
+            }
+
+            inline PreNumber parent() const
+            {
+                return m_parent;
+            }
+
+            /**
+             * @see AccelTree::size()
+             */
+            inline PreNumber size() const
+            {
+                /* Remember that we use the m_size to signal compression if
+                 * we're a text node. */
+                if(m_kind == QXmlNodeModelIndex::Text)
+                    return 0;
+                else
+                    return m_size;
+            }
+
+            inline void setSize(const PreNumber aSize)
+            {
+                m_size = aSize;
+            }
+
+            inline QXmlNodeModelIndex::NodeKind kind() const
+            {
+                return m_kind;
+            }
+
+            inline QXmlName name() const
+            {
+                return m_name;
+            }
+
+            inline bool isCompressed() const
+            {
+                Q_ASSERT_X(m_kind == QXmlNodeModelIndex::Text, Q_FUNC_INFO,
+                           "Currently, only text nodes are compressed.");
+                /* Note, we don't call size() here, since it has logic for text
+                 * nodes. */
+                return m_size == IsCompressed;
+            }
+
+        private:
+            /**
+             * This is the pre number of the parent.
+             */
+            PreNumber                       m_parent;
+
+            /**
+             * This is the count of children this node has.
+             *
+             * In the case of a text node, which cannot have children,
+             * it is set to IsCompressed, if the content has been the result
+             * of CompressedWhitespace::compress(). If it's not compressed,
+             * it is zero.
+             */
+            PreNumber                       m_size;
+
+            /**
+             * For text nodes, and less importantly, comments,
+             * this variable is not used.
+             */
+            QXmlName                        m_name;
+
+            Depth                           m_depth;
+
+            /**
+             * Technically it is sufficient with 8 bits. However, at least MSVC
+             * 2005 miscompiles it such that QXmlNodeModelIndex::Text becomes
+             * -64 instead of 64 with hilarious crashes as result.
+             *
+             * Fortunately this extra bit would be padded anyway.
+             */
+            QXmlNodeModelIndex::NodeKind    m_kind : 8;
+        };
+
+        virtual QUrl baseUri(const QXmlNodeModelIndex &ni) const;
+        virtual QUrl documentUri(const QXmlNodeModelIndex &ni) const;
+        virtual QXmlNodeModelIndex::NodeKind kind(const QXmlNodeModelIndex &ni) const;
+        virtual QXmlNodeModelIndex::DocumentOrder compareOrder(const QXmlNodeModelIndex &ni1,
+                                                               const QXmlNodeModelIndex &ni2) const;
+
+        /**
+         * @short Returns the root node.
+         *
+         * This function does not use @p n, so a default constructed
+         * QXmlNodeModelIndex may be passed.
+         */
+        virtual QXmlNodeModelIndex root(const QXmlNodeModelIndex &n) const;
+
+        virtual QXmlNodeModelIndex parent(const QXmlNodeModelIndex &ni) const;
+        virtual QXmlNodeModelIndex::Iterator::Ptr iterate(const QXmlNodeModelIndex &ni,
+                                                          QXmlNodeModelIndex::Axis axis) const;
+        virtual QXmlName name(const QXmlNodeModelIndex &ni) const;
+        virtual QVector<QXmlName> namespaceBindings(const QXmlNodeModelIndex &n) const;
+        virtual void sendNamespaces(const QXmlNodeModelIndex &n,
+                                    QAbstractXmlReceiver *const receiver) const;
+        virtual QString stringValue(const QXmlNodeModelIndex &n) const;
+        virtual QVariant typedValue(const QXmlNodeModelIndex &n) const;
+        virtual Item::Iterator::Ptr sequencedTypedValue(const QXmlNodeModelIndex &n) const;
+        virtual ItemType::Ptr type(const QXmlNodeModelIndex &ni) const;
+        virtual QXmlNodeModelIndex elementById(const QXmlName &id) const;
+        virtual QVector<QXmlNodeModelIndex> nodesByIdref(const QXmlName &idref) const;
+        virtual void copyNodeTo(const QXmlNodeModelIndex &node,
+                                QAbstractXmlReceiver *const receiver,
+                                const NodeCopySettings &settings) const;
+
+        friend class AccelTreeBuilder<false>;
+        friend class AccelTreeBuilder<true>;
+
+        enum Constants
+        {
+            IsCompressed = 1
+        };
+
+        /**
+         * The key is the pre number of an element, and the value is a vector
+         * containing the namespace declarations being declared on that
+         * element. Therefore, it does not reflect the namespaces being in
+         * scope for that element. For that, a walk along axis ancestor is
+         * necessary.
+         */
+        QHash<PreNumber, QVector<QXmlName> > namespaces;
+
+        /**
+         * Stores data for nodes. The QHash's value is the data of the processing instruction, and the
+         * content of a text node or comment.
+         */
+        QHash<PreNumber, QString> data;
+
+        QVector<BasicNodeData> basicData;
+
+        inline QUrl documentUri() const
+        {
+            return m_documentURI;
+        }
+
+        inline QUrl baseUri() const
+        {
+            return m_baseURI;
+        }
+
+        /**
+         * @short Returns @c true if the node identified by @p pre has child
+         * nodes(in the sense of the XDM), but also if it has namespace nodes,
+         * or attribute nodes.
+         */
+        inline bool hasChildren(const PreNumber pre) const
+        {
+            return basicData.at(pre).size() > 0;
+        }
+
+        /**
+         * @short Returns the parent node of @p pre.
+         *
+         * If @p pre parent doesn't have a parent node, the return value is
+         * undefined.
+         *
+         * @see hasParent()
+         */
+        inline PreNumber parent(const PreNumber pre) const
+        {
+            return basicData.at(pre).parent();
+        }
+
+        inline bool hasParent(const PreNumber pre) const
+        {
+            return basicData.at(pre).depth() > 0;
+        }
+
+        inline bool hasFollowingSibling(const PreNumber pre) const
+        {
+            return pre < maximumPreNumber();
+        }
+
+        inline PostNumber postNumber(const PreNumber pre) const
+        {
+            const BasicNodeData &b = basicData.at(pre);
+            return pre + b.size() - b.depth();
+        }
+
+        inline QXmlNodeModelIndex::NodeKind kind(const PreNumber pre) const
+        {
+            return basicData.at(pre).kind();
+        }
+
+        inline PreNumber maximumPreNumber() const
+        {
+            return basicData.count() - 1;
+        }
+
+        inline PreNumber toPreNumber(const QXmlNodeModelIndex n) const
+        {
+            return n.data();
+        }
+
+        inline PreNumber size(const PreNumber pre) const
+        {
+            Q_ASSERT_X(basicData.at(pre).size() != -1, Q_FUNC_INFO,
+                       "The size cannot be -1. That means an uninitialized value is attempted to be used.");
+            return basicData.at(pre).size();
+        }
+
+        inline Depth depth(const PreNumber pre) const
+        {
+            return basicData.at(pre).depth();
+        }
+
+        void printStats(const NamePool::Ptr &np) const;
+
+        inline QXmlName name(const PreNumber pre) const
+        {
+            return basicData.at(pre).name();
+        }
+
+        inline bool isCompressed(const PreNumber pre) const
+        {
+            return basicData.at(pre).isCompressed();
+        }
+
+        static inline bool hasPrefix(const QVector<QXmlName> &nbs, const QXmlName::PrefixCode prefix);
+
+        QUrl m_documentURI;
+        QUrl m_baseURI;
+
+    protected:
+        virtual QXmlNodeModelIndex nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis,
+                                                      const QXmlNodeModelIndex&) const;
+        virtual QVector<QXmlNodeModelIndex> attributes(const QXmlNodeModelIndex &element) const;
+
+    private:
+        /**
+         * Copies the children of @p node to @p receiver.
+         */
+        inline void copyChildren(const QXmlNodeModelIndex &node,
+                                 QAbstractXmlReceiver *const receiver,
+                                 const NodeCopySettings &settings) const;
+
+        /**
+         * The key is the xml:id value, and the value is the element
+         * with that value.
+         */
+        QHash<QXmlName::LocalNameCode, PreNumber> m_IDs;
+    };
+}
+
+Q_DECLARE_TYPEINFO(QPatternist::AccelTree::BasicNodeData, Q_MOVABLE_TYPE);
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/acceltree/qacceltreebuilder.cpp b/src/xmlpatterns/acceltree/qacceltreebuilder.cpp
new file mode 100644
index 0000000..5b16cc3
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceltreebuilder.cpp
@@ -0,0 +1,429 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/**
+ * @file
+ * @short This file is included by qacceltreebuilder_p.h.
+ * If you need includes in this file, put them in qacceltreebuilder_p.h, outside of the namespace.
+ */
+
+template <bool FromDocument>
+AccelTreeBuilder<FromDocument>::AccelTreeBuilder(const QUrl &docURI,
+                                                 const QUrl &baseURI,
+                                                 const NamePool::Ptr &np,
+                                                 ReportContext *const context) : m_preNumber(-1)
+                                                                               , m_isPreviousAtomic(false)
+                                                                               , m_hasCharacters(false)
+                                                                               , m_isCharactersCompressed(false)
+                                                                               , m_namePool(np)
+                                                                               , m_document(new AccelTree(docURI, baseURI))
+                                                                               , m_skippedDocumentNodes(0)
+                                                                               , m_documentURI(docURI)
+                                                                               , m_context(context)
+{
+    Q_ASSERT(m_namePool);
+
+    /* TODO Perhaps we can merge m_ancestors and m_size
+     * into one, and store a struct for the two instead? */
+    m_ancestors.reserve(DefaultNodeStackSize);
+    m_ancestors.push(-1);
+
+    m_size.reserve(DefaultNodeStackSize);
+    m_size.push(0);
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::startStructure()
+{
+    if(m_hasCharacters)
+    {
+        /* We create a node even if m_characters is empty.
+         * Remember that `text {""}' creates one text node
+         * with string value "". */
+
+        ++m_preNumber;
+        m_document->basicData.append(AccelTree::BasicNodeData(currentDepth(),
+                                                              currentParent(),
+                                                              QXmlNodeModelIndex::Text,
+                                                              m_isCharactersCompressed ? AccelTree::IsCompressed : 0));
+        m_document->data.insert(m_preNumber, m_characters);
+        ++m_size.top();
+
+        m_characters.clear(); /* We don't want it added twice. */
+        m_hasCharacters = false;
+
+        if(m_isCharactersCompressed)
+            m_isCharactersCompressed = false;
+    }
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::item(const Item &it)
+{
+    Q_ASSERT(it);
+
+    if(it.isAtomicValue())
+    {
+        if(m_isPreviousAtomic)
+        {
+            m_characters += QLatin1Char(' ');
+            m_characters += it.stringValue();
+        }
+        else
+        {
+            m_isPreviousAtomic = true;
+            const QString sv(it.stringValue());
+
+            if(!sv.isEmpty())
+            {
+                m_characters += sv;
+                m_hasCharacters = true;
+            }
+        }
+    }
+    else
+        sendAsNode(it);
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::startElement(const QXmlName &name)
+{
+    startStructure();
+
+    m_document->basicData.append(AccelTree::BasicNodeData(currentDepth(), currentParent(), QXmlNodeModelIndex::Element, -1, name));
+
+    ++m_preNumber;
+    m_ancestors.push(m_preNumber);
+
+    ++m_size.top();
+    m_size.push(0);
+
+    /* With node constructors, we can receive names for which we have no namespace
+     * constructors, such as in the query '<xs:space/>'. Since the 'xs' prefix has no
+     * NamespaceConstructor in this case, we synthesize the namespace.
+     *
+     * In case we're constructing from an XML document we avoid the call because
+     * although it's redundant, it's on extra virtual call for each element. */
+    if(!FromDocument)
+        namespaceBinding(QXmlName(name.namespaceURI(), 0, name.prefix()));
+
+    m_isPreviousAtomic = false;
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::endElement()
+{
+    startStructure();
+    const AccelTree::PreNumber index = m_ancestors.pop();
+    AccelTree::BasicNodeData &data = m_document->basicData[index];
+
+    /* Sub trees needs to be included in upper trees, so we add the count of this element
+     * to our parent. */
+    m_size[m_size.count() - 2] += m_size.top();
+
+    data.setSize(m_size.pop());
+    m_isPreviousAtomic = false;
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::attribute(const QXmlName &name, const QStringRef &value)
+{
+    /* Attributes adds a namespace binding, so lets synthesize one.
+     *
+     * We optimize by checking whether we have a namespace for which a binding would
+     * be generated. Happens relatively rarely. */
+    if(name.hasPrefix())
+        namespaceBinding(QXmlName(name.namespaceURI(), 0, name.prefix()));
+
+    m_document->basicData.append(AccelTree::BasicNodeData(currentDepth(), currentParent(), QXmlNodeModelIndex::Attribute, 0, name));
+    ++m_preNumber;
+    ++m_size.top();
+
+    m_isPreviousAtomic = false;
+
+    if(name.namespaceURI() == StandardNamespaces::xml && name.localName() == StandardLocalNames::id)
+    {
+        const QString normalized(value.toString().simplified());
+
+        if(QXmlUtils::isNCName(normalized))
+        {
+            const QXmlName::LocalNameCode id = m_namePool->allocateLocalName(normalized);
+
+            const int oldSize = m_document->m_IDs.count();
+            m_document->m_IDs.insert(id, currentParent());
+            /* We don't run the value through m_attributeCompress here, because
+             * the likelyhood of it deing identical to another attribute is
+             * very small. */
+            m_document->data.insert(m_preNumber, normalized);
+
+            /**
+             * In the case that we're called for doc-available(), m_context is
+             * null, and we need to flag somehow that we failed to load this
+             * document.
+             */
+            if(oldSize == m_document->m_IDs.count() && m_context) // TODO
+            {
+                Q_ASSERT(m_context);
+                m_context->error(QtXmlPatterns::tr("An %1-attribute with value %2 has already been declared.")
+                                                   .arg(formatKeyword("xml:id"),
+                                                        formatData(normalized)),
+                                 FromDocument ? ReportContext::FODC0002 : ReportContext::XQDY0091,
+                                 this);
+            }
+        }
+        else if(m_context) // TODO
+        {
+            Q_ASSERT(m_context);
+
+            /* If we're building from an XML Document(e.g, we're fed from QXmlStreamReader, we raise FODC0002,
+             * otherwise XQDY0091. */
+            m_context->error(QtXmlPatterns::tr("An %1-attribute must have a "
+                                               "valid %2 as value, which %3 isn't.").arg(formatKeyword("xml:id"),
+                                                                                         formatType(m_namePool, BuiltinTypes::xsNCName),
+                                                                                         formatData(value.toString())),
+                             FromDocument ? ReportContext::FODC0002 : ReportContext::XQDY0091,
+                             this);
+        }
+    }
+    else
+        m_document->data.insert(m_preNumber, *m_attributeCompress.insert(value.toString()));
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::characters(const QStringRef &ch)
+{
+
+    /* If a text node constructor appears by itself, a node needs to
+     * be created. Therefore, we set m_hasCharacters
+     * if we're the only node.
+     * However, if the text node appears as a child of a document or element
+     * node it is discarded if it's empty.
+     */
+    if(m_hasCharacters && m_isCharactersCompressed)
+    {
+        m_characters = CompressedWhitespace::decompress(m_characters);
+        m_isCharactersCompressed = false;
+    }
+
+    m_characters += ch;
+
+    m_isPreviousAtomic = false;
+    m_hasCharacters = !m_characters.isEmpty() || m_preNumber == -1; /* -1 is our start value. */
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::whitespaceOnly(const QStringRef &ch)
+{
+    Q_ASSERT(!ch.isEmpty());
+    Q_ASSERT(ch.toString().trimmed().isEmpty());
+
+    /* This gets problematic due to how QXmlStreamReader works(which
+     * is the only one we get whitespaceOnly() events from). Namely, text intermingled
+     * with CDATA gets reported as individual Characters events, and
+     * QXmlStreamReader::isWhitespace() can return differently for each of those. However,
+     * it will occur very rarely, so this workaround of 1) mistakenly compressing 2) decompressing 3)
+     * appending, will happen infrequently.
+     */
+    if(m_hasCharacters)
+    {
+        if(m_isCharactersCompressed)
+        {
+            m_characters = CompressedWhitespace::decompress(m_characters);
+            m_isCharactersCompressed = false;
+        }
+
+        m_characters.append(ch.toString());
+    }
+    else
+    {
+        /* We haven't received a text node previously. */
+        m_characters = CompressedWhitespace::compress(ch);
+        m_isCharactersCompressed = true;
+        m_isPreviousAtomic = false;
+        m_hasCharacters = true;
+    }
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::processingInstruction(const QXmlName &target,
+                                                           const QString &data)
+{
+    startStructure();
+    ++m_preNumber;
+    m_document->data.insert(m_preNumber, data);
+
+    m_document->basicData.append(AccelTree::BasicNodeData(currentDepth(),
+                                                          currentParent(),
+                                                          QXmlNodeModelIndex::ProcessingInstruction,
+                                                          0,
+                                                          target));
+    ++m_size.top();
+    m_isPreviousAtomic = false;
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::comment(const QString &content)
+{
+    startStructure();
+    m_document->basicData.append(AccelTree::BasicNodeData(currentDepth(), currentParent(), QXmlNodeModelIndex::Comment, 0));
+    ++m_preNumber;
+    m_document->data.insert(m_preNumber, content);
+    ++m_size.top();
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::namespaceBinding(const QXmlName &nb)
+{
+    /* Note, because attribute() sometimes generate namespaceBinding() calls, this function
+     * can be called after attributes, in contrast to what the class documentation says. This is ok,
+     * as long as we're not dealing with public API. */
+
+    /* If we've received attributes, it means the element's size have changed and m_preNumber have advanced,
+     * so "reverse back" to the actual element. */
+    const AccelTree::PreNumber pn = m_preNumber - m_size.top();
+
+    QVector<QXmlName> &nss = m_document->namespaces[pn];
+
+    /* "xml" hasn't been declared for each node, AccelTree::namespaceBindings() adds it, so avoid it
+     * such that we don't get duplicates. */
+    if(nb.prefix() == StandardPrefixes::xml)
+        return;
+
+    /* If we already have the binding, skip it. */
+    const int len = nss.count();
+    for(int i = 0; i < len; ++i)
+    {
+        if(nss.at(i).prefix() == nb.prefix())
+            return;
+    }
+
+    nss.append(nb);
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::startDocument()
+{
+    /* If we have already received nodes, we can't add a document node. */
+    if(m_preNumber == -1) /* -1 is our start value. */
+    {
+        m_size.push(0);
+        m_document->basicData.append(AccelTree::BasicNodeData(0, -1, QXmlNodeModelIndex::Document, -1));
+        ++m_preNumber;
+        m_ancestors.push(m_preNumber);
+    }
+    else
+        ++m_skippedDocumentNodes;
+
+    m_isPreviousAtomic = false;
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::endDocument()
+{
+    if(m_skippedDocumentNodes == 0)
+    {
+        /* Create text nodes, if we've received any. We do this only if we're the
+         * top node because if we're getting this event as being a child of an element,
+         * text nodes or atomic values can appear after us, and which must get
+         * merged with the previous text.
+         *
+         * We call startStructure() before we pop the ancestor, such that the text node becomes
+         * a child of this document node. */
+        startStructure();
+
+        m_document->basicData.first().setSize(m_size.pop());
+        m_ancestors.pop();
+    }
+    else
+        --m_skippedDocumentNodes;
+
+    m_isPreviousAtomic = false;
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::atomicValue(const QVariant &value)
+{
+    Q_UNUSED(value);
+    // TODO
+}
+
+template <bool FromDocument>
+QAbstractXmlNodeModel::Ptr AccelTreeBuilder<FromDocument>::builtDocument()
+{
+    /* Create a text node, if we have received text in some way. */
+    startStructure();
+    m_document->printStats(m_namePool);
+
+    return m_document;
+}
+
+template <bool FromDocument>
+NodeBuilder::Ptr AccelTreeBuilder<FromDocument>::create(const QUrl &baseURI) const
+{
+    Q_UNUSED(baseURI);
+    return NodeBuilder::Ptr(new AccelTreeBuilder(QUrl(), baseURI, m_namePool, m_context));
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::startOfSequence()
+{
+}
+
+template <bool FromDocument>
+void AccelTreeBuilder<FromDocument>::endOfSequence()
+{
+}
+
+template <bool FromDocument>
+const SourceLocationReflection *AccelTreeBuilder<FromDocument>::actualReflection() const
+{
+    return this;
+}
+
+template <bool FromDocument>
+QSourceLocation AccelTreeBuilder<FromDocument>::sourceLocation() const
+{
+    if(m_documentURI.isEmpty())
+        return QSourceLocation(QUrl(QLatin1String("AnonymousNodeTree")));
+    else
+        return QSourceLocation(m_documentURI);
+}
+
diff --git a/src/xmlpatterns/acceltree/qacceltreebuilder_p.h b/src/xmlpatterns/acceltree/qacceltreebuilder_p.h
new file mode 100644
index 0000000..653eb85
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceltreebuilder_p.h
@@ -0,0 +1,187 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+
+#ifndef Patternist_AccelTreeBuilder_H
+#define Patternist_AccelTreeBuilder_H
+
+#include <QSet>
+#include <QStack>
+
+#include "private/qxmlutils_p.h"
+#include "qacceltree_p.h"
+#include "qbuiltintypes_p.h"
+#include "qcompressedwhitespace_p.h"
+#include "qnamepool_p.h"
+#include "qnodebuilder_p.h"
+#include "qreportcontext_p.h"
+#include "qsourcelocationreflection_p.h"
+#include "qpatternistlocale_p.h"
+#include <QtDebug>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+namespace QPatternist
+{
+    /**
+     * @short Builds an AccelTree from a stream of XML/Item events
+     * received through the NodeBuilder interface.
+     *
+     * If FromDocument is @c true, it is assumed that AccelTreeBuilder is fed
+     * events from an XML document, otherwise it is assumed the events
+     * are from node constructor expressions.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    template<bool FromDocument>
+    class AccelTreeBuilder : public NodeBuilder
+                           , public SourceLocationReflection
+    {
+    public:
+        typedef QExplicitlySharedDataPointer<AccelTreeBuilder> Ptr;
+
+        /**
+         * @param context may be @c null.
+         */
+        AccelTreeBuilder(const QUrl &docURI,
+                         const QUrl &baseURI,
+                         const NamePool::Ptr &np,
+                         ReportContext *const context);
+        virtual void startDocument();
+        virtual void endDocument();
+        virtual void startElement(const QXmlName &name);
+        virtual void endElement();
+        virtual void attribute(const QXmlName &name, const QStringRef &value);
+        virtual void characters(const QStringRef &ch);
+        virtual void whitespaceOnly(const QStringRef &ch);
+        virtual void processingInstruction(const QXmlName &target,
+                                           const QString &data);
+        virtual void namespaceBinding(const QXmlName &nb);
+        virtual void comment(const QString &content);
+        virtual void item(const Item &it);
+
+        virtual QAbstractXmlNodeModel::Ptr builtDocument();
+        virtual NodeBuilder::Ptr create(const QUrl &baseURI) const;
+        virtual void startOfSequence();
+        virtual void endOfSequence();
+
+        inline AccelTree::Ptr builtDocument() const
+        {
+            return m_document;
+        }
+
+        virtual void atomicValue(const QVariant &value);
+
+        virtual const SourceLocationReflection *actualReflection() const;
+        virtual QSourceLocation sourceLocation() const;
+
+    private:
+        inline void startStructure();
+
+        inline AccelTree::PreNumber currentDepth() const
+        {
+            return m_ancestors.count() -1;
+        }
+
+        inline AccelTree::PreNumber currentParent() const
+        {
+            return m_ancestors.isEmpty() ? -1 : m_ancestors.top();
+        }
+
+        enum Constants
+        {
+            DefaultNodeStackSize = 10,
+            SizeIsEmpty = 0
+        };
+
+        AccelTree::PreNumber            m_preNumber;
+        bool                            m_isPreviousAtomic;
+        bool                            m_hasCharacters;
+        /**
+         * Whether m_characters has been run through
+         * CompressedWhitespace::compress().
+         */
+        bool                            m_isCharactersCompressed;
+        QString                         m_characters;
+        NamePool::Ptr                   m_namePool;
+        AccelTree::Ptr                  m_document;
+        QStack<AccelTree::PreNumber>    m_ancestors;
+        QStack<AccelTree::PreNumber>    m_size;
+
+        /** If we have already commenced a document, we don't want to
+         * add more document nodes. We keep track of them with this
+         * counter, which ensures that startDocument() and endDocument()
+         * are skipped consistently. */
+        AccelTree::PreNumber            m_skippedDocumentNodes;
+
+        /**
+         * All attribute values goes through this set such that we store only
+         * one QString for identical attribute values.
+         */
+        QSet<QString>                   m_attributeCompress;
+        const QUrl                      m_documentURI;
+        /**
+         * We don't store a reference pointer here because then we get a
+         * circular reference with GenericDynamicContext, when it stores us as
+         * a member.
+         */
+        ReportContext *const            m_context;
+    };
+
+#include "qacceltreebuilder.cpp"
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/acceltree/qacceltreeresourceloader.cpp b/src/xmlpatterns/acceltree/qacceltreeresourceloader.cpp
new file mode 100644
index 0000000..4a5c219
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceltreeresourceloader.cpp
@@ -0,0 +1,411 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/QFile>
+#include <QtCore/QTextCodec>
+#include <QtCore/QTimer>
+#include <QtCore/QXmlStreamReader>
+
+#include <QtNetwork/QNetworkRequest>
+
+#include "qacceltreebuilder_p.h"
+#include "qatomicstring_p.h"
+#include "qautoptr_p.h"
+#include "qcommonsequencetypes_p.h"
+
+#include "qacceltreeresourceloader_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+static inline uint qHash(const QUrl &uri)
+{
+        return qHash(uri.toString());
+}
+
+AccelTreeResourceLoader::AccelTreeResourceLoader(const NamePool::Ptr &np,
+                                                 const NetworkAccessDelegator::Ptr &manager) : m_namePool(np)
+                                                                                             , m_networkAccessDelegator(manager)
+{
+    Q_ASSERT(m_namePool);
+    Q_ASSERT(m_networkAccessDelegator);
+}
+
+bool AccelTreeResourceLoader::retrieveDocument(const QUrl &uri,
+                                               const ReportContext::Ptr &context)
+{
+    Q_ASSERT(uri.isValid());
+    AccelTreeBuilder<true> builder(uri, uri, m_namePool, context.data());
+
+    const AutoPtr<QNetworkReply> reply(load(uri, m_networkAccessDelegator, context));
+
+    if(!reply)
+        return false;
+
+    bool success = false;
+    success = streamToReceiver(reply.data(), &builder, m_namePool, context, uri);
+
+    m_loadedDocuments.insert(uri, builder.builtDocument());
+    return success;
+}
+
+QNetworkReply *AccelTreeResourceLoader::load(const QUrl &uri,
+                                             const NetworkAccessDelegator::Ptr &networkDelegator,
+                                             const ReportContext::Ptr &context)
+{
+    return load(uri,
+                networkDelegator->managerFor(uri),
+                context);
+}
+
+QNetworkReply *AccelTreeResourceLoader::load(const QUrl &uri,
+                                             QNetworkAccessManager *const networkManager,
+                                             const ReportContext::Ptr &context)
+{
+    Q_ASSERT(networkManager);
+    Q_ASSERT(uri.isValid());
+
+    NetworkLoop networkLoop;
+
+    QNetworkRequest request(uri);
+    QNetworkReply *const reply = networkManager->get(request);
+    networkLoop.connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(error(QNetworkReply::NetworkError)));
+    networkLoop.connect(reply, SIGNAL(finished()), SLOT(finished()));
+
+    if(networkLoop.exec())
+    {
+        const QString errorMessage(escape(reply->errorString()));
+
+        /* Note, we delete reply before we exit this function with error(). */
+        delete reply;
+
+        const QSourceLocation location(uri);
+
+        if(context)
+            context->error(errorMessage, ReportContext::FODC0002, location);
+
+        return 0;
+    }
+    else
+        return reply;
+}
+
+bool AccelTreeResourceLoader::streamToReceiver(QIODevice *const dev,
+                                               QAbstractXmlReceiver *const receiver,
+                                               const NamePool::Ptr &np,
+                                               const ReportContext::Ptr &context,
+                                               const QUrl &uri)
+{
+    Q_ASSERT(dev);
+    Q_ASSERT(receiver);
+    Q_ASSERT(np);
+
+    QXmlStreamReader reader(dev);
+
+    /* Optimize: change NamePool to take QStringRef such that we don't have to call toString() below. That
+     * will save us a gazillion of temporary QStrings. */
+
+    while(!reader.atEnd())
+    {
+        reader.readNext();
+
+        switch(reader.tokenType())
+        {
+            case QXmlStreamReader::StartElement:
+            {
+                /* Send the name. */
+                receiver->startElement(np->allocateQName(reader.namespaceUri().toString(), reader.name().toString(),
+                                                         reader.prefix().toString()));
+
+                /* Send namespace declarations. */
+                const QXmlStreamNamespaceDeclarations &nss = reader.namespaceDeclarations();
+
+                /* The far most common case, is for it to be empty. */
+                if(!nss.isEmpty())
+                {
+                    const int len = nss.size();
+
+                    for(int i = 0; i < len; ++i)
+                    {
+                        const QXmlStreamNamespaceDeclaration &ns = nss.at(i);
+                        receiver->namespaceBinding(np->allocateBinding(ns.prefix().toString(), ns.namespaceUri().toString()));
+                    }
+                }
+
+                /* Send attributes. */
+                const QXmlStreamAttributes &attrs = reader.attributes();
+                const int len = attrs.size();
+
+                for(int i = 0; i < len; ++i)
+                {
+                    const QXmlStreamAttribute &attr = attrs.at(i);
+
+                    receiver->attribute(np->allocateQName(attr.namespaceUri().toString(), attr.name().toString(),
+                                                          attr.prefix().toString()),
+                                        attr.value());
+                }
+
+                continue;
+            }
+            case QXmlStreamReader::EndElement:
+            {
+                receiver->endElement();
+                continue;
+            }
+            case QXmlStreamReader::Characters:
+            {
+                if(reader.isWhitespace())
+                    receiver->whitespaceOnly(reader.text());
+                else
+                    receiver->characters(reader.text());
+
+                continue;
+            }
+            case QXmlStreamReader::Comment:
+            {
+                receiver->comment(reader.text().toString());
+                continue;
+            }
+            case QXmlStreamReader::ProcessingInstruction:
+            {
+                receiver->processingInstruction(np->allocateQName(QString(), reader.processingInstructionTarget().toString()),
+                                                reader.processingInstructionData().toString());
+                continue;
+            }
+            case QXmlStreamReader::StartDocument:
+            {
+                receiver->startDocument();
+                continue;
+            }
+            case QXmlStreamReader::EndDocument:
+            {
+                receiver->endDocument();
+                continue;
+            }
+            case QXmlStreamReader::EntityReference:
+            /* Fallthrough. */
+            case QXmlStreamReader::DTD:
+            {
+                /* We just ignore any DTD and entity references. */
+                continue;
+            }
+            case QXmlStreamReader::Invalid:
+            {
+                if(context)
+                    context->error(escape(reader.errorString()), ReportContext::FODC0002, QSourceLocation(uri, reader.lineNumber(), reader.columnNumber()));
+
+                return false;
+            }
+            case QXmlStreamReader::NoToken:
+            {
+                Q_ASSERT_X(false, Q_FUNC_INFO,
+                           "This token is never expected to be received.");
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+Item AccelTreeResourceLoader::openDocument(const QUrl &uri,
+                                           const ReportContext::Ptr &context)
+{
+    const AccelTree::Ptr doc(m_loadedDocuments.value(uri));
+
+    if(doc)
+        return doc->root(QXmlNodeModelIndex()); /* Pass in dummy object. We know AccelTree doesn't use it. */
+    else
+    {
+        if(retrieveDocument(uri, context))
+            return m_loadedDocuments.value(uri)->root(QXmlNodeModelIndex()); /* Pass in dummy object. We know AccelTree doesn't use it. */
+        else
+            return Item();
+    }
+}
+
+SequenceType::Ptr AccelTreeResourceLoader::announceDocument(const QUrl &uri, const Usage)
+{
+    // TODO deal with the usage thingy
+    Q_ASSERT(uri.isValid());
+    Q_ASSERT(!uri.isRelative());
+    Q_UNUSED(uri); /* Needed when compiling in release mode. */
+
+    return CommonSequenceTypes::ZeroOrOneDocumentNode;
+}
+
+bool AccelTreeResourceLoader::isDocumentAvailable(const QUrl &uri)
+{
+    return retrieveDocument(uri, ReportContext::Ptr());
+}
+
+static inline uint qHash(const QPair<QUrl, QString> &desc)
+{
+    /* Probably a lousy hash. */
+    return qHash(desc.first) + qHash(desc.second);
+}
+
+bool AccelTreeResourceLoader::retrieveUnparsedText(const QUrl &uri,
+                                                   const QString &encoding,
+                                                   const ReportContext::Ptr &context,
+                                                   const SourceLocationReflection *const where)
+{
+    const AutoPtr<QNetworkReply> reply(load(uri, m_networkAccessDelegator, context));
+
+    if(!reply)
+        return false;
+
+    const QTextCodec * codec;
+    if(encoding.isEmpty())
+    {
+        /* XSL Transformations (XSLT) Version 2.0 16.2 Reading Text Files:
+         *
+         * "if the media type of the resource is text/xml or application/xml
+         * (see [RFC2376]), or if it matches the conventions text/\*+xml or
+         * application/\*+xml (see [RFC3023] and/or its successors), then the
+         * encoding is recognized as specified in [XML 1.0]"
+         */
+        codec = QTextCodec::codecForMib(106);
+    }
+    else
+    {
+        codec = QTextCodec::codecForName(encoding.toLatin1());
+        if(codec && context)
+        {
+            context->error(QtXmlPatterns::tr("%1 is an unsupported encoding.").arg(formatURI(encoding)),
+                           ReportContext::XTDE1190,
+                           where);
+        }
+        else
+            return false;
+    }
+
+    QTextCodec::ConverterState converterState;
+    const QByteArray inData(reply->readAll());
+    const QString result(codec->toUnicode(inData.constData(), inData.length(), &converterState));
+
+    if(converterState.invalidChars)
+    {
+        if(context)
+        {
+            context->error(QtXmlPatterns::tr("%1 contains octets which are disallowed in "
+                                             "the requested encoding %2.").arg(formatURI(uri),
+                                                                               formatURI(encoding)),
+                           ReportContext::XTDE1190,
+                           where);
+        }
+        else
+            return false;
+    }
+
+    const int len = result.length();
+    /* This code is a candidate for threading. Divide and conqueror. */
+    for(int i = 0; i < len; ++i)
+    {
+        if(!QXmlUtils::isChar(result.at(i)))
+        {
+            if(context)
+            {
+                context->error(QtXmlPatterns::tr("The codepoint %1, occurring in %2 using encoding %3, "
+                                                 "is an invalid XML character.").arg(formatData(result.at(i)),
+                                                                                     formatURI(uri),
+                                                                                     formatURI(encoding)),
+                               ReportContext::XTDE1190,
+                               where);
+            }
+            else
+                return false;
+        }
+    }
+
+    m_unparsedTexts.insert(qMakePair(uri, encoding), result);
+    return true;
+}
+
+bool AccelTreeResourceLoader::isUnparsedTextAvailable(const QUrl &uri,
+                                                      const QString &encoding)
+{
+    return retrieveUnparsedText(uri, encoding, ReportContext::Ptr(), 0);
+}
+
+Item AccelTreeResourceLoader::openUnparsedText(const QUrl &uri,
+                                               const QString &encoding,
+                                               const ReportContext::Ptr &context,
+                                               const SourceLocationReflection *const where)
+{
+    const QString &text = m_unparsedTexts.value(qMakePair(uri, encoding));
+
+    if(text.isNull())
+    {
+        if(retrieveUnparsedText(uri, encoding, context, where))
+            return openUnparsedText(uri, encoding, context, where);
+        else
+            return Item();
+    }
+    else
+        return AtomicString::fromValue(text);
+}
+
+QSet<QUrl> AccelTreeResourceLoader::deviceURIs() const
+{
+     QHash<QUrl, AccelTree::Ptr>::const_iterator it(m_loadedDocuments.constBegin());
+     const QHash<QUrl, AccelTree::Ptr>::const_iterator end(m_loadedDocuments.constEnd());
+     QSet<QUrl> retval;
+
+     while (it != end)
+     {
+         if(it.key().toString().startsWith(QLatin1String("tag:trolltech.com,2007:QtXmlPatterns:QIODeviceVariable:")))
+             retval.insert(it.key());
+
+         ++it;
+     }
+
+     return retval;
+}
+
+void AccelTreeResourceLoader::clear(const QUrl &uri)
+{
+    m_loadedDocuments.remove(uri);
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/acceltree/qacceltreeresourceloader_p.h b/src/xmlpatterns/acceltree/qacceltreeresourceloader_p.h
new file mode 100644
index 0000000..863fd65
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qacceltreeresourceloader_p.h
@@ -0,0 +1,195 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+
+#ifndef Patternist_AccelTreeResourceLoader_H
+#define Patternist_AccelTreeResourceLoader_H
+
+#include <QtCore/QHash>
+#include <QtCore/QEventLoop>
+#include <QtNetwork/QNetworkReply>
+
+#include "qabstractxmlreceiver.h"
+#include "qacceltree_p.h"
+#include "qdeviceresourceloader_p.h"
+#include "qnamepool_p.h"
+#include "qnetworkaccessdelegator_p.h"
+#include "qreportcontext_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QIODevice;
+
+namespace QPatternist
+{
+    /**
+     * @short An helper class which enables QNetworkAccessManager
+     * to be used in a blocking manner.
+     *
+     * @see AccelTreeResourceLoader::load()
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    class NetworkLoop : public QEventLoop
+    {
+        Q_OBJECT
+    public:
+        NetworkLoop() : m_hasReceivedError(false)
+        {
+        }
+
+    public Q_SLOTS:
+        void error(QNetworkReply::NetworkError code)
+        {
+            Q_UNUSED(code);
+            m_hasReceivedError = true;
+            exit(1);
+        }
+
+        void finished()
+        {
+            if(m_hasReceivedError)
+                exit(1);
+            else
+                exit(0);
+        }
+    private:
+        bool m_hasReceivedError;
+    };
+
+    /**
+     * @short Handles requests for documents, and instantiates
+     * them as AccelTree instances.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    class Q_AUTOTEST_EXPORT AccelTreeResourceLoader : public DeviceResourceLoader
+    {
+    public:
+        /**
+         * AccelTreeResourceLoader does not own @p context.
+         */
+        AccelTreeResourceLoader(const NamePool::Ptr &np,
+                                const NetworkAccessDelegator::Ptr &networkDelegator);
+
+        virtual Item openDocument(const QUrl &uri,
+                                  const ReportContext::Ptr &context);
+        virtual SequenceType::Ptr announceDocument(const QUrl &uri, const Usage usageHint);
+        virtual bool isDocumentAvailable(const QUrl &uri);
+
+        virtual bool isUnparsedTextAvailable(const QUrl &uri,
+                                             const QString &encoding);
+
+        virtual Item openUnparsedText(const QUrl &uri,
+                                      const QString &encoding,
+                                      const ReportContext::Ptr &context,
+                                      const SourceLocationReflection *const where);
+
+
+        /**
+         * @short Helper function that do NetworkAccessDelegator::get(), but
+         * does it blocked.
+         *
+         * The returned QNetworkReply has emitted QNetworkReply::finished().
+         *
+         * The caller owns the return QIODevice instance.
+         *
+         * @p context may be @c null or valid. If @c null, no error reporting
+         * is done and @c null is returned.
+         *
+         * @see NetworkAccessDelegator
+         */
+        static QNetworkReply *load(const QUrl &uri,
+                                   QNetworkAccessManager *const networkManager,
+                                   const ReportContext::Ptr &context);
+
+        /**
+         * @overload
+         */
+        static QNetworkReply *load(const QUrl &uri,
+                                   const NetworkAccessDelegator::Ptr &networkDelegator,
+                                   const ReportContext::Ptr &context);
+
+        /**
+         * @short Returns the URIs this AccelTreeResourceLoader has loaded
+         * which are for devices through variable bindings.
+         */
+        virtual QSet<QUrl> deviceURIs() const;
+
+        virtual void clear(const QUrl &uri);
+    private:
+        static bool streamToReceiver(QIODevice *const dev,
+                                     QAbstractXmlReceiver *const receiver,
+                                     const NamePool::Ptr &np,
+                                     const ReportContext::Ptr &context,
+                                     const QUrl &uri);
+        bool retrieveDocument(const QUrl &uri,
+                              const ReportContext::Ptr &context);
+        /**
+         * If @p context is @c null, no error reporting should be done.
+         */
+        bool retrieveUnparsedText(const QUrl &uri,
+                                  const QString &encoding,
+                                  const ReportContext::Ptr &context,
+                                  const SourceLocationReflection *const where);
+
+        QHash<QUrl, AccelTree::Ptr>             m_loadedDocuments;
+        const NamePool::Ptr                     m_namePool;
+        const NetworkAccessDelegator::Ptr       m_networkAccessDelegator;
+        QHash<QPair<QUrl, QString>, QString>    m_unparsedTexts;
+    };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/xmlpatterns/acceltree/qcompressedwhitespace.cpp b/src/xmlpatterns/acceltree/qcompressedwhitespace.cpp
new file mode 100644
index 0000000..730d1d9
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qcompressedwhitespace.cpp
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QString>
+
+#include "qcompressedwhitespace_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+CompressedWhitespace::CharIdentifier CompressedWhitespace::toIdentifier(const QChar ch)
+{
+    switch(ch.unicode())
+    {
+        case ' ':
+            return Space;
+        case '\n':
+            return LF;
+        case '\r':
+            return CR;
+        case '\t':
+            return Tab;
+        default:
+        {
+            Q_ASSERT_X(false, Q_FUNC_INFO,
+                       "The caller must guarantee only whitespace is passed.");
+            return Tab;
+        }
+    }
+}
+
+bool CompressedWhitespace::isEven(const int number)
+{
+    Q_ASSERT(number >= 0);
+    return number % 2 == 0;
+}
+
+quint8 CompressedWhitespace::toCompressedChar(const QChar ch, const int len)
+{
+    Q_ASSERT(len > 0);
+    Q_ASSERT(len <= MaxCharCount);
+
+    return len + toIdentifier(ch);
+}
+
+QChar CompressedWhitespace::toChar(const CharIdentifier id)
+{
+    switch(id)
+    {
+        case Space: return QLatin1Char(' ');
+        case CR:    return QLatin1Char('\r');
+        case LF:    return QLatin1Char('\n');
+        case Tab:   return QLatin1Char('\t');
+        default:
+                    {
+                        Q_ASSERT_X(false, Q_FUNC_INFO, "Unexpected input");
+                        return QChar();
+                    }
+    }
+}
+
+QString CompressedWhitespace::compress(const QStringRef &input)
+{
+    Q_ASSERT(!isEven(1) && isEven(0) && isEven(2));
+    Q_ASSERT(!input.isEmpty());
+
+    QString result;
+    const int len = input.length();
+
+    /* The amount of compressed characters. For instance, if input is
+     * four spaces followed by one tab, compressedChars will be 2, and the resulting
+     * QString will have a length of 1, two compressedChars stored in one QChar. */
+    int compressedChars = 0;
+
+    for(int i = 0; i < len; ++i)
+    {
+        const QChar c(input.at(i));
+
+        int start = i;
+
+        while(true)
+        {
+            if(i + 1 == input.length() || input.at(i + 1) != c)
+                break;
+            else
+                ++i;
+        }
+
+        /* The length of subsequent whitespace characters in the input. */
+        int wsLen = (i - start) + 1;
+
+        /* We might get a sequence of whitespace that is so long, that we can't
+         * store it in one unit/byte. In that case we chop it into as many subsequent
+         * ones that is needed. */
+        while(true)
+        {
+            const int unitLength = qMin(wsLen, int(MaxCharCount));
+            wsLen -= unitLength;
+
+            ushort resultCP = toCompressedChar(c, unitLength);
+
+            if(isEven(compressedChars))
+                result += QChar(resultCP);
+            else
+            {
+                resultCP = resultCP << 8;
+                resultCP |= result.at(result.size() - 1).unicode();
+                result[result.size() - 1] = resultCP;
+            }
+
+            ++compressedChars;
+
+            if(wsLen == 0)
+                break;
+        }
+    }
+
+    return result;
+}
+
+QString CompressedWhitespace::decompress(const QString &input)
+{
+    Q_ASSERT(!input.isEmpty());
+    const int len = input.length() * 2;
+    QString retval;
+
+    for(int i = 0; i < len; ++i)
+    {
+        ushort cp = input.at(i / 2).unicode();
+
+        if(isEven(i))
+            cp &= Lower8Bits;
+        else
+        {
+            cp = cp >> 8;
+
+            if(cp == 0)
+                return retval;
+        }
+
+        const quint8 wsLen = cp & Lower6Bits;
+        const quint8 id = cp & UpperTwoBits;
+
+        /* Resize retval, and fill in on the top. */
+        const int oldSize = retval.size();
+        const int newSize = retval.size() + wsLen;
+        retval.resize(newSize);
+        const QChar ch(toChar(CharIdentifier(id)));
+
+        for(int f = oldSize; f < newSize; ++f)
+            retval[f] = ch;
+    }
+
+    return retval;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/xmlpatterns/acceltree/qcompressedwhitespace_p.h b/src/xmlpatterns/acceltree/qcompressedwhitespace_p.h
new file mode 100644
index 0000000..92bc0a5
--- /dev/null
+++ b/src/xmlpatterns/acceltree/qcompressedwhitespace_p.h
@@ -0,0 +1,186 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+
+#ifndef Patternist_CompressedWhitespace_H
+#define Patternist_CompressedWhitespace_H
+
+#include <QtGlobal>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QChar;
+class QString;
+class QStringRef;
+
+namespace QPatternist
+{
+    /**
+     * @short A compression facility for whitespace nodes.
+     *
+     * CompressedWhitespace compresses and decompresses strings that consists of
+     * whitespace only, and do so with a scheme that is designed to do this
+     * specialized task in an efficient way. The approach is simple: each
+     * sequence of equal whitespace in the input gets coded into one byte,
+     * where the first two bits signals the type, CharIdentifier, and the
+     * remininding six bits is the count.
+     *
+     * For instance, this scheme manages to compress a sequence of spaces
+     * followed by a new line into 16 bits(one QChar), and QString stores
+     * strings of one QChar quite efficiently, by avoiding a heap allocation.
+     *
+     * There is no way to tell whether a QString is compressed or not.
+     *
+     * The compression scheme originates from Saxon, by Michael Kay.
+     *
+     * @author Frans Englich <fenglich@trolltech.com>
+     */
+    class CompressedWhitespace
+    {
+        public:
+            /**
+             * @short Compresses @p input into a compressed format, returned
+             * as a QString.
+             *
+             * The caller guarantees that input is not empty
+             * and consists only of whitespace.
+             *
+             * The returned format is opaque. There is no way to find out
+             * whether a QString contains compressed data or not.
+             *
+             * @see decompress()
+             */
+            static QString compress(const QStringRef &input);
+
+            /**
+             * @short Decompresses @p input into a usual QString.
+             *
+             * @p input must be a QString as per returned from compress().
+             *
+             * @see compress()
+             */
+            static QString decompress(const QString &input);
+
+        private:
+            /**
+             * We use the two upper bits for communicating what space it is.
+             */
+            enum CharIdentifier
+            {
+                Space   = 0x0,
+
+                /**
+                 * 0xA, \\r
+                 *
+                 * Binary: 10000000
+                 */
+                CR      = 0x80,
+
+                /**
+                 * 0xD, \\n
+                 *
+                 * Binary: 01000000
+                 */
+                LF      = 0x40,
+
+                /**
+                 * Binary: 11000000
+                 */
+                Tab     = 0xC0
+            };
+
+            enum Constants
+            {
+                /* We can at maximum store this many consecutive characters
+                 * of one type. We use 6 bits for the count. */
+                MaxCharCount = (1 << 6) - 1,
+
+                /**
+                 * Binary: 11111111
+                 */
+                Lower8Bits = (1 << 8) - 1,
+
+                /**
+                 * Binary: 111111
+                 */
+                Lower6Bits = (1 << 6) - 1,
+
+                /*
+                 * Binary: 11000000
+                 */
+                UpperTwoBits = 3 << 6
+            };
+
+            static inline CharIdentifier toIdentifier(const QChar ch);
+
+            static inline quint8 toCompressedChar(const QChar ch, const int len);
+            static inline QChar toChar(const CharIdentifier id);
+
+            /**
+             * @short Returns @c true if @p number is an even number, otherwise
+             * @c false.
+             */
+            static inline bool isEven(const int number);
+
+            /**
+             * @short This class can only be used via its static members.
+             */
+            inline CompressedWhitespace();
+            Q_DISABLE_COPY(CompressedWhitespace)
+    };
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif