src/corelib/io/qresource.cpp
changeset 0 1918ee327afb
child 3 41300fa6a67c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/corelib/io/qresource.cpp	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,1510 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qresource.h"
+#include "qresource_p.h"
+#include "qresource_iterator_p.h"
+#include "qset.h"
+#include "qhash.h"
+#include "qmutex.h"
+#include "qdebug.h"
+#include "qlocale.h"
+#include "qglobal.h"
+#include "qvector.h"
+#include "qdatetime.h"
+#include "qbytearray.h"
+#include "qstringlist.h"
+#include <qshareddata.h>
+#include <qplatformdefs.h>
+#include "private/qabstractfileengine_p.h"
+
+#ifdef Q_OS_UNIX
+# include "private/qcore_unix_p.h"
+#endif
+
+//#define DEBUG_RESOURCE_MATCH
+
+#if defined(Q_OS_VXWORKS)
+#  if defined(m_data)
+#    undef m_data
+#  endif
+#  if defined(m_len)
+#    undef m_len
+#  endif
+#endif
+
+QT_BEGIN_NAMESPACE
+
+
+class QStringSplitter
+{
+public:
+    QStringSplitter(const QString &s)
+        : m_string(s), m_data(m_string.constData()), m_len(s.length()), m_pos(0)
+    {
+        m_splitChar = QLatin1Char('/');
+    }
+
+    inline bool hasNext() {
+        while (m_pos < m_len && m_data[m_pos] == m_splitChar)
+            ++m_pos;
+        return m_pos < m_len;
+    }
+
+    inline QStringRef next() {
+        int start = m_pos;
+        while (m_pos < m_len && m_data[m_pos] != m_splitChar)
+            ++m_pos;
+        return QStringRef(&m_string, start, m_pos - start);
+    }
+
+    QString m_string;
+    const QChar *m_data;
+    QChar m_splitChar;
+    int m_len;
+    int m_pos;
+};
+
+
+//resource glue
+class QResourceRoot
+{
+    enum Flags
+    {
+        Compressed = 0x01,
+        Directory = 0x02
+    };
+    const uchar *tree, *names, *payloads;
+    inline int findOffset(int node) const { return node * 14; } //sizeof each tree element
+    int hash(int node) const;
+    QString name(int node) const;
+    short flags(int node) const;
+public:
+    mutable QAtomicInt ref;
+
+    inline QResourceRoot(): tree(0), names(0), payloads(0) {}
+    inline QResourceRoot(const uchar *t, const uchar *n, const uchar *d) { setSource(t, n, d); }
+    virtual ~QResourceRoot() { }
+    int findNode(const QString &path, const QLocale &locale=QLocale()) const;
+    inline bool isContainer(int node) const { return flags(node) & Directory; }
+    inline bool isCompressed(int node) const { return flags(node) & Compressed; }
+    const uchar *data(int node, qint64 *size) const;
+    QStringList children(int node) const;
+    virtual QString mappingRoot() const { return QString(); }
+    bool mappingRootSubdir(const QString &path, QString *match=0) const;
+    inline bool operator==(const QResourceRoot &other) const
+    { return tree == other.tree && names == other.names && payloads == other.payloads; }
+    inline bool operator!=(const QResourceRoot &other) const
+    { return !operator==(other); }
+    enum ResourceRootType { Resource_Builtin, Resource_File, Resource_Buffer };
+    virtual ResourceRootType type() const { return Resource_Builtin; }
+
+protected:
+    inline void setSource(const uchar *t, const uchar *n, const uchar *d) {
+        tree = t;
+        names = n;
+        payloads = d;
+    }
+};
+
+static QString cleanPath(const QString &_path)
+{
+    QString path = QDir::cleanPath(_path);
+    // QDir::cleanPath does not remove two trailing slashes under _Windows_
+    // due to support for UNC paths. Remove those manually.
+    if (path.startsWith(QLatin1String("//")))
+        path.remove(0, 1);
+    return path;
+}
+
+Q_DECLARE_TYPEINFO(QResourceRoot, Q_MOVABLE_TYPE);
+
+Q_GLOBAL_STATIC_WITH_ARGS(QMutex, resourceMutex, (QMutex::Recursive))
+
+typedef QList<QResourceRoot*> ResourceList;
+Q_GLOBAL_STATIC(ResourceList, resourceList)
+
+Q_GLOBAL_STATIC(QStringList, resourceSearchPaths)
+
+/*!
+    \class QResource
+    \brief The QResource class provides an interface for reading directly from resources.
+
+    \ingroup io
+
+    \reentrant
+    \since 4.2
+
+    QResource is an object that represents a set of data (and possibly
+    children) relating to a single resource entity. QResource gives direct
+    access to the bytes in their raw format. In this way direct access
+    allows reading data without buffer copying or indirection. Indirection
+    is often useful when interacting with the resource entity as if it is a
+    file, this can be achieved with QFile. The data and children behind a
+    QResource are normally compiled into an application/library, but it is
+    also possible to load a resource at runtime. When loaded at run time
+    the resource file will be loaded as one big set of data and then given
+    out in pieces via references into the resource tree.
+
+    A QResource can either be loaded with an absolute path, either treated
+    as a file system rooted with a \c{/} character, or in resource notation
+    rooted with a \c{:} character. A relative resource can also be opened
+    which will be found through the searchPaths().
+
+    A QResource that is representing a file will have data backing it, this
+    data can possibly be compressed, in which case qUncompress() must be
+    used to access the real data; this happens implicitly when accessed
+    through a QFile. A QResource that is representing a directory will have
+    only children and no data.
+
+    \section1 Dynamic Resource Loading
+
+    A resource can be left out of an application's binary and loaded when
+    it is needed at run-time by using the registerResource() function. The
+    resource file passed into registerResource() must be a binary resource
+    as created by rcc. Further information about binary resources can be
+    found in \l{The Qt Resource System} documentation.
+
+    This can often be useful when loading a large set of application icons
+    that may change based on a setting, or that can be edited by a user and
+    later recreated. The resource is immediately loaded into memory, either
+    as a result of a single file read operation, or as a memory mapped file.
+
+    This approach can prove to be a significant performance gain as only a
+    single file will be loaded, and pieces of data will be given out via the
+    path requested in setFileName().
+
+    The unregisterResource() function removes a reference to a particular
+    file. If there are QResources that currently reference resources related
+    to the unregistered file, they will continue to be valid but the resource
+    file itself will be removed from the resource roots, and thus no further
+    QResource can be created pointing into this resource data. The resource
+    itself will be unmapped from memory when the last QResource that points
+    to it is destroyed.
+
+    \sa {The Qt Resource System}, QFile, QDir, QFileInfo
+*/
+
+class QResourcePrivate {
+public:
+    inline QResourcePrivate(QResource *_q) : q_ptr(_q) { clear(); }
+    inline ~QResourcePrivate() { clear(); }
+
+    void ensureInitialized() const;
+    void ensureChildren() const;
+
+    bool load(const QString &file);
+    void clear();
+
+    QLocale locale;
+    QString fileName, absoluteFilePath;
+    QList<QResourceRoot*> related;
+    uint container : 1;
+    mutable uint compressed : 1;
+    mutable qint64 size;
+    mutable const uchar *data;
+    mutable QStringList children;
+
+    QResource *q_ptr;
+    Q_DECLARE_PUBLIC(QResource)
+};
+
+void
+QResourcePrivate::clear()
+{
+    absoluteFilePath.clear();
+    compressed = 0;
+    data = 0;
+    size = 0;
+    children.clear();
+    container = 0;
+    for(int i = 0; i < related.size(); ++i) {
+        QResourceRoot *root = related.at(i);
+        if(!root->ref.deref())
+            delete root;
+    }
+    related.clear();
+}
+
+bool
+QResourcePrivate::load(const QString &file)
+{
+    related.clear();
+    QMutexLocker lock(resourceMutex());
+    const ResourceList *list = resourceList();
+    QString cleaned = cleanPath(file);
+    for(int i = 0; i < list->size(); ++i) {
+        QResourceRoot *res = list->at(i);
+        const int node = res->findNode(cleaned);
+        if(node != -1) {
+            if(related.isEmpty()) {
+                container = res->isContainer(node);
+                if(!container) {
+                    data = res->data(node, &size);
+                    compressed = res->isCompressed(node);
+                } else {
+                    data = 0;
+                    size = 0;
+                    compressed = 0;
+                }
+            } else if(res->isContainer(node) != container) {
+                qWarning("QResourceInfo: Resource [%s] has both data and children!", file.toLatin1().constData());
+            }
+            res->ref.ref();
+            related.append(res);
+        } else if(res->mappingRootSubdir(file)) {
+            container = true;
+            data = 0;
+            size = 0;
+            compressed = 0;
+            res->ref.ref();
+            related.append(res);
+        }
+    }
+    return !related.isEmpty();
+}
+
+void
+QResourcePrivate::ensureInitialized() const
+{
+    if(!related.isEmpty())
+        return;
+    QResourcePrivate *that = const_cast<QResourcePrivate *>(this);
+    if(fileName == QLatin1String(":"))
+        that->fileName += QLatin1Char('/');
+    that->absoluteFilePath = fileName;
+    if(!that->absoluteFilePath.startsWith(QLatin1Char(':')))
+        that->absoluteFilePath.prepend(QLatin1Char(':'));
+
+    QString path = fileName;
+    if(path.startsWith(QLatin1Char(':')))
+        path = path.mid(1);
+
+    if(path.startsWith(QLatin1Char('/'))) {
+        that->load(path);
+    } else {
+        QMutexLocker lock(resourceMutex());
+        QStringList searchPaths = *resourceSearchPaths();
+        searchPaths << QLatin1String("");
+        for(int i = 0; i < searchPaths.size(); ++i) {
+            const QString searchPath(searchPaths.at(i) + QLatin1Char('/') + path);
+            if(that->load(searchPath)) {
+                that->absoluteFilePath = QLatin1Char(':') + searchPath;
+                break;
+            }
+        }
+    }
+}
+
+void
+QResourcePrivate::ensureChildren() const
+{
+    ensureInitialized();
+    if(!children.isEmpty() || !container || related.isEmpty())
+        return;
+
+    QString path = absoluteFilePath, k;
+    if(path.startsWith(QLatin1Char(':')))
+        path = path.mid(1);
+    QSet<QString> kids;
+    QString cleaned = cleanPath(path);
+    for(int i = 0; i < related.size(); ++i) {
+        QResourceRoot *res = related.at(i);
+        if(res->mappingRootSubdir(path, &k) && !k.isEmpty()) {
+            if(!kids.contains(k)) {
+                children += k;
+                kids.insert(k);
+            }
+        } else {
+            const int node = res->findNode(cleaned);
+            if(node != -1) {
+                QStringList related_children = res->children(node);
+                for(int kid = 0; kid < related_children.size(); ++kid) {
+                    k = related_children.at(kid);
+                    if(!kids.contains(k)) {
+                        children += k;
+                        kids.insert(k);
+                    }
+                }
+            }
+        }
+    }
+}
+
+/*!
+    Constructs a QResource pointing to \a file. \a locale is used to
+    load a specific localization of a resource data.
+
+    \sa QFileInfo, searchPaths(), setFileName(), setLocale()
+*/
+
+QResource::QResource(const QString &file, const QLocale &locale) : d_ptr(new QResourcePrivate(this))
+{
+    Q_D(QResource);
+    d->fileName = file;
+    d->locale = locale;
+}
+
+/*!
+    Releases the resources of the QResource object.
+*/
+QResource::~QResource()
+{
+}
+
+/*!
+    Sets a QResource to only load the localization of resource to for \a
+    locale. If a resource for the specific locale is not found then the
+    C locale is used.
+
+    \sa setFileName()
+*/
+
+void QResource::setLocale(const QLocale &locale)
+{
+    Q_D(QResource);
+    d->clear();
+    d->locale = locale;
+}
+
+/*!
+    Returns the locale used to locate the data for the QResource.
+*/
+
+QLocale QResource::locale() const
+{
+    Q_D(const QResource);
+    return d->locale;
+}
+
+/*!
+    Sets a QResource to point to \a file. \a file can either be absolute,
+    in which case it is opened directly, if relative then the file will be
+    tried to be found in searchPaths().
+
+    \sa absoluteFilePath()
+*/
+
+void QResource::setFileName(const QString &file)
+{
+    Q_D(QResource);
+    d->clear();
+    d->fileName = file;
+}
+
+/*!
+    Returns the full path to the file that this QResource represents as it
+    was passed.
+
+    \sa absoluteFilePath()
+*/
+
+QString QResource::fileName() const
+{
+    Q_D(const QResource);
+    d->ensureInitialized();
+    return d->fileName;
+}
+
+/*!
+    Returns the real path that this QResource represents, if the resource
+    was found via the searchPaths() it will be indicated in the path.
+
+    \sa fileName()
+*/
+
+QString QResource::absoluteFilePath() const
+{
+    Q_D(const QResource);
+    d->ensureInitialized();
+    return d->absoluteFilePath;
+}
+
+/*!
+    Returns true if the resource really exists in the resource hierarchy,
+    false otherwise.
+
+*/
+
+bool QResource::isValid() const
+{
+    Q_D(const QResource);
+    d->ensureInitialized();
+    return !d->related.isEmpty();
+}
+
+/*!
+    \fn bool QResource::isFile() const
+
+    Returns true if the resource represents a file and thus has data
+    backing it, false if it represents a directory.
+
+    \sa isDir()
+*/
+
+
+/*!
+    Returns true if the resource represents a file and the data backing it
+    is in a compressed format, false otherwise.
+
+    \sa data(), isFile()
+*/
+
+bool QResource::isCompressed() const
+{
+    Q_D(const QResource);
+    d->ensureInitialized();
+    return d->compressed;
+}
+
+/*!
+    Returns the size of the data backing the resource.
+
+    \sa data(), isFile()
+*/
+
+qint64 QResource::size() const
+{
+    Q_D(const QResource);
+    d->ensureInitialized();
+    return d->size;
+}
+
+/*!
+    Returns direct access to a read only segment of data that this resource
+    represents. If the resource is compressed the data returns is
+    compressed and qUncompress() must be used to access the data. If the
+    resource is a directory 0 is returned.
+
+    \sa size(), isCompressed(), isFile()
+*/
+
+const uchar *QResource::data() const
+{
+    Q_D(const QResource);
+    d->ensureInitialized();
+    return d->data;
+}
+
+/*!
+    Returns true if the resource represents a directory and thus may have
+    children() in it, false if it represents a file.
+
+    \sa isFile()
+*/
+
+bool QResource::isDir() const
+{
+    Q_D(const QResource);
+    d->ensureInitialized();
+    return d->container;
+}
+
+/*!
+    Returns a list of all resources in this directory, if the resource
+    represents a file the list will be empty.
+
+    \sa isDir()
+*/
+
+QStringList QResource::children() const
+{
+    Q_D(const QResource);
+    d->ensureChildren();
+    return d->children;
+}
+
+/*!
+  \obsolete
+
+  Adds \a path to the search paths searched in to find resources that are
+  not specified with an absolute path. The \a path must be an absolute
+  path (start with \c{/}).
+
+  The default search path is to search only in the root (\c{:/}). The last
+  path added will be consulted first upon next QResource creation.
+
+  Use QDir::addSearchPath() with a prefix instead.
+*/
+
+void
+QResource::addSearchPath(const QString &path)
+{
+    if (!path.startsWith(QLatin1Char('/'))) {
+        qWarning("QResource::addResourceSearchPath: Search paths must be absolute (start with /) [%s]",
+                 path.toLocal8Bit().data());
+        return;
+    }
+    QMutexLocker lock(resourceMutex());
+    resourceSearchPaths()->prepend(path);
+}
+
+/*!
+  Returns the current search path list. This list is consulted when
+  creating a relative resource.
+
+  \sa QDir::addSearchPath() QDir::setSearchPaths()
+*/
+
+QStringList
+QResource::searchPaths()
+{
+    QMutexLocker lock(resourceMutex());
+    return *resourceSearchPaths();
+}
+
+inline int QResourceRoot::hash(int node) const
+{
+    if(!node) //root
+        return 0;
+    const int offset = findOffset(node);
+    int name_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
+                      (tree[offset+2] << 8) + (tree[offset+3] << 0);
+    name_offset += 2; //jump past name length
+    return (names[name_offset+0] << 24) + (names[name_offset+1] << 16) +
+           (names[name_offset+2] << 8) + (names[name_offset+3] << 0);
+}
+inline QString QResourceRoot::name(int node) const
+{
+    if(!node) // root
+        return QString();
+    const int offset = findOffset(node);
+
+    QString ret;
+    int name_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
+                      (tree[offset+2] << 8) + (tree[offset+3] << 0);
+    const short name_length = (names[name_offset+0] << 8) +
+                              (names[name_offset+1] << 0);
+    name_offset += 2;
+    name_offset += 4; //jump past hash
+
+    ret.resize(name_length);
+    QChar *strData = ret.data();
+    for(int i = 0; i < name_length*2; i+=2) {
+        QChar c(names[name_offset+i+1], names[name_offset+i]);
+        *strData = c;
+        ++strData;
+    }
+    return ret;
+}
+
+int QResourceRoot::findNode(const QString &_path, const QLocale &locale) const
+{
+    QString path = _path;
+    {
+        QString root = mappingRoot();
+        if(!root.isEmpty()) {
+            if(root == path) {
+                path = QLatin1Char('/');
+            } else {
+                if(!root.endsWith(QLatin1Char('/')))
+                    root += QLatin1Char('/');
+                if(path.size() >= root.size() && path.startsWith(root))
+                    path = path.mid(root.length()-1);
+                if(path.isEmpty())
+                    path = QLatin1Char('/');
+            }
+        }
+    }
+#ifdef DEBUG_RESOURCE_MATCH
+    qDebug() << "!!!!" << "START" << path << locale.country() << locale.language();
+#endif
+
+    if(path == QLatin1String("/"))
+        return 0;
+
+    //the root node is always first
+    int child_count = (tree[6] << 24) + (tree[7] << 16) +
+                      (tree[8] << 8) + (tree[9] << 0);
+    int child       = (tree[10] << 24) + (tree[11] << 16) +
+                      (tree[12] << 8) + (tree[13] << 0);
+
+    //now iterate up the tree
+    int node = -1;
+
+    QStringSplitter splitter(path);
+    while (child_count && splitter.hasNext()) {
+        QStringRef segment = splitter.next();
+
+#ifdef DEBUG_RESOURCE_MATCH
+        qDebug() << "  CHILDREN" << segment;
+        for(int j = 0; j < child_count; ++j) {
+            qDebug() << "   " << child+j << " :: " << name(child+j);
+        }
+#endif
+        const int h = qHash(segment);
+
+        //do the binary search for the hash
+        int l = 0, r = child_count-1;
+        int sub_node = (l+r+1)/2;
+        while(r != l) {
+            const int sub_node_hash = hash(child+sub_node);
+            if(h == sub_node_hash)
+                break;
+            else if(h < sub_node_hash)
+                r = sub_node - 1;
+            else
+                l = sub_node;
+            sub_node = (l + r + 1) / 2;
+        }
+        sub_node += child;
+
+        //now do the "harder" compares
+        bool found = false;
+        if(hash(sub_node) == h) {
+            while(sub_node > child && hash(sub_node-1) == h) //backup for collisions
+                --sub_node;
+            for(; sub_node < child+child_count && hash(sub_node) == h; ++sub_node) { //here we go...
+                if(name(sub_node) == segment) {
+                    found = true;
+                    int offset = findOffset(sub_node);
+#ifdef DEBUG_RESOURCE_MATCH
+                    qDebug() << "  TRY" << sub_node << name(sub_node) << offset;
+#endif
+                    offset += 4;  //jump past name
+
+                    const short flags = (tree[offset+0] << 8) +
+                                        (tree[offset+1] << 0);
+                    offset += 2;
+
+                    if(!splitter.hasNext()) {
+                        if(!(flags & Directory)) {
+                            const short country = (tree[offset+0] << 8) +
+                                                  (tree[offset+1] << 0);
+                            offset += 2;
+
+                            const short language = (tree[offset+0] << 8) +
+                                                   (tree[offset+1] << 0);
+                            offset += 2;
+#ifdef DEBUG_RESOURCE_MATCH
+                            qDebug() << "    " << "LOCALE" << country << language;
+#endif
+                            if(country == locale.country() && language == locale.language()) {
+#ifdef DEBUG_RESOURCE_MATCH
+                                qDebug() << "!!!!" << "FINISHED" << __LINE__ << sub_node;
+#endif
+                                return sub_node;
+                            } else if((country == QLocale::AnyCountry && language == locale.language()) ||
+                                      (country == QLocale::AnyCountry && language == QLocale::C && node == -1)) {
+                                node = sub_node;
+                            }
+                            continue;
+                        } else {
+#ifdef DEBUG_RESOURCE_MATCH
+                            qDebug() << "!!!!" << "FINISHED" << __LINE__ << sub_node;
+#endif
+
+                            return sub_node;
+                        }
+                    }
+
+                    if(!(flags & Directory))
+                        return -1;
+
+                    child_count = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
+                                  (tree[offset+2] << 8) + (tree[offset+3] << 0);
+                    offset += 4;
+                    child = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
+                            (tree[offset+2] << 8) + (tree[offset+3] << 0);
+                    break;
+                }
+            }
+        }
+        if(!found)
+            break;
+    }
+#ifdef DEBUG_RESOURCE_MATCH
+    qDebug() << "!!!!" << "FINISHED" << __LINE__ << node;
+#endif
+    return node;
+}
+short QResourceRoot::flags(int node) const
+{
+    if(node == -1)
+        return 0;
+    const int offset = findOffset(node) + 4; //jump past name
+    return (tree[offset+0] << 8) + (tree[offset+1] << 0);
+}
+const uchar *QResourceRoot::data(int node, qint64 *size) const
+{
+    if(node == -1) {
+        *size = 0;
+        return 0;
+    }
+    int offset = findOffset(node) + 4; //jump past name
+
+    const short flags = (tree[offset+0] << 8) + (tree[offset+1] << 0);
+    offset += 2;
+
+    offset += 4; //jump past locale
+
+    if(!(flags & Directory)) {
+        const int data_offset = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
+                                (tree[offset+2] << 8) + (tree[offset+3] << 0);
+        const uint data_length = (payloads[data_offset+0] << 24) + (payloads[data_offset+1] << 16) +
+                                 (payloads[data_offset+2] << 8) + (payloads[data_offset+3] << 0);
+        const uchar *ret = payloads+data_offset+4;
+        *size = data_length;
+        return ret;
+    }
+    *size = 0;
+    return 0;
+}
+QStringList QResourceRoot::children(int node) const
+{
+    if(node == -1)
+        return QStringList();
+    int offset = findOffset(node) + 4; //jump past name
+
+    const short flags = (tree[offset+0] << 8) + (tree[offset+1] << 0);
+    offset += 2;
+
+    QStringList ret;
+    if(flags & Directory) {
+        const int child_count = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
+                                (tree[offset+2] << 8) + (tree[offset+3] << 0);
+        offset += 4;
+        const int child_off = (tree[offset+0] << 24) + (tree[offset+1] << 16) +
+                              (tree[offset+2] << 8) + (tree[offset+3] << 0);
+        for(int i = child_off; i < child_off+child_count; ++i)
+            ret << name(i);
+    }
+    return ret;
+}
+bool QResourceRoot::mappingRootSubdir(const QString &path, QString *match) const
+{
+    const QString root = mappingRoot();
+    if(!root.isEmpty()) {
+        const QStringList root_segments = root.split(QLatin1Char('/'), QString::SkipEmptyParts),
+                          path_segments = path.split(QLatin1Char('/'), QString::SkipEmptyParts);
+        if(path_segments.size() <= root_segments.size()) {
+            int matched = 0;
+            for(int i = 0; i < path_segments.size(); ++i) {
+                if(root_segments[i] != path_segments[i])
+                    break;
+                ++matched;
+            }
+            if(matched == path_segments.size()) {
+                if(match && root_segments.size() > matched)
+                    *match = root_segments.at(matched);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+Q_CORE_EXPORT bool qRegisterResourceData(int version, const unsigned char *tree,
+                                         const unsigned char *name, const unsigned char *data)
+{
+    QMutexLocker lock(resourceMutex());
+    if(version == 0x01 && resourceList()) {
+        bool found = false;
+        QResourceRoot res(tree, name, data);
+        for(int i = 0; i < resourceList()->size(); ++i) {
+            if(*resourceList()->at(i) == res) {
+                found = true;
+                break;
+            }
+        }
+        if(!found) {
+            QResourceRoot *root = new QResourceRoot(tree, name, data);
+            root->ref.ref();
+            resourceList()->append(root);
+        }
+        return true;
+    }
+    return false;
+}
+
+Q_CORE_EXPORT bool qUnregisterResourceData(int version, const unsigned char *tree,
+                                           const unsigned char *name, const unsigned char *data)
+{
+    QMutexLocker lock(resourceMutex());
+    if(version == 0x01 && resourceList()) {
+        QResourceRoot res(tree, name, data);
+        for(int i = 0; i < resourceList()->size(); ) {
+            if(*resourceList()->at(i) == res) {
+                QResourceRoot *root = resourceList()->takeAt(i);
+                if(!root->ref.deref())
+                    delete root;
+            } else {
+                ++i;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+//run time resource creation
+
+class QDynamicBufferResourceRoot: public QResourceRoot
+{
+    QString root;
+    const uchar *buffer;
+
+public:
+    inline QDynamicBufferResourceRoot(const QString &_root) : root(_root), buffer(0) { }
+    inline ~QDynamicBufferResourceRoot() { }
+    inline const uchar *mappingBuffer() const { return buffer; }
+    virtual QString mappingRoot() const { return root; }
+    virtual ResourceRootType type() const { return Resource_Buffer; }
+
+    bool registerSelf(const uchar *b) {
+        //setup the data now
+        int offset = 0;
+
+        //magic number
+        if(b[offset+0] != 'q' || b[offset+1] != 'r' ||
+           b[offset+2] != 'e' || b[offset+3] != 's') {
+            return false;
+        }
+        offset += 4;
+
+        const int version = (b[offset+0] << 24) + (b[offset+1] << 16) +
+                         (b[offset+2] << 8) + (b[offset+3] << 0);
+        offset += 4;
+
+        const int tree_offset = (b[offset+0] << 24) + (b[offset+1] << 16) +
+                                (b[offset+2] << 8) + (b[offset+3] << 0);
+        offset += 4;
+
+        const int data_offset = (b[offset+0] << 24) + (b[offset+1] << 16) +
+                                (b[offset+2] << 8) + (b[offset+3] << 0);
+        offset += 4;
+
+        const int name_offset = (b[offset+0] << 24) + (b[offset+1] << 16) +
+                                (b[offset+2] << 8) + (b[offset+3] << 0);
+        offset += 4;
+
+        if(version == 0x01) {
+            buffer = b;
+            setSource(b+tree_offset, b+name_offset, b+data_offset);
+            return true;
+        }
+        return false;
+    }
+};
+
+#if defined(Q_OS_UNIX)
+#define QT_USE_MMAP
+#endif
+
+// most of the headers below are already included in qplatformdefs.h
+// also this lacks Large File support but that's probably irrelevant
+#if defined(QT_USE_MMAP)
+// for mmap
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <sys/mman.h>
+#include <errno.h>
+QT_END_INCLUDE_NAMESPACE
+#endif
+
+
+
+class QDynamicFileResourceRoot: public QDynamicBufferResourceRoot
+{
+    QString fileName;
+    // for mmap'ed files, this is what needs to be unmapped.
+    uchar *unmapPointer;
+    unsigned int unmapLength;
+
+public:
+    inline QDynamicFileResourceRoot(const QString &_root) : QDynamicBufferResourceRoot(_root), unmapPointer(0), unmapLength(0) { }
+    ~QDynamicFileResourceRoot() {
+#if defined(QT_USE_MMAP)
+        if (unmapPointer) {
+            munmap((char*)unmapPointer, unmapLength);
+            unmapPointer = 0;
+            unmapLength = 0;
+        } else
+#endif
+        {
+            delete [] (uchar *)mappingBuffer();
+        }
+    }
+    QString mappingFile() const { return fileName; }
+    virtual ResourceRootType type() const { return Resource_File; }
+
+    bool registerSelf(const QString &f) {
+        bool fromMM = false;
+        uchar *data = 0;
+        unsigned int data_len = 0;
+
+#ifdef QT_USE_MMAP
+
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
+#ifndef MAP_FAILED
+#define MAP_FAILED -1
+#endif
+
+        int fd = QT_OPEN(QFile::encodeName(f), O_RDONLY,
+#if defined(Q_OS_WIN)
+                         _S_IREAD | _S_IWRITE
+#else
+                         0666
+#endif
+            );
+        if (fd >= 0) {
+            QT_STATBUF st;
+            if (!QT_FSTAT(fd, &st)) {
+                uchar *ptr;
+                ptr = reinterpret_cast<uchar *>(
+                    mmap(0, st.st_size,             // any address, whole file
+                         PROT_READ,                 // read-only memory
+                         MAP_FILE | MAP_PRIVATE,    // swap-backed map from file
+                         fd, 0));                   // from offset 0 of fd
+                if (ptr && ptr != reinterpret_cast<uchar *>(MAP_FAILED)) {
+                    data = ptr;
+                    data_len = st.st_size;
+                    fromMM = true;
+                }
+            }
+            ::close(fd);
+        }
+#endif // QT_USE_MMAP
+        if(!data) {
+            QFile file(f);
+            if (!file.exists())
+                return false;
+            data_len = file.size();
+            data = new uchar[data_len];
+
+            bool ok = false;
+            if (file.open(QIODevice::ReadOnly))
+                ok = (data_len == (uint)file.read((char*)data, data_len));
+            if (!ok) {
+                delete [] data;
+                data = 0;
+                data_len = 0;
+                return false;
+            }
+            fromMM = false;
+        }
+        if(data && QDynamicBufferResourceRoot::registerSelf(data)) {
+            if(fromMM) {
+                unmapPointer = data;
+                unmapLength = data_len;
+            }
+            fileName = f;
+            return true;
+        }
+        return false;
+    }
+};
+
+static QString qt_resource_fixResourceRoot(QString r) {
+    if(!r.isEmpty()) {
+        if(r.startsWith(QLatin1Char(':')))
+            r = r.mid(1);
+        if(!r.isEmpty())
+            r = QDir::cleanPath(r);
+    }
+    return r;
+}
+
+
+/*!
+   \fn bool QResource::registerResource(const QString &rccFileName, const QString &mapRoot)
+
+   Registers the resource with the given \a rccFileName at the location in the
+   resource tree specified by \a mapRoot, and returns true if the file is
+   successfully opened; otherwise returns false.
+
+   \sa unregisterResource()
+*/
+
+bool
+QResource::registerResource(const QString &rccFilename, const QString &resourceRoot)
+{
+    QString r = qt_resource_fixResourceRoot(resourceRoot);
+    if(!r.isEmpty() && r[0] != QLatin1Char('/')) {
+        qWarning("QDir::registerResource: Registering a resource [%s] must be rooted in an absolute path (start with /) [%s]",
+                 rccFilename.toLocal8Bit().data(), resourceRoot.toLocal8Bit().data());
+        return false;
+    }
+
+    QDynamicFileResourceRoot *root = new QDynamicFileResourceRoot(r);
+    if(root->registerSelf(rccFilename)) {
+        root->ref.ref();
+        QMutexLocker lock(resourceMutex());
+        resourceList()->append(root);
+        return true;
+    }
+    delete root;
+    return false;
+}
+
+/*!
+  \fn bool QResource::unregisterResource(const QString &rccFileName, const QString &mapRoot)
+
+  Unregisters the resource with the given \a rccFileName at the location in
+  the resource tree specified by \a mapRoot, and returns true if the
+  resource is successfully unloaded and no references exist for the
+  resource; otherwise returns false.
+
+  \sa registerResource()
+*/
+
+bool
+QResource::unregisterResource(const QString &rccFilename, const QString &resourceRoot)
+{
+    QString r = qt_resource_fixResourceRoot(resourceRoot);
+
+    QMutexLocker lock(resourceMutex());
+    ResourceList *list = resourceList();
+    for(int i = 0; i < list->size(); ++i) {
+        QResourceRoot *res = list->at(i);
+        if(res->type() == QResourceRoot::Resource_File) {
+	    QDynamicFileResourceRoot *root = reinterpret_cast<QDynamicFileResourceRoot*>(res);
+	    if(root->mappingFile() == rccFilename && root->mappingRoot() == r) {
+                resourceList()->removeAt(i);
+                if(!root->ref.deref()) {
+                    delete root;
+                    return true;
+                }
+                return false;
+            }
+	}
+    }
+    return false;
+}
+
+
+/*!
+   \fn bool QResource::registerResource(const uchar *rccData, const QString &mapRoot)
+   \since 4.3
+
+   Registers the resource with the given \a rccData at the location in the
+   resource tree specified by \a mapRoot, and returns true if the file is
+   successfully opened; otherwise returns false.
+
+   \warning The data must remain valid throughout the life of any QFile
+   that may reference the resource data.
+
+   \sa unregisterResource()
+*/
+
+bool
+QResource::registerResource(const uchar *rccData, const QString &resourceRoot)
+{
+    QString r = qt_resource_fixResourceRoot(resourceRoot);
+    if(!r.isEmpty() && r[0] != QLatin1Char('/')) {
+        qWarning("QDir::registerResource: Registering a resource [%p] must be rooted in an absolute path (start with /) [%s]",
+                 rccData, resourceRoot.toLocal8Bit().data());
+        return false;
+    }
+
+    QDynamicBufferResourceRoot *root = new QDynamicBufferResourceRoot(r);
+    if(root->registerSelf(rccData)) {
+        root->ref.ref();
+        QMutexLocker lock(resourceMutex());
+        resourceList()->append(root);
+        return true;
+    }
+    delete root;
+    return false;
+}
+
+/*!
+  \fn bool QResource::unregisterResource(const uchar *rccData, const QString &mapRoot)
+  \since 4.3
+
+  Unregisters the resource with the given \a rccData at the location in the
+  resource tree specified by \a mapRoot, and returns true if the resource is
+  successfully unloaded and no references exist into the resource; otherwise returns false.
+
+  \sa registerResource()
+*/
+
+bool
+QResource::unregisterResource(const uchar *rccData, const QString &resourceRoot)
+{
+    QString r = qt_resource_fixResourceRoot(resourceRoot);
+
+    QMutexLocker lock(resourceMutex());
+    ResourceList *list = resourceList();
+    for(int i = 0; i < list->size(); ++i) {
+        QResourceRoot *res = list->at(i);
+        if(res->type() == QResourceRoot::Resource_Buffer) {
+	    QDynamicBufferResourceRoot *root = reinterpret_cast<QDynamicBufferResourceRoot*>(res);
+	    if(root->mappingBuffer() == rccData && root->mappingRoot() == r) {
+                resourceList()->removeAt(i);
+                if(!root->ref.deref()) {
+                    delete root;
+                    return true;
+                }
+		return false;
+            }
+	}
+    }
+    return false;
+}
+
+//file type handler
+class QResourceFileEngineHandler : public QAbstractFileEngineHandler
+{
+public:
+    QResourceFileEngineHandler() { }
+    ~QResourceFileEngineHandler() { }
+    QAbstractFileEngine *create(const QString &path) const;
+};
+QAbstractFileEngine *QResourceFileEngineHandler::create(const QString &path) const
+{
+    if (path.size() > 0 && path.startsWith(QLatin1Char(':')))
+        return new QResourceFileEngine(path);
+    return 0;
+}
+
+//resource engine
+class QResourceFileEnginePrivate : public QAbstractFileEnginePrivate
+{
+protected:
+    Q_DECLARE_PUBLIC(QResourceFileEngine)
+private:
+    uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
+    bool unmap(uchar *ptr);
+    qint64 offset;
+    QResource resource;
+    QByteArray uncompressed;
+protected:
+    QResourceFileEnginePrivate() : offset(0) { }
+};
+
+bool QResourceFileEngine::mkdir(const QString &, bool) const
+{
+    return false;
+}
+
+bool QResourceFileEngine::rmdir(const QString &, bool) const
+{
+    return false;
+}
+
+bool QResourceFileEngine::setSize(qint64)
+{
+    return false;
+}
+
+QStringList QResourceFileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
+{
+    return QAbstractFileEngine::entryList(filters, filterNames);
+}
+
+bool QResourceFileEngine::caseSensitive() const
+{
+    return true;
+}
+
+QResourceFileEngine::QResourceFileEngine(const QString &file) :
+    QAbstractFileEngine(*new QResourceFileEnginePrivate)
+{
+    Q_D(QResourceFileEngine);
+    d->resource.setFileName(file);
+    if(d->resource.isCompressed() && d->resource.size()) {
+#ifndef QT_NO_COMPRESS
+        d->uncompressed = qUncompress(d->resource.data(), d->resource.size());
+#else
+        Q_ASSERT(!"QResourceFileEngine::open: Qt built without support for compression");
+#endif
+    }
+}
+
+QResourceFileEngine::~QResourceFileEngine()
+{
+}
+
+void QResourceFileEngine::setFileName(const QString &file)
+{
+    Q_D(QResourceFileEngine);
+    d->resource.setFileName(file);
+}
+
+bool QResourceFileEngine::open(QIODevice::OpenMode flags)
+{
+    Q_D(QResourceFileEngine);
+    if (d->resource.fileName().isEmpty()) {
+        qWarning("QResourceFileEngine::open: Missing file name");
+        return false;
+    }
+    if(flags & QIODevice::WriteOnly)
+        return false;
+    if(!d->resource.isValid())
+       return false;
+    return true;
+}
+
+bool QResourceFileEngine::close()
+{
+    Q_D(QResourceFileEngine);
+    d->offset = 0;
+    d->uncompressed.clear();
+    return true;
+}
+
+bool QResourceFileEngine::flush()
+{
+    return false;
+}
+
+qint64 QResourceFileEngine::read(char *data, qint64 len)
+{
+    Q_D(QResourceFileEngine);
+    if(len > size()-d->offset)
+        len = size()-d->offset;
+    if(len <= 0)
+        return 0;
+    if(d->resource.isCompressed())
+        memcpy(data, d->uncompressed.constData()+d->offset, len);
+    else
+        memcpy(data, d->resource.data()+d->offset, len);
+    d->offset += len;
+    return len;
+}
+
+qint64 QResourceFileEngine::write(const char *, qint64)
+{
+    return -1;
+}
+
+bool QResourceFileEngine::remove()
+{
+    return false;
+}
+
+bool QResourceFileEngine::copy(const QString &)
+{
+    return false;
+}
+
+bool QResourceFileEngine::rename(const QString &)
+{
+    return false;
+}
+
+bool QResourceFileEngine::link(const QString &)
+{
+    return false;
+}
+
+qint64 QResourceFileEngine::size() const
+{
+    Q_D(const QResourceFileEngine);
+    if(!d->resource.isValid())
+        return 0;
+    if(d->resource.isCompressed())
+        return d->uncompressed.size();
+    return d->resource.size();
+}
+
+qint64 QResourceFileEngine::pos() const
+{
+    Q_D(const QResourceFileEngine);
+    return d->offset;
+}
+
+bool QResourceFileEngine::atEnd() const
+{
+    Q_D(const QResourceFileEngine);
+    if(!d->resource.isValid())
+        return true;
+    return d->offset == size();
+}
+
+bool QResourceFileEngine::seek(qint64 pos)
+{
+    Q_D(QResourceFileEngine);
+    if(!d->resource.isValid())
+        return false;
+
+    if(d->offset > size())
+        return false;
+    d->offset = pos;
+    return true;
+}
+
+bool QResourceFileEngine::isSequential() const
+{
+    return false;
+}
+
+QAbstractFileEngine::FileFlags QResourceFileEngine::fileFlags(QAbstractFileEngine::FileFlags type) const
+{
+    Q_D(const QResourceFileEngine);
+    QAbstractFileEngine::FileFlags ret = 0;
+    if(!d->resource.isValid())
+        return ret;
+
+    if(type & PermsMask)
+        ret |= QAbstractFileEngine::FileFlags(ReadOwnerPerm|ReadUserPerm|ReadGroupPerm|ReadOtherPerm);
+    if(type & TypesMask) {
+        if(d->resource.isDir())
+            ret |= DirectoryType;
+        else
+            ret |= FileType;
+    }
+    if(type & FlagsMask) {
+        ret |= ExistsFlag;
+        if(d->resource.absoluteFilePath() == QLatin1String(":/"))
+            ret |= RootFlag;
+    }
+    return ret;
+}
+
+bool QResourceFileEngine::setPermissions(uint)
+{
+    return false;
+}
+
+QString QResourceFileEngine::fileName(FileName file) const
+{
+    Q_D(const QResourceFileEngine);
+    if(file == BaseName) {
+	int slash = d->resource.fileName().lastIndexOf(QLatin1Char('/'));
+	if (slash == -1)
+	    return d->resource.fileName();
+	return d->resource.fileName().mid(slash + 1);
+    } else if(file == PathName || file == AbsolutePathName) {
+        const QString path = (file == AbsolutePathName) ? d->resource.absoluteFilePath() : d->resource.fileName();
+	const int slash = path.lastIndexOf(QLatin1Char('/'));
+	if (slash != -1)
+	    return path.left(slash);
+    } else if(file == CanonicalName || file == CanonicalPathName) {
+        const QString absoluteFilePath = d->resource.absoluteFilePath();
+        if(file == CanonicalPathName) {
+            const int slash = absoluteFilePath.lastIndexOf(QLatin1Char('/'));
+            if (slash != -1)
+                return absoluteFilePath.left(slash);
+        }
+        return absoluteFilePath;
+    }
+    return d->resource.fileName();
+}
+
+bool QResourceFileEngine::isRelativePath() const
+{
+    return false;
+}
+
+uint QResourceFileEngine::ownerId(FileOwner) const
+{
+    static const uint nobodyID = (uint) -2;
+    return nobodyID;
+}
+
+QString QResourceFileEngine::owner(FileOwner) const
+{
+    return QString();
+}
+
+QDateTime QResourceFileEngine::fileTime(FileTime) const
+{
+    return QDateTime();
+}
+
+/*!
+    \internal
+*/
+QAbstractFileEngine::Iterator *QResourceFileEngine::beginEntryList(QDir::Filters filters,
+                                                                   const QStringList &filterNames)
+{
+    return new QResourceFileEngineIterator(filters, filterNames);
+}
+
+/*!
+    \internal
+*/
+QAbstractFileEngine::Iterator *QResourceFileEngine::endEntryList()
+{
+    return 0;
+}
+
+bool QResourceFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
+{
+    Q_D(QResourceFileEngine);
+    if (extension == MapExtension) {
+        const MapExtensionOption *options = (MapExtensionOption*)(option);
+        MapExtensionReturn *returnValue = static_cast<MapExtensionReturn*>(output);
+        returnValue->address = d->map(options->offset, options->size, options->flags);
+        return (returnValue->address != 0);
+    }
+    if (extension == UnMapExtension) {
+        UnMapExtensionOption *options = (UnMapExtensionOption*)option;
+        return d->unmap(options->address);
+    }
+    return false;
+}
+
+bool QResourceFileEngine::supportsExtension(Extension extension) const
+{
+    return (extension == UnMapExtension || extension == MapExtension);
+}
+
+uchar *QResourceFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
+{
+    Q_Q(QResourceFileEngine);
+    Q_UNUSED(flags);
+    if (offset < 0 || size <= 0 || !resource.isValid() || offset + size > resource.size()) {
+        q->setError(QFile::UnspecifiedError, QString());
+        return 0;
+    }
+    uchar *address = const_cast<uchar *>(resource.data());
+    return (address + offset);
+}
+
+bool QResourceFileEnginePrivate::unmap(uchar *ptr)
+{
+    Q_UNUSED(ptr);
+    return true;
+}
+
+//Initialization and cleanup
+Q_GLOBAL_STATIC(QResourceFileEngineHandler, resource_file_handler)
+
+static int qt_force_resource_init() { resource_file_handler(); return 1; }
+Q_CORE_EXPORT void qInitResourceIO() { resource_file_handler(); }
+static int qt_forced_resource_init = qt_force_resource_init();
+Q_CONSTRUCTOR_FUNCTION(qt_force_resource_init)
+
+QT_END_NAMESPACE