Long live Qt!

66 files changed, 45176 insertions, 0 deletions

diff --git a/src/corelib/io/io.pri b/src/corelib/io/io.pri
new file mode 100644
index 0000000..3690d4b
--- /dev/null
+++ b/src/corelib/io/io.pri
@@ -0,0 +1,82 @@
+# Qt core io module
+
+HEADERS +=  \
+        io/qabstractfileengine.h \
+        io/qabstractfileengine_p.h \
+        io/qbuffer.h \
+        io/qdatastream.h \
+        io/qdebug.h \
+        io/qdir.h \
+        io/qdiriterator.h \
+        io/qfile.h \
+        io/qfileinfo.h \
+        io/qfileinfo_p.h \
+        io/qiodevice.h \
+        io/qiodevice_p.h \
+        io/qprocess.h \
+        io/qprocess_p.h \
+        io/qtextstream.h \
+        io/qtemporaryfile.h \
+        io/qresource_p.h \
+        io/qresource_iterator_p.h \
+        io/qurl.h \
+        io/qsettings.h \
+        io/qsettings_p.h \
+        io/qfsfileengine.h \
+        io/qfsfileengine_p.h \
+        io/qfsfileengine_iterator_p.h \
+        io/qfilesystemwatcher.h \
+        io/qfilesystemwatcher_p.h
+
+SOURCES += \
+        io/qabstractfileengine.cpp \
+        io/qbuffer.cpp \
+        io/qdatastream.cpp \
+        io/qdebug.cpp \
+        io/qdir.cpp \
+        io/qdiriterator.cpp \
+        io/qfile.cpp \
+        io/qfileinfo.cpp \
+        io/qiodevice.cpp \
+        io/qprocess.cpp \
+        io/qtextstream.cpp \
+        io/qtemporaryfile.cpp \
+        io/qresource.cpp \
+        io/qresource_iterator.cpp \
+        io/qurl.cpp \
+        io/qsettings.cpp \
+        io/qfsfileengine.cpp \
+        io/qfsfileengine_iterator.cpp \
+        io/qfilesystemwatcher.cpp
+
+win32 {
+        SOURCES += io/qsettings_win.cpp
+        SOURCES += io/qprocess_win.cpp
+        SOURCES += io/qfsfileengine_win.cpp
+
+        SOURCES += io/qfsfileengine_iterator_win.cpp
+        SOURCES += io/qfilesystemwatcher_win.cpp
+        HEADERS += io/qfilesystemwatcher_win_p.h
+        HEADERS += io/qwindowspipewriter_p.h
+        SOURCES += io/qwindowspipewriter.cpp
+} else:unix {
+        SOURCES += io/qfsfileengine_unix.cpp
+        SOURCES += io/qfsfileengine_iterator_unix.cpp
+        SOURCES += io/qprocess_unix.cpp
+        mac:SOURCES += io/qsettings_mac.cpp
+
+        linux-*:{
+            SOURCES += \
+                    io/qfilesystemwatcher_inotify.cpp \
+                    io/qfilesystemwatcher_dnotify.cpp
+
+            HEADERS += \
+                    io/qfilesystemwatcher_inotify_p.h \
+                    io/qfilesystemwatcher_dnotify_p.h
+        }
+
+        freebsd-*|macx-*|darwin-*|openbsd-*:{
+            SOURCES += io/qfilesystemwatcher_kqueue.cpp
+            HEADERS += io/qfilesystemwatcher_kqueue_p.h
+        }
+}
diff --git a/src/corelib/io/qabstractfileengine.cpp b/src/corelib/io/qabstractfileengine.cpp
new file mode 100644
index 0000000..bedc121
--- /dev/null
+++ b/src/corelib/io/qabstractfileengine.cpp
@@ -0,0 +1,1219 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qabstractfileengine.h"
+#include "private/qabstractfileengine_p.h"
+#include "qdatetime.h"
+#include "qmutex.h"
+#include "qvariant.h"
+// built-in handlers
+#include "qfsfileengine.h"
+#include "qdiriterator.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QAbstractFileEngineHandler
+    \reentrant
+
+    \brief The QAbstractFileEngineHandler class provides a way to register
+    custom file engines with your application.
+
+    \ingroup io
+    \since 4.1
+
+    QAbstractFileEngineHandler is a factory for creating QAbstractFileEngine
+    objects (file engines), which are used internally by QFile, QFileInfo, and
+    QDir when working with files and directories.
+
+    When you open a file, Qt chooses a suitable file engine by passing the
+    file name from QFile or QDir through an internal list of registered file
+    engine handlers. The first handler to recognize the file name is used to
+    create the engine. Qt provides internal file engines for working with
+    regular files and resources, but you can also register your own
+    QAbstractFileEngine subclasses.
+
+    To install an application-specific file engine, you subclass
+    QAbstractFileEngineHandler and reimplement create(). When you instantiate
+    the handler (e.g. by creating an instance on the stack or on the heap), it
+    will automatically register with Qt. (The latest registered handler takes
+    precedence over existing handlers.)
+
+    For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 0
+
+    When the handler is destroyed, it is automatically removed from Qt.
+
+    The most common approach to registering a handler is to create an instance
+    as part of the start-up phase of your application. It is also possible to
+    limit the scope of the file engine handler to a particular area of
+    interest (e.g. a special file dialog that needs a custom file engine). By
+    creating the handler inside a local scope, you can precisely control the
+    area in which your engine will be applied without disturbing file
+    operations in other parts of your application.
+
+    \sa QAbstractFileEngine, QAbstractFileEngine::create()
+*/
+
+/*
+    All application-wide handlers are stored in this list. The mutex must be
+    acquired to ensure thread safety.
+ */
+Q_GLOBAL_STATIC_WITH_ARGS(QMutex, fileEngineHandlerMutex, (QMutex::Recursive))
+static bool qt_abstractfileenginehandlerlist_shutDown = false;
+class QAbstractFileEngineHandlerList : public QList<QAbstractFileEngineHandler *>
+{
+public:
+    ~QAbstractFileEngineHandlerList()
+    {
+        QMutexLocker locker(fileEngineHandlerMutex());
+        qt_abstractfileenginehandlerlist_shutDown = true;
+    }
+};
+Q_GLOBAL_STATIC(QAbstractFileEngineHandlerList, fileEngineHandlers)
+
+/*!
+    Constructs a file handler and registers it with Qt. Once created this
+    handler's create() function will be called (along with all the other
+    handlers) for any paths used. The most recently created handler that
+    recognizes the given path (i.e. that returns a QAbstractFileEngine) is
+    used for the new path.
+
+    \sa create()
+ */
+QAbstractFileEngineHandler::QAbstractFileEngineHandler()
+{
+    QMutexLocker locker(fileEngineHandlerMutex());
+    fileEngineHandlers()->prepend(this);
+}
+
+/*!
+    Destroys the file handler. This will automatically unregister the handler
+    from Qt.
+ */
+QAbstractFileEngineHandler::~QAbstractFileEngineHandler()
+{
+    QMutexLocker locker(fileEngineHandlerMutex());
+    // Remove this handler from the handler list only if the list is valid.
+    if (!qt_abstractfileenginehandlerlist_shutDown)
+        fileEngineHandlers()->removeAll(this);
+}
+
+/*!
+    \fn QAbstractFileEngine *QAbstractFileEngineHandler::create(const QString &fileName) const
+
+    Creates a file engine for file \a fileName. Returns 0 if this
+    file handler cannot handle \a fileName.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 1
+
+    \sa QAbstractFileEngine::create()
+*/
+
+/*!
+    Creates and returns a QAbstractFileEngine suitable for processing \a
+    fileName.
+
+    You should not need to call this function; use QFile, QFileInfo or
+    QDir directly instead.
+
+    If you reimplemnt this function, it should only return file
+    engines that knows how to handle \a fileName; otherwise, it should
+    return 0.
+
+    \sa QAbstractFileEngineHandler
+*/
+QAbstractFileEngine *QAbstractFileEngine::create(const QString &fileName)
+{
+    QMutexLocker locker(fileEngineHandlerMutex());
+
+    // check for registered handlers that can load the file
+    for (int i = 0; i < fileEngineHandlers()->size(); i++) {
+        if (QAbstractFileEngine *ret = fileEngineHandlers()->at(i)->create(fileName))
+            return ret;
+    }
+
+#ifdef QT_BUILD_CORE_LIB
+    if (!fileName.startsWith(QLatin1Char('/'))) {
+        int prefixSeparator = fileName.indexOf(QLatin1Char(':'));
+        if (prefixSeparator > 1) {
+            QString prefix = fileName.left(prefixSeparator);
+            QString fileNameWithoutPrefix = fileName.mid(prefixSeparator + 1).prepend(QLatin1Char('/'));
+            const QStringList &paths = QDir::searchPaths(prefix);
+            for (int i = 0; i < paths.count(); i++) {
+                QString path = paths.at(i);
+                path.append(fileNameWithoutPrefix);
+                QAbstractFileEngine *engine = create(path);
+                if (engine && (engine->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::ExistsFlag)) {
+                    return engine;
+                }
+                delete engine;
+            }
+        }
+    }
+#endif
+
+#ifdef QT_NO_FSFILEENGINE
+    return 0;
+#else
+    // fall back to regular file engine
+    return new QFSFileEngine(fileName);
+#endif
+}
+
+/*!
+    \class QAbstractFileEngine
+    \reentrant
+
+    \brief The QAbstractFileEngine class provides an abstraction for accessing
+    the filesystem.
+
+    \ingroup io
+    \since 4.1
+
+    The QDir, QFile, and QFileInfo classes all make use of a
+    QAbstractFileEngine internally. If you create your own QAbstractFileEngine
+    subclass (and register it with Qt by creating a QAbstractFileEngineHandler
+    subclass), your file engine will be used when the path is one that your
+    file engine handles.
+
+    A QAbstractFileEngine refers to one file or one directory. If the referent
+    is a file, the setFileName(), rename(), and remove() functions are
+    applicable. If the referent is a directory the mkdir(), rmdir(), and
+    entryList() functions are applicable. In all cases the caseSensitive(),
+    isRelativePath(), fileFlags(), ownerId(), owner(), and fileTime()
+    functions are applicable.
+
+    A QAbstractFileEngine subclass can be created to do synchronous network I/O
+    based file system operations, local file system operations, or to operate
+    as a resource system to access file based resources.
+
+   \sa QAbstractFileEngineHandler
+*/
+
+/*!
+    \enum QAbstractFileEngine::FileName
+
+    These values are used to request a file name in a particular
+    format.
+
+    \value DefaultName The same filename that was passed to the
+    QAbstractFileEngine.
+    \value BaseName The name of the file excluding the path.
+    \value PathName The path to the file excluding the base name.
+    \value AbsoluteName The absolute path to the file (including
+    the base name).
+    \value AbsolutePathName The absolute path to the file (excluding
+    the base name).
+    \value LinkName The full file name of the file that this file is a
+    link to. (This will be empty if this file is not a link.)
+    \value CanonicalName Often very similar to LinkName. Will return the true path to the file.
+    \value CanonicalPathName Same as CanonicalName, excluding the base name.
+    \value BundleName Returns the name of the bundle implies BundleType is set.
+
+    \sa fileName(), setFileName()
+*/
+
+/*!
+    \enum QAbstractFileEngine::FileFlag
+
+    The permissions and types of a file, suitable for OR'ing together.
+
+    \value ReadOwnerPerm The owner of the file has permission to read
+    it.
+    \value WriteOwnerPerm The owner of the file has permission to
+    write to it.
+    \value ExeOwnerPerm The owner of the file has permission to
+    execute it.
+    \value ReadUserPerm The current user has permission to read the
+    file.
+    \value WriteUserPerm The current user has permission to write to
+    the file.
+    \value ExeUserPerm The current user has permission to execute the
+    file.
+    \value ReadGroupPerm Members of the current user's group have
+    permission to read the file.
+    \value WriteGroupPerm Members of the current user's group have
+    permission to write to the file.
+    \value ExeGroupPerm Members of the current user's group have
+    permission to execute the file.
+    \value ReadOtherPerm All users have permission to read the file.
+    \value WriteOtherPerm All users have permission to write to the
+    file.
+    \value ExeOtherPerm All users have permission to execute the file.
+
+    \value LinkType The file is a link to another file (or link) in
+    the file system (i.e. not a file or directory).
+    \value FileType The file is a regular file to the file system
+    (i.e. not a link or directory)
+    \value BundleType The file is a Mac OS X bundle implies DirectoryType
+    \value DirectoryType The file is a directory in the file system
+    (i.e. not a link or file).
+
+    \value HiddenFlag The file is hidden.
+    \value ExistsFlag The file actually exists in the file system.
+    \value RootFlag  The file or the file pointed to is the root of the filesystem.
+    \value LocalDiskFlag The file resides on the local disk and can be passed to standard file functions.
+    \value Refresh Passing this flag will force the file engine to refresh all flags.
+
+    \omitvalue PermsMask
+    \omitvalue TypesMask
+    \omitvalue FlagsMask
+    \omitvalue FileInfoAll
+
+    \sa fileFlags(), setFileName()
+*/
+
+/*!
+    \enum QAbstractFileEngine::FileTime
+
+    These are used by the fileTime() function.
+
+    \value CreationTime When the file was created.
+    \value ModificationTime When the file was most recently modified.
+    \value AccessTime When the file was most recently accessed (e.g.
+    read or written to).
+
+    \sa setFileName()
+*/
+
+/*!
+    \enum QAbstractFileEngine::FileOwner
+
+    \value OwnerUser The user who owns the file.
+    \value OwnerGroup The group who owns the file.
+
+    \sa owner(), ownerId(), setFileName()
+*/
+
+/*!
+   Constructs a new QAbstractFileEngine that does not refer to any file or directory.
+
+   \sa setFileName()
+ */
+QAbstractFileEngine::QAbstractFileEngine() : d_ptr(new QAbstractFileEnginePrivate)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*!
+   \internal
+
+   Constructs a QAbstractFileEngine.
+ */
+QAbstractFileEngine::QAbstractFileEngine(QAbstractFileEnginePrivate &dd) : d_ptr(&dd)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*!
+    Destroys the QAbstractFileEngine.
+ */
+QAbstractFileEngine::~QAbstractFileEngine()
+{
+    delete d_ptr;
+    d_ptr = 0;
+}
+
+/*!
+    \fn bool QAbstractFileEngine::open(QIODevice::OpenMode mode)
+
+    Opens the file in the specified \a mode. Returns true if the file
+    was successfully opened; otherwise returns false.
+
+    The \a mode is an OR combination of QIODevice::OpenMode and
+    QIODevice::HandlingMode values.
+*/
+bool QAbstractFileEngine::open(QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(openMode);
+    return false;
+}
+
+/*!
+    Closes the file, returning true if successful; otherwise returns false.
+
+    The default implementation always returns false.
+*/
+bool QAbstractFileEngine::close()
+{
+    return false;
+}
+
+/*!
+    Flushes the open file, returning true if successful; otherwise returns
+    false.
+
+    The default implementation always returns false.
+*/
+bool QAbstractFileEngine::flush()
+{
+    return false;
+}
+
+/*!
+    Returns the size of the file.
+*/
+qint64 QAbstractFileEngine::size() const
+{
+    return 0;
+}
+
+/*!
+    Returns the current file position.
+
+    This is the position of the data read/write head of the file.
+*/
+qint64 QAbstractFileEngine::pos() const
+{
+    return 0;
+}
+
+/*!
+    \fn bool QAbstractFileEngine::seek(qint64 offset)
+
+    Sets the file position to the given \a offset. Returns true if
+    the position was successfully set; otherwise returns false.
+
+    The offset is from the beginning of the file, unless the
+    file is sequential.
+
+    \sa isSequential()
+*/
+bool QAbstractFileEngine::seek(qint64 pos)
+{
+    Q_UNUSED(pos);
+    return false;
+}
+
+/*!
+    Returns true if the file is a sequential access device; returns
+    false if the file is a direct access device.
+
+    Operations involving size() and seek(int) are not valid on
+    sequential devices.
+*/
+bool QAbstractFileEngine::isSequential() const
+{
+    return false;
+}
+
+/*!
+    Requests that the file is deleted from the file system. If the
+    operation succeeds return true; otherwise return false.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName() rmdir()
+ */
+bool QAbstractFileEngine::remove()
+{
+    return false;
+}
+
+/*!
+    Copies the contents of this file to a file with the name \a newName.
+    Returns true on success; otherwise, false is returned.
+*/
+bool QAbstractFileEngine::copy(const QString &newName)
+{
+    Q_UNUSED(newName);
+    return false;
+}
+
+/*!
+    Requests that the file be renamed to \a newName in the file
+    system. If the operation succeeds return true; otherwise return
+    false.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName()
+ */
+bool QAbstractFileEngine::rename(const QString &newName)
+{
+    Q_UNUSED(newName);
+    return false;
+}
+
+/*!
+    Creates a link from the file currently specified by fileName() to
+    \a newName. What a link is depends on the underlying filesystem
+    (be it a shortcut on Windows or a symbolic link on Unix). Returns
+    true if successful; otherwise returns false.
+*/
+bool QAbstractFileEngine::link(const QString &newName)
+{
+    Q_UNUSED(newName);
+    return false;
+}
+
+/*!
+    Requests that the directory \a dirName be created. If
+    \a createParentDirectories is true, then any sub-directories in \a dirName
+    that don't exist must be created. If \a createParentDirectories is false then
+    any sub-directories in \a dirName must already exist for the function to
+    succeed. If the operation succeeds return true; otherwise return
+    false.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName() rmdir() isRelativePath()
+ */
+bool QAbstractFileEngine::mkdir(const QString &dirName, bool createParentDirectories) const
+{
+    Q_UNUSED(dirName);
+    Q_UNUSED(createParentDirectories);
+    return false;
+}
+
+/*!
+    Requests that the directory \a dirName is deleted from the file
+    system. When \a recurseParentDirectories is true, then any empty
+    parent-directories in \a dirName must also be deleted. If
+    \a recurseParentDirectories is false, only the \a dirName leaf-node
+    should be deleted. In most file systems a directory cannot be deleted
+    using this function if it is non-empty. If the operation succeeds
+    return true; otherwise return false.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName() remove() mkdir() isRelativePath()
+ */
+bool QAbstractFileEngine::rmdir(const QString &dirName, bool recurseParentDirectories) const
+{
+    Q_UNUSED(dirName);
+    Q_UNUSED(recurseParentDirectories);
+    return false;
+}
+
+/*!
+    Requests that the file be set to size \a size. If \a size is larger
+    than the current file then it is filled with 0's, if smaller it is
+    simply truncated. If the operations succceeds return true; otherwise
+    return false;
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa size()
+*/
+bool QAbstractFileEngine::setSize(qint64 size)
+{
+    Q_UNUSED(size);
+    return false;
+}
+
+/*!
+    Should return true if the underlying file system is case-sensitive;
+    otherwise return false.
+
+    This virtual function must be reimplemented by all subclasses.
+ */
+bool QAbstractFileEngine::caseSensitive() const
+{
+    return false;
+}
+
+/*!
+    Return true if the file referred to by this file engine has a
+    relative path; otherwise return false.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName()
+ */
+bool QAbstractFileEngine::isRelativePath() const
+{
+    return false;
+}
+
+/*!
+    Requests that a list of all the files matching the \a filters
+    list based on the \a filterNames in the file engine's directory
+    are returned.
+
+    Should return an empty list if the file engine refers to a file
+    rather than a directory, or if the directory is unreadable or does
+    not exist or if nothing matches the specifications.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName()
+ */
+QStringList QAbstractFileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
+{
+    QStringList ret;
+    QDirIterator it(fileName(), filterNames, filters);
+    while (it.hasNext()) {
+        it.next();
+        ret << it.fileName();
+    }
+    return ret;
+}
+
+/*!
+    This function should return the set of OR'd flags that are true
+    for the file engine's file, and that are in the \a type's OR'd
+    members.
+
+    In your reimplementation you can use the \a type argument as an
+    optimization hint and only return the OR'd set of members that are
+    true and that match those in \a type; in other words you can
+    ignore any members not mentioned in \a type, thus avoiding some
+    potentially expensive lookups or system calls.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName()
+*/
+QAbstractFileEngine::FileFlags QAbstractFileEngine::fileFlags(FileFlags type) const
+{
+    Q_UNUSED(type);
+    return 0;
+}
+
+/*!
+    Requests that the file's permissions be set to \a perms. The argument
+    perms will be set to the OR-ed together combination of
+    QAbstractFileEngine::FileInfo, with only the QAbstractFileEngine::PermsMask being
+    honored. If the operations succceeds return true; otherwise return
+    false;
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa size()
+*/
+bool QAbstractFileEngine::setPermissions(uint perms)
+{
+    Q_UNUSED(perms);
+    return false;
+}
+
+/*!
+    Return  the file engine's current file name in the format
+    specified by \a file.
+
+    If you don't handle some \c FileName possibilities, return the
+    file name set in setFileName() when an unhandled format is
+    requested.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName(), FileName
+ */
+QString QAbstractFileEngine::fileName(FileName file) const
+{
+    Q_UNUSED(file);
+    return QString();
+}
+
+/*!
+    If \a owner is \c OwnerUser return the ID of the user who owns
+    the file. If \a owner is \c OwnerGroup return the ID of the group
+    that own the file. If you can't determine the owner return -2.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa owner() setFileName(), FileOwner
+ */
+uint QAbstractFileEngine::ownerId(FileOwner owner) const
+{
+    Q_UNUSED(owner);
+    return 0;
+}
+
+/*!
+    If \a owner is \c OwnerUser return the name of the user who owns
+    the file. If \a owner is \c OwnerGroup return the name of the group
+    that own the file. If you can't determine the owner return
+    QString().
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa ownerId() setFileName(), FileOwner
+ */
+QString QAbstractFileEngine::owner(FileOwner owner) const
+{
+    Q_UNUSED(owner);
+    return QString();
+}
+
+/*!
+    If \a time is \c CreationTime, return when the file was created.
+    If \a time is \c ModificationTime, return when the file was most
+    recently modified. If \a time is \c AccessTime, return when the
+    file was most recently accessed (e.g. read or written).
+    If the time cannot be determined return QDateTime() (an invalid
+    date time).
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa setFileName(), QDateTime, QDateTime::isValid(), FileTime
+ */
+QDateTime QAbstractFileEngine::fileTime(FileTime time) const
+{
+    Q_UNUSED(time);
+    return QDateTime();
+}
+
+/*!
+    Sets the file engine's file name to \a file. This file name is the
+    file that the rest of the virtual functions will operate on.
+
+    This virtual function must be reimplemented by all subclasses.
+
+    \sa rename()
+ */
+void QAbstractFileEngine::setFileName(const QString &file)
+{
+    Q_UNUSED(file);
+}
+
+/*!
+    Returns the native file handle for this file engine. This handle must be
+    used with care; its value and type are platform specific, and using it
+    will most likely lead to non-portable code.
+*/
+int QAbstractFileEngine::handle() const
+{
+    return -1;
+}
+
+/*!
+    \since 4.3
+
+    Returns true if the current position is at the end of the file; otherwise,
+    returns false.
+
+    This function bases its behavior on calling extension() with
+    AtEndExtension. If the engine does not support this extension, false is
+    returned.
+
+    \sa extension(), supportsExtension(), QFile::atEnd()
+*/
+bool QAbstractFileEngine::atEnd() const
+{
+    return const_cast<QAbstractFileEngine *>(this)->extension(AtEndExtension);
+}
+
+/*!
+    \since 4.4
+
+    Maps \a size bytes of the file into memory starting at \a offset.
+    Returns a pointer to the memory if successful; otherwise returns false
+    if, for example, an error occurs.
+
+    This function bases its behavior on calling extension() with
+    MapExtensionOption. If the engine does not support this extension, 0 is
+    returned.
+
+    \a flags is currently not used, but could be used in the future.
+
+    \sa unmap(), supportsExtension()
+ */
+
+uchar *QAbstractFileEngine::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
+{
+    MapExtensionOption option;
+    option.offset = offset;
+    option.size = size;
+    option.flags = flags;
+    MapExtensionReturn r;
+    if (!extension(MapExtension, &option, &r))
+        return 0;
+    return r.address;
+}
+
+/*!
+    \since 4.4
+
+    Unmaps the memory \a address.  Returns true if the unmap succeeds; otherwise
+    returns false.
+
+    This function bases its behavior on calling extension() with
+    UnMapExtensionOption. If the engine does not support this extension, false is
+    returned.
+
+    \sa map(), supportsExtension()
+ */
+bool QAbstractFileEngine::unmap(uchar *address)
+{
+    UnMapExtensionOption options;
+    options.address = address;
+    return extension(UnMapExtension, &options);
+}
+
+/*!
+    \since 4.3
+    \class QAbstractFileEngineIterator
+    \brief The QAbstractFileEngineIterator class provides an iterator
+    interface for custom file engines.
+
+    If all you want is to iterate over entries in a directory, see
+    QDirIterator instead. This class is only for custom file engine authors.
+
+    QAbstractFileEngineIterator is a unidirectional single-use virtual
+    iterator that plugs into QDirIterator, providing transparent proxy
+    iteration for custom file engines.
+
+    You can subclass QAbstractFileEngineIterator to provide an iterator when
+    writing your own file engine. To plug the iterator into your file system,
+    you simply return an instance of this subclass from a reimplementation of
+    QAbstractFileEngine::beginEntryList().
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 2
+
+    QAbstractFileEngineIterator is associated with a path, name filters, and
+    entry filters. The path is the directory that the iterator lists entries
+    in. The name filters and entry filters are provided for file engines that
+    can optimize directory listing at the iterator level (e.g., network file
+    systems that need to minimize network traffic), but they can also be
+    ignored by the iterator subclass; QAbstractFileEngineIterator already
+    provides the required filtering logics in the matchesFilters() function.
+    You can call dirName() to get the directory name, nameFilters() to get a
+    stringlist of name filters, and filters() to get the entry filters.
+
+    The pure virual function hasNext() returns true if the current directory
+    has at least one more entry (i.e., the directory name is valid and
+    accessible, and we have not reached the end of the entry list), and false
+    otherwise. Reimplement next() to seek to the next entry.
+
+    The pure virtual function currentFileName() returns the name of the
+    current entry without advancing the iterator. The currentFilePath()
+    function is provided for convenience; it returns the full path of the
+    current entry.
+
+    Here is an example of how to implement an interator that returns each of
+    three fixed entries in sequence.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qabstractfileengine.cpp 3
+
+    Note: QAbstractFileEngineIterator does not deal with QDir::IteratorFlags;
+    it simply returns entries for a single directory.
+
+    \sa QDirIterator
+*/
+
+/*!
+    \enum QAbstractFileEngineIterator::EntryInfoType
+    \internal
+
+    This enum describes the different types of information that can be
+    requested through the QAbstractFileEngineIterator::entryInfo() function.
+*/
+
+/*!
+    \typedef QAbstractFileEngine::Iterator
+    \since 4.3
+    \relates QAbstractFileEngine
+
+    Synonym for QAbstractFileEngineIterator.
+*/
+
+class QAbstractFileEngineIteratorPrivate
+{
+public:
+    QString path;
+    QDir::Filters filters;
+    QStringList nameFilters;
+    QFileInfo fileInfo;
+};
+
+/*!
+    Constructs a QAbstractFileEngineIterator, using the entry filters \a
+    filters, and wildcard name filters \a nameFilters.
+*/
+QAbstractFileEngineIterator::QAbstractFileEngineIterator(QDir::Filters filters,
+                                                         const QStringList &nameFilters)
+    : d(new QAbstractFileEngineIteratorPrivate)
+{
+    d->nameFilters = nameFilters;
+    d->filters = filters;
+}
+
+/*!
+    Destroys the QAbstractFileEngineIterator.
+
+    \sa QDirIterator
+*/
+QAbstractFileEngineIterator::~QAbstractFileEngineIterator()
+{
+    delete d;
+}
+
+/*!
+    Returns the path for this iterator. QDirIterator is responsible for
+    assigning this path; it cannot change during the iterator's lifetime.
+
+    \sa nameFilters(), filters()
+*/
+QString QAbstractFileEngineIterator::path() const
+{
+    return d->path;
+}
+
+/*!
+    \internal
+
+    Sets the iterator path to \a path. This function is called from within
+    QDirIterator.
+*/
+void QAbstractFileEngineIterator::setPath(const QString &path)
+{
+    d->path = path;
+}
+
+/*!
+    Returns the name filters for this iterator.
+
+    \sa QDir::nameFilters(), filters(), path()
+*/
+QStringList QAbstractFileEngineIterator::nameFilters() const
+{
+    return d->nameFilters;
+}
+
+/*!
+    Returns the entry filters for this iterator.
+
+    \sa QDir::filter(), nameFilters(), path()
+*/
+QDir::Filters QAbstractFileEngineIterator::filters() const
+{
+    return d->filters;
+}
+
+/*!
+    \fn QString QAbstractFileEngineIterator::currentFileName() const = 0
+
+    This pure virtual function returns the name of the current directory
+    entry, excluding the path.
+
+    \sa currentFilePath()
+*/
+
+/*!
+    Returns the path to the current directory entry. It's the same as
+    prepending path() to the return value of currentFileName().
+
+    \sa currentFileName()
+*/
+QString QAbstractFileEngineIterator::currentFilePath() const
+{
+    QString name = currentFileName();
+    if (!name.isNull()) {
+        QString tmp = path();
+        if (!tmp.isEmpty()) {
+            if (!tmp.endsWith(QLatin1Char('/')))
+                tmp.append(QLatin1Char('/'));
+            name.prepend(tmp);
+        }
+    }
+    return name;
+}
+
+/*!
+    The virtual function returns a QFileInfo for the current directory
+    entry. This function is provided for convenience. It can also be slightly
+    faster that creating a QFileInfo object yourself, as the object returned
+    by this function might contain cached information that QFileInfo otherwise
+    would have to access through the file engine.
+
+    \sa currentFileName()
+*/
+QFileInfo QAbstractFileEngineIterator::currentFileInfo() const
+{
+    QString path = currentFilePath();
+    if (d->fileInfo.filePath() != path)
+        d->fileInfo.setFile(path);
+
+    // return a shallow copy
+    return d->fileInfo;
+}
+
+/*!
+    \internal
+
+    Returns the entry info \a type for this iterator's current directory entry
+    as a QVariant. If \a type is undefined for this entry, a null QVariant is
+    returned.
+
+    \sa QAbstractFileEngine::beginEntryList(), QDir::beginEntryList()
+*/
+QVariant QAbstractFileEngineIterator::entryInfo(EntryInfoType type) const
+{
+    Q_UNUSED(type)
+    return QVariant();
+}
+
+/*!
+    \fn virtual QString QAbstractFileEngineIterator::next() = 0
+
+    This pure virtual function advances the iterator to the next directory
+    entry, and returns the file path to the current entry.
+
+    This function can optionally make use of nameFilters() and filters() to
+    optimize its performance.
+
+    Reimplement this function in a subclass to advance the iterator.
+
+    \sa QDirIterator::next()
+*/
+
+/*!
+    \fn virtual bool QAbstractFileEngineIterator::hasNext() const = 0
+
+    This pure virtual function returns true if there is at least one more
+    entry in the current directory (i.e., the iterator path is valid and
+    accessible, and the iterator has not reached the end of the entry list).
+
+    \sa QDirIterator::hasNext()
+*/
+
+/*!
+    Returns an instance of a QAbstractFileEngineIterator using \a filters for
+    entry filtering and \a filterNames for name filtering. This function is
+    called by QDirIterator to initiate directory iteration.
+
+    QDirIterator takes ownership of the returned instance, and deletes it when
+    it's done.
+
+    \sa QDirIterator
+*/
+QAbstractFileEngine::Iterator *QAbstractFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
+{
+    Q_UNUSED(filters);
+    Q_UNUSED(filterNames);
+    return 0;
+}
+
+/*!
+    \internal
+*/
+QAbstractFileEngine::Iterator *QAbstractFileEngine::endEntryList()
+{
+    return 0;
+}
+
+/*!
+    Reads a number of characters from the file into \a data. At most
+    \a maxlen characters will be read.
+
+    Returns -1 if a fatal error occurs, or 0 if there are no bytes to
+    read.
+*/
+qint64 QAbstractFileEngine::read(char *data, qint64 maxlen)
+{
+    Q_UNUSED(data);
+    Q_UNUSED(maxlen);
+    return -1;
+}
+
+/*!
+    Writes \a len bytes from \a data to the file. Returns the number
+    of characters written on success; otherwise returns -1.
+*/
+qint64 QAbstractFileEngine::write(const char *data, qint64 len)
+{
+    Q_UNUSED(data);
+    Q_UNUSED(len);
+    return -1;
+}
+
+/*!
+    This function reads one line, terminated by a '\n' character, from the
+    file info \a data. At most \a maxlen characters will be read. The
+    end-of-line character is included.
+*/
+qint64 QAbstractFileEngine::readLine(char *data, qint64 maxlen)
+{
+    qint64 readSoFar = 0;
+    while (readSoFar < maxlen) {
+        char c;
+        qint64 readResult = read(&c, 1);
+        if (readResult <= 0)
+            return (readSoFar > 0) ? readSoFar : -1;
+        ++readSoFar;
+        *data++ = c;
+        if (c == '\n')
+            return readSoFar;
+    }
+    return readSoFar;
+}
+
+/*!
+   \enum QAbstractFileEngine::Extension
+   \since 4.3
+
+   This enum describes the types of extensions that the file engine can
+   support. Before using these extensions, you must verify that the extension
+   is supported (i.e., call supportsExtension()).
+
+   \value AtEndExtension Whether the current file position is at the end of
+   the file or not. This extension allows file engines that implement local
+   buffering to report end-of-file status without having to check the size of
+   the file. It is also useful for sequential files, where the size of the
+   file cannot be used to determine whether or not you have reached the end.
+   This extension returns true if the file is at the end; otherwise it returns
+   false. The input and output arguments to extension() are ignored.
+
+   \value FastReadLineExtension Whether the file engine provides a
+   fast implementation for readLine() or not. If readLine() remains
+   unimplemented in the file engine, QAbstractFileEngine will provide
+   an implementation based on calling read() repeatedly. If
+   supportsExtension() returns false for this extension, however,
+   QIODevice can provide a faster implementation by making use of its
+   internal buffer. For engines that already provide a fast readLine()
+   implementation, returning false for this extension can avoid
+   unnnecessary double-buffering in QIODevice.
+
+   \value MapExtension Whether the file engine provides the ability to map
+   a file to memory.
+
+   \value UnMapExtension Whether the file engine provides the ability to
+   unmap memory that was previously mapped.
+*/
+
+/*!
+   \class QAbstractFileEngine::ExtensionOption
+   \since 4.3
+   \brief provides an extended input argument to QAbstractFileEngine's
+   extension support.
+
+   \sa QAbstractFileEngine::extension()
+*/
+
+/*!
+   \class QAbstractFileEngine::ExtensionReturn
+   \since 4.3
+   \brief provides an extended output argument to QAbstractFileEngine's
+   extension support.
+
+   \sa QAbstractFileEngine::extension()
+*/
+
+/*!
+    \since 4.3
+
+    This virtual function can be reimplemented in a QAbstractFileEngine
+    subclass to provide support for extensions. The \a option argument is
+    provided as input to the extension, and this function can store output
+    results in \a output.
+
+    The behavior of this function is determined by \a extension; see the
+    Extension documentation for details.
+
+    You can call supportsExtension() to check if an extension is supported by
+    the file engine.
+
+    By default, no extensions are supported, and this function returns false.
+
+    \sa supportsExtension(), Extension
+*/
+bool QAbstractFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
+{
+    Q_UNUSED(extension);
+    Q_UNUSED(option);
+    Q_UNUSED(output);
+    return false;
+}
+
+/*!
+    \since 4.3
+
+    This virtual function returns true if the file engine supports \a
+    extension; otherwise, false is returned. By default, no extensions are
+    supported.
+
+    \sa extension()
+*/
+bool QAbstractFileEngine::supportsExtension(Extension extension) const
+{
+    Q_UNUSED(extension);
+    return false;
+}
+
+/*!
+  Returns the QFile::FileError that resulted from the last failed
+  operation. If QFile::UnspecifiedError is returned, QFile will
+  use its own idea of the error status.
+
+  \sa QFile::FileError, errorString()
+ */
+QFile::FileError QAbstractFileEngine::error() const
+{
+    Q_D(const QAbstractFileEngine);
+    return d->fileError;
+}
+
+/*!
+  Returns the human-readable message appropriate to the current error
+  reported by error(). If no suitable string is available, an
+  empty string is returned.
+
+  \sa error()
+ */
+QString QAbstractFileEngine::errorString() const
+{
+    Q_D(const QAbstractFileEngine);
+    return d->errorString;
+}
+
+/*!
+    Sets the error type to \a error, and the error string to \a errorString.
+    Call this function to set the error values returned by the higher-level
+    classes.
+
+    \sa QFile::error(), QIODevice::errorString(), QIODevice::setErrorString()
+*/
+void QAbstractFileEngine::setError(QFile::FileError error, const QString &errorString)
+{
+    Q_D(QAbstractFileEngine);
+    d->fileError = error;
+    d->errorString = errorString;
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qabstractfileengine.h b/src/corelib/io/qabstractfileengine.h
new file mode 100644
index 0000000..d742467
--- /dev/null
+++ b/src/corelib/io/qabstractfileengine.h
@@ -0,0 +1,247 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTFILEENGINE_H
+#define QABSTRACTFILEENGINE_H
+
+#include <QtCore/qdir.h>
+
+#ifdef open
+#error qabstractfileengine.h must be included before any header file that defines open
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QFileExtension;
+class QFileExtensionResult;
+class QVariant;
+class QAbstractFileEngineIterator;
+class QAbstractFileEnginePrivate;
+
+class Q_CORE_EXPORT QAbstractFileEngine
+{
+public:
+    enum FileFlag {
+        //perms (overlaps the QFile::Permission)
+        ReadOwnerPerm = 0x4000, WriteOwnerPerm = 0x2000, ExeOwnerPerm = 0x1000,
+        ReadUserPerm  = 0x0400, WriteUserPerm  = 0x0200, ExeUserPerm  = 0x0100,
+        ReadGroupPerm = 0x0040, WriteGroupPerm = 0x0020, ExeGroupPerm = 0x0010,
+        ReadOtherPerm = 0x0004, WriteOtherPerm = 0x0002, ExeOtherPerm = 0x0001,
+
+        //types
+        LinkType      = 0x10000,
+        FileType      = 0x20000,
+        DirectoryType = 0x40000,
+        BundleType    = 0x80000,
+
+        //flags
+        HiddenFlag     = 0x0100000,
+        LocalDiskFlag  = 0x0200000,
+        ExistsFlag     = 0x0400000,
+        RootFlag       = 0x0800000,
+        Refresh        = 0x1000000,
+
+        //masks
+        PermsMask  = 0x0000FFFF,
+        TypesMask  = 0x000F0000,
+        FlagsMask  = 0x0FF00000,
+        FileInfoAll = FlagsMask | PermsMask | TypesMask
+    };
+    Q_DECLARE_FLAGS(FileFlags, FileFlag)
+
+    enum FileName {
+        DefaultName,
+        BaseName,
+        PathName,
+        AbsoluteName,
+        AbsolutePathName,
+        LinkName,
+        CanonicalName,
+        CanonicalPathName,
+        BundleName
+    };
+    enum FileOwner {
+        OwnerUser,
+        OwnerGroup
+    };
+    enum FileTime {
+        CreationTime,
+        ModificationTime,
+        AccessTime
+    };
+
+    virtual ~QAbstractFileEngine();
+
+    virtual bool open(QIODevice::OpenMode openMode);
+    virtual bool close();
+    virtual bool flush();
+    virtual qint64 size() const;
+    virtual qint64 pos() const;
+    virtual bool seek(qint64 pos);
+    virtual bool isSequential() const;
+    virtual bool remove();
+    virtual bool copy(const QString &newName);
+    virtual bool rename(const QString &newName);
+    virtual bool link(const QString &newName);
+    virtual bool mkdir(const QString &dirName, bool createParentDirectories) const;
+    virtual bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
+    virtual bool setSize(qint64 size);
+    virtual bool caseSensitive() const;
+    virtual bool isRelativePath() const;
+    virtual QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
+    virtual FileFlags fileFlags(FileFlags type=FileInfoAll) const;
+    virtual bool setPermissions(uint perms);
+    virtual QString fileName(FileName file=DefaultName) const;
+    virtual uint ownerId(FileOwner) const;
+    virtual QString owner(FileOwner) const;
+    virtual QDateTime fileTime(FileTime time) const;
+    virtual void setFileName(const QString &file);
+    virtual int handle() const;
+    bool atEnd() const;
+    uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
+    bool unmap(uchar *ptr);
+
+    typedef QAbstractFileEngineIterator Iterator;
+    virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
+    virtual Iterator *endEntryList();
+
+    virtual qint64 read(char *data, qint64 maxlen);
+    virtual qint64 readLine(char *data, qint64 maxlen);
+    virtual qint64 write(const char *data, qint64 len);
+
+    QFile::FileError error() const;
+    QString errorString() const;
+
+    enum Extension {
+        AtEndExtension,
+        FastReadLineExtension,
+        MapExtension,
+        UnMapExtension
+    };
+    class ExtensionOption
+    {};
+    class ExtensionReturn
+    {};
+
+    class MapExtensionOption : public ExtensionOption {
+    public:
+        qint64 offset;
+        qint64 size;
+        QFile::MemoryMapFlags flags;
+    };
+    class MapExtensionReturn : public ExtensionReturn {
+    public:
+        uchar *address;
+    };
+
+    class UnMapExtensionOption : public ExtensionOption {
+    public:
+        uchar *address;
+    };
+
+    virtual bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
+    virtual bool supportsExtension(Extension extension) const;
+
+    // Factory
+    static QAbstractFileEngine *create(const QString &fileName);
+
+protected:
+    void setError(QFile::FileError error, const QString &str);
+
+    QAbstractFileEngine();
+    QAbstractFileEngine(QAbstractFileEnginePrivate &);
+
+    QAbstractFileEnginePrivate *d_ptr;
+private:
+    Q_DECLARE_PRIVATE(QAbstractFileEngine)
+    Q_DISABLE_COPY(QAbstractFileEngine)
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QAbstractFileEngine::FileFlags)
+
+class Q_CORE_EXPORT QAbstractFileEngineHandler
+{
+public:
+    QAbstractFileEngineHandler();
+    virtual ~QAbstractFileEngineHandler();
+    virtual QAbstractFileEngine *create(const QString &fileName) const = 0;
+};
+
+class QAbstractFileEngineIteratorPrivate;
+class Q_CORE_EXPORT QAbstractFileEngineIterator
+{
+public:
+    QAbstractFileEngineIterator(QDir::Filters filters, const QStringList &nameFilters);
+    virtual ~QAbstractFileEngineIterator();
+
+    virtual QString next() = 0;
+    virtual bool hasNext() const = 0;
+
+    QString path() const;
+    QStringList nameFilters() const;
+    QDir::Filters filters() const;
+
+    virtual QString currentFileName() const = 0;
+    virtual QFileInfo currentFileInfo() const;
+    QString currentFilePath() const;
+
+protected:
+    enum EntryInfoType {
+    };
+    virtual QVariant entryInfo(EntryInfoType type) const;
+
+private:
+    Q_DISABLE_COPY(QAbstractFileEngineIterator)
+    friend class QDirIterator;
+    friend class QDirIteratorPrivate;
+    void setPath(const QString &path);
+    QAbstractFileEngineIteratorPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QABSTRACTFILEENGINE_H
diff --git a/src/corelib/io/qabstractfileengine_p.h b/src/corelib/io/qabstractfileengine_p.h
new file mode 100644
index 0000000..34a5a02
--- /dev/null
+++ b/src/corelib/io/qabstractfileengine_p.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTFILEENGINE_P_H
+#define QABSTRACTFILEENGINE_P_H
+
+//
+//  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.
+//
+
+#include "QtCore/qabstractfileengine.h"
+#include "QtCore/qfile.h"
+
+QT_BEGIN_NAMESPACE
+
+class QAbstractFileEnginePrivate
+{
+public:
+    inline QAbstractFileEnginePrivate()
+        : fileError(QFile::UnspecifiedError)
+    {
+    }
+    inline virtual ~QAbstractFileEnginePrivate() { }
+
+    QFile::FileError fileError;
+    QString errorString;
+
+    QAbstractFileEngine *q_ptr;
+    Q_DECLARE_PUBLIC(QAbstractFileEngine)
+};
+
+QT_END_NAMESPACE
+
+#endif // QABSTRACTFILEENGINE_P_H
diff --git a/src/corelib/io/qbuffer.cpp b/src/corelib/io/qbuffer.cpp
new file mode 100644
index 0000000..a34f7ba
--- /dev/null
+++ b/src/corelib/io/qbuffer.cpp
@@ -0,0 +1,475 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qbuffer.h"
+#include "private/qiodevice_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/** QBufferPrivate **/
+class QBufferPrivate : public QIODevicePrivate
+{
+    Q_DECLARE_PUBLIC(QBuffer)
+
+public:
+    QBufferPrivate()
+    : buf(0)
+#ifndef QT_NO_QOBJECT
+        , writtenSinceLastEmit(0), signalConnectionCount(0), signalsEmitted(false)
+#endif
+    { }
+    ~QBufferPrivate() { }
+
+    QByteArray *buf;
+    QByteArray defaultBuf;
+    int ioIndex;
+
+#ifndef QT_NO_QOBJECT
+    // private slots
+    void _q_emitSignals();
+
+    qint64 writtenSinceLastEmit;
+    int signalConnectionCount;
+    bool signalsEmitted;
+#endif
+};
+
+#ifndef QT_NO_QOBJECT
+void QBufferPrivate::_q_emitSignals()
+{
+    Q_Q(QBuffer);
+    emit q->bytesWritten(writtenSinceLastEmit);
+    writtenSinceLastEmit = 0;
+    emit q->readyRead();
+    signalsEmitted = false;
+}
+#endif
+
+/*!
+    \class QBuffer
+    \reentrant
+    \brief The QBuffer class provides a QIODevice interface for a QByteArray.
+
+    \ingroup io
+
+    QBuffer allows you to access a QByteArray using the QIODevice
+    interface. The QByteArray is treated just as a standard random-accessed
+    file. Example:
+
+    \snippet doc/src/snippets/buffer/buffer.cpp 0
+
+    By default, an internal QByteArray buffer is created for you when
+    you create a QBuffer. You can access this buffer directly by
+    calling buffer(). You can also use QBuffer with an existing
+    QByteArray by calling setBuffer(), or by passing your array to
+    QBuffer's constructor.
+
+    Call open() to open the buffer. Then call write() or
+    putChar() to write to the buffer, and read(), readLine(),
+    readAll(), or getChar() to read from it. size() returns the
+    current size of the buffer, and you can seek to arbitrary
+    positions in the buffer by calling seek(). When you are done with
+    accessing the buffer, call close().
+
+    The following code snippet shows how to write data to a
+    QByteArray using QDataStream and QBuffer:
+
+    \snippet doc/src/snippets/buffer/buffer.cpp 1
+
+    Effectively, we convert the application's QPalette into a byte
+    array. Here's how to read the data from the QByteArray:
+
+    \snippet doc/src/snippets/buffer/buffer.cpp 2
+
+    QTextStream and QDataStream also provide convenience constructors
+    that take a QByteArray and that create a QBuffer behind the
+    scenes.
+
+    QBuffer emits readyRead() when new data has arrived in the
+    buffer. By connecting to this signal, you can use QBuffer to
+    store temporary data before processing it. For example, you can
+    pass the buffer to QFtp when downloading a file from an FTP
+    server. Whenever a new payload of data has been downloaded,
+    readyRead() is emitted, and you can process the data that just
+    arrived. QBuffer also emits bytesWritten() every time new data
+    has been written to the buffer.
+
+    \sa QFile, QDataStream, QTextStream, QByteArray
+*/
+
+#ifdef QT_NO_QOBJECT
+QBuffer::QBuffer()
+    : QIODevice(*new QBufferPrivate)
+{
+    Q_D(QBuffer);
+    d->buf = &d->defaultBuf;
+    d->ioIndex = 0;
+}
+QBuffer::QBuffer(QByteArray *buf)
+    : QIODevice(*new QBufferPrivate)
+{
+    Q_D(QBuffer);
+    d->buf = buf ? buf : &d->defaultBuf;
+    d->ioIndex = 0;
+    d->defaultBuf.clear();
+}
+#else
+/*!
+    Constructs an empty buffer with the given \a parent. You can call
+    setData() to fill the buffer with data, or you can open it in
+    write mode and use write().
+
+    \sa open()
+*/
+QBuffer::QBuffer(QObject *parent)
+    : QIODevice(*new QBufferPrivate, parent)
+{
+    Q_D(QBuffer);
+    d->buf = &d->defaultBuf;
+    d->ioIndex = 0;
+}
+
+/*!
+    Constructs a QBuffer that uses the QByteArray pointed to by \a
+    byteArray as its internal buffer, and with the given \a parent.
+    The caller is responsible for ensuring that \a byteArray remains
+    valid until the QBuffer is destroyed, or until setBuffer() is
+    called to change the buffer. QBuffer doesn't take ownership of
+    the QByteArray.
+
+    If you open the buffer in write-only mode or read-write mode and
+    write something into the QBuffer, \a byteArray will be modified.
+
+    Example:
+
+    \snippet doc/src/snippets/buffer/buffer.cpp 3
+
+    \sa open(), setBuffer(), setData()
+*/
+QBuffer::QBuffer(QByteArray *byteArray, QObject *parent)
+    : QIODevice(*new QBufferPrivate, parent)
+{
+    Q_D(QBuffer);
+    d->buf = byteArray ? byteArray : &d->defaultBuf;
+    d->defaultBuf.clear();
+    d->ioIndex = 0;
+}
+#endif
+
+/*!
+    Destroys the buffer.
+*/
+
+QBuffer::~QBuffer()
+{
+}
+
+/*!
+    Makes QBuffer uses the QByteArray pointed to by \a
+    byteArray as its internal buffer. The caller is responsible for
+    ensuring that \a byteArray remains valid until the QBuffer is
+    destroyed, or until setBuffer() is called to change the buffer.
+    QBuffer doesn't take ownership of the QByteArray.
+
+    Does nothing if isOpen() is true.
+
+    If you open the buffer in write-only mode or read-write mode and
+    write something into the QBuffer, \a byteArray will be modified.
+
+    Example:
+
+    \snippet doc/src/snippets/buffer/buffer.cpp 4
+
+    If \a byteArray is 0, the buffer creates its own internal
+    QByteArray to work on. This byte array is initially empty.
+
+    \sa buffer(), setData(), open()
+*/
+
+void QBuffer::setBuffer(QByteArray *byteArray)
+{
+    Q_D(QBuffer);
+    if (isOpen()) {
+        qWarning("QBuffer::setBuffer: Buffer is open");
+        return;
+    }
+    if (byteArray) {
+        d->buf = byteArray;
+    } else {
+        d->buf = &d->defaultBuf;
+    }
+    d->defaultBuf.clear();
+    d->ioIndex = 0;
+}
+
+/*!
+    Returns a reference to the QBuffer's internal buffer. You can use
+    it to modify the QByteArray behind the QBuffer's back.
+
+    \sa setBuffer(), data()
+*/
+
+QByteArray &QBuffer::buffer()
+{
+    Q_D(QBuffer);
+    return *d->buf;
+}
+
+/*!
+    \overload
+
+    This is the same as data().
+*/
+
+const QByteArray &QBuffer::buffer() const
+{
+    Q_D(const QBuffer);
+    return *d->buf;
+}
+
+
+/*!
+    Returns the data contained in the buffer.
+
+    This is the same as buffer().
+
+    \sa setData(), setBuffer()
+*/
+
+const QByteArray &QBuffer::data() const
+{
+    Q_D(const QBuffer);
+    return *d->buf;
+}
+
+/*!
+    Sets the contents of the internal buffer to be \a data. This is
+    the same as assigning \a data to buffer().
+
+    Does nothing if isOpen() is true.
+
+    \sa setBuffer()
+*/
+void QBuffer::setData(const QByteArray &data)
+{
+    Q_D(QBuffer);
+    if (isOpen()) {
+        qWarning("QBuffer::setData: Buffer is open");
+        return;
+    }
+    *d->buf = data;
+    d->ioIndex = 0;
+}
+
+/*!
+    \fn void QBuffer::setData(const char *data, int size)
+
+    \overload
+
+    Sets the contents of the internal buffer to be the first \a size
+    bytes of \a data.
+*/
+
+/*!
+   \reimp
+*/
+bool QBuffer::open(OpenMode flags)
+{
+    Q_D(QBuffer);
+
+    if ((flags & Append) == Append)
+        flags |= WriteOnly;
+    setOpenMode(flags);
+    if (!(isReadable() || isWritable())) {
+        qWarning("QFile::open: File access not specified");
+        return false;
+    }
+
+    if ((flags & QIODevice::Truncate) == QIODevice::Truncate) {
+        d->buf->resize(0);
+    }
+    if ((flags & QIODevice::Append) == QIODevice::Append) // append to end of buffer
+        seek(d->buf->size());
+    else
+        seek(0);
+
+    return true;
+}
+
+/*!
+    \reimp
+*/
+void QBuffer::close()
+{
+    QIODevice::close();
+}
+
+/*!
+    \reimp
+*/
+qint64 QBuffer::pos() const
+{
+    return QIODevice::pos();
+}
+
+/*!
+    \reimp
+*/
+qint64 QBuffer::size() const
+{
+    Q_D(const QBuffer);
+    return qint64(d->buf->size());
+}
+
+/*!
+    \reimp
+*/
+bool QBuffer::seek(qint64 pos)
+{
+    Q_D(QBuffer);
+    if (pos > d->buf->size() && isWritable()) {
+        if (seek(d->buf->size())) {
+            const qint64 gapSize = pos - d->buf->size();
+            if (write(QByteArray(gapSize, 0)) != gapSize) {
+                qWarning("QBuffer::seek: Unable to fill gap");
+                return false;
+            }
+        } else {
+            return false;
+        }
+    } else if (pos > d->buf->size() || pos < 0) {
+        qWarning("QBuffer::seek: Invalid pos: %d", int(pos));
+        return false;
+    }
+    d->ioIndex = int(pos);
+    return QIODevice::seek(pos);
+}
+
+/*!
+    \reimp
+*/
+bool QBuffer::atEnd() const
+{
+    return QIODevice::atEnd();
+}
+
+/*!
+   \reimp
+*/
+bool QBuffer::canReadLine() const
+{
+    Q_D(const QBuffer);
+    if (!isOpen())
+        return false;
+
+    return d->buf->indexOf('\n', int(pos())) != -1 || QIODevice::canReadLine();
+}
+
+/*!
+    \reimp
+*/
+qint64 QBuffer::readData(char *data, qint64 len)
+{
+    Q_D(QBuffer);
+    if ((len = qMin(len, qint64(d->buf->size()) - d->ioIndex)) <= 0)
+        return qint64(0);
+    memcpy(data, d->buf->constData() + d->ioIndex, len);
+    d->ioIndex += int(len);
+    return len;
+}
+
+/*!
+    \reimp
+*/
+qint64 QBuffer::writeData(const char *data, qint64 len)
+{
+    Q_D(QBuffer);
+    int extraBytes = d->ioIndex + len - d->buf->size();
+    if (extraBytes > 0) { // overflow
+        int newSize = d->buf->size() + extraBytes;
+        d->buf->resize(newSize);
+        if (d->buf->size() != newSize) { // could not resize
+            qWarning("QBuffer::writeData: Memory allocation error");
+            return -1;
+        }
+    }
+
+    memcpy(d->buf->data() + d->ioIndex, (uchar *)data, int(len));
+    d->ioIndex += int(len);
+
+#ifndef QT_NO_QOBJECT
+    d->writtenSinceLastEmit += len;
+    if (d->signalConnectionCount && !d->signalsEmitted && !signalsBlocked()) {
+        d->signalsEmitted = true;
+        QMetaObject::invokeMethod(this, "_q_emitSignals", Qt::QueuedConnection);
+    }
+#endif
+    return len;
+}
+
+#ifndef QT_NO_QOBJECT
+/*!
+    \reimp
+    \internal
+*/
+void QBuffer::connectNotify(const char *signal)
+{
+    if (strcmp(signal + 1, "readyRead()") == 0 || strcmp(signal + 1, "bytesWritten(qint64)"))
+        d_func()->signalConnectionCount++;
+}
+
+/*!
+    \reimp
+    \internal
+*/
+void QBuffer::disconnectNotify(const char *signal)
+{
+    if (!signal || strcmp(signal + 1, "readyRead()") == 0 || strcmp(signal + 1, "bytesWritten(qint64)") == 0)
+        d_func()->signalConnectionCount--;
+}
+#endif
+
+QT_END_NAMESPACE
+
+#ifndef QT_NO_QOBJECT
+# include "moc_qbuffer.cpp"
+#endif
+
diff --git a/src/corelib/io/qbuffer.h b/src/corelib/io/qbuffer.h
new file mode 100644
index 0000000..37aefb2
--- /dev/null
+++ b/src/corelib/io/qbuffer.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBUFFER_H
+#define QBUFFER_H
+
+#include <QtCore/qiodevice.h>
+#include <QtCore/qbytearray.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QObject;
+class QBufferPrivate;
+
+class Q_CORE_EXPORT QBuffer : public QIODevice
+{
+#ifndef QT_NO_QOBJECT
+    Q_OBJECT
+#endif
+
+public:
+#ifndef QT_NO_QOBJECT
+     explicit QBuffer(QObject *parent = 0);
+     QBuffer(QByteArray *buf, QObject *parent = 0);
+#else
+     QBuffer();
+     explicit QBuffer(QByteArray *buf);
+#endif
+    ~QBuffer();
+
+    QByteArray &buffer();
+    const QByteArray &buffer() const;
+    void setBuffer(QByteArray *a);
+
+    void setData(const QByteArray &data);
+    inline void setData(const char *data, int len);
+    const QByteArray &data() const;
+
+    bool open(OpenMode openMode);
+
+    void close();
+    qint64 size() const;
+    qint64 pos() const;
+    bool seek(qint64 off);
+    bool atEnd() const;
+    bool canReadLine() const;
+
+protected:
+#ifndef QT_NO_QOBJECT
+    void connectNotify(const char*);
+    void disconnectNotify(const char*);
+#endif
+    qint64 readData(char *data, qint64 maxlen);
+    qint64 writeData(const char *data, qint64 len);
+
+private:
+    Q_DECLARE_PRIVATE(QBuffer)
+    Q_DISABLE_COPY(QBuffer)
+
+    Q_PRIVATE_SLOT(d_func(), void _q_emitSignals())
+};
+
+inline void QBuffer::setData(const char *adata, int alen)
+{ setData(QByteArray(adata, alen)); }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QBUFFER_H
diff --git a/src/corelib/io/qdatastream.cpp b/src/corelib/io/qdatastream.cpp
new file mode 100644
index 0000000..9990696
--- /dev/null
+++ b/src/corelib/io/qdatastream.cpp
@@ -0,0 +1,1260 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qdatastream.h"
+
+#ifndef QT_NO_DATASTREAM
+#include "qbuffer.h"
+#include "qstring.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QDataStream
+    \reentrant
+    \brief The QDataStream class provides serialization of binary data
+    to a QIODevice.
+
+    \ingroup io
+    \mainclass
+
+    A data stream is a binary stream of encoded information which is
+    100% independent of the host computer's operating system, CPU or
+    byte order. For example, a data stream that is written by a PC
+    under Windows can be read by a Sun SPARC running Solaris.
+
+    You can also use a data stream to read/write \l{raw}{raw
+    unencoded binary data}. If you want a "parsing" input stream, see
+    QTextStream.
+
+    The QDataStream class implements the serialization of C++'s basic
+    data types, like \c char, \c short, \c int, \c{char *}, etc.
+    Serialization of more complex data is accomplished by breaking up
+    the data into primitive units.
+
+    A data stream cooperates closely with a QIODevice. A QIODevice
+    represents an input/output medium one can read data from and write
+    data to. The QFile class is an example of an I/O device.
+
+    Example (write binary data to a stream):
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdatastream.cpp 0
+
+    Example (read binary data from a stream):
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdatastream.cpp 1
+
+    Each item written to the stream is written in a predefined binary
+    format that varies depending on the item's type. Supported Qt
+    types include QBrush, QColor, QDateTime, QFont, QPixmap, QString,
+    QVariant and many others. For the complete list of all Qt types
+    supporting data streaming see the \l{Format of the QDataStream
+    operators}.
+
+    For integers it is best to always cast to a Qt integer type for
+    writing, and to read back into the same Qt integer type. This
+    ensures that you get integers of the size you want and insulates
+    you from compiler and platform differences.
+
+    To take one example, a \c{char *} string is written as a 32-bit
+    integer equal to the length of the string including the '\\0' byte,
+    followed by all the characters of the string including the
+    '\\0' byte. When reading a \c{char *} string, 4 bytes are read to
+    create the 32-bit length value, then that many characters for the
+    \c {char *} string including the '\\0' terminator are read.
+
+    The initial I/O device is usually set in the constructor, but can be
+    changed with setDevice(). If you've reached the end of the data
+    (or if there is no I/O device set) atEnd() will return true.
+
+    \section1 Versioning
+
+    QDataStream's binary format has evolved since Qt 1.0, and is
+    likely to continue evolving to reflect changes done in Qt. When
+    inputting or outputting complex types, it's very important to
+    make sure that the same version of the stream (version()) is used
+    for reading and writing. If you need both forward and backward
+    compatibility, you can hardcode the version number in the
+    application:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdatastream.cpp 2
+
+    If you are producing a new binary data format, such as a file
+    format for documents created by your application, you could use a
+    QDataStream to write the data in a portable format. Typically, you
+    would write a brief header containing a magic string and a version
+    number to give yourself room for future expansion. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdatastream.cpp 3
+
+    Then read it in with:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdatastream.cpp 4
+
+    You can select which byte order to use when serializing data. The
+    default setting is big endian (MSB first). Changing it to little
+    endian breaks the portability (unless the reader also changes to
+    little endian). We recommend keeping this setting unless you have
+    special requirements.
+
+    \target raw
+    \section1 Reading and writing raw binary data
+
+    You may wish to read/write your own raw binary data to/from the
+    data stream directly. Data may be read from the stream into a
+    preallocated \c{char *} using readRawData(). Similarly data can be
+    written to the stream using writeRawData(). Note that any
+    encoding/decoding of the data must be done by you.
+
+    A similar pair of functions is readBytes() and writeBytes(). These
+    differ from their \e raw counterparts as follows: readBytes()
+    reads a quint32 which is taken to be the length of the data to be
+    read, then that number of bytes is read into the preallocated
+    \c{char *}; writeBytes() writes a quint32 containing the length of the
+    data, followed by the data. Note that any encoding/decoding of
+    the data (apart from the length quint32) must be done by you.
+
+    \target Serializing Qt Classes
+    \section1 Reading and writing other Qt classes.
+
+    In addition to the overloaded stream operators documented here,
+    any Qt classes that you might want to serialize to a QDataStream
+    will have appropriate stream operators declared as non-member of
+    the class:
+
+    \code
+    QDataStream &operator<<(QDataStream &, const QXxx &);
+    QDataStream &operator>>(QDataStream &, QXxx &);
+    \endcode
+
+    For example, here are the stream operators declared as non-members
+    of the QImage class:
+
+    \code
+    QDataStream & operator<< (QDataStream& stream, const QImage& image);
+    QDataStream & operator>> (QDataStream& stream, QImage& image);
+    \endcode
+
+    To see if your favorite Qt class has similar stream operators
+    defined, check the \bold {Related Non-Members} section of the
+    class's documentation page.
+
+    \sa QTextStream QVariant
+*/
+
+/*!
+    \enum QDataStream::ByteOrder
+
+    The byte order used for reading/writing the data.
+
+    \value BigEndian Most significant byte first (the default)
+    \value LittleEndian Least significant byte first
+*/
+
+/*!
+    \enum QDataStream::Status
+
+    This enum describes the current status of the data stream.
+
+    \value Ok               The data stream is operating normally.
+    \value ReadPastEnd      The data stream has read past the end of the
+                            data in the underlying device.
+    \value ReadCorruptData  The data stream has read corrupt data.
+*/
+
+/*****************************************************************************
+  QDataStream member functions
+ *****************************************************************************/
+
+#undef  CHECK_STREAM_PRECOND
+#ifndef QT_NO_DEBUG
+#define CHECK_STREAM_PRECOND(retVal) \
+    if (!dev) { \
+        qWarning("QDataStream: No device"); \
+        return retVal; \
+    }
+#else
+#define CHECK_STREAM_PRECOND(retVal) \
+    if (!dev) { \
+        return retVal; \
+    }
+#endif
+
+enum {
+    DefaultStreamVersion = QDataStream::Qt_4_5
+};
+
+// ### 5.0: when streaming invalid QVariants, just the type should
+// be written, no "data" after it
+
+/*!
+    Constructs a data stream that has no I/O device.
+
+    \sa setDevice()
+*/
+
+QDataStream::QDataStream()
+{
+    dev = 0;
+    owndev = false;
+    byteorder = BigEndian;
+    ver = DefaultStreamVersion;
+    noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;
+    q_status = Ok;
+}
+
+/*!
+    Constructs a data stream that uses the I/O device \a d.
+
+    \warning If you use QSocket or QSocketDevice as the I/O device \a d
+    for reading data, you must make sure that enough data is available
+    on the socket for the operation to successfully proceed;
+    QDataStream does not have any means to handle or recover from
+    short-reads.
+
+    \sa setDevice(), device()
+*/
+
+QDataStream::QDataStream(QIODevice *d)
+{
+    dev = d;                                // set device
+    owndev = false;
+    byteorder = BigEndian;                        // default byte order
+    ver = DefaultStreamVersion;
+    noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;
+    q_status = Ok;
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    \fn QDataStream::QDataStream(QByteArray *array, int mode)
+    \compat
+
+    Constructs a data stream that operates on the given \a array. The
+    \a mode specifies how the byte array is to be used, and is
+    usually either QIODevice::ReadOnly or QIODevice::WriteOnly.
+*/
+QDataStream::QDataStream(QByteArray *a, int mode)
+{
+    QBuffer *buf = new QBuffer(a);
+#ifndef QT_NO_QOBJECT
+    buf->blockSignals(true);
+#endif
+    buf->open(QIODevice::OpenMode(mode));
+    dev = buf;
+    owndev = true;
+    byteorder = BigEndian;
+    ver = DefaultStreamVersion;
+    noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;
+    q_status = Ok;
+}
+#endif
+
+/*!
+    \fn QDataStream::QDataStream(QByteArray *a, QIODevice::OpenMode mode)
+
+    Constructs a data stream that operates on a byte array, \a a. The
+    \a mode describes how the device is to be used.
+
+    Alternatively, you can use QDataStream(const QByteArray &) if you
+    just want to read from a byte array.
+
+    Since QByteArray is not a QIODevice subclass, internally a QBuffer
+    is created to wrap the byte array.
+*/
+
+QDataStream::QDataStream(QByteArray *a, QIODevice::OpenMode flags)
+{
+    QBuffer *buf = new QBuffer(a);
+#ifndef QT_NO_QOBJECT
+    buf->blockSignals(true);
+#endif
+    buf->open(flags);
+    dev = buf;
+    owndev = true;
+    byteorder = BigEndian;
+    ver = DefaultStreamVersion;
+    noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;
+    q_status = Ok;
+}
+
+/*!
+    Constructs a read-only data stream that operates on byte array \a a.
+    Use QDataStream(QByteArray*, int) if you want to write to a byte
+    array.
+
+    Since QByteArray is not a QIODevice subclass, internally a QBuffer
+    is created to wrap the byte array.
+*/
+QDataStream::QDataStream(const QByteArray &a)
+{
+    QBuffer *buf = new QBuffer;
+#ifndef QT_NO_QOBJECT
+    buf->blockSignals(true);
+#endif
+    buf->setData(a);
+    buf->open(QIODevice::ReadOnly);
+    dev = buf;
+    owndev = true;
+    byteorder = BigEndian;
+    ver = DefaultStreamVersion;
+    noswap = QSysInfo::ByteOrder == QSysInfo::BigEndian;
+    q_status = Ok;
+}
+
+/*!
+    Destroys the data stream.
+
+    The destructor will not affect the current I/O device, unless it is
+    an internal I/O device (e.g. a QBuffer) processing a QByteArray
+    passed in the \e constructor, in which case the internal I/O device
+    is destroyed.
+*/
+
+QDataStream::~QDataStream()
+{
+    if (owndev)
+        delete dev;
+}
+
+
+/*!
+    \fn QIODevice *QDataStream::device() const
+
+    Returns the I/O device currently set.
+
+    \sa setDevice(), unsetDevice()
+*/
+
+/*!
+    void QDataStream::setDevice(QIODevice *d)
+
+    Sets the I/O device to \a d.
+
+    \sa device(), unsetDevice()
+*/
+
+void QDataStream::setDevice(QIODevice *d)
+{
+    if (owndev) {
+        delete dev;
+        owndev = false;
+    }
+    dev = d;
+}
+
+/*!
+    \obsolete
+    Unsets the I/O device.
+    Use setDevice(0) instead.
+*/
+
+void QDataStream::unsetDevice()
+{
+    setDevice(0);
+}
+
+
+/*!
+    \fn bool QDataStream::atEnd() const
+
+    Returns true if the I/O device has reached the end position (end of
+    the stream or file) or if there is no I/O device set; otherwise
+    returns false.
+
+    \sa QIODevice::atEnd()
+*/
+
+bool QDataStream::atEnd() const
+{
+    return dev ? dev->atEnd() : true;
+}
+
+/*!
+    Returns the status of the data stream.
+
+    \sa Status setStatus() resetStatus()
+*/
+
+QDataStream::Status QDataStream::status() const
+{
+    return q_status;
+}
+
+/*!
+    Resets the status of the data stream.
+
+    \sa Status status() setStatus()
+*/
+void QDataStream::resetStatus()
+{
+    q_status = Ok;
+}
+
+/*!
+    Sets the status of the data stream to the \a status given.
+
+    \sa Status status() resetStatus()
+*/
+void QDataStream::setStatus(Status status)
+{
+    if (q_status == Ok)
+        q_status = status;
+}
+
+/*!\fn bool QDataStream::eof() const
+
+    Use atEnd() instead.
+*/
+
+/*!
+    \fn int QDataStream::byteOrder() const
+
+    Returns the current byte order setting -- either BigEndian or
+    LittleEndian.
+
+    \sa setByteOrder()
+*/
+
+/*!
+    Sets the serialization byte order to \a bo.
+
+    The \a bo parameter can be QDataStream::BigEndian or
+    QDataStream::LittleEndian.
+
+    The default setting is big endian. We recommend leaving this
+    setting unless you have special requirements.
+
+    \sa byteOrder()
+*/
+
+void QDataStream::setByteOrder(ByteOrder bo)
+{
+    byteorder = bo;
+    if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
+        noswap = (byteorder == BigEndian);
+    else
+        noswap = (byteorder == LittleEndian);
+}
+
+
+/*!
+    \fn bool QDataStream::isPrintableData() const
+
+    In Qt 4, this function always returns false.
+
+    \sa setPrintableData()
+*/
+
+/*!
+    \fn void QDataStream::setPrintableData(bool enable)
+
+    In Qt 3, this function enabled output in a human-readable
+    format if \a enable was false.
+
+    In Qt 4, QDataStream no longer provides a human-readable output.
+    This function does nothing.
+*/
+
+/*!
+    \enum QDataStream::Version
+
+    This enum provides symbolic synonyms for the data serialization
+    format version numbers.
+
+    \value Qt_1_0 Version 1 (Qt 1.x)
+    \value Qt_2_0 Version 2 (Qt 2.0)
+    \value Qt_2_1 Version 3 (Qt 2.1, 2.2, 2.3)
+    \value Qt_3_0 Version 4 (Qt 3.0)
+    \value Qt_3_1 Version 5 (Qt 3.1, 3.2)
+    \value Qt_3_3 Version 6 (Qt 3.3)
+    \value Qt_4_0 Version 7 (Qt 4.0, Qt 4.1)
+    \value Qt_4_1 Version 7 (Qt 4.0, Qt 4.1)
+    \value Qt_4_2 Version 8 (Qt 4.2)
+    \value Qt_4_3 Version 9 (Qt 4.3)
+    \value Qt_4_4 Version 10 (Qt 4.4)
+    \value Qt_4_5 Version 10 (Qt 4.5)
+    \omitvalue Qt_4_6
+
+    \sa setVersion(), version()
+*/
+
+/*!
+    \fn int QDataStream::version() const
+
+    Returns the version number of the data serialization format.
+
+    \sa setVersion(), Version
+*/
+
+/*!
+    \fn void QDataStream::setVersion(int v)
+
+    Sets the version number of the data serialization format to \a v.
+
+    You don't \e have to set a version if you are using the current
+    version of Qt, but for your own custom binary formats we
+    recommend that you do; see \l{Versioning} in the Detailed
+    Description.
+
+    In order to accommodate new functionality, the datastream
+    serialization format of some Qt classes has changed in some
+    versions of Qt. If you want to read data that was created by an
+    earlier version of Qt, or write data that can be read by a
+    program that was compiled with an earlier version of Qt, use this
+    function to modify the serialization format used by QDataStream.
+
+    \table
+    \header \i Qt Version       \i QDataStream Version
+    \row \i Qt 4.4                  \i 10
+    \row \i Qt 4.3                  \i 9
+    \row \i Qt 4.2                  \i 8
+    \row \i Qt 4.0, 4.1            \i 7
+    \row \i Qt 3.3                  \i 6
+    \row \i Qt 3.1, 3.2             \i 5
+    \row \i Qt 3.0                  \i 4
+    \row \i Qt 2.1, 2.2, 2.3      \i 3
+    \row \i Qt 2.0                  \i 2
+    \row \i Qt 1.x                  \i 1
+    \endtable
+
+    The \l Version enum provides symbolic constants for the different
+    versions of Qt. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdatastream.cpp 5
+
+    \sa version(), Version
+*/
+
+/*****************************************************************************
+  QDataStream read functions
+ *****************************************************************************/
+
+/*!
+    \fn QDataStream &QDataStream::operator>>(quint8 &i)
+    \overload
+
+    Reads an unsigned byte from the stream into \a i, and returns a
+    reference to the stream.
+*/
+
+/*!
+    Reads a signed byte from the stream into \a i, and returns a
+    reference to the stream.
+*/
+
+QDataStream &QDataStream::operator>>(qint8 &i)
+{
+    i = 0;
+    CHECK_STREAM_PRECOND(*this)
+    char c;
+    if (!dev->getChar(&c))
+        setStatus(ReadPastEnd);
+    else
+        i = qint8(c);
+    return *this;
+}
+
+
+/*!
+    \fn QDataStream &QDataStream::operator>>(quint16 &i)
+    \overload
+
+    Reads an unsigned 16-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Reads a signed 16-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+QDataStream &QDataStream::operator>>(qint16 &i)
+{
+    i = 0;
+    CHECK_STREAM_PRECOND(*this)
+    if (noswap) {
+        if (dev->read((char *)&i, 2) != 2) {
+            i = 0;
+            setStatus(ReadPastEnd);
+        }
+    } else {
+        register uchar *p = (uchar *)(&i);
+        char b[2];
+        if (dev->read(b, 2) == 2) {
+            *p++ = b[1];
+            *p = b[0];
+        } else {
+            setStatus(ReadPastEnd);
+        }
+    }
+    return *this;
+}
+
+
+/*!
+    \fn QDataStream &QDataStream::operator>>(quint32 &i)
+    \overload
+
+    Reads an unsigned 32-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Reads a signed 32-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+QDataStream &QDataStream::operator>>(qint32 &i)
+{
+    i = 0;
+    CHECK_STREAM_PRECOND(*this)
+    if (noswap) {
+        if (dev->read((char *)&i, 4) != 4) {
+            i = 0;
+            setStatus(ReadPastEnd);
+        }
+    } else {                                        // swap bytes
+        uchar *p = (uchar *)(&i);
+        char b[4];
+        if (dev->read(b, 4) == 4) {
+            *p++ = b[3];
+            *p++ = b[2];
+            *p++ = b[1];
+            *p   = b[0];
+        } else {
+            setStatus(ReadPastEnd);
+        }
+    }
+    return *this;
+}
+
+/*!
+    \fn QDataStream &QDataStream::operator>>(quint64 &i)
+    \overload
+
+    Reads an unsigned 64-bit integer from the stream, into \a i, and
+    returns a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Reads a signed 64-bit integer from the stream into \a i, and
+    returns a reference to the stream.
+*/
+
+QDataStream &QDataStream::operator>>(qint64 &i)
+{
+    i = qint64(0);
+    CHECK_STREAM_PRECOND(*this)
+    if (version() < 6) {
+        quint32 i1, i2;
+        *this >> i2 >> i1;
+        i = ((quint64)i1 << 32) + i2;
+    } else if (noswap) {                        // no conversion needed
+        if (dev->read((char *)&i, 8) != 8) {
+            i = qint64(0);
+            setStatus(ReadPastEnd);
+        }
+    } else {                                        // swap bytes
+        uchar *p = (uchar *)(&i);
+        char b[8];
+        if (dev->read(b, 8) == 8) {
+            *p++ = b[7];
+            *p++ = b[6];
+            *p++ = b[5];
+            *p++ = b[4];
+            *p++ = b[3];
+            *p++ = b[2];
+            *p++ = b[1];
+            *p   = b[0];
+        } else {
+            setStatus(ReadPastEnd);
+        }
+    }
+    return *this;
+}
+
+/*!
+    Reads a boolean value from the stream into \a i. Returns a
+    reference to the stream.
+*/
+QDataStream &QDataStream::operator>>(bool &i)
+{
+    qint8 v;
+    *this >> v;
+    i = !!v;
+    return *this;
+}
+
+/*!
+    \overload
+
+    Reads a 32-bit floating point number from the stream into \a f,
+    using the standard IEEE 754 format. Returns a reference to the
+    stream.
+*/
+
+QDataStream &QDataStream::operator>>(float &f)
+{
+    f = 0.0f;
+    CHECK_STREAM_PRECOND(*this)
+    if (noswap) {
+        if (dev->read((char *)&f, 4) != 4) {
+            f = 0.0f;
+            setStatus(ReadPastEnd);
+        }
+    } else {                                        // swap bytes
+        uchar *p = (uchar *)(&f);
+        char b[4];
+        if (dev->read(b, 4) == 4) {
+            *p++ = b[3];
+            *p++ = b[2];
+            *p++ = b[1];
+            *p = b[0];
+        } else {
+            setStatus(ReadPastEnd);
+        }
+    }
+    return *this;
+}
+
+#if defined(Q_DOUBLE_FORMAT)
+#define Q_DF(x) Q_DOUBLE_FORMAT[(x)] - '0'
+#endif
+
+/*!
+    \overload
+
+    Reads a 64-bit floating point number from the stream into \a f,
+    using the standard IEEE 754 format. Returns a reference to the
+    stream.
+*/
+
+QDataStream &QDataStream::operator>>(double &f)
+{
+    f = 0.0;
+    CHECK_STREAM_PRECOND(*this)
+#ifndef Q_DOUBLE_FORMAT
+    if (noswap) {
+        if (dev->read((char *)&f, 8) != 8) {
+            f = 0.0;
+            setStatus(ReadPastEnd);
+        }
+    } else {                                        // swap bytes
+        register uchar *p = (uchar *)(&f);
+        char b[8];
+        if (dev->read(b, 8) == 8) {
+            *p++ = b[7];
+            *p++ = b[6];
+            *p++ = b[5];
+            *p++ = b[4];
+            *p++ = b[3];
+            *p++ = b[2];
+            *p++ = b[1];
+            *p   = b[0];
+        } else {
+            setStatus(ReadPastEnd);
+        }
+    }
+#else
+    //non-standard floating point format
+    register uchar *p = (uchar *)(&f);
+    char b[8];
+    if (dev->read(b, 8) == 8) {
+        if (noswap) {
+            *p++ = b[Q_DF(0)];
+            *p++ = b[Q_DF(1)];
+            *p++ = b[Q_DF(2)];
+            *p++ = b[Q_DF(3)];
+            *p++ = b[Q_DF(4)];
+            *p++ = b[Q_DF(5)];
+            *p++ = b[Q_DF(6)];
+            *p = b[Q_DF(7)];
+        } else {
+            *p++ = b[Q_DF(7)];
+            *p++ = b[Q_DF(6)];
+            *p++ = b[Q_DF(5)];
+            *p++ = b[Q_DF(4)];
+            *p++ = b[Q_DF(3)];
+            *p++ = b[Q_DF(2)];
+            *p++ = b[Q_DF(1)];
+            *p = b[Q_DF(0)];
+        }
+    } else {
+        setStatus(ReadPastEnd);
+    }
+#endif
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Reads the '\0'-terminated string \a s from the stream and returns
+    a reference to the stream.
+
+    Space for the string is allocated using \c new -- the caller must
+    destroy it with \c{delete[]}.
+*/
+
+QDataStream &QDataStream::operator>>(char *&s)
+{
+    uint len = 0;
+    return readBytes(s, len);
+}
+
+
+/*!
+    Reads the buffer \a s from the stream and returns a reference to
+    the stream.
+
+    The buffer \a s is allocated using \c new. Destroy it with the \c
+    delete[] operator.
+
+    The \a l parameter is set to the length of the buffer. If the
+    string read is empty, \a l is set to 0 and \a s is set to
+    a null pointer.
+
+    The serialization format is a quint32 length specifier first,
+    then \a l bytes of data.
+
+    \sa readRawData(), writeBytes()
+*/
+
+QDataStream &QDataStream::readBytes(char *&s, uint &l)
+{
+    s = 0;
+    l = 0;
+    CHECK_STREAM_PRECOND(*this)
+
+    quint32 len;
+    *this >> len;
+    if (len == 0)
+        return *this;
+
+    const quint32 Step = 1024 * 1024;
+    quint32 allocated = 0;
+    char *prevBuf = 0;
+    char *curBuf = 0;
+
+    do {
+        int blockSize = qMin(Step, len - allocated);
+        prevBuf = curBuf;
+        curBuf = new char[allocated + blockSize + 1];
+        if (prevBuf) {
+            memcpy(curBuf, prevBuf, allocated);
+            delete [] prevBuf;
+        }
+        if (dev->read(curBuf + allocated, blockSize) != blockSize) {
+            delete [] curBuf;
+            setStatus(ReadPastEnd);
+            return *this;
+        }
+        allocated += blockSize;
+    } while (allocated < len);
+
+    s = curBuf;
+    s[len] = '\0';
+    l = (uint)len;
+    return *this;
+}
+
+/*!
+    Reads at most \a len bytes from the stream into \a s and returns the number of
+    bytes read. If an error occurs, this function returns -1.
+
+    The buffer \a s must be preallocated. The data is \e not encoded.
+
+    \sa readBytes(), QIODevice::read(), writeRawData()
+*/
+
+int QDataStream::readRawData(char *s, int len)
+{
+    CHECK_STREAM_PRECOND(-1)
+    return dev->read(s, len);
+}
+
+
+/*****************************************************************************
+  QDataStream write functions
+ *****************************************************************************/
+
+
+/*!
+    \fn QDataStream &QDataStream::operator<<(quint8 i)
+    \overload
+
+    Writes an unsigned byte, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    Writes a signed byte, \a i, to the stream and returns a reference
+    to the stream.
+*/
+
+QDataStream &QDataStream::operator<<(qint8 i)
+{
+    CHECK_STREAM_PRECOND(*this)
+    dev->putChar(i);
+    return *this;
+}
+
+
+/*!
+    \fn QDataStream &QDataStream::operator<<(quint16 i)
+    \overload
+
+    Writes an unsigned 16-bit integer, \a i, to the stream and returns
+    a reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Writes a signed 16-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+QDataStream &QDataStream::operator<<(qint16 i)
+{
+    CHECK_STREAM_PRECOND(*this)
+    if (noswap) {
+        dev->write((char *)&i, sizeof(qint16));
+    } else {                                        // swap bytes
+        register uchar *p = (uchar *)(&i);
+        char b[2];
+        b[1] = *p++;
+        b[0] = *p;
+        dev->write(b, 2);
+    }
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes a signed 32-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+QDataStream &QDataStream::operator<<(qint32 i)
+{
+    CHECK_STREAM_PRECOND(*this)
+    if (noswap) {
+        dev->write((char *)&i, sizeof(qint32));
+    } else {                                        // swap bytes
+        register uchar *p = (uchar *)(&i);
+        char b[4];
+        b[3] = *p++;
+        b[2] = *p++;
+        b[1] = *p++;
+        b[0] = *p;
+        dev->write(b, 4);
+    }
+    return *this;
+}
+
+/*!
+    \fn QDataStream &QDataStream::operator<<(quint64 i)
+    \overload
+
+    Writes an unsigned 64-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    \overload
+
+    Writes a signed 64-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+QDataStream &QDataStream::operator<<(qint64 i)
+{
+    CHECK_STREAM_PRECOND(*this)
+    if (version() < 6) {
+	quint32 i1 = i & 0xffffffff;
+	quint32 i2 = i >> 32;
+	*this << i2 << i1;
+    } else if (noswap) {                        // no conversion needed
+        dev->write((char *)&i, sizeof(qint64));
+    } else {                                        // swap bytes
+        register uchar *p = (uchar *)(&i);
+        char b[8];
+        b[7] = *p++;
+        b[6] = *p++;
+        b[5] = *p++;
+        b[4] = *p++;
+        b[3] = *p++;
+        b[2] = *p++;
+        b[1] = *p++;
+        b[0] = *p;
+        dev->write(b, 8);
+    }
+    return *this;
+}
+
+/*!
+    \fn QDataStream &QDataStream::operator<<(quint32 i)
+    \overload
+
+    Writes an unsigned integer, \a i, to the stream as a 32-bit
+    unsigned integer (quint32). Returns a reference to the stream.
+*/
+
+/*!
+    Writes a boolean value, \a i, to the stream. Returns a reference
+    to the stream.
+*/
+
+QDataStream &QDataStream::operator<<(bool i)
+{
+    CHECK_STREAM_PRECOND(*this)
+    dev->putChar(qint8(i));
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes a 32-bit floating point number, \a f, to the stream using
+    the standard IEEE 754 format. Returns a reference to the stream.
+*/
+
+QDataStream &QDataStream::operator<<(float f)
+{
+    CHECK_STREAM_PRECOND(*this)
+    float g = f;                                // fixes float-on-stack problem
+    if (noswap) {                                // no conversion needed
+        dev->write((char *)&g, sizeof(float));
+    } else {                                // swap bytes
+        register uchar *p = (uchar *)(&g);
+        char b[4];
+        b[3] = *p++;
+        b[2] = *p++;
+        b[1] = *p++;
+        b[0] = *p;
+        dev->write(b, 4);
+    }
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Writes a 64-bit floating point number, \a f, to the stream using
+    the standard IEEE 754 format. Returns a reference to the stream.
+*/
+
+QDataStream &QDataStream::operator<<(double f)
+{
+    CHECK_STREAM_PRECOND(*this)
+#ifndef Q_DOUBLE_FORMAT
+    if (noswap) {
+        dev->write((char *)&f, sizeof(double));
+    } else {
+        register uchar *p = (uchar *)(&f);
+        char b[8];
+        b[7] = *p++;
+        b[6] = *p++;
+        b[5] = *p++;
+        b[4] = *p++;
+        b[3] = *p++;
+        b[2] = *p++;
+        b[1] = *p++;
+        b[0] = *p;
+        dev->write(b, 8);
+    }
+#else
+    register uchar *p = (uchar *)(&f);
+    char b[8];
+    if (noswap) {
+        b[Q_DF(0)] = *p++;
+        b[Q_DF(1)] = *p++;
+        b[Q_DF(2)] = *p++;
+        b[Q_DF(3)] = *p++;
+        b[Q_DF(4)] = *p++;
+        b[Q_DF(5)] = *p++;
+        b[Q_DF(6)] = *p++;
+        b[Q_DF(7)] = *p;
+    } else {
+        b[Q_DF(7)] = *p++;
+        b[Q_DF(6)] = *p++;
+        b[Q_DF(5)] = *p++;
+        b[Q_DF(4)] = *p++;
+        b[Q_DF(3)] = *p++;
+        b[Q_DF(2)] = *p++;
+        b[Q_DF(1)] = *p++;
+        b[Q_DF(0)] = *p;
+    }
+    dev->write(b, 8);
+#endif
+    return *this;
+}
+
+
+/*!
+    \overload
+
+    Writes the '\0'-terminated string \a s to the stream and returns a
+    reference to the stream.
+
+    The string is serialized using writeBytes().
+*/
+
+QDataStream &QDataStream::operator<<(const char *s)
+{
+    if (!s) {
+        *this << (quint32)0;
+        return *this;
+    }
+    uint len = qstrlen(s) + 1;                        // also write null terminator
+    *this << (quint32)len;                        // write length specifier
+    writeRawData(s, len);
+    return *this;
+}
+
+
+/*!
+    Writes the length specifier \a len and the buffer \a s to the
+    stream and returns a reference to the stream.
+
+    The \a len is serialized as a quint32, followed by \a len bytes
+    from \a s. Note that the data is \e not encoded.
+
+    \sa writeRawData(), readBytes()
+*/
+
+QDataStream &QDataStream::writeBytes(const char *s, uint len)
+{
+    CHECK_STREAM_PRECOND(*this)
+    *this << (quint32)len;                        // write length specifier
+    if (len)
+        writeRawData(s, len);
+    return *this;
+}
+
+
+/*!
+    Writes \a len bytes from \a s to the stream. Returns the
+    number of bytes actually written, or -1 on error.
+    The data is \e not encoded.
+
+    \sa writeBytes(), QIODevice::write(), readRawData()
+*/
+
+int QDataStream::writeRawData(const char *s, int len)
+{
+    CHECK_STREAM_PRECOND(-1)
+    return dev->write(s, len);
+}
+
+/*!
+    \since 4.1
+
+    Skips \a len bytes from the device. Returns the number of bytes
+    actually skipped, or -1 on error.
+
+    This is equivalent to calling readRawData() on a buffer of length
+    \a len and ignoring the buffer.
+
+    \sa QIODevice::seek()
+*/
+int QDataStream::skipRawData(int len)
+{
+    CHECK_STREAM_PRECOND(-1)
+
+    if (dev->isSequential()) {
+        char buf[4096];
+        int sumRead = 0;
+
+        while (len > 0) {
+            int blockSize = qMin(len, (int)sizeof(buf));
+            int n = dev->read(buf, blockSize);
+            if (n == -1)
+                return -1;
+            if (n == 0)
+                return sumRead;
+
+            sumRead += n;
+            len -= blockSize;
+        }
+        return sumRead;
+    } else {
+        qint64 pos = dev->pos();
+        qint64 size = dev->size();
+        if (pos + len > size)
+            len = size - pos;
+        if (!dev->seek(pos + len))
+            return -1;
+        return len;
+    }
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    \fn QDataStream &QDataStream::readRawBytes(char *str, uint len)
+
+    Use readRawData() instead.
+*/
+
+/*!
+    \fn QDataStream &QDataStream::writeRawBytes(const char *str, uint len)
+
+    Use writeRawData() instead.
+*/
+#endif
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_DATASTREAM
diff --git a/src/corelib/io/qdatastream.h b/src/corelib/io/qdatastream.h
new file mode 100644
index 0000000..ec5780c
--- /dev/null
+++ b/src/corelib/io/qdatastream.h
@@ -0,0 +1,428 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDATASTREAM_H
+#define QDATASTREAM_H
+
+#include <QtCore/qiodevice.h>
+#include <QtCore/qglobal.h>
+
+#ifdef Status
+#error qdatastream.h must be included before any header file that defines Status
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QByteArray;
+class QIODevice;
+
+template <typename T> class QList;
+template <typename T> class QLinkedList;
+template <typename T> class QVector;
+template <typename T> class QSet;
+template <class Key, class T> class QHash;
+template <class Key, class T> class QMap;
+
+class QDataStreamPrivate;
+
+#ifndef QT_NO_DATASTREAM
+class Q_CORE_EXPORT QDataStream
+{
+public:
+    enum Version {
+        Qt_1_0 = 1,
+        Qt_2_0 = 2,
+        Qt_2_1 = 3,
+        Qt_3_0 = 4,
+        Qt_3_1 = 5,
+        Qt_3_3 = 6,
+        Qt_4_0 = 7,
+        Qt_4_1 = Qt_4_0,
+        Qt_4_2 = 8,
+        Qt_4_3 = 9,
+        Qt_4_4 = 10,
+        Qt_4_5 = 11,
+        Qt_4_6 = Qt_4_5
+#if QT_VERSION >= 0x040700
+#error Add the datastream version for this Qt version
+        Qt_4_7 = Qt_4_6
+#endif
+    };
+
+    enum ByteOrder {
+        BigEndian = QSysInfo::BigEndian,
+        LittleEndian = QSysInfo::LittleEndian
+    };
+
+    enum Status {
+        Ok,
+        ReadPastEnd,
+	ReadCorruptData
+    };
+
+    QDataStream();
+    explicit QDataStream(QIODevice *);
+#ifdef QT3_SUPPORT
+    QDataStream(QByteArray *, int mode);
+#endif
+    QDataStream(QByteArray *, QIODevice::OpenMode flags);
+    QDataStream(const QByteArray &);
+    virtual ~QDataStream();
+
+    QIODevice *device() const;
+    void setDevice(QIODevice *);
+    void unsetDevice();
+
+    bool atEnd() const;
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT bool eof() const { return atEnd(); }
+#endif
+
+    Status status() const;
+    void setStatus(Status status);
+    void resetStatus();
+
+    ByteOrder byteOrder() const;
+    void setByteOrder(ByteOrder);
+
+    int version() const;
+    void setVersion(int);
+
+    QDataStream &operator>>(qint8 &i);
+    QDataStream &operator>>(quint8 &i);
+    QDataStream &operator>>(qint16 &i);
+    QDataStream &operator>>(quint16 &i);
+    QDataStream &operator>>(qint32 &i);
+    QDataStream &operator>>(quint32 &i);
+    QDataStream &operator>>(qint64 &i);
+    QDataStream &operator>>(quint64 &i);
+
+    QDataStream &operator>>(bool &i);
+    QDataStream &operator>>(float &f);
+    QDataStream &operator>>(double &f);
+    QDataStream &operator>>(char *&str);
+
+    QDataStream &operator<<(qint8 i);
+    QDataStream &operator<<(quint8 i);
+    QDataStream &operator<<(qint16 i);
+    QDataStream &operator<<(quint16 i);
+    QDataStream &operator<<(qint32 i);
+    QDataStream &operator<<(quint32 i);
+    QDataStream &operator<<(qint64 i);
+    QDataStream &operator<<(quint64 i);
+    QDataStream &operator<<(bool i);
+    QDataStream &operator<<(float f);
+    QDataStream &operator<<(double f);
+    QDataStream &operator<<(const char *str);
+
+    QDataStream &readBytes(char *&, uint &len);
+    int readRawData(char *, int len);
+
+    QDataStream &writeBytes(const char *, uint len);
+    int writeRawData(const char *, int len);
+
+    int skipRawData(int len);
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT QDataStream &readRawBytes(char *str, uint len)
+        { readRawData(str, static_cast<int>(len)); return *this; }
+    inline QT3_SUPPORT QDataStream &writeRawBytes(const char *str, uint len)
+        { writeRawData(str, static_cast<int>(len)); return *this; }
+    inline QT3_SUPPORT bool isPrintableData() const { return false; }
+    inline QT3_SUPPORT void setPrintableData(bool) {}
+#endif
+
+private:
+    Q_DISABLE_COPY(QDataStream)
+
+    QDataStreamPrivate *d;
+
+    QIODevice *dev;
+    bool owndev;
+    bool noswap;
+    ByteOrder byteorder;
+    int ver;
+    Status q_status;
+};
+
+
+/*****************************************************************************
+  QDataStream inline functions
+ *****************************************************************************/
+
+inline QIODevice *QDataStream::device() const
+{ return dev; }
+
+inline QDataStream::ByteOrder QDataStream::byteOrder() const
+{ return byteorder; }
+
+inline int QDataStream::version() const
+{ return ver; }
+
+inline void QDataStream::setVersion(int v)
+{ ver = v; }
+
+inline QDataStream &QDataStream::operator>>(quint8 &i)
+{ return *this >> reinterpret_cast<qint8&>(i); }
+
+inline QDataStream &QDataStream::operator>>(quint16 &i)
+{ return *this >> reinterpret_cast<qint16&>(i); }
+
+inline QDataStream &QDataStream::operator>>(quint32 &i)
+{ return *this >> reinterpret_cast<qint32&>(i); }
+
+inline QDataStream &QDataStream::operator>>(quint64 &i)
+{ return *this >> reinterpret_cast<qint64&>(i); }
+
+inline QDataStream &QDataStream::operator<<(quint8 i)
+{ return *this << qint8(i); }
+
+inline QDataStream &QDataStream::operator<<(quint16 i)
+{ return *this << qint16(i); }
+
+inline QDataStream &QDataStream::operator<<(quint32 i)
+{ return *this << qint32(i); }
+
+inline QDataStream &QDataStream::operator<<(quint64 i)
+{ return *this << qint64(i); }
+
+template <typename T>
+QDataStream& operator>>(QDataStream& s, QList<T>& l)
+{
+    l.clear();
+    quint32 c;
+    s >> c;
+    for(quint32 i = 0; i < c; ++i)
+    {
+        T t;
+        s >> t;
+        l.append(t);
+        if (s.atEnd())
+            break;
+    }
+    return s;
+}
+
+template <typename T>
+QDataStream& operator<<(QDataStream& s, const QList<T>& l)
+{
+    s << quint32(l.size());
+    for (int i = 0; i < l.size(); ++i)
+        s << l.at(i);
+    return s;
+}
+
+template <typename T>
+QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l)
+{
+    l.clear();
+    quint32 c;
+    s >> c;
+    for(quint32 i = 0; i < c; ++i)
+    {
+        T t;
+        s >> t;
+        l.append(t);
+        if (s.atEnd())
+            break;
+    }
+    return s;
+}
+
+template <typename T>
+QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
+{
+    s << quint32(l.size());
+    typename QLinkedList<T>::ConstIterator it = l.constBegin();
+    for(; it != l.constEnd(); ++it)
+        s << *it;
+    return s;
+}
+
+template<typename T>
+QDataStream& operator>>(QDataStream& s, QVector<T>& v)
+{
+    v.clear();
+    quint32 c;
+    s >> c;
+    v.resize(c);
+    for(quint32 i = 0; i < c; ++i) {
+        T t;
+        s >> t;
+        v[i] = t;
+    }
+    return s;
+}
+
+template<typename T>
+QDataStream& operator<<(QDataStream& s, const QVector<T>& v)
+{
+    s << quint32(v.size());
+    for (typename QVector<T>::const_iterator it = v.begin(); it != v.end(); ++it)
+        s << *it;
+    return s;
+}
+
+template <typename T>
+QDataStream &operator>>(QDataStream &in, QSet<T> &set)
+{
+    set.clear();
+    quint32 c;
+    in >> c;
+    for (quint32 i = 0; i < c; ++i) {
+        T t;
+        in >> t;
+        set << t;
+        if (in.atEnd())
+            break;
+    }
+    return in;
+}
+
+template <typename T>
+QDataStream& operator<<(QDataStream &out, const QSet<T> &set)
+{
+    out << quint32(set.size());
+    typename QSet<T>::const_iterator i = set.constBegin();
+    while (i != set.constEnd()) {
+        out << *i;
+        ++i;
+    }
+    return out;
+}
+
+template <class Key, class T>
+Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
+{
+    QDataStream::Status oldStatus = in.status();
+    in.resetStatus();
+    hash.clear();
+
+    quint32 n;
+    in >> n;
+
+    for (quint32 i = 0; i < n; ++i) {
+        if (in.status() != QDataStream::Ok)
+            break;
+
+        Key k;
+        T t;
+        in >> k >> t;
+        hash.insertMulti(k, t);
+    }
+
+    if (in.status() != QDataStream::Ok)
+        hash.clear();
+    if (oldStatus != QDataStream::Ok)
+        in.setStatus(oldStatus);
+    return in;
+}
+
+template <class Key, class T>
+Q_OUTOFLINE_TEMPLATE QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
+{
+    out << quint32(hash.size());
+    typename QHash<Key, T>::ConstIterator it = hash.end();
+    typename QHash<Key, T>::ConstIterator begin = hash.begin();
+    while (it != begin) {
+        --it;
+        out << it.key() << it.value();
+    }
+    return out;
+}
+#ifdef qdoc
+template <class Key, class T>
+Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QMap<Key, T> &map)
+#else
+template <class aKey, class aT>
+Q_OUTOFLINE_TEMPLATE QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map)
+#endif
+{
+    QDataStream::Status oldStatus = in.status();
+    in.resetStatus();
+    map.clear();
+
+    quint32 n;
+    in >> n;
+
+    map.detach();
+    map.setInsertInOrder(true);
+    for (quint32 i = 0; i < n; ++i) {
+        if (in.status() != QDataStream::Ok)
+            break;
+
+        aKey key;
+        aT value;
+        in >> key >> value;
+        map.insertMulti(key, value);
+    }
+    map.setInsertInOrder(false);
+    if (in.status() != QDataStream::Ok)
+        map.clear();
+    if (oldStatus != QDataStream::Ok)
+        in.setStatus(oldStatus);
+    return in;
+}
+
+template <class Key, class T>
+Q_OUTOFLINE_TEMPLATE QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map)
+{
+    out << quint32(map.size());
+    typename QMap<Key, T>::ConstIterator it = map.end();
+    typename QMap<Key, T>::ConstIterator begin = map.begin();
+    while (it != begin) {
+        --it;
+        out << it.key() << it.value();
+    }
+    return out;
+}
+
+#endif // QT_NO_DATASTREAM
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDATASTREAM_H
diff --git a/src/corelib/io/qdebug.cpp b/src/corelib/io/qdebug.cpp
new file mode 100644
index 0000000..611b19a
--- /dev/null
+++ b/src/corelib/io/qdebug.cpp
@@ -0,0 +1,308 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+#ifdef QT_NO_DEBUG
+#undef QT_NO_DEBUG
+#endif
+#ifdef qDebug
+#undef qDebug
+#endif
+
+#include "qdebug.h"
+
+// This file is needed to force compilation of QDebug into the kernel library.
+
+/*!
+    \class QDebug
+    \ingroup io
+    \mainclass
+    \brief The QDebug class provides an output stream for debugging information.
+
+    QDebug is used whenever the developer needs to write out debugging or tracing
+    information to a device, file, string or console.
+
+    \section1 Basic Use
+
+    In the common case, it is useful to call the qDebug() function to obtain a
+    default QDebug object to use for writing debugging information.
+
+    \snippet doc/src/snippets/qdebug/qdebugsnippet.cpp 1
+
+    This constructs a QDebug object using the constructor that accepts a QtMsgType
+    value of QtDebugMsg. Similarly, the qWarning(), qCritical() and qFatal()
+    functions also return QDebug objects for the corresponding message types.
+
+    The class also provides several constructors for other situations, including
+    a constructor that accepts a QFile or any other QIODevice subclass that is
+    used to write debugging information to files and other devices. The constructor
+    that accepts a QString is used to write to a string for display or serialization.
+
+    \section1 Writing Custom Types to a Stream
+
+    Many standard types can be written to QDebug objects, and Qt provides support for
+    most Qt value types. To add support for custom types, you need to implement a
+    streaming operator, as in the following example:
+
+    \snippet doc/src/snippets/qdebug/qdebugsnippet.cpp 0
+
+    This is described in the \l{Debugging Techniques} and
+    \l{Creating Custom Qt Types#Making the Type Printable}{Creating Custom Qt Types}
+    documents.
+*/
+
+/*!
+    \fn QDebug::QDebug(QIODevice *device)
+
+    Constructs a debug stream that writes to the given \a device.
+*/
+
+/*!
+    \fn QDebug::QDebug(QString *string)
+
+    Constructs a debug stream that writes to the given \a string.
+*/
+
+/*!
+    \fn QDebug::QDebug(QtMsgType type)
+
+    Constructs a debug stream that writes to the handler for the message type specified by \a type.
+*/
+
+/*!
+    \fn QDebug::QDebug(const QDebug &other)
+
+    Constructs a copy of the \a other debug stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator=(const QDebug &other)
+
+    Assigns the \a other debug stream to this stream and returns a reference to
+    this stream.
+*/
+
+/*!
+    \fn QDebug::~QDebug()
+
+    Flushes any pending data to be written and destroys the debug stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::space()
+
+    Writes a space character to the debug stream and returns a reference to
+    the stream.
+
+    The stream will record that the last character sent to the stream was a
+    space.
+
+    \sa nospace(), maybeSpace()
+*/
+
+/*!
+    \fn QDebug &QDebug::nospace()
+
+    Clears the stream's internal flag that records whether the last character
+    was a space and returns a reference to the stream.
+
+    \sa space(), maybeSpace()
+*/
+
+/*!
+    \fn QDebug &QDebug::maybeSpace()
+
+    Writes a space character to the debug stream, depending on the last
+    character sent to the stream, and returns a reference to the stream.
+
+    If the last character was a space character, this function writes a space
+    character to the stream; otherwise, no characters are written to the stream.
+
+    \sa space(), nospace()
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(QChar t)
+
+    Writes the character, \a t, to the stream and returns a reference to the
+    stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(QBool t)
+    \internal
+
+    Writes the boolean value, \a t, to the stream and returns a reference to the
+    stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(bool t)
+
+    Writes the boolean value, \a t, to the stream and returns a reference to the
+    stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(char t)
+
+    Writes the character, \a t, to the stream and returns a reference to the
+    stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(signed short i)
+
+    Writes the signed short integer, \a i, to the stream and returns a reference
+    to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(unsigned short i)
+
+    Writes then unsigned short integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(signed int i)
+
+    Writes the signed integer, \a i, to the stream and returns a reference
+    to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(unsigned int i)
+
+    Writes then unsigned integer, \a i, to the stream and returns a reference to
+    the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(signed long l)
+
+    Writes the signed long integer, \a l, to the stream and returns a reference
+    to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(unsigned long l)
+
+    Writes then unsigned long integer, \a l, to the stream and returns a reference
+    to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(qint64 i)
+
+    Writes the signed 64-bit integer, \a i, to the stream and returns a reference
+    to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(quint64 i)
+
+    Writes then unsigned 64-bit integer, \a i, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(float f)
+
+    Writes the 32-bit floating point number, \a f, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(double f)
+
+    Writes the 64-bit floating point number, \a f, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(const char *s)
+
+    Writes the '\0'-terminated string, \a s, to the stream and returns a
+    reference to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(const QString &s)
+
+    Writes the string, \a s, to the stream and returns a reference to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(const QStringRef &s)
+
+    Writes the string reference, \a s, to the stream and returns a reference to
+    the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(const QLatin1String &s)
+
+    Writes the Latin1-encoded string, \a s, to the stream and returns a reference
+    to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(const QByteArray &b)
+
+    Writes the byte array, \a b, to the stream and returns a reference to the
+    stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(const void *p)
+
+    Writes a pointer, \a p, to the stream and returns a reference to the stream.
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(QTextStreamFunction f)
+    \internal
+*/
+
+/*!
+    \fn QDebug &QDebug::operator<<(QTextStreamManipulator m)
+    \internal
+*/
diff --git a/src/corelib/io/qdebug.h b/src/corelib/io/qdebug.h
new file mode 100644
index 0000000..8334146
--- /dev/null
+++ b/src/corelib/io/qdebug.h
@@ -0,0 +1,262 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDEBUG_H
+#define QDEBUG_H
+
+#include <QtCore/qalgorithms.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qmap.h>
+#include <QtCore/qpair.h>
+#include <QtCore/qtextstream.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qset.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class Q_CORE_EXPORT QDebug
+{
+    struct Stream {
+        Stream(QIODevice *device) : ts(device), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
+        Stream(QString *string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
+        Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t), space(true), message_output(true) {}
+        QTextStream ts;
+        QString buffer;
+        int ref;
+        QtMsgType type;
+        bool space;
+        bool message_output;
+    } *stream;
+public:
+    inline QDebug(QIODevice *device) : stream(new Stream(device)) {}
+    inline QDebug(QString *string) : stream(new Stream(string)) {}
+    inline QDebug(QtMsgType t) : stream(new Stream(t)) {}
+    inline QDebug(const QDebug &o):stream(o.stream) { ++stream->ref; }
+    inline QDebug &operator=(const QDebug &other);
+    inline ~QDebug() {
+        if (!--stream->ref) {
+            if(stream->message_output)
+                qt_message_output(stream->type, stream->buffer.toLocal8Bit().data());
+            delete stream;
+        }
+    }
+    inline QDebug &space() { stream->space = true; stream->ts << " "; return *this; }
+    inline QDebug &nospace() { stream->space = false; return *this; }
+    inline QDebug &maybeSpace() { if (stream->space) stream->ts << " "; return *this; }
+
+    inline QDebug &operator<<(QChar t) { stream->ts << "\'" << t << "\'"; return maybeSpace(); }
+    inline QDebug &operator<<(QBool t) { stream->ts << (bool(t) ? "true" : "false"); return maybeSpace(); }
+    inline QDebug &operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); }
+    inline QDebug &operator<<(char t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed short t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(qint64 t)
+        { stream->ts << QString::number(t); return maybeSpace(); }
+    inline QDebug &operator<<(quint64 t)
+        { stream->ts << QString::number(t); return maybeSpace(); }
+    inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(const char* t) { stream->ts << QString::fromAscii(t); return maybeSpace(); }
+    inline QDebug &operator<<(const QString & t) { stream->ts << "\"" << t  << "\""; return maybeSpace(); }
+    inline QDebug &operator<<(const QStringRef & t) { return operator<<(t.toString()); }
+    inline QDebug &operator<<(const QLatin1String &t) { stream->ts << "\""  << t.latin1() << "\""; return maybeSpace(); }
+    inline QDebug &operator<<(const QByteArray & t) { stream->ts  << "\"" << t << "\""; return maybeSpace(); }
+    inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(QTextStreamFunction f) {
+        stream->ts << f;
+        return *this;
+    }
+
+    inline QDebug &operator<<(QTextStreamManipulator m)
+    { stream->ts << m; return *this; }
+};
+
+class QNoDebug
+{
+public:
+    inline QNoDebug(){}
+    inline QNoDebug(const QDebug &){}
+    inline ~QNoDebug(){}
+#if !defined( QT_NO_TEXTSTREAM )
+    inline QNoDebug &operator<<(QTextStreamFunction) { return *this; }
+    inline QNoDebug &operator<<(QTextStreamManipulator) { return *this; }
+#endif
+    inline QNoDebug &space() { return *this; }
+    inline QNoDebug &nospace() { return *this; }
+    inline QNoDebug &maybeSpace() { return *this; }
+
+#ifndef QT_NO_MEMBER_TEMPLATES
+    template<typename T>
+    inline QNoDebug &operator<<(const T &) { return *this; }
+#endif
+};
+
+Q_CORE_EXPORT_INLINE QDebug qCritical() { return QDebug(QtCriticalMsg); }
+
+inline QDebug &QDebug::operator=(const QDebug &other)
+{
+    if (this != &other) {
+        QDebug copy(other);
+        qSwap(stream, copy.stream);
+    }
+    return *this;
+}
+
+#if defined(FORCE_UREF)
+template <class T>
+inline QDebug &operator<<(QDebug debug, const QList<T> &list)
+#else
+template <class T>
+inline QDebug operator<<(QDebug debug, const QList<T> &list)
+#endif
+{
+    debug.nospace() << "(";
+    for (Q_TYPENAME QList<T>::size_type i = 0; i < list.count(); ++i) {
+        if (i)
+            debug << ", ";
+        debug << list.at(i);
+    }
+    debug << ")";
+    return debug.space();
+}
+
+#if defined(FORCE_UREF)
+template <typename T>
+inline QDebug &operator<<(QDebug debug, const QVector<T> &vec)
+#else
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QVector<T> &vec)
+#endif
+{
+    debug.nospace() << "QVector";
+    return operator<<(debug, vec.toList());
+}
+
+#if defined(FORCE_UREF)
+template <class aKey, class aT>
+inline QDebug &operator<<(QDebug debug, const QMap<aKey, aT> &map)
+#else
+template <class aKey, class aT>
+inline QDebug operator<<(QDebug debug, const QMap<aKey, aT> &map)
+#endif
+{
+    debug.nospace() << "QMap(";
+    for (typename QMap<aKey, aT>::const_iterator it = map.constBegin();
+         it != map.constEnd(); ++it) {
+        debug << "(" << it.key() << ", " << it.value() << ")";
+    }
+    debug << ")";
+    return debug.space();
+}
+
+#if defined(FORCE_UREF)
+template <class aKey, class aT>
+inline QDebug &operator<<(QDebug debug, const QHash<aKey, aT> &hash)
+#else
+template <class aKey, class aT>
+inline QDebug operator<<(QDebug debug, const QHash<aKey, aT> &hash)
+#endif
+{
+    debug.nospace() << "QHash(";
+    for (typename QHash<aKey, aT>::const_iterator it = hash.constBegin();
+            it != hash.constEnd(); ++it)
+        debug << "(" << it.key() << ", " << it.value() << ")";
+    debug << ")";
+    return debug.space();
+}
+
+#if defined(FORCE_UREF)
+template <class T1, class T2>
+inline QDebug &operator<<(QDebug debug, const QPair<T1, T2> &pair)
+#else
+template <class T1, class T2>
+inline QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair)
+#endif
+{
+    debug.nospace() << "QPair(" << pair.first << "," << pair.second << ")";
+    return debug.space();
+}
+
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QSet<T> &set)
+{
+    debug.nospace() << "QSet";
+    return operator<<(debug, set.toList());
+}
+
+#if !defined(QT_NO_DEBUG_STREAM)
+Q_CORE_EXPORT_INLINE QDebug qDebug() { return QDebug(QtDebugMsg); }
+
+#else // QT_NO_DEBUG_STREAM
+#undef qDebug
+inline QNoDebug qDebug() { return QNoDebug(); }
+#define qDebug QT_NO_QDEBUG_MACRO
+
+#ifdef QT_NO_MEMBER_TEMPLATES
+template<typename T>
+inline QNoDebug operator<<(QNoDebug debug, const T &) { return debug; }
+#endif
+
+#endif
+
+#if !defined(QT_NO_WARNING_OUTPUT)
+Q_CORE_EXPORT_INLINE QDebug qWarning() { return QDebug(QtWarningMsg); }
+#else
+#undef qWarning
+inline QNoDebug qWarning() { return QNoDebug(); }
+#define qWarning QT_NO_QWARNING_MACRO
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDEBUG_H
diff --git a/src/corelib/io/qdir.cpp b/src/corelib/io/qdir.cpp
new file mode 100644
index 0000000..6d75c59
--- /dev/null
+++ b/src/corelib/io/qdir.cpp
@@ -0,0 +1,2472 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qdir.h"
+#include "qabstractfileengine.h"
+#ifndef QT_NO_DEBUG_STREAM
+#include "qdebug.h"
+#endif
+#include "qfsfileengine.h"
+#include "qdatetime.h"
+#include "qstring.h"
+#include "qregexp.h"
+#include "qvector.h"
+#ifdef QT_BUILD_CORE_LIB
+# include "qresource.h"
+#endif
+
+#include "../kernel/qcoreglobaldata_p.h"
+#include <stdlib.h>
+
+QT_BEGIN_NAMESPACE
+
+static QString driveSpec(const QString &path)
+{
+#ifdef Q_OS_WIN
+    if (path.size() < 2)
+        return QString();
+    char c = path.at(0).toAscii();
+    if (c < 'a' && c > 'z' && c < 'A' && c > 'Z')
+        return QString();
+    if (path.at(1).toAscii() != ':')
+        return QString();
+    return path.mid(0, 2);
+#else
+    Q_UNUSED(path);
+    return QString();
+#endif
+}
+
+//************* QDirPrivate
+class QDirPrivate
+{
+    QDir *q_ptr;
+    Q_DECLARE_PUBLIC(QDir)
+
+protected:
+    QDirPrivate(QDir*, const QDir *copy=0);
+    ~QDirPrivate();
+
+    QString initFileEngine(const QString &file);
+
+    void updateFileLists() const;
+    void sortFileList(QDir::SortFlags, QStringList &, QStringList *, QFileInfoList *) const;
+
+private:
+#ifdef QT3_SUPPORT
+    QChar filterSepChar;
+    bool matchAllDirs;
+#endif
+    static inline QChar getFilterSepChar(const QString &nameFilter)
+    {
+        QChar sep(QLatin1Char(';'));
+        int i = nameFilter.indexOf(sep, 0);
+        if (i == -1 && nameFilter.indexOf(QLatin1Char(' '), 0) != -1)
+            sep = QChar(QLatin1Char(' '));
+        return sep;
+    }
+    static inline QStringList splitFilters(const QString &nameFilter, QChar sep=0) {
+        if(sep == 0)
+            sep = getFilterSepChar(nameFilter);
+        QStringList ret = nameFilter.split(sep);
+        for(int i = 0; i < ret.count(); i++)
+            ret[i] = ret[i].trimmed();
+        return ret;
+    }
+
+    struct Data {
+        inline Data()
+            : ref(1), fileEngine(0)
+        { clear(); }
+        inline Data(const Data &copy)
+            : ref(1), path(copy.path), nameFilters(copy.nameFilters), sort(copy.sort),
+              filters(copy.filters), fileEngine(0)
+        { clear(); }
+        inline ~Data()
+        { delete fileEngine; }
+
+        inline void clear() {
+            listsDirty = 1;
+        }
+        mutable QAtomicInt ref;
+
+        QString path;
+        QStringList nameFilters;
+        QDir::SortFlags sort;
+        QDir::Filters filters;
+
+        mutable QAbstractFileEngine *fileEngine;
+
+        mutable uint listsDirty : 1;
+        mutable QStringList files;
+        mutable QFileInfoList fileInfos;
+    } *data;
+    inline void setPath(const QString &p)
+    {
+        detach(false);
+        QString path = p;
+        if ((path.endsWith(QLatin1Char('/')) || path.endsWith(QLatin1Char('\\')))
+                && path.length() > 1) {
+#ifdef Q_OS_WIN
+            if (!(path.length() == 3 && path.at(1) == QLatin1Char(':')))
+#endif
+                path.truncate(path.length() - 1);
+        }
+        if(!data->fileEngine || !QDir::isRelativePath(path))
+            path = initFileEngine(path);
+        data->fileEngine->setFileName(path);
+        // set the path to be the qt friendly version so then we can operate on it using just /
+        data->path = data->fileEngine->fileName(QAbstractFileEngine::DefaultName);
+        data->clear();
+    }
+    inline void reset() {
+        detach();
+        data->clear();
+    }
+    void detach(bool createFileEngine = true);
+};
+
+QDirPrivate::QDirPrivate(QDir *qq, const QDir *copy) : q_ptr(qq)
+#ifdef QT3_SUPPORT
+                                                     , filterSepChar(0)
+                                                     , matchAllDirs(false)
+#endif
+{
+    if(copy) {
+        copy->d_func()->data->ref.ref();
+        data = copy->d_func()->data;
+    } else {
+        data = new QDirPrivate::Data;
+        data->clear();
+    }
+}
+
+QDirPrivate::~QDirPrivate()
+{
+    if (!data->ref.deref())
+        delete data;
+    data = 0;
+    q_ptr = 0;
+}
+
+/* For sorting */
+struct QDirSortItem {
+    QString filename_cache;
+    QString suffix_cache;
+    QFileInfo item;
+};
+static int qt_cmp_si_sort_flags;
+
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+
+#ifdef Q_OS_WINCE
+static int __cdecl qt_cmp_si(const void *n1, const void *n2)
+#else
+static int qt_cmp_si(const void *n1, const void *n2)
+#endif
+{
+    if (!n1 || !n2)
+        return 0;
+
+    QDirSortItem* f1 = (QDirSortItem*)n1;
+    QDirSortItem* f2 = (QDirSortItem*)n2;
+
+    if ((qt_cmp_si_sort_flags & QDir::DirsFirst) && (f1->item.isDir() != f2->item.isDir()))
+        return f1->item.isDir() ? -1 : 1;
+    if ((qt_cmp_si_sort_flags & QDir::DirsLast) && (f1->item.isDir() != f2->item.isDir()))
+        return f1->item.isDir() ? 1 : -1;
+
+    int r = 0;
+    int sortBy = (qt_cmp_si_sort_flags & QDir::SortByMask)
+                 | (qt_cmp_si_sort_flags & QDir::Type);
+
+    switch (sortBy) {
+      case QDir::Time:
+        r = f1->item.lastModified().secsTo(f2->item.lastModified());
+        break;
+      case QDir::Size:
+          r = int(qBound<qint64>(-1, f2->item.size() - f1->item.size(), 1));
+        break;
+      case QDir::Type:
+      {
+        bool ic = qt_cmp_si_sort_flags & QDir::IgnoreCase;
+
+        if (f1->suffix_cache.isNull())
+            f1->suffix_cache = ic ? f1->item.suffix().toLower()
+                               : f1->item.suffix();
+        if (f2->suffix_cache.isNull())
+            f2->suffix_cache = ic ? f2->item.suffix().toLower()
+                               : f2->item.suffix();
+
+	r = qt_cmp_si_sort_flags & QDir::LocaleAware
+            ? f1->suffix_cache.localeAwareCompare(f2->suffix_cache)
+            : f1->suffix_cache.compare(f2->suffix_cache);
+      }
+        break;
+      default:
+        ;
+    }
+
+    if (r == 0 && sortBy != QDir::Unsorted) {
+        // Still not sorted - sort by name
+        bool ic = qt_cmp_si_sort_flags & QDir::IgnoreCase;
+
+        if (f1->filename_cache.isNull())
+            f1->filename_cache = ic ? f1->item.fileName().toLower()
+                                    : f1->item.fileName();
+        if (f2->filename_cache.isNull())
+            f2->filename_cache = ic ? f2->item.fileName().toLower()
+                                    : f2->item.fileName();
+
+	r = qt_cmp_si_sort_flags & QDir::LocaleAware
+            ? f1->filename_cache.localeAwareCompare(f2->filename_cache)
+            : f1->filename_cache.compare(f2->filename_cache);
+    }
+
+    if (r == 0) // Enforce an order - the order the items appear in the array
+        r = (char*)n1 - (char*)n2;
+
+    if (qt_cmp_si_sort_flags & QDir::Reversed)
+        return -r;
+    return r;
+}
+
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+
+inline void QDirPrivate::sortFileList(QDir::SortFlags sort, QStringList &l,
+                                      QStringList *names, QFileInfoList *infos) const
+{
+    if(names)
+        names->clear();
+    if(infos)
+        infos->clear();
+    if(!l.isEmpty()) {
+        QDirSortItem *si= new QDirSortItem[l.count()];
+        int i;
+        for (i = 0; i < l.size(); ++i) {
+            QString path = data->path;
+            if (!path.isEmpty() && !path.endsWith(QLatin1Char('/')))
+                path += QLatin1Char('/');
+            si[i].item = QFileInfo(path + l.at(i));
+        }
+        qt_cmp_si_sort_flags = sort;
+        if ((sort & QDir::SortByMask) != QDir::Unsorted)
+            qsort(si, i, sizeof(si[0]), qt_cmp_si);
+        // put them back in the list(s)
+        for (int j = 0; j<i; j++) {
+            if(infos)
+                infos->append(si[j].item);
+            if(names)
+                names->append(si[j].item.fileName());
+        }
+        delete [] si;
+    }
+}
+
+inline void QDirPrivate::updateFileLists() const
+{
+    if(data->listsDirty) {
+        QStringList l = data->fileEngine->entryList(data->filters, data->nameFilters);
+        sortFileList(data->sort, l, &data->files, &data->fileInfos);
+        data->listsDirty = 0;
+    }
+}
+
+QString QDirPrivate::initFileEngine(const QString &path)
+{
+    detach(false);
+    delete data->fileEngine;
+    data->fileEngine = 0;
+    data->clear();
+    data->fileEngine = QAbstractFileEngine::create(path);
+    return data->fileEngine->fileName(QAbstractFileEngine::DefaultName);
+}
+
+void QDirPrivate::detach(bool createFileEngine)
+{
+    qAtomicDetach(data);
+    if (createFileEngine) {
+        delete data->fileEngine;
+        data->fileEngine = QAbstractFileEngine::create(data->path);
+    }
+}
+
+/*!
+    \class QDir
+    \brief The QDir class provides access to directory structures and their contents.
+
+    \ingroup io
+    \ingroup shared
+    \reentrant
+    \mainclass
+
+    A QDir is used to manipulate path names, access information
+    regarding paths and files, and manipulate the underlying file
+    system. It can also be used to access Qt's \l{resource system}.
+
+    Qt uses "/" as a universal directory separator in the same way
+    that "/" is used as a path separator in URLs. If you always use
+    "/" as a directory separator, Qt will translate your paths to
+    conform to the underlying operating system.
+
+    A QDir can point to a file using either a relative or an absolute
+    path. Absolute paths begin with the directory separator
+    (optionally preceded by a drive specification under Windows).
+    Relative file names begin with a directory name or a file name and
+    specify a path relative to the current directory.
+
+    Examples of absolute paths:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 0
+
+    On Windows, the second example above will be translated to
+    \c{C:\Documents and Settings} when used to access files.
+
+    Examples of relative paths:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 1
+
+    You can use the isRelative() or isAbsolute() functions to check if
+    a QDir is using a relative or an absolute file path. Call
+    makeAbsolute() to convert a relative QDir to an absolute one.
+
+    \section1 Navigation and Directory Operations
+
+    A directory's path can be obtained with the path() function, and
+    a new path set with the setPath() function. The absolute path to
+    a directory is found by calling absolutePath().
+
+    The name of a directory is found using the dirName() function. This
+    typically returns the last element in the absolute path that specifies
+    the location of the directory. However, it can also return "." if
+    the QDir represents the current directory.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 2
+
+    The path for a directory can also be changed with the cd() and cdUp()
+    functions, both of which operate like familiar shell commands.
+    When cd() is called with the name of an existing directory, the QDir
+    object changes directory so that it represents that directory instead.
+    The cdUp() function changes the directory of the QDir object so that
+    it refers to its parent directory; i.e. cd("..") is equivalent to
+    cdUp().
+
+    Directories can be created with mkdir(), renamed with rename(), and
+    removed with rmdir().
+
+    You can test for the presence of a directory with a given name by
+    using exists(), and the properties of a directory can be tested with
+    isReadable(), isAbsolute(), isRelative(), and isRoot().
+
+    The refresh() function re-reads the directory's data from disk.
+
+    \section1 Files and Directory Contents
+
+    Directories contain a number of entries, representing files,
+    directories, and symbolic links. The number of entries in a
+    directory is returned by count().
+    A string list of the names of all the entries in a directory can be
+    obtained with entryList(). If you need information about each
+    entry, use entryInfoList() to obtain a list of QFileInfo objects.
+
+    Paths to files and directories within a directory can be
+    constructed using filePath() and absoluteFilePath().
+    The filePath() function returns a path to the specified file
+    or directory relative to the path of the QDir object;
+    absoluteFilePath() returns an absolute path to the specified
+    file or directory. Neither of these functions checks for the
+    existence of files or directory; they only construct paths.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 3
+
+    Files can be removed by using the remove() function. Directories
+    cannot be removed in the same way as files; use rmdir() to remove
+    them instead.
+
+    It is possible to reduce the number of entries returned by
+    entryList() and entryInfoList() by applying filters to a QDir object.
+    You can apply a name filter to specify a pattern with wildcards that
+    file names need to match, an attribute filter that selects properties
+    of entries and can distinguish between files and directories, and a
+    sort order.
+
+    Name filters are lists of strings that are passed to setNameFilters().
+    Attribute filters consist of a bitwise OR combination of Filters, and
+    these are specified when calling setFilter().
+    The sort order is specified using setSorting() with a bitwise OR
+    combination of SortFlags.
+
+    You can test to see if a filename matches a filter using the match()
+    function.
+
+    Filter and sort order flags may also be specified when calling
+    entryList() and entryInfoList() in order to override previously defined
+    behavior.
+
+    \section1 The Current Directory and Other Special Paths
+
+    Access to some common directories is provided with a number of static
+    functions that return QDir objects. There are also corresponding functions
+    for these that return strings:
+
+    \table
+    \header \o QDir      \o QString         \o Return Value
+    \row    \o current() \o currentPath()   \o The application's working directory
+    \row    \o home()    \o homePath()      \o The user's home directory
+    \row    \o root()    \o rootPath()      \o The root directory
+    \row    \o temp()    \o tempPath()      \o The system's temporary directory
+    \endtable
+
+    The setCurrent() static function can also be used to set the application's
+    working directory.
+
+    If you want to find the directory containing the application's executable,
+    see \l{QCoreApplication::applicationDirPath()}.
+
+    The drives() static function provides a list of root directories for each
+    device that contains a filing system. On Unix systems this returns a list
+    containing a single root directory "/"; on Windows the list will usually
+    contain \c{C:/}, and possibly other drive letters such as \c{D:/}, depending
+    on the configuration of the user's system.
+
+    \section1 Path Manipulation and Strings
+
+    Paths containing "." elements that reference the current directory at that
+    point in the path, ".." elements that reference the parent directory, and
+    symbolic links can be reduced to a canonical form using the canonicalPath()
+    function.
+
+    Paths can also be simplified by using cleanPath() to remove redundant "/"
+    and ".." elements.
+
+    It is sometimes necessary to be able to show a path in the native
+    representation for the user's platform. The static toNativeSeparators()
+    function returns a copy of the specified path in which each directory
+    separator is replaced by the appropriate separator for the underlying
+    operating system.
+
+    \section1 Examples
+
+    Check if a directory exists:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 4
+
+    (We could also use the static convenience function
+    QFile::exists().)
+
+    Traversing directories and reading a file:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 5
+
+    A program that lists all the files in the current directory
+    (excluding symbolic links), sorted by size, smallest first:
+
+    \snippet doc/src/snippets/qdir-listfiles/main.cpp 0
+
+    \sa QFileInfo, QFile, QFileDialog, QApplication::applicationDirPath(), {Find Files Example}
+*/
+
+/*!
+    Constructs a QDir pointing to the given directory \a path. If path
+    is empty the program's working directory, ("."), is used.
+
+    \sa currentPath()
+*/
+
+QDir::QDir(const QString &path) : d_ptr(new QDirPrivate(this))
+{
+    Q_D(QDir);
+    d->setPath(path.isEmpty() ? QString::fromLatin1(".") : path);
+    d->data->nameFilters = QStringList(QString::fromLatin1("*"));
+    d->data->filters = AllEntries;
+    d->data->sort = SortFlags(Name | IgnoreCase);
+}
+
+/*!
+    Constructs a QDir with path \a path, that filters its entries by
+    name using \a nameFilter and by attributes using \a filters. It
+    also sorts the names using \a sort.
+
+    The default \a nameFilter is an empty string, which excludes
+    nothing; the default \a filters is \l AllEntries, which also means
+    exclude nothing. The default \a sort is \l Name | \l IgnoreCase,
+    i.e. sort by name case-insensitively.
+
+    If \a path is an empty string, QDir uses "." (the current
+    directory). If \a nameFilter is an empty string, QDir uses the
+    name filter "*" (all files).
+
+    Note that \a path need not exist.
+
+    \sa exists(), setPath(), setNameFilter(), setFilter(), setSorting()
+*/
+
+QDir::QDir(const QString &path, const QString &nameFilter,
+           SortFlags sort, Filters filters)  : d_ptr(new QDirPrivate(this))
+{
+    Q_D(QDir);
+    d->setPath(path.isEmpty() ? QString::fromLatin1(".") : path);
+    d->data->nameFilters = QDir::nameFiltersFromString(nameFilter);
+    bool empty = d->data->nameFilters.isEmpty();
+    if(!empty) {
+        empty = true;
+        for(int i = 0; i < d->data->nameFilters.size(); ++i) {
+            if(!d->data->nameFilters.at(i).isEmpty()) {
+                empty = false;
+                break;
+            }
+        }
+    }
+    if (empty)
+        d->data->nameFilters = QStringList(QString::fromLatin1("*"));
+    d->data->sort = sort;
+    d->data->filters = filters;
+}
+
+/*!
+    Constructs a QDir object that is a copy of the QDir object for
+    directory \a dir.
+
+    \sa operator=()
+*/
+
+QDir::QDir(const QDir &dir)  : d_ptr(new QDirPrivate(this, &dir))
+{
+}
+
+/*!
+    Destroys the QDir object frees up its resources. This has no
+    effect on the underlying directory in the file system.
+*/
+
+QDir::~QDir()
+{
+    delete d_ptr;
+    d_ptr = 0;
+}
+
+/*!
+    Sets the path of the directory to \a path. The path is cleaned of
+    redundant ".", ".." and of multiple separators. No check is made
+    to see whether a directory with this path actually exists; but you
+    can check for yourself using exists().
+
+    The path can be either absolute or relative. Absolute paths begin
+    with the directory separator "/" (optionally preceded by a drive
+    specification under Windows). Relative file names begin with a
+    directory name or a file name and specify a path relative to the
+    current directory. An example of an absolute path is the string
+    "/tmp/quartz", a relative path might look like "src/fatlib".
+
+    \sa path(), absolutePath(), exists(), cleanPath(), dirName(),
+      absoluteFilePath(), isRelative(), makeAbsolute()
+*/
+
+void QDir::setPath(const QString &path)
+{
+    Q_D(QDir);
+    d->setPath(path);
+}
+
+/*!
+    Returns the path. This may contain symbolic links, but never
+    contains redundant ".", ".." or multiple separators.
+
+    The returned path can be either absolute or relative (see
+    setPath()).
+
+    \sa setPath(), absolutePath(), exists(), cleanPath(), dirName(),
+    absoluteFilePath(), toNativeSeparators(), makeAbsolute()
+*/
+
+QString QDir::path() const
+{
+    Q_D(const QDir);
+    return d->data->path;
+}
+
+/*!
+    Returns the absolute path (a path that starts with "/" or with a
+    drive specification), which may contain symbolic links, but never
+    contains redundant ".", ".." or multiple separators.
+
+    \sa setPath(), canonicalPath(), exists(), cleanPath(),
+    dirName(), absoluteFilePath()
+*/
+
+QString QDir::absolutePath() const
+{
+    Q_D(const QDir);
+    QString ret = d->data->path;
+    if (QDir::isRelativePath(ret))
+        ret = absoluteFilePath(QString::fromLatin1(""));
+    return cleanPath(ret);
+}
+
+
+/*!
+    Returns the canonical path, i.e. a path without symbolic links or
+    redundant "." or ".." elements.
+
+    On systems that do not have symbolic links this function will
+    always return the same string that absolutePath() returns. If the
+    canonical path does not exist (normally due to dangling symbolic
+    links) canonicalPath() returns an empty string.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 6
+
+    \sa path(), absolutePath(), exists(), cleanPath(), dirName(),
+        absoluteFilePath()
+*/
+
+QString QDir::canonicalPath() const
+{
+    Q_D(const QDir);
+
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return cleanPath(d->data->fileEngine->fileName(QAbstractFileEngine::CanonicalName));
+}
+
+/*!
+    Returns the name of the directory; this is \e not the same as the
+    path, e.g. a directory with the name "mail", might have the path
+    "/var/spool/mail". If the directory has no name (e.g. it is the
+    root directory) an empty string is returned.
+
+    No check is made to ensure that a directory with this name
+    actually exists; but see exists().
+
+    \sa path(), filePath(), absolutePath(), absoluteFilePath()
+*/
+
+QString QDir::dirName() const
+{
+    Q_D(const QDir);
+    int pos = d->data->path.lastIndexOf(QLatin1Char('/'));
+    if (pos == -1)
+        return d->data->path;
+    return d->data->path.mid(pos + 1);
+}
+
+/*!
+    Returns the path name of a file in the directory. Does \e not
+    check if the file actually exists in the directory; but see
+    exists(). If the QDir is relative the returned path name will also
+    be relative. Redundant multiple separators or "." and ".."
+    directories in \a fileName are not removed (see cleanPath()).
+
+    \sa dirName() absoluteFilePath(), isRelative(), canonicalPath()
+*/
+
+QString QDir::filePath(const QString &fileName) const
+{
+    Q_D(const QDir);
+    if (isAbsolutePath(fileName))
+        return QString(fileName);
+
+    QString ret = d->data->path;
+    if(!fileName.isEmpty()) {
+        if (!ret.isEmpty() && ret[(int)ret.length()-1] != QLatin1Char('/') && fileName[0] != QLatin1Char('/'))
+            ret += QLatin1Char('/');
+        ret += fileName;
+    }
+    return ret;
+}
+
+/*!
+    Returns the absolute path name of a file in the directory. Does \e
+    not check if the file actually exists in the directory; but see
+    exists(). Redundant multiple separators or "." and ".."
+    directories in \a fileName are not removed (see cleanPath()).
+
+    \sa relativeFilePath() filePath() canonicalPath()
+*/
+
+QString QDir::absoluteFilePath(const QString &fileName) const
+{
+    Q_D(const QDir);
+    if (isAbsolutePath(fileName))
+        return fileName;
+    if(!d->data->fileEngine)
+        return fileName;
+
+    QString ret;
+#ifndef QT_NO_FSFILEENGINE
+    if (isRelativePath(d->data->path)) //get pwd
+        ret = QFSFileEngine::currentPath(fileName);
+#endif
+    if(!d->data->path.isEmpty() && d->data->path != QLatin1String(".")) {
+        if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
+            ret += QLatin1Char('/');
+        ret += d->data->path;
+    }
+    if (!fileName.isEmpty()) {
+        if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
+            ret += QLatin1Char('/');
+        ret += fileName;
+    }
+    return ret;
+}
+
+/*!
+    Returns the path to \a fileName relative to the directory.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 7
+
+    \sa absoluteFilePath() filePath() canonicalPath()
+*/
+
+QString QDir::relativeFilePath(const QString &fileName) const
+{
+    QString dir = absolutePath();
+    QString file = cleanPath(fileName);
+
+    if (isRelativePath(file) || isRelativePath(dir))
+        return file;
+
+    QString dirDrive = driveSpec(dir);
+    QString fileDrive = driveSpec(file);
+
+    bool fileDriveMissing = false;
+    if (fileDrive.isEmpty()) {
+        fileDrive = dirDrive;
+        fileDriveMissing = true;
+    }
+
+#ifdef Q_OS_WIN
+    if (fileDrive.toLower() != dirDrive.toLower()
+        || (file.startsWith(QLatin1String("//"))
+        && !dir.startsWith(QLatin1String("//"))))
+#else
+    if (fileDrive != dirDrive)
+#endif
+        return file;
+
+    dir.remove(0, dirDrive.size());
+    if (!fileDriveMissing)
+        file.remove(0, fileDrive.size());
+
+    QString result;
+    QStringList dirElts = dir.split(QLatin1Char('/'), QString::SkipEmptyParts);
+    QStringList fileElts = file.split(QLatin1Char('/'), QString::SkipEmptyParts);
+
+    int i = 0;
+    while (i < dirElts.size() && i < fileElts.size() &&
+#ifdef Q_OS_WIN
+           dirElts.at(i).toLower() == fileElts.at(i).toLower())
+#else
+           dirElts.at(i) == fileElts.at(i))
+#endif
+        ++i;
+
+    for (int j = 0; j < dirElts.size() - i; ++j)
+        result += QLatin1String("../");
+
+    for (int j = i; j < fileElts.size(); ++j) {
+        result += fileElts.at(j);
+        if (j < fileElts.size() - 1)
+            result += QLatin1Char('/');
+    }
+
+    return result;
+}
+
+/*!
+    \obsolete
+
+    Use QDir::toNativeSeparators() instead.
+*/
+QString QDir::convertSeparators(const QString &pathName)
+{
+    return toNativeSeparators(pathName);
+}
+
+/*!
+    \since 4.2
+
+    Returns \a pathName with the '/' separators converted to
+    separators that are appropriate for the underlying operating
+    system.
+
+    On Windows, toNativeSeparators("c:/winnt/system32") returns
+    "c:\\winnt\\system32".
+
+    The returned string may be the same as the argument on some
+    operating systems, for example on Unix.
+
+    \sa fromNativeSeparators(), separator()
+*/
+QString QDir::toNativeSeparators(const QString &pathName)
+{
+    QString n(pathName);
+#if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX)
+    for (int i=0; i<(int)n.length(); i++) {
+        if (n[i] == QLatin1Char('/'))
+            n[i] = QLatin1Char('\\');
+    }
+#endif
+    return n;
+}
+
+/*!
+    \since 4.2
+
+    Returns \a pathName using '/' as file separator. On Windows,
+    for instance, fromNativeSeparators("\c{c:\\winnt\\system32}") returns
+    "c:/winnt/system32".
+
+    The returned string may be the same as the argument on some
+    operating systems, for example on Unix.
+
+    \sa toNativeSeparators(), separator()
+*/
+QString QDir::fromNativeSeparators(const QString &pathName)
+{
+    QString n(pathName);
+#if defined(Q_FS_FAT) || defined(Q_OS_OS2EMX)
+    for (int i=0; i<(int)n.length(); i++) {
+        if (n[i] == QLatin1Char('\\'))
+            n[i] = QLatin1Char('/');
+    }
+#endif
+    return n;
+}
+
+/*!
+    Changes the QDir's directory to \a dirName.
+
+    Returns true if the new directory exists and is readable;
+    otherwise returns false. Note that the logical cd() operation is
+    not performed if the new directory does not exist.
+
+    Calling cd("..") is equivalent to calling cdUp().
+
+    \sa cdUp(), isReadable(), exists(), path()
+*/
+
+bool QDir::cd(const QString &dirName)
+{
+    Q_D(QDir);
+
+    if (dirName.isEmpty() || dirName == QLatin1String("."))
+        return true;
+    QString newPath = d->data->path;
+    if (isAbsolutePath(dirName)) {
+        newPath = cleanPath(dirName);
+    } else {
+        if (isRoot()) {
+            if (dirName == QLatin1String(".."))
+                return false;
+        } else {
+            newPath += QLatin1Char('/');
+        }
+
+        newPath += dirName;
+        if (dirName.indexOf(QLatin1Char('/')) >= 0
+            || d->data->path == QLatin1String(".")
+            || dirName == QLatin1String("..")) {
+            newPath = cleanPath(newPath);
+            /*
+              If newPath starts with .., we convert it to absolute to
+              avoid infinite looping on
+
+                  QDir dir(".");
+                  while (dir.cdUp())
+                      ;
+            */
+            if (newPath.startsWith(QLatin1String(".."))) {
+                newPath = QFileInfo(newPath).absoluteFilePath();
+            }
+        }
+    }
+    {
+        QFileInfo fi(newPath);
+        if (!(fi.exists() && fi.isDir()))
+            return false;
+    }
+
+    d->setPath(newPath);
+    refresh();
+    return true;
+}
+
+/*!
+    Changes directory by moving one directory up from the QDir's
+    current directory.
+
+    Returns true if the new directory exists and is readable;
+    otherwise returns false. Note that the logical cdUp() operation is
+    not performed if the new directory does not exist.
+
+    \sa cd(), isReadable(), exists(), path()
+*/
+
+bool QDir::cdUp()
+{
+    return cd(QString::fromLatin1(".."));
+}
+
+/*!
+    Returns the string list set by setNameFilters()
+*/
+
+QStringList QDir::nameFilters() const
+{
+    Q_D(const QDir);
+
+    return d->data->nameFilters;
+}
+
+/*!
+    Sets the name filters used by entryList() and entryInfoList() to the
+    list of filters specified by \a nameFilters.
+
+    Each name filter is a wildcard (globbing) filter that understands
+    \c{*} and \c{?} wildcards. (See \l{QRegExp wildcard matching}.)
+
+    For example, the following code sets three name filters on a QDir
+    to ensure that only files with extensions typically used for C++
+    source files are listed:
+
+    \snippet doc/src/snippets/qdir-namefilters/main.cpp 0
+
+    \sa nameFilters(), setFilter()
+*/
+
+void QDir::setNameFilters(const QStringList &nameFilters)
+{
+    Q_D(QDir);
+    d->detach();
+    d->data->nameFilters = nameFilters;
+}
+
+/*!
+    \obsolete
+    Adds \a path to the search paths searched in to find resources
+    that are not specified with an absolute path. The default search
+    path is to search only in the root (\c{:/}).
+
+    Use QDir::addSearchPath() with a prefix instead.
+
+    \sa {The Qt Resource System}, QResource::addSearchPath()
+*/
+
+void QDir::addResourceSearchPath(const QString &path)
+{
+#ifdef QT_BUILD_CORE_LIB
+    QResource::addSearchPath(path);
+#else
+    Q_UNUSED(path)
+#endif
+}
+
+#ifdef QT_BUILD_CORE_LIB
+/*!
+    \since 4.3
+
+    Sets or replaces Qt's search paths for file names with the prefix \a prefix
+    to \a searchPaths.
+
+    To specify a prefix for a file name, prepend the prefix followed by a single
+    colon (e.g., "images:undo.png", "xmldocs:books.xml"). \a prefix can only
+    contain letters or numbers (e.g., it cannot contain a colon, nor a slash).
+
+    Qt uses this search path to locate files with a known prefix. The search
+    path entries are tested in order, starting with the first entry.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 8
+
+    File name prefix must be at least 2 characters long to avoid conflicts with
+    Windows drive letters.
+
+    Search paths may contain paths to \l{The Qt Resource System}.
+*/
+void QDir::setSearchPaths(const QString &prefix, const QStringList &searchPaths)
+{
+    if (prefix.length() < 2) {
+        qWarning("QDir::setSearchPaths: Prefix must be longer than 1 character");
+        return;
+    }
+
+    for (int i = 0; i < prefix.count(); i++) {
+        if (!prefix.at(i).isLetterOrNumber()) {
+            qWarning("QDir::setSearchPaths: Prefix can only contain letters or numbers");
+            return;
+        }
+    }
+
+    QWriteLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);
+    QMap<QString, QStringList> &paths = QCoreGlobalData::instance()->dirSearchPaths;
+    if (searchPaths.isEmpty()) {
+        paths.remove(prefix);
+    } else {
+        paths.insert(prefix, searchPaths);
+    }
+}
+
+/*!
+    \since 4.3
+
+    Adds \a path to the search path for \a prefix.
+
+    \sa setSearchPaths()
+*/
+void QDir::addSearchPath(const QString &prefix, const QString &path)
+{
+    if (path.isEmpty())
+        return;
+
+    QWriteLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);
+    QCoreGlobalData::instance()->dirSearchPaths[prefix] += path;
+}
+
+/*!
+    \since 4.3
+
+    Returns the search paths for \a prefix.
+
+    \sa setSearchPaths(), addSearchPath()
+*/
+QStringList QDir::searchPaths(const QString &prefix)
+{
+    QReadLocker lock(&QCoreGlobalData::instance()->dirSearchPathsLock);
+    return QCoreGlobalData::instance()->dirSearchPaths.value(prefix);
+}
+
+#endif // QT_BUILD_CORE_LIB
+
+/*!
+    Returns the value set by setFilter()
+*/
+
+QDir::Filters QDir::filter() const
+{
+    Q_D(const QDir);
+
+    return d->data->filters;
+}
+
+/*!
+    \enum QDir::Filter
+
+    This enum describes the filtering options available to QDir; e.g.
+    for entryList() and entryInfoList(). The filter value is specified
+    by combining values from the following list using the bitwise OR
+    operator:
+
+    \value Dirs    List directories that match the filters.
+    \value AllDirs  List all directories; i.e. don't apply the filters
+                    to directory names.
+    \value Files   List files.
+    \value Drives  List disk drives (ignored under Unix).
+    \value NoSymLinks  Do not list symbolic links (ignored by operating
+                       systems that don't support symbolic links).
+    \value NoDotAndDotDot Do not list the special entries "." and "..".
+    \value AllEntries  List directories, files, drives and symlinks (this does not list
+                broken symlinks unless you specify System).
+    \value Readable    List files for which the application has read
+                       access. The Readable value needs to be combined
+                       with Dirs or Files.
+    \value Writable    List files for which the application has write
+                       access. The Writable value needs to be combined
+                       with Dirs or Files.
+    \value Executable  List files for which the application has
+                       execute access. The Executable value needs to be
+                       combined with Dirs or Files.
+    \value Modified  Only list files that have been modified (ignored
+                     under Unix).
+    \value Hidden  List hidden files (on Unix, files starting with a .).
+    \value System  List system files (on Unix, FIFOs, sockets and
+                   device files)
+    \value CaseSensitive  The filter should be case sensitive.
+
+    \omitvalue DefaultFilter
+    \omitvalue TypeMask
+    \omitvalue All
+    \omitvalue RWEMask
+    \omitvalue AccessMask
+    \omitvalue PermissionMask
+    \omitvalue NoFilter
+
+    Functions that use Filter enum values to filter lists of files
+    and directories will include symbolic links to files and directories
+    unless you set the NoSymLinks value.
+
+    A default constructed QDir will not filter out files based on
+    their permissions, so entryList() and entryInfoList() will return
+    all files that are readable, writable, executable, or any
+    combination of the three.  This makes the default easy to write,
+    and at the same time useful.
+
+    For example, setting the \c Readable, \c Writable, and \c Files
+    flags allows all files to be listed for which the application has read
+    access, write access or both. If the \c Dirs and \c Drives flags are
+    also included in this combination then all drives, directories, all
+    files that the application can read, write, or execute, and symlinks
+    to such files/directories can be listed.
+
+    To retrieve the permissons for a directory, use the
+    entryInfoList() function to get the associated QFileInfo objects
+    and then use the QFileInfo::permissons() to obtain the permissions
+    and ownership for each file.
+*/
+
+/*!
+    Sets the filter used by entryList() and entryInfoList() to \a
+    filters. The filter is used to specify the kind of files that
+    should be returned by entryList() and entryInfoList(). See
+    \l{QDir::Filter}.
+
+    \sa filter(), setNameFilters()
+*/
+
+void QDir::setFilter(Filters filters)
+{
+    Q_D(QDir);
+
+    d->detach();
+    d->data->filters = filters;
+}
+
+/*!
+    Returns the value set by setSorting()
+
+    \sa setSorting() SortFlag
+*/
+
+QDir::SortFlags QDir::sorting() const
+{
+    Q_D(const QDir);
+
+    return d->data->sort;
+}
+
+/*!
+    \enum QDir::SortFlag
+
+    This enum describes the sort options available to QDir, e.g. for
+    entryList() and entryInfoList(). The sort value is specified by
+    OR-ing together values from the following list:
+
+    \value Name  Sort by name.
+    \value Time  Sort by time (modification time).
+    \value Size  Sort by file size.
+    \value Type  Sort by file type (extension).
+    \value Unsorted  Do not sort.
+    \value NoSort Not sorted by default.
+
+    \value DirsFirst  Put the directories first, then the files.
+    \value DirsLast Put the files first, then the directories.
+    \value Reversed  Reverse the sort order.
+    \value IgnoreCase  Sort case-insensitively.
+    \value LocaleAware Sort items appropriately using the current locale settings.
+
+    \omitvalue SortByMask
+    \omitvalue DefaultSort
+
+    You can only specify one of the first four.
+
+    If you specify both DirsFirst and Reversed, directories are
+    still put first, but in reverse order; the files will be listed
+    after the directories, again in reverse order.
+*/
+
+/*!
+    Sets the sort order used by entryList() and entryInfoList().
+
+    The \a sort is specified by OR-ing values from the enum
+    \l{QDir::SortFlag}.
+
+    \sa sorting() SortFlag
+*/
+
+void QDir::setSorting(SortFlags sort)
+{
+    Q_D(QDir);
+
+    d->detach();
+    d->data->sort = sort;
+}
+
+
+/*!
+    Returns the total number of directories and files in the directory.
+
+    Equivalent to entryList().count().
+
+    \sa operator[](), entryList()
+*/
+
+uint QDir::count() const
+{
+    Q_D(const QDir);
+
+    d->updateFileLists();
+    return d->data->files.count();
+}
+
+/*!
+    Returns the file name at position \a pos in the list of file
+    names. Equivalent to entryList().at(index).
+
+    Returns an empty string if \a pos is out of range or if the
+    entryList() function failed.
+
+    \sa count(), entryList()
+*/
+
+QString QDir::operator[](int pos) const
+{
+    Q_D(const QDir);
+
+    d->updateFileLists();
+    return d->data->files[pos];
+}
+
+/*!
+    \overload
+
+    Returns a list of the names of all the files and directories in
+    the directory, ordered according to the name and attribute filters
+    previously set with setNameFilters() and setFilter(), and sorted according
+    to the flags set with setSorting().
+
+    The attribute filter and sorting specifications can be overridden using the
+    \a filters and \a sort arguments.
+
+    Returns an empty list if the directory is unreadable, does not
+    exist, or if nothing matches the specification.
+
+    \note To list symlinks that point to non existing files, \l System must be
+     passed to the filter.
+
+    \sa entryInfoList(), setNameFilters(), setSorting(), setFilter()
+*/
+
+QStringList QDir::entryList(Filters filters, SortFlags sort) const
+{
+    Q_D(const QDir);
+
+    return entryList(d->data->nameFilters, filters, sort);
+}
+
+
+/*!
+    \overload
+
+    Returns a list of QFileInfo objects for all the files and directories in
+    the directory, ordered according to the name and attribute filters
+    previously set with setNameFilters() and setFilter(), and sorted according
+    to the flags set with setSorting().
+
+    The attribute filter and sorting specifications can be overridden using the
+    \a filters and \a sort arguments.
+
+    Returns an empty list if the directory is unreadable, does not
+    exist, or if nothing matches the specification.
+
+    \sa entryList(), setNameFilters(), setSorting(), setFilter(), isReadable(), exists()
+*/
+
+QFileInfoList QDir::entryInfoList(Filters filters, SortFlags sort) const
+{
+    Q_D(const QDir);
+
+    return entryInfoList(d->data->nameFilters, filters, sort);
+}
+
+/*!
+    Returns a list of the names of all the files and
+    directories in the directory, ordered according to the name
+    and attribute filters previously set with setNameFilters()
+    and setFilter(), and sorted according to the flags set with
+    setSorting().
+
+    The name filter, file attribute filter, and sorting specification
+    can be overridden using the \a nameFilters, \a filters, and \a sort
+    arguments.
+
+    Returns an empty list if the directory is unreadable, does not
+    exist, or if nothing matches the specification.
+
+    \sa entryInfoList(), setNameFilters(), setSorting(), setFilter()
+*/
+
+QStringList QDir::entryList(const QStringList &nameFilters, Filters filters,
+                            SortFlags sort) const
+{
+    Q_D(const QDir);
+
+    if (filters == NoFilter)
+        filters = d->data->filters;
+#ifdef QT3_SUPPORT
+    if (d->matchAllDirs)
+        filters |= AllDirs;
+#endif
+    if (sort == NoSort)
+        sort = d->data->sort;
+    if (filters == NoFilter && sort == NoSort && nameFilters == d->data->nameFilters) {
+        d->updateFileLists();
+        return d->data->files;
+    }
+    QStringList l = d->data->fileEngine->entryList(filters, nameFilters);
+    if ((sort & QDir::SortByMask) == QDir::Unsorted)
+        return l;
+
+    QStringList ret;
+    d->sortFileList(sort, l, &ret, 0);
+    return ret;
+}
+
+/*!
+    Returns a list of QFileInfo objects for all the files and
+    directories in the directory, ordered according to the name
+    and attribute filters previously set with setNameFilters()
+    and setFilter(), and sorted according to the flags set with
+    setSorting().
+
+    The name filter, file attribute filter, and sorting specification
+    can be overridden using the \a nameFilters, \a filters, and \a sort
+    arguments.
+
+    Returns an empty list if the directory is unreadable, does not
+    exist, or if nothing matches the specification.
+
+    \sa entryList(), setNameFilters(), setSorting(), setFilter(), isReadable(), exists()
+*/
+
+QFileInfoList QDir::entryInfoList(const QStringList &nameFilters, Filters filters,
+                                  SortFlags sort) const
+{
+    Q_D(const QDir);
+
+    if (filters == NoFilter)
+        filters = d->data->filters;
+#ifdef QT3_SUPPORT
+    if (d->matchAllDirs)
+        filters |= AllDirs;
+#endif
+    if (sort == NoSort)
+        sort = d->data->sort;
+    if (filters == NoFilter && sort == NoSort && nameFilters == d->data->nameFilters) {
+        d->updateFileLists();
+        return d->data->fileInfos;
+    }
+    QFileInfoList ret;
+    QStringList l = d->data->fileEngine->entryList(filters, nameFilters);
+    d->sortFileList(sort, l, 0, &ret);
+    return ret;
+}
+
+/*!
+    Creates a sub-directory called \a dirName.
+
+    Returns true on success; otherwise returns false.
+
+    \sa rmdir()
+*/
+
+bool QDir::mkdir(const QString &dirName) const
+{
+    Q_D(const QDir);
+
+    if (dirName.isEmpty()) {
+        qWarning("QDir::mkdir: Empty or null file name(s)");
+        return false;
+    }
+    if(!d->data->fileEngine)
+        return false;
+
+    QString fn = filePath(dirName);
+    return d->data->fileEngine->mkdir(fn, false);
+}
+
+/*!
+    Removes the directory specified by \a dirName.
+
+    The directory must be empty for rmdir() to succeed.
+
+    Returns true if successful; otherwise returns false.
+
+    \sa mkdir()
+*/
+
+bool QDir::rmdir(const QString &dirName) const
+{
+    Q_D(const QDir);
+
+    if (dirName.isEmpty()) {
+        qWarning("QDir::rmdir: Empty or null file name(s)");
+        return false;
+    }
+    if(!d->data->fileEngine)
+        return false;
+
+    QString fn = filePath(dirName);
+    return d->data->fileEngine->rmdir(fn, false);
+}
+
+/*!
+    Creates the directory path \a dirPath.
+
+    The function will create all parent directories necessary to
+    create the directory.
+
+    Returns true if successful; otherwise returns false.
+
+    \sa rmpath()
+*/
+
+bool QDir::mkpath(const QString &dirPath) const
+{
+    Q_D(const QDir);
+
+    if (dirPath.isEmpty()) {
+        qWarning("QDir::mkpath: Empty or null file name(s)");
+        return false;
+    }
+    if(!d->data->fileEngine)
+        return false;
+
+    QString fn = filePath(dirPath);
+    return d->data->fileEngine->mkdir(fn, true);
+}
+
+/*!
+    Removes the directory path \a dirPath.
+
+    The function will remove all parent directories in \a dirPath,
+    provided that they are empty. This is the opposite of
+    mkpath(dirPath).
+
+    Returns true if successful; otherwise returns false.
+
+    \sa mkpath()
+*/
+bool QDir::rmpath(const QString &dirPath) const
+{
+    Q_D(const QDir);
+
+    if (dirPath.isEmpty()) {
+        qWarning("QDir::rmpath: Empty or null file name(s)");
+        return false;
+    }
+    if(!d->data->fileEngine)
+        return false;
+
+    QString fn = filePath(dirPath);
+    return d->data->fileEngine->rmdir(fn, true);
+}
+
+/*!
+    Returns true if the directory is readable \e and we can open files
+    by name; otherwise returns false.
+
+    \warning A false value from this function is not a guarantee that
+    files in the directory are not accessible.
+
+    \sa QFileInfo::isReadable()
+*/
+
+
+bool QDir::isReadable() const
+{
+    Q_D(const QDir);
+
+    if(!d->data->fileEngine)
+        return false;
+    const QAbstractFileEngine::FileFlags info = d->data->fileEngine->fileFlags(QAbstractFileEngine::DirectoryType
+                                                                       |QAbstractFileEngine::PermsMask);
+    if(!(info & QAbstractFileEngine::DirectoryType))
+        return false;
+    return info & QAbstractFileEngine::ReadUserPerm;
+}
+
+/*!
+    \overload
+
+    Returns true if the \e directory exists; otherwise returns false.
+    (If a file with the same name is found this function will return
+    false).
+
+    \sa QFileInfo::exists(), QFile::exists()
+*/
+
+bool QDir::exists() const
+{
+    Q_D(const QDir);
+
+    if(!d->data->fileEngine)
+        return false;
+    const QAbstractFileEngine::FileFlags info =
+        d->data->fileEngine->fileFlags(
+            QAbstractFileEngine::DirectoryType
+            | QAbstractFileEngine::ExistsFlag
+            | QAbstractFileEngine::Refresh);
+    if(!(info & QAbstractFileEngine::DirectoryType))
+        return false;
+    return info & QAbstractFileEngine::ExistsFlag;
+}
+
+/*!
+    Returns true if the directory is the root directory; otherwise
+    returns false.
+
+    Note: If the directory is a symbolic link to the root directory
+    this function returns false. If you want to test for this use
+    canonicalPath(), e.g.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 9
+
+    \sa root(), rootPath()
+*/
+
+bool QDir::isRoot() const
+{
+    Q_D(const QDir);
+
+    if(!d->data->fileEngine)
+        return true;
+    return d->data->fileEngine->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::RootFlag;
+}
+
+/*!
+    \fn bool QDir::isAbsolute() const
+
+    Returns true if the directory's path is absolute; otherwise
+    returns false. See isAbsolutePath().
+
+    \sa isRelative() makeAbsolute() cleanPath()
+*/
+
+/*!
+   \fn bool QDir::isAbsolutePath(const QString &)
+
+    Returns true if \a path is absolute; returns false if it is
+    relative.
+
+    \sa isAbsolute() isRelativePath() makeAbsolute() cleanPath()
+*/
+
+/*!
+    Returns true if the directory path is relative; otherwise returns
+    false. (Under Unix a path is relative if it does not start with a
+    "/").
+
+    \sa makeAbsolute() isAbsolute() isAbsolutePath() cleanPath()
+*/
+
+bool QDir::isRelative() const
+{
+    Q_D(const QDir);
+
+    if(!d->data->fileEngine)
+        return false;
+    return d->data->fileEngine->isRelativePath();
+}
+
+
+/*!
+    Converts the directory path to an absolute path. If it is already
+    absolute nothing happens. Returns true if the conversion
+    succeeded; otherwise returns false.
+
+    \sa isAbsolute() isAbsolutePath() isRelative() cleanPath()
+*/
+
+bool QDir::makeAbsolute() // ### What do the return values signify?
+{
+    Q_D(QDir);
+
+    if(!d->data->fileEngine)
+        return false;
+    QString absolutePath = d->data->fileEngine->fileName(QAbstractFileEngine::AbsoluteName);
+    if(QDir::isRelativePath(absolutePath))
+        return false;
+    d->detach();
+    d->data->path = absolutePath;
+    d->data->fileEngine->setFileName(absolutePath);
+    if(!(d->data->fileEngine->fileFlags(QAbstractFileEngine::TypesMask) & QAbstractFileEngine::DirectoryType))
+        return false;
+    return true;
+}
+
+/*!
+    Returns true if directory \a dir and this directory have the same
+    path and their sort and filter settings are the same; otherwise
+    returns false.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 10
+*/
+
+bool QDir::operator==(const QDir &dir) const
+{
+    const QDirPrivate *d = d_func();
+    const QDirPrivate *other = dir.d_func();
+
+    if(d->data == other->data)
+        return true;
+    Q_ASSERT(d->data->fileEngine && other->data->fileEngine);
+    if(d->data->fileEngine->caseSensitive() != other->data->fileEngine->caseSensitive())
+        return false;
+    if(d->data->filters == other->data->filters
+       && d->data->sort == other->data->sort
+       && d->data->nameFilters == other->data->nameFilters) {
+        QString dir1 = absolutePath(), dir2 = dir.absolutePath();
+        if(!other->data->fileEngine->caseSensitive())
+            return (dir1.toLower() == dir2.toLower());
+
+        return (dir1 == dir2);
+
+    }
+    return false;
+}
+
+/*!
+    Makes a copy of the \a dir object and assigns it to this QDir
+    object.
+*/
+
+QDir &QDir::operator=(const QDir &dir)
+{
+    if (this == &dir)
+        return *this;
+
+    Q_D(QDir);
+    qAtomicAssign(d->data, dir.d_func()->data);
+    return *this;
+}
+
+/*!
+    \overload
+    \obsolete
+
+    Sets the directory path to the given \a path.
+
+    Use setPath() instead.
+*/
+
+QDir &QDir::operator=(const QString &path)
+{
+    Q_D(QDir);
+
+    d->setPath(path);
+    return *this;
+}
+
+/*!
+    \fn bool QDir::operator!=(const QDir &dir) const
+
+    Returns true if directory \a dir and this directory have different
+    paths or different sort or filter settings; otherwise returns
+    false.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 11
+*/
+
+
+/*!
+    Removes the file, \a fileName.
+
+    Returns true if the file is removed successfully; otherwise
+    returns false.
+*/
+
+bool QDir::remove(const QString &fileName)
+{
+    if (fileName.isEmpty()) {
+        qWarning("QDir::remove: Empty or null file name");
+        return false;
+    }
+    QString p = filePath(fileName);
+    return QFile::remove(p);
+}
+
+/*!
+    Renames a file or directory from \a oldName to \a newName, and returns
+    true if successful; otherwise returns false.
+
+    On most file systems, rename() fails only if \a oldName does not
+    exist, if \a newName and \a oldName are not on the same
+    partition or if a file with the new name already exists.
+    However, there are also other reasons why rename() can
+    fail. For example, on at least one file system rename() fails if
+    \a newName points to an open file.
+*/
+
+bool QDir::rename(const QString &oldName, const QString &newName)
+{
+    Q_D(QDir);
+
+    if (oldName.isEmpty() || newName.isEmpty()) {
+        qWarning("QDir::rename: Empty or null file name(s)");
+        return false;
+    }
+    if(!d->data->fileEngine)
+        return false;
+
+    QFile file(filePath(oldName));
+    if(!file.exists())
+        return false;
+    return file.rename(filePath(newName));
+}
+
+/*!
+    Returns true if the file called \a name exists; otherwise returns
+    false. Unless \a name contains an absolute file path, the file
+    name is assumed to be relative to the current directory.
+
+    \sa QFileInfo::exists(), QFile::exists()
+*/
+
+bool QDir::exists(const QString &name) const
+{
+    if (name.isEmpty()) {
+        qWarning("QDir::exists: Empty or null file name");
+        return false;
+    }
+    QString tmp = filePath(name);
+    return QFile::exists(tmp);
+}
+
+/*!
+    Returns a list of the root directories on this system.
+
+    On Windows this returns a list of QFileInfo objects containing "C:/",
+    "D:/", etc. On other operating systems, it returns a list containing
+    just one root directory (i.e. "/").
+
+    \sa root(), rootPath()
+*/
+
+QFileInfoList QDir::drives()
+{
+#ifdef QT_NO_FSFILEENGINE
+    return QFileInfoList();
+#else
+    return QFSFileEngine::drives();
+#endif
+}
+
+/*!
+    Returns the native directory separator: "/" under Unix (including
+    Mac OS X) and "\\" under Windows.
+
+    You do not need to use this function to build file paths. If you
+    always use "/", Qt will translate your paths to conform to the
+    underlying operating system. If you want to display paths to the
+    user using their operating system's separator use
+    toNativeSeparators().
+*/
+
+QChar QDir::separator()
+{
+#if defined(Q_OS_UNIX)
+    return QLatin1Char('/');
+#elif defined (Q_FS_FAT) || defined(Q_WS_WIN)
+    return QLatin1Char('\\');
+#elif defined (Q_OS_MAC)
+    return QLatin1Char(':');
+#else
+    return QLatin1Char('/');
+#endif
+}
+
+/*!
+    Sets the application's current working directory to \a path.
+    Returns true if the directory was successfully changed; otherwise
+    returns false.
+
+    \sa current() currentPath() home() root() temp()
+*/
+
+bool QDir::setCurrent(const QString &path)
+{
+#ifdef QT_NO_FSFILEENGINE
+    Q_UNUSED(path);
+    return false;
+#else
+    return QFSFileEngine::setCurrentPath(path);
+#endif
+}
+
+/*!
+    \fn QDir QDir::current()
+
+    Returns the application's current directory.
+
+    The directory is constructed using the absolute path of the current directory,
+    ensuring that its path() will be the same as its absolutePath().
+
+    \sa currentPath(), home(), root(), temp()
+*/
+
+/*!
+    Returns the absolute path of the application's current directory.
+
+    \sa current(), homePath(), rootPath(), tempPath()
+*/
+QString QDir::currentPath()
+{
+#ifdef QT_NO_FSFILEENGINE
+    return QString();
+#else
+    return QFSFileEngine::currentPath();
+#endif
+}
+
+/*!
+  \fn QString QDir::currentDirPath()
+    Returns the absolute path of the application's current directory.
+
+    Use currentPath() instead.
+
+    \sa currentPath()
+*/
+
+/*!
+    \fn QDir QDir::home()
+
+    Returns the user's home directory.
+
+    The directory is constructed using the absolute path of the home directory,
+    ensuring that its path() will be the same as its absolutePath().
+
+    See homePath() for details.
+
+    \sa drives(), current(), root(), temp()
+*/
+
+/*!
+    Returns the absolute path of the user's home directory.
+
+    Under Windows this function will return the directory of the
+    current user's profile. Typically, this is:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 12
+
+    Use the toNativeSeparators() function to convert the separators to
+    the ones that are appropriate for the underlying operating system.
+
+    If the directory of the current user's profile does not exist or
+    cannot be retrieved, the following alternatives will be checked (in
+    the given order) until an existing and available path is found:
+
+    \list 1
+    \o The path specified by the \c USERPROFILE environment variable.
+    \o The path formed by concatenating the \c HOMEDRIVE and \c HOMEPATH
+    environment variables.
+    \o The path specified by the \c HOME environment variable.
+    \o The path returned by the rootPath() function (which uses the \c SystemDrive
+    environment variable)
+    \o  The \c{C:/} directory.
+    \endlist
+
+    Under non-Windows operating systems the \c HOME environment
+    variable is used if it exists, otherwise the path returned by the
+    rootPath() function is used.
+
+    \sa home(), currentPath(), rootPath(), tempPath()
+*/
+QString QDir::homePath()
+{
+#ifdef QT_NO_FSFILEENGINE
+    return QString();
+#else
+    return cleanPath(QFSFileEngine::homePath());
+#endif
+}
+
+/*!
+  \fn QString QDir::homeDirPath()
+
+  Returns the absolute path of the user's home directory.
+
+  Use homePath() instead.
+
+  \sa homePath()
+ */
+
+/*!
+    \fn QDir QDir::temp()
+
+    Returns the system's temporary directory.
+
+    The directory is constructed using the absolute path of the temporary directory,
+    ensuring that its path() will be the same as its absolutePath().
+
+    See tempPath() for details.
+
+    \sa drives(), current(), home(), root()
+*/
+
+/*!
+    Returns the absolute path of the system's temporary directory.
+
+    On Unix/Linux systems this is usually \c{/tmp}; on Windows this is
+    usually the path in the \c TEMP or \c TMP environment
+    variable. Whether a directory separator is added to the end or
+    not, depends on the operating system.
+
+    \sa temp(), currentPath(), homePath(), rootPath()
+*/
+QString QDir::tempPath()
+{
+#ifdef QT_NO_FSFILEENGINE
+    return QString();
+#else
+    return cleanPath(QFSFileEngine::tempPath());
+#endif
+}
+
+/*!
+    \fn QDir QDir::root()
+
+    Returns the root directory.
+
+    The directory is constructed using the absolute path of the root directory,
+    ensuring that its path() will be the same as its absolutePath().
+
+    See rootPath() for details.
+
+    \sa drives(), current(), home(), temp()
+*/
+
+/*!
+    Returns the absolute path of the root directory.
+
+    For Unix operating systems this returns "/". For Windows file
+    systems this normally returns "c:/".
+
+    \sa root(), drives(), currentPath(), homePath(), tempPath()
+*/
+QString QDir::rootPath()
+{
+#ifdef QT_NO_FSFILEENGINE
+    return QString();
+#else
+    return QFSFileEngine::rootPath();
+#endif
+}
+
+/*!
+  \fn QString QDir::rootDirPath()
+
+  Returns the absolute path of the root directory.
+
+  Use rootPath() instead.
+
+  \sa rootPath()
+*/
+
+#ifndef QT_NO_REGEXP
+/*!
+    \overload
+
+    Returns true if the \a fileName matches any of the wildcard (glob)
+    patterns in the list of \a filters; otherwise returns false. The
+    matching is case insensitive.
+
+    \sa {QRegExp wildcard matching}, QRegExp::exactMatch() entryList() entryInfoList()
+*/
+
+
+bool QDir::match(const QStringList &filters, const QString &fileName)
+{
+    for(QStringList::ConstIterator sit = filters.begin(); sit != filters.end(); ++sit) {
+        QRegExp rx(*sit, Qt::CaseInsensitive, QRegExp::Wildcard);
+        if (rx.exactMatch(fileName))
+            return true;
+    }
+    return false;
+}
+
+/*!
+    Returns true if the \a fileName matches the wildcard (glob)
+    pattern \a filter; otherwise returns false. The \a filter may
+    contain multiple patterns separated by spaces or semicolons.
+    The matching is case insensitive.
+
+    \sa {QRegExp wildcard matching}, QRegExp::exactMatch() entryList() entryInfoList()
+*/
+
+bool QDir::match(const QString &filter, const QString &fileName)
+{
+    return match(nameFiltersFromString(filter), fileName);
+}
+#endif
+
+/*!
+    Removes all multiple directory separators "/" and resolves any
+    "."s or ".."s found in the path, \a path.
+
+    Symbolic links are kept. This function does not return the
+    canonical path, but rather the simplest version of the input.
+    For example, "./local" becomes "local", "local/../bin" becomes
+    "bin" and "/local/usr/../bin" becomes "/local/bin".
+
+    \sa absolutePath() canonicalPath()
+*/
+
+QString QDir::cleanPath(const QString &path)
+{
+    if (path.isEmpty())
+        return path;
+    QString name = path;
+    QChar dir_separator = separator();
+    if(dir_separator != QLatin1Char('/'))
+	name.replace(dir_separator, QLatin1Char('/'));
+
+    int used = 0, levels = 0;
+    const int len = name.length();
+    QVector<QChar> out(len);
+    const QChar *p = name.unicode();
+    for(int i = 0, last = -1, iwrite = 0; i < len; i++) {
+        if(p[i] == QLatin1Char('/')) {
+            while(i < len-1 && p[i+1] == QLatin1Char('/')) {
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) //allow unc paths
+                if(!i)
+                    break;
+#endif
+                i++;
+            }
+            bool eaten = false;
+            if(i < len - 1 && p[i+1] == QLatin1Char('.')) {
+                int dotcount = 1;
+                if(i < len - 2 && p[i+2] == QLatin1Char('.'))
+                    dotcount++;
+                if(i == len - dotcount - 1) {
+                    if(dotcount == 1) {
+                        break;
+                    } else if(levels) {
+                        if(last == -1) {
+                            for(int i2 = iwrite-1; i2 >= 0; i2--) {
+                                if(out[i2] == QLatin1Char('/')) {
+                                    last = i2;
+                                    break;
+                                }
+                            }
+                        }
+                        used -= iwrite - last - 1;
+                        break;
+                    }
+                } else if(p[i+dotcount+1] == QLatin1Char('/')) {
+                    if(dotcount == 2 && levels) {
+                        if(last == -1 || iwrite - last == 1) {
+                            for(int i2 = (last == -1) ? (iwrite-1) : (last-1); i2 >= 0; i2--) {
+                                if(out[i2] == QLatin1Char('/')) {
+                                    eaten = true;
+                                    last = i2;
+                                    break;
+                                }
+                            }
+                        } else {
+                            eaten = true;
+                        }
+                        if(eaten) {
+                            levels--;
+                            used -= iwrite - last;
+                            iwrite = last;
+                            last = -1;
+                        }
+                    } else if (dotcount == 2 && i > 0 && p[i - 1] != QLatin1Char('.')) {
+                        eaten = true;
+                        used -= iwrite - qMax(0, last);
+                        iwrite = qMax(0, last);
+                        last = -1;
+                        ++i;
+                    } else if(dotcount == 1) {
+                        eaten = true;
+                    }
+                    if(eaten)
+                        i += dotcount;
+                } else {
+                    levels++;
+                }
+            } else if(last != -1 && iwrite - last == 1) {
+#ifdef Q_OS_WIN
+                eaten = (iwrite > 2);
+#else
+                eaten = true;
+#endif
+                last = -1;
+            } else if(last != -1 && i == len-1) {
+                eaten = true;
+            } else {
+                levels++;
+            }
+            if(!eaten)
+                last = i - (i - iwrite);
+            else
+                continue;
+        } else if(!i && p[i] == QLatin1Char('.')) {
+            int dotcount = 1;
+            if(len >= 1 && p[1] == QLatin1Char('.'))
+                dotcount++;
+            if(len >= dotcount && p[dotcount] == QLatin1Char('/')) {
+                if(dotcount == 1) {
+                    i++;
+                    while(i+1 < len-1 && p[i+1] == QLatin1Char('/'))
+                        i++;
+                    continue;
+                }
+            }
+        }
+        out[iwrite++] = p[i];
+        used++;
+    }
+    QString ret;
+    if(used == len)
+        ret = name;
+    else
+	ret = QString(out.data(), used);
+
+    // Strip away last slash except for root directories
+    if (ret.endsWith(QLatin1Char('/'))
+        && !(ret.size() == 1 || (ret.size() == 3 && ret.at(1) == QLatin1Char(':'))))
+        ret = ret.left(ret.length() - 1);
+
+    return ret;
+}
+
+/*!
+    Returns true if \a path is relative; returns false if it is
+    absolute.
+
+    \sa isRelative() isAbsolutePath() makeAbsolute()
+*/
+
+bool QDir::isRelativePath(const QString &path)
+{
+    return QFileInfo(path).isRelative();
+}
+
+/*!
+    Refreshes the directory information.
+*/
+
+void QDir::refresh() const
+{
+    Q_D(const QDir);
+
+    d->data->clear();
+}
+
+/*!
+    \internal
+
+    Returns a list of name filters from the given \a nameFilter. (If
+    there is more than one filter, each pair of filters is separated
+    by a space or by a semicolon.)
+*/
+
+QStringList QDir::nameFiltersFromString(const QString &nameFilter)
+{
+    return QDirPrivate::splitFilters(nameFilter);
+}
+
+/*!
+    \macro void Q_INIT_RESOURCE(name)
+    \relates QDir
+
+    Initializes the resources specified by the \c .qrc file with the
+    specified base \a name. Normally, Qt resources are loaded
+    automatically at startup. The Q_INIT_RESOURCE() macro is
+    necessary on some platforms for resources stored in a static
+    library.
+
+    For example, if your application's resources are listed in a file
+    called \c myapp.qrc, you can ensure that the resources are
+    initialized at startup by adding this line to your \c main()
+    function:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 13
+
+    If the file name contains characters that cannot be part of a valid C++ function name 
+    (such as '-'), they have to be replaced by the underscore character ('_').
+
+    Note: This macro cannot be used in a namespace. It should be called from
+    main(). If that is not possible, the following workaround can be used
+    to init the resource \c myapp from the function \c{MyNamespace::myFunction}:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 14
+
+    \sa Q_CLEANUP_RESOURCE(), {The Qt Resource System}
+*/
+
+/*!
+    \since 4.1
+    \macro void Q_CLEANUP_RESOURCE(name)
+    \relates QDir
+
+    Unloads the resources specified by the \c .qrc file with the base
+    name \a name.
+
+    Normally, Qt resources are unloaded automatically when the
+    application terminates, but if the resources are located in a
+    plugin that is being unloaded, call Q_CLEANUP_RESOURCE() to force
+    removal of your resources.
+
+    Note: This macro cannot be used in a namespace. Please see the
+    Q_INIT_RESOURCE documentation for a workaround.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdir.cpp 15
+
+    \sa Q_INIT_RESOURCE(), {The Qt Resource System}
+*/
+
+#ifdef QT3_SUPPORT
+
+/*!
+    \fn bool QDir::matchAllDirs() const
+
+    Use filter() & AllDirs instead.
+*/
+bool QDir::matchAllDirs() const
+{
+    Q_D(const QDir);
+    return d->matchAllDirs;
+}
+
+
+/*!
+    \fn void QDir::setMatchAllDirs(bool on)
+
+    Use setFilter() instead.
+*/
+void QDir::setMatchAllDirs(bool on)
+{
+    Q_D(QDir);
+    d->matchAllDirs = on;
+}
+
+/*!
+    Use nameFilters() instead.
+*/
+QString QDir::nameFilter() const
+{
+    Q_D(const QDir);
+
+    return nameFilters().join(QString(d->filterSepChar));
+}
+
+/*!
+    Use setNameFilters() instead.
+
+    The \a nameFilter is a wildcard (globbing) filter that understands
+    "*" and "?" wildcards. (See \l{QRegExp wildcard matching}.) You may
+    specify several filter entries, each separated by spaces or by
+    semicolons.
+
+    For example, if you want entryList() and entryInfoList() to list
+    all files ending with either ".cpp" or ".h", you would use either
+    dir.setNameFilters("*.cpp *.h") or dir.setNameFilters("*.cpp;*.h").
+
+    \oldcode
+        QString filter = "*.cpp *.cxx *.cc";
+        dir.setNameFilter(filter);
+    \newcode
+        QString filter = "*.cpp *.cxx *.cc";
+        dir.setNameFilters(filter.split(' '));
+    \endcode
+*/
+void QDir::setNameFilter(const QString &nameFilter)
+{
+    Q_D(QDir);
+
+    d->filterSepChar = QDirPrivate::getFilterSepChar(nameFilter);
+    setNameFilters(QDirPrivate::splitFilters(nameFilter, d->filterSepChar));
+}
+
+/*!
+    \fn QString QDir::absPath() const
+
+    Use absolutePath() instead.
+*/
+
+/*!
+    \fn QString QDir::absFilePath(const QString &fileName, bool acceptAbsPath) const
+
+    Use absoluteFilePath(\a fileName) instead.
+
+    The \a acceptAbsPath parameter is ignored.
+*/
+
+/*!
+    \fn bool QDir::mkdir(const QString &dirName, bool acceptAbsPath) const
+
+    Use mkdir(\a dirName) instead.
+
+    The \a acceptAbsPath parameter is ignored.
+*/
+
+/*!
+    \fn bool QDir::rmdir(const QString &dirName, bool acceptAbsPath) const
+
+    Use rmdir(\a dirName) instead.
+
+    The \a acceptAbsPath parameter is ignored.
+*/
+
+/*!
+    \fn QStringList QDir::entryList(const QString &nameFilter, Filters filters,
+                                    SortFlags sort) const
+    \overload
+
+    Use the overload that takes a name filter string list as first
+    argument instead of a combination of attribute filter flags.
+*/
+
+/*!
+    \fn QFileInfoList QDir::entryInfoList(const QString &nameFilter, Filters filters,
+                                          SortFlags sort) const
+    \overload
+
+    Use the overload that takes a name filter string list as first
+    argument instead of a combination of attribute filter flags.
+*/
+
+/*!
+    \fn void QDir::convertToAbs()
+
+    Use makeAbsolute() instead.
+*/
+
+/*!
+    \fn QString QDir::cleanDirPath(const QString &name)
+
+    Use cleanPath() instead.
+*/
+
+/*!
+    \typedef QDir::FilterSpec
+
+    Use QDir::Filters instead.
+*/
+
+/*!
+    \typedef QDir::SortSpec
+
+    Use QDir::SortFlags instead.
+*/
+#endif
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, QDir::Filters filters)
+{
+    QStringList flags;
+    if (filters == QDir::NoFilter) {
+        flags << QLatin1String("NoFilter");
+    } else {
+        if (filters & QDir::Dirs) flags << QLatin1String("Dirs");
+        if (filters & QDir::AllDirs) flags << QLatin1String("AllDirs");
+        if (filters & QDir::Files) flags << QLatin1String("Files");
+        if (filters & QDir::Drives) flags << QLatin1String("Drives");
+        if (filters & QDir::NoSymLinks) flags << QLatin1String("NoSymLinks");
+        if (filters & QDir::NoDotAndDotDot) flags << QLatin1String("NoDotAndDotDot");
+        if ((filters & QDir::AllEntries) == QDir::AllEntries) flags << QLatin1String("AllEntries");
+        if (filters & QDir::Readable) flags << QLatin1String("Readable");
+        if (filters & QDir::Writable) flags << QLatin1String("Writable");
+        if (filters & QDir::Executable) flags << QLatin1String("Executable");
+        if (filters & QDir::Modified) flags << QLatin1String("Modified");
+        if (filters & QDir::Hidden) flags << QLatin1String("Hidden");
+        if (filters & QDir::System) flags << QLatin1String("System");
+        if (filters & QDir::CaseSensitive) flags << QLatin1String("CaseSensitive");
+    }
+    debug << "QDir::Filters(" << qPrintable(flags.join(QLatin1String("|"))) << ")";
+    return debug;
+}
+
+QDebug operator<<(QDebug debug, QDir::SortFlags sorting)
+{
+    if (sorting == QDir::NoSort) {
+        debug << "QDir::SortFlags(NoSort)";
+    } else {
+        QString type;
+        if ((sorting & 3) == QDir::Name) type = QLatin1String("Name");
+        if ((sorting & 3) == QDir::Time) type = QLatin1String("Time");
+        if ((sorting & 3) == QDir::Size) type = QLatin1String("Size");
+        if ((sorting & 3) == QDir::Unsorted) type = QLatin1String("Unsorted");
+
+        QStringList flags;
+        if (sorting & QDir::DirsFirst) flags << QLatin1String("DirsFirst");
+        if (sorting & QDir::DirsLast) flags << QLatin1String("DirsLast");
+        if (sorting & QDir::IgnoreCase) flags << QLatin1String("IgnoreCase");
+        if (sorting & QDir::LocaleAware) flags << QLatin1String("LocaleAware");
+        if (sorting & QDir::Type) flags << QLatin1String("Type");
+        debug << "QDir::SortFlags(" << qPrintable(type)
+              << "|"
+              << qPrintable(flags.join(QLatin1String("|"))) << ")";
+    }
+    return debug;
+}
+
+QDebug operator<<(QDebug debug, const QDir &dir)
+{
+    debug.maybeSpace() << "QDir(" << dir.path()
+                       << ", nameFilters = {"
+                       << qPrintable(dir.nameFilters().join(QLatin1String(",")))
+                       << "}, "
+                       << dir.sorting()
+                       << ","
+                       << dir.filter()
+                       << ")";
+    return debug.space();
+}
+
+
+
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qdir.h b/src/corelib/io/qdir.h
new file mode 100644
index 0000000..c4f6b1a
--- /dev/null
+++ b/src/corelib/io/qdir.h
@@ -0,0 +1,264 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDIR_H
+#define QDIR_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qfileinfo.h>
+#include <QtCore/qstringlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QDirPrivate;
+
+class Q_CORE_EXPORT QDir
+{
+protected:
+    QDirPrivate *d_ptr;
+private:
+    Q_DECLARE_PRIVATE(QDir)
+public:
+    enum Filter { Dirs        = 0x001,
+                  Files       = 0x002,
+                  Drives      = 0x004,
+                  NoSymLinks  = 0x008,
+                  AllEntries  = Dirs | Files | Drives,
+                  TypeMask    = 0x00f,
+#ifdef QT3_SUPPORT
+                  All         = AllEntries,
+#endif
+
+                  Readable    = 0x010,
+                  Writable    = 0x020,
+                  Executable  = 0x040,
+                  PermissionMask    = 0x070,
+#ifdef QT3_SUPPORT
+                  RWEMask     = 0x070,
+#endif
+
+                  Modified    = 0x080,
+                  Hidden      = 0x100,
+                  System      = 0x200,
+                 
+                  AccessMask  = 0x3F0,
+
+                  AllDirs       = 0x400,
+                  CaseSensitive = 0x800,
+                  NoDotAndDotDot = 0x1000,
+
+                  NoFilter = -1
+#ifdef QT3_SUPPORT
+                  ,DefaultFilter = NoFilter
+#endif
+    };
+    Q_DECLARE_FLAGS(Filters, Filter)
+#ifdef QT3_SUPPORT
+    typedef Filters FilterSpec;
+#endif
+
+    enum SortFlag { Name        = 0x00,
+                    Time        = 0x01,
+                    Size        = 0x02,
+                    Unsorted    = 0x03,
+                    SortByMask  = 0x03,
+
+                    DirsFirst   = 0x04,
+                    Reversed    = 0x08,
+                    IgnoreCase  = 0x10,
+                    DirsLast    = 0x20,
+                    LocaleAware = 0x40, 
+                    Type        = 0x80,
+                    NoSort = -1
+#ifdef QT3_SUPPORT
+                  ,DefaultSort = NoSort
+#endif
+    };
+    Q_DECLARE_FLAGS(SortFlags, SortFlag)
+
+    QDir(const QDir &);
+    QDir(const QString &path = QString());
+    QDir(const QString &path, const QString &nameFilter,
+         SortFlags sort = SortFlags(Name | IgnoreCase), Filters filter = AllEntries);
+    ~QDir();
+
+    QDir &operator=(const QDir &);
+    QDir &operator=(const QString &path);
+
+    void setPath(const QString &path);
+    QString path() const;
+    QString absolutePath() const;
+    QString canonicalPath() const;
+
+    static void addResourceSearchPath(const QString &path);
+
+    static void setSearchPaths(const QString &prefix, const QStringList &searchPaths);
+    static void addSearchPath(const QString &prefix, const QString &path);
+    static QStringList searchPaths(const QString &prefix);
+
+    QString dirName() const;
+    QString filePath(const QString &fileName) const;
+    QString absoluteFilePath(const QString &fileName) const;
+    QString relativeFilePath(const QString &fileName) const;
+
+#ifdef QT_DEPRECATED
+    QT_DEPRECATED static QString convertSeparators(const QString &pathName);
+#endif
+    static QString toNativeSeparators(const QString &pathName);
+    static QString fromNativeSeparators(const QString &pathName);
+
+    bool cd(const QString &dirName);
+    bool cdUp();
+
+    QStringList nameFilters() const;
+    void setNameFilters(const QStringList &nameFilters);
+
+    Filters filter() const;
+    void setFilter(Filters filter);
+    SortFlags sorting() const;
+    void setSorting(SortFlags sort);
+
+    uint count() const;
+    QString operator[](int) const;
+
+    static QStringList nameFiltersFromString(const QString &nameFilter);
+
+    QStringList entryList(Filters filters = NoFilter, SortFlags sort = NoSort) const;
+    QStringList entryList(const QStringList &nameFilters, Filters filters = NoFilter,
+                          SortFlags sort = NoSort) const;
+
+    QFileInfoList entryInfoList(Filters filters = NoFilter, SortFlags sort = NoSort) const;
+    QFileInfoList entryInfoList(const QStringList &nameFilters, Filters filters = NoFilter,
+                                SortFlags sort = NoSort) const;
+
+    bool mkdir(const QString &dirName) const;
+    bool rmdir(const QString &dirName) const;
+    bool mkpath(const QString &dirPath) const;
+    bool rmpath(const QString &dirPath) const;
+
+    bool isReadable() const;
+    bool exists() const;
+    bool isRoot() const;
+
+    static bool isRelativePath(const QString &path);
+    inline static bool isAbsolutePath(const QString &path) { return !isRelativePath(path); }
+    bool isRelative() const;
+    inline bool isAbsolute() const { return !isRelative(); }
+    bool makeAbsolute();
+
+    bool operator==(const QDir &dir) const;
+    inline bool operator!=(const QDir &dir) const {  return !operator==(dir); }
+
+    bool remove(const QString &fileName);
+    bool rename(const QString &oldName, const QString &newName);
+    bool exists(const QString &name) const;
+
+    static QFileInfoList drives();
+
+    static QChar separator();
+
+    static bool setCurrent(const QString &path);
+    static inline QDir current() { return QDir(currentPath()); }
+    static QString currentPath();
+
+    static inline QDir home() { return QDir(homePath()); }
+    static QString homePath();
+    static inline QDir root() { return QDir(rootPath()); }
+    static QString rootPath();
+    static inline QDir temp() { return QDir(tempPath()); }
+    static QString tempPath();
+
+#ifndef QT_NO_REGEXP
+    static bool match(const QStringList &filters, const QString &fileName);
+    static bool match(const QString &filter, const QString &fileName);
+#endif
+    static QString cleanPath(const QString &path);
+    void refresh() const;
+
+#ifdef QT3_SUPPORT
+    typedef SortFlags SortSpec;
+    inline QT3_SUPPORT QString absPath() const { return absolutePath(); }
+    inline QT3_SUPPORT QString absFilePath(const QString &fileName, bool acceptAbsPath = true) const
+       { Q_UNUSED(acceptAbsPath); return absoluteFilePath(fileName); }
+    QT3_SUPPORT bool matchAllDirs() const;
+    QT3_SUPPORT void setMatchAllDirs(bool on);
+    inline QT3_SUPPORT QStringList entryList(const QString &nameFilter, Filters filters = NoFilter,
+                                           SortFlags sort = NoSort) const
+    { return entryList(nameFiltersFromString(nameFilter), filters, sort); }
+    inline QT3_SUPPORT QFileInfoList entryInfoList(const QString &nameFilter,
+                                                 Filters filters = NoFilter,
+                                                 SortFlags sort = NoSort) const
+    { return entryInfoList(nameFiltersFromString(nameFilter), filters, sort); }
+
+    QT3_SUPPORT QString nameFilter() const;
+    QT3_SUPPORT void setNameFilter(const QString &nameFilter);
+
+    inline QT3_SUPPORT bool mkdir(const QString &dirName, bool acceptAbsPath) const
+        { Q_UNUSED(acceptAbsPath); return mkdir(dirName); }
+    inline QT3_SUPPORT bool rmdir(const QString &dirName, bool acceptAbsPath) const
+        { Q_UNUSED(acceptAbsPath); return rmdir(dirName); }
+
+    inline QT3_SUPPORT void convertToAbs() { makeAbsolute(); }
+    inline QT3_SUPPORT static QString currentDirPath() { return currentPath(); }
+    inline QT3_SUPPORT static QString homeDirPath() { return homePath(); }
+    inline QT3_SUPPORT static QString rootDirPath() { return rootPath(); }
+    inline QT3_SUPPORT static QString cleanDirPath(const QString &name) { return cleanPath(name); }
+#endif
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QDir::Filters)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QDir::SortFlags)
+
+#ifndef QT_NO_DEBUG_STREAM
+class QDebug;
+Q_CORE_EXPORT QDebug operator<<(QDebug debug, QDir::Filters filters);
+Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QDir &dir);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDIR_H
diff --git a/src/corelib/io/qdiriterator.cpp b/src/corelib/io/qdiriterator.cpp
new file mode 100644
index 0000000..46c7dd8
--- /dev/null
+++ b/src/corelib/io/qdiriterator.cpp
@@ -0,0 +1,559 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+/*!
+    \since 4.3
+    \class QDirIterator
+    \brief The QDirIterator class provides an iterator for directory entrylists.
+
+    You can use QDirIterator to navigate entries of a directory one at a time.
+    It is similar to QDir::entryList() and QDir::entryInfoList(), but because
+    it lists entries one at a time instead of all at once, it scales better
+    and is more suitable for large directories. It also supports listing
+    directory contents recursively, and following symbolic links. Unlike
+    QDir::entryList(), QDirIterator does not support sorting.
+
+    The QDirIterator constructor takes a QDir or a directory as
+    argument. After construction, the iterator is located before the first
+    directory entry. Here's how to iterate over all the entries sequentially:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qdiriterator.cpp 0
+
+    The next() function returns the path to the next directory entry and
+    advances the iterator. You can also call filePath() to get the current
+    file path without advancing the iterator.  The fileName() function returns
+    only the name of the file, similar to how QDir::entryList() works. You can
+    also call fileInfo() to get a QFileInfo for the current entry.
+
+    Unlike Qt's container iterators, QDirIterator is uni-directional (i.e.,
+    you cannot iterate directories in reverse order) and does not allow random
+    access.
+
+    QDirIterator works with all supported file engines, and is implemented
+    using QAbstractFileEngineIterator.
+
+    \sa QDir, QDir::entryList(), QAbstractFileEngineIterator
+*/
+
+/*! \enum QDirIterator::IteratorFlag
+
+    This enum describes flags that you can combine to configure the behavior
+    of QDirIterator.
+
+    \value NoIteratorFlags The default value, representing no flags. The
+    iterator will return entries for the assigned path.
+
+    \value Subdirectories List entries inside all subdirectories as well.
+
+    \value FollowSymlinks When combined with Subdirectories, this flag
+    enables iterating through all subdirectories of the assigned path,
+    following all symbolic links. Symbolic link loops (e.g., "link" => "." or
+    "link" => "..") are automatically detected and ignored.
+*/
+
+#include "qdiriterator.h"
+
+#include "qabstractfileengine.h"
+
+#include <QtCore/qset.h>
+#include <QtCore/qstack.h>
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDirIteratorPrivate
+{
+public:
+    QDirIteratorPrivate(const QString &path, const QStringList &nameFilters,
+                        QDir::Filters filters, QDirIterator::IteratorFlags flags);
+    ~QDirIteratorPrivate();
+
+    void pushSubDirectory(const QString &path, const QStringList &nameFilters,
+                          QDir::Filters filters);
+    void advance();
+    bool shouldFollowDirectory(const QFileInfo &);
+    bool matchesFilters(const QAbstractFileEngineIterator *it) const;
+
+    QSet<QString> visitedLinks;
+    QAbstractFileEngine *engine;
+    QStack<QAbstractFileEngineIterator *> fileEngineIterators;
+    QString path;
+    QFileInfo fileInfo;
+    QString currentFilePath;
+    QDirIterator::IteratorFlags iteratorFlags;
+    QDir::Filters filters;
+    QStringList nameFilters;
+    bool followNextDir;
+    bool first;
+    bool done;
+
+    QDirIterator *q;
+};
+
+/*!
+    \internal
+*/
+QDirIteratorPrivate::QDirIteratorPrivate(const QString &path, const QStringList &nameFilters,
+                                         QDir::Filters filters, QDirIterator::IteratorFlags flags)
+    : engine(0), path(path), iteratorFlags(flags), followNextDir(false), first(true), done(false)
+{
+    if (filters == QDir::NoFilter)
+        filters = QDir::AllEntries;
+    this->filters = filters;
+    this->nameFilters = nameFilters;
+
+    fileInfo.setFile(path);
+    pushSubDirectory(fileInfo.isSymLink() ? fileInfo.canonicalFilePath() : path,
+                     nameFilters, filters);
+}
+
+/*!
+    \internal
+*/
+QDirIteratorPrivate::~QDirIteratorPrivate()
+{
+    delete engine;
+}
+
+/*!
+    \internal
+*/
+void QDirIteratorPrivate::pushSubDirectory(const QString &path, const QStringList &nameFilters,
+                                           QDir::Filters filters)
+{
+    if (iteratorFlags & QDirIterator::FollowSymlinks) {
+        if (fileInfo.filePath() != path)
+            fileInfo.setFile(path);
+        if (fileInfo.isSymLink()) {
+            visitedLinks << fileInfo.canonicalFilePath();
+        } else {
+            visitedLinks << fileInfo.absoluteFilePath();
+        }
+    }
+    
+    if (engine || (engine = QAbstractFileEngine::create(this->path))) {
+        engine->setFileName(path);
+        QAbstractFileEngineIterator *it = engine->beginEntryList(filters, nameFilters);
+        if (it) {
+            it->setPath(path);
+            fileEngineIterators << it;
+        } else {
+            // No iterator; no entry list.
+        }
+    }
+}
+
+/*!
+    \internal
+*/
+void QDirIteratorPrivate::advance()
+{
+    // Store the current entry
+    if (!fileEngineIterators.isEmpty())
+        currentFilePath = fileEngineIterators.top()->currentFilePath();
+
+    // Advance to the next entry
+    if (followNextDir) {
+        // Start by navigating into the current directory.
+        followNextDir = false;
+
+        QAbstractFileEngineIterator *it = fileEngineIterators.top();
+
+        QString subDir = it->currentFilePath();
+#ifdef Q_OS_WIN
+        if (fileInfo.isSymLink())
+            subDir = fileInfo.canonicalFilePath();
+#endif
+        pushSubDirectory(subDir, it->nameFilters(), it->filters());
+    }
+
+    while (!fileEngineIterators.isEmpty()) {
+        QAbstractFileEngineIterator *it = fileEngineIterators.top();
+
+        // Find the next valid iterator that matches the filters.
+        bool foundDirectory = false;
+        while (it->hasNext()) {
+            it->next();
+            if (matchesFilters(it)) {
+                fileInfo = it->currentFileInfo();
+                // Signal that we want to follow this entry.
+                followNextDir = shouldFollowDirectory(fileInfo);
+                
+                //We found a matching entry.
+                return;
+
+            } else if (iteratorFlags & QDirIterator::Subdirectories) {
+                QFileInfo fileInfo = it->currentFileInfo();
+                if (!shouldFollowDirectory(fileInfo))
+                    continue;
+                QString subDir = it->currentFilePath();
+#ifdef Q_OS_WIN
+                if (fileInfo.isSymLink())
+                    subDir = fileInfo.canonicalFilePath();
+#endif
+                pushSubDirectory(subDir, it->nameFilters(), it->filters());
+                
+                foundDirectory = true;
+                break;
+            }
+        }
+        if (!foundDirectory)
+            delete fileEngineIterators.pop();
+    }
+    done = true;
+}
+
+/*!
+    \internal
+ */
+bool QDirIteratorPrivate::shouldFollowDirectory(const QFileInfo &fileInfo)
+{
+    // If we're doing flat iteration, we're done.
+    if (!(iteratorFlags & QDirIterator::Subdirectories))
+        return false;
+    
+    // Never follow non-directory entries
+    if (!fileInfo.isDir())
+        return false;
+
+
+    // Never follow . and ..
+    if (fileInfo.fileName() == QLatin1String(".") || fileInfo.fileName() == QLatin1String(".."))
+        return false;
+
+      
+    // Check symlinks
+    if (fileInfo.isSymLink() && !(iteratorFlags & QDirIterator::FollowSymlinks)) {
+        // Follow symlinks only if FollowSymlinks was passed
+        return false;
+    }
+
+    // Stop link loops
+    if (visitedLinks.contains(fileInfo.canonicalFilePath()))
+        return false;
+    
+    return true;
+}
+    
+
+/*!
+    \internal
+
+    This convenience function implements the iterator's filtering logics and
+    applies then to the current directory entry.
+
+    It returns true if the current entry matches the filters (i.e., the
+    current entry will be returned as part of the directory iteration);
+    otherwise, false is returned.
+*/
+bool QDirIteratorPrivate::matchesFilters(const QAbstractFileEngineIterator *it) const
+{
+    const bool filterPermissions = ((filters & QDir::PermissionMask)
+                                    && (filters & QDir::PermissionMask) != QDir::PermissionMask);
+    const bool skipDirs     = !(filters & (QDir::Dirs | QDir::AllDirs));
+    const bool skipFiles    = !(filters & QDir::Files);
+    const bool skipSymlinks = (filters & QDir::NoSymLinks);
+    const bool doReadable   = !filterPermissions || (filters & QDir::Readable);
+    const bool doWritable   = !filterPermissions || (filters & QDir::Writable);
+    const bool doExecutable = !filterPermissions || (filters & QDir::Executable);
+    const bool includeHidden = (filters & QDir::Hidden);
+    const bool includeSystem = (filters & QDir::System);
+
+#ifndef QT_NO_REGEXP
+    // Prepare name filters
+    QList<QRegExp> regexps;
+    bool hasNameFilters = !nameFilters.isEmpty() && !(nameFilters.contains(QLatin1String("*")));
+    if (hasNameFilters) {
+        for (int i = 0; i < nameFilters.size(); ++i) {
+            regexps << QRegExp(nameFilters.at(i),
+                               (filters & QDir::CaseSensitive) ? Qt::CaseSensitive : Qt::CaseInsensitive,
+                               QRegExp::Wildcard);
+        }
+    }
+#endif
+
+    QString fileName = it->currentFileName();
+    if (fileName.isEmpty()) {
+        // invalid entry
+        return false;
+    }
+
+    QFileInfo fi = it->currentFileInfo();
+    QString filePath = it->currentFilePath();
+
+#ifndef QT_NO_REGEXP
+    // Pass all entries through name filters, except dirs if the AllDirs
+    // filter is passed.
+    if (hasNameFilters && !((filters & QDir::AllDirs) && fi.isDir())) {
+        bool matched = false;
+        for (int i = 0; i < regexps.size(); ++i) {
+            if (regexps.at(i).exactMatch(fileName)) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+#endif
+    
+    bool dotOrDotDot = (fileName == QLatin1String(".") || fileName == QLatin1String(".."));
+    if ((filters & QDir::NoDotAndDotDot) && dotOrDotDot)
+        return false;
+
+    bool isHidden = !dotOrDotDot && fi.isHidden();
+    if (!includeHidden && isHidden)
+        return false;
+
+    bool isSystem = (!fi.isFile() && !fi.isDir() && !fi.isSymLink())
+                    || (!fi.exists() && fi.isSymLink());
+    if (!includeSystem && isSystem)
+        return false;
+
+    bool alwaysShow = (filters & QDir::TypeMask) == 0
+        && ((isHidden && includeHidden)
+            || (includeSystem && isSystem));
+
+    // Skip files and directories
+    if ((filters & QDir::AllDirs) == 0 && skipDirs && fi.isDir()) {
+        if (!alwaysShow)
+            return false;
+    }
+
+    if ((skipFiles && (fi.isFile() || !fi.exists()))
+        || (skipSymlinks && fi.isSymLink())) {
+        if (!alwaysShow)
+            return false;
+    }
+
+    if (filterPermissions
+        && ((doReadable && !fi.isReadable())
+            || (doWritable && !fi.isWritable())
+            || (doExecutable && !fi.isExecutable()))) {
+        return false;
+    }
+
+    if (!includeSystem && !dotOrDotDot && ((fi.exists() && !fi.isFile() && !fi.isDir() && !fi.isSymLink())
+                                           || (!fi.exists() && fi.isSymLink()))) {
+        return false;
+    }
+    
+    return true;
+}
+
+/*!
+    Constructs a QDirIterator that can iterate over \a dir's entrylist, using
+    \a dir's name filters and regular filters. You can pass options via \a
+    flags to decide how the directory should be iterated.
+
+    By default, \a flags is NoIteratorFlags, which provides the same behavior
+    as in QDir::entryList().
+
+    The sorting in \a dir is ignored.
+
+    \note To list symlinks that point to non existing files, QDir::System must be
+     passed to the flags.
+
+    \sa hasNext(), next(), IteratorFlags
+*/
+QDirIterator::QDirIterator(const QDir &dir, IteratorFlags flags)
+    : d(new QDirIteratorPrivate(dir.path(), dir.nameFilters(), dir.filter(), flags))
+{
+    d->q = this;
+}
+
+/*!
+    Constructs a QDirIterator that can iterate over \a path, with no name
+    filtering and \a filters for entry filtering. You can pass options via \a
+    flags to decide how the directory should be iterated.
+
+    By default, \a filters is QDir::NoFilter, and \a flags is NoIteratorFlags,
+    which provides the same behavior as in QDir::entryList().
+
+    \note To list symlinks that point to non existing files, QDir::System must be
+     passed to the flags.
+
+    \warning This constructor expects \a flags to be left at its default value. Use
+             the constructors that do not take the \a filters argument instead.
+
+    \sa hasNext(), next(), IteratorFlags
+*/
+QDirIterator::QDirIterator(const QString &path, QDir::Filters filters, IteratorFlags flags)
+    : d(new QDirIteratorPrivate(path, QStringList(QLatin1String("*")), filters, flags))
+{
+    d->q = this;
+}
+
+/*!
+    Constructs a QDirIterator that can iterate over \a path. You can pass
+    options via \a flags to decide how the directory should be iterated.
+
+    By default, \a flags is NoIteratorFlags, which provides the same behavior
+    as in QDir::entryList().
+
+    \note To list symlinks that point to non existing files, QDir::System must be
+     passed to the flags.
+
+    \sa hasNext(), next(), IteratorFlags
+*/
+QDirIterator::QDirIterator(const QString &path, IteratorFlags flags)
+    : d(new QDirIteratorPrivate(path, QStringList(QLatin1String("*")), QDir::NoFilter, flags))
+{
+    d->q = this;
+}
+
+/*!
+    Constructs a QDirIterator that can iterate over \a path, using \a
+    nameFilters and \a filters. You can pass options via \a flags to decide
+    how the directory should be iterated.
+
+    By default, \a flags is NoIteratorFlags, which provides the same behavior
+    as QDir::entryList().
+
+    \note To list symlinks that point to non existing files, QDir::System must be
+     passed to the flags.
+
+    \warning This constructor expects \c flags to be left at its default value. Use the
+             constructors that do not take the \a filters argument instead. 
+
+    \sa hasNext(), next(), IteratorFlags
+*/
+QDirIterator::QDirIterator(const QString &path, const QStringList &nameFilters,
+                           QDir::Filters filters, IteratorFlags flags)
+    : d(new QDirIteratorPrivate(path, nameFilters, filters, flags))
+{
+    d->q = this;
+}
+
+/*!
+    Destroys the QDirIterator.
+*/
+QDirIterator::~QDirIterator()
+{
+    qDeleteAll(d->fileEngineIterators);
+    delete d;
+}
+
+/*!
+    Advances the iterator to the next entry, and returns the file path of this
+    new entry. If hasNext() returns false, this function does nothing, and
+    returns a null QString.
+
+    You can call fileName() or filePath() to get the current entry file name
+    or path, or fileInfo() to get a QFileInfo for the current entry.
+
+    \sa hasNext(), fileName(), filePath(), fileInfo()
+*/
+QString QDirIterator::next()
+{
+    if (!hasNext())
+        return QString();
+    d->advance();
+    return filePath();
+}
+
+/*!
+    Returns true if there is at least one more entry in the directory;
+    otherwise, false is returned.
+
+    \sa next(), fileName(), filePath(), fileInfo()
+*/
+bool QDirIterator::hasNext() const
+{
+    if (d->first) {
+        d->first = false;
+        d->advance();
+    }
+    return !d->done;
+}
+
+/*!
+    Returns the file name for the current directory entry, without the path
+    prepended. If the current entry is invalid (i.e., isValid() returns
+    false), a null QString is returned.
+
+    This function is provided for the convenience when iterating single
+    directories. For recursive iteration, you should call filePath() or
+    fileInfo() instead.
+    
+    \sa filePath(), fileInfo()
+*/
+QString QDirIterator::fileName() const
+{
+    if (d->fileInfo.path() != d->currentFilePath)
+        d->fileInfo.setFile(d->currentFilePath);
+    return d->fileInfo.fileName();
+}
+
+/*!
+    Returns the full file path for the current directory entry. If the current
+    entry is invalid (i.e., isValid() returns false), a null QString is
+    returned.
+
+    \sa fileInfo(), fileName()
+*/
+QString QDirIterator::filePath() const
+{
+    return d->currentFilePath;
+}
+
+/*!
+    Returns a QFileInfo for the current directory entry. If the current entry
+    is invalid (i.e., isValid() returns false), a null QFileInfo is returned.
+
+    \sa filePath(), fileName()
+*/
+QFileInfo QDirIterator::fileInfo() const
+{
+    if (d->fileInfo.filePath() != d->currentFilePath)
+        d->fileInfo.setFile(d->currentFilePath);
+    return d->fileInfo;
+}
+
+/*!
+    Returns the base directory of the iterator.
+*/
+QString QDirIterator::path() const
+{
+    return d->path;
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qdiriterator.h b/src/corelib/io/qdiriterator.h
new file mode 100644
index 0000000..540ad4f
--- /dev/null
+++ b/src/corelib/io/qdiriterator.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDIRITERATOR_H
+#define QDIRITERATOR_H
+
+#include <QtCore/qdir.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QDirIteratorPrivate;
+class Q_CORE_EXPORT QDirIterator {
+public:
+    enum IteratorFlag {
+        NoIteratorFlags = 0x0,
+        FollowSymlinks = 0x1,
+        Subdirectories = 0x2
+    };
+    Q_DECLARE_FLAGS(IteratorFlags, IteratorFlag)
+
+    QDirIterator(const QDir &dir, IteratorFlags flags = NoIteratorFlags);
+    QDirIterator(const QString &path,
+                 IteratorFlags flags = NoIteratorFlags);
+    QDirIterator(const QString &path,
+                 QDir::Filters filter,
+                 IteratorFlags flags = NoIteratorFlags);
+    QDirIterator(const QString &path,
+                 const QStringList &nameFilters,
+                 QDir::Filters filters = QDir::NoFilter,
+                 IteratorFlags flags = NoIteratorFlags);
+
+    virtual ~QDirIterator();
+
+    QString next();
+    bool hasNext() const;
+
+    QString fileName() const;
+    QString filePath() const;
+    QFileInfo fileInfo() const;
+    QString path() const;
+
+private:
+    Q_DISABLE_COPY(QDirIterator)
+
+    QDirIteratorPrivate *d;
+    friend class QDir;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QDirIterator::IteratorFlags)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/io/qfile.cpp b/src/corelib/io/qfile.cpp
new file mode 100644
index 0000000..d8f08c9
--- /dev/null
+++ b/src/corelib/io/qfile.cpp
@@ -0,0 +1,1638 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qdebug.h"
+#include "qfile.h"
+#include "qfsfileengine.h"
+#include "qtemporaryfile.h"
+#include "qlist.h"
+#include "qfileinfo.h"
+#include "private/qiodevice_p.h"
+#include "private/qfile_p.h"
+#if defined(QT_BUILD_CORE_LIB)
+# include "qcoreapplication.h"
+#endif
+
+#if !defined(Q_OS_WINCE)
+#include <errno.h>
+#endif
+
+#ifdef QT_NO_QOBJECT
+#define tr(X) QString::fromLatin1(X)
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static const int QFILE_WRITEBUFFER_SIZE = 16384;
+
+static QByteArray locale_encode(const QString &f)
+{
+#ifndef Q_OS_DARWIN
+    return f.toLocal8Bit();
+#else
+    // Mac always expects UTF-8... and decomposed...
+    return f.normalized(QString::NormalizationForm_D).toUtf8();
+#endif
+}
+
+static QString locale_decode(const QByteArray &f)
+{
+#ifndef Q_OS_DARWIN
+    return QString::fromLocal8Bit(f);
+#else
+    // Mac always gives us UTF-8 and decomposed, we want that composed...
+    return QString::fromUtf8(f).normalized(QString::NormalizationForm_C);
+#endif
+}
+
+//************* QFilePrivate
+QFile::EncoderFn QFilePrivate::encoder = locale_encode;
+QFile::DecoderFn QFilePrivate::decoder = locale_decode;
+
+QFilePrivate::QFilePrivate()
+    : fileEngine(0), lastWasWrite(false),
+      writeBuffer(QFILE_WRITEBUFFER_SIZE), error(QFile::NoError)
+{
+}
+
+QFilePrivate::~QFilePrivate()
+{
+    delete fileEngine;
+    fileEngine = 0;
+}
+
+bool
+QFilePrivate::openExternalFile(int flags, int fd)
+{
+#ifdef QT_NO_FSFILEENGINE
+    Q_UNUSED(flags);
+    Q_UNUSED(fd);
+    return false;
+#else
+    delete fileEngine;
+    QFSFileEngine *fe = new QFSFileEngine;
+    fe->setFileName(fileName);
+    fileEngine = fe;
+    return fe->open(QIODevice::OpenMode(flags), fd);
+#endif
+}
+
+bool
+QFilePrivate::openExternalFile(int flags, FILE *fh)
+{
+#ifdef QT_NO_FSFILEENGINE
+    Q_UNUSED(flags);
+    Q_UNUSED(fh);
+    return false;
+#else
+    delete fileEngine;
+    QFSFileEngine *fe = new QFSFileEngine;
+    fe->setFileName(fileName);
+    fileEngine = fe;
+    return fe->open(QIODevice::OpenMode(flags), fh);
+#endif
+}
+
+inline bool QFilePrivate::ensureFlushed() const
+{
+    // This function ensures that the write buffer has been flushed (const
+    // because certain const functions need to call it.
+    if (lastWasWrite) {
+        const_cast<QFilePrivate *>(this)->lastWasWrite = false;
+        if (!const_cast<QFile *>(q_func())->flush())
+            return false;
+    }
+    return true;
+}
+
+void
+QFilePrivate::setError(QFile::FileError err)
+{
+    error = err;
+    errorString.clear();
+}
+
+void
+QFilePrivate::setError(QFile::FileError err, const QString &errStr)
+{
+    Q_Q(QFile);
+    error = err;
+    q->setErrorString(errStr);
+}
+
+void
+QFilePrivate::setError(QFile::FileError err, int errNum)
+{
+    Q_Q(QFile);
+    error = err;
+    q->setErrorString(qt_error_string(errNum));
+}
+
+//************* QFile
+
+/*!
+    \class QFile
+    \brief The QFile class provides an interface for reading from and writing to files.
+
+    \ingroup io
+    \mainclass
+    \reentrant
+
+    QFile is an I/O device for reading and writing text and binary
+    files and \l{The Qt Resource System}{resources}. A QFile may be
+    used by itself or, more conveniently, with a QTextStream or
+    QDataStream.
+
+    The file name is usually passed in the constructor, but it can be
+    set at any time using setFileName(). QFile expects the file
+    separator to be '/' regardless of operating system. The use of
+    other separators (e.g., '\\') is not supported.
+
+    You can check for a file's existence using exists(), and remove a
+    file using remove(). (More advanced file system related operations
+    are provided by QFileInfo and QDir.)
+
+    The file is opened with open(), closed with close(), and flushed
+    with flush(). Data is usually read and written using QDataStream
+    or QTextStream, but you can also call the QIODevice-inherited
+    functions read(), readLine(), readAll(), write(). QFile also
+    inherits getChar(), putChar(), and ungetChar(), which work one
+    character at a time.
+
+    The size of the file is returned by size(). You can get the
+    current file position using pos(), or move to a new file position
+    using seek(). If you've reached the end of the file, atEnd()
+    returns true.
+
+    \section1 Reading Files Directly
+
+    The following example reads a text file line by line:
+
+    \snippet doc/src/snippets/file/file.cpp 0
+
+    The QIODevice::Text flag passed to open() tells Qt to convert
+    Windows-style line terminators ("\\r\\n") into C++-style
+    terminators ("\\n"). By default, QFile assumes binary, i.e. it
+    doesn't perform any conversion on the bytes stored in the file.
+
+    \section1 Using Streams to Read Files
+
+    The next example uses QTextStream to read a text file
+    line by line:
+
+    \snippet doc/src/snippets/file/file.cpp 1
+
+    QTextStream takes care of converting the 8-bit data stored on
+    disk into a 16-bit Unicode QString. By default, it assumes that
+    the user system's local 8-bit encoding is used (e.g., ISO 8859-1
+    for most of Europe; see QTextCodec::codecForLocale() for
+    details). This can be changed using setCodec().
+
+    To write text, we can use operator<<(), which is overloaded to
+    take a QTextStream on the left and various data types (including
+    QString) on the right:
+
+    \snippet doc/src/snippets/file/file.cpp 2
+
+    QDataStream is similar, in that you can use operator<<() to write
+    data and operator>>() to read it back. See the class
+    documentation for details.
+
+    When you use QFile, QFileInfo, and QDir to access the file system
+    with Qt, you can use Unicode file names. On Unix, these file
+    names are converted to an 8-bit encoding. If you want to use
+    standard C++ APIs (\c <cstdio> or \c <iostream>) or
+    platform-specific APIs to access files instead of QFile, you can
+    use the encodeName() and decodeName() functions to convert
+    between Unicode file names and 8-bit file names.
+
+    On Unix, there are some special system files (e.g. in \c /proc) for which
+    size() will always return 0, yet you may still be able to read more data
+    from such a file; the data is generated in direct response to you calling
+    read(). In this case, however, you cannot use atEnd() to determine if
+    there is more data to read (since atEnd() will return true for a file that
+    claims to have size 0). Instead, you should either call readAll(), or call
+    read() or readLine() repeatedly until no more data can be read. The next
+    example uses QTextStream to read \c /proc/modules line by line:
+
+    \snippet doc/src/snippets/file/file.cpp 3
+
+    \section1 Signals
+
+    Unlike other QIODevice implementations, such as QTcpSocket, QFile does not
+    emit the aboutToClose(), bytesWritten(), or readyRead() signals. This
+    implementation detail means that QFile is not suitable for reading and
+    writing certain types of files, such as device files on Unix platforms.
+
+    \section1 Platform Specific Issues
+
+    File permissions are handled differently on Linux/Mac OS X and
+    Windows.  In a non \l{QIODevice::isWritable()}{writable}
+    directory on Linux, files cannot be created. This is not always
+    the case on Windows, where, for instance, the 'My Documents'
+    directory usually is not writable, but it is still possible to
+    create files in it.
+
+    \sa QTextStream, QDataStream, QFileInfo, QDir, {The Qt Resource System}
+*/
+
+/*!
+    \enum QFile::FileError
+
+    This enum describes the errors that may be returned by the error()
+    function.
+
+    \value NoError          No error occurred.
+    \value ReadError        An error occurred when reading from the file.
+    \value WriteError       An error occurred when writing to the file.
+    \value FatalError       A fatal error occurred.
+    \value ResourceError
+    \value OpenError        The file could not be opened.
+    \value AbortError       The operation was aborted.
+    \value TimeOutError     A timeout occurred.
+    \value UnspecifiedError An unspecified error occurred.
+    \value RemoveError      The file could not be removed.
+    \value RenameError      The file could not be renamed.
+    \value PositionError    The position in the file could not be changed.
+    \value ResizeError      The file could not be resized.
+    \value PermissionsError The file could not be accessed.
+    \value CopyError        The file could not be copied.
+
+    \omitvalue ConnectError
+*/
+
+/*!
+    \enum QFile::Permission
+
+    This enum is used by the permission() function to report the
+    permissions and ownership of a file. The values may be OR-ed
+    together to test multiple permissions and ownership values.
+
+    \value ReadOwner The file is readable by the owner of the file.
+    \value WriteOwner The file is writable by the owner of the file.
+    \value ExeOwner The file is executable by the owner of the file.
+    \value ReadUser The file is readable by the user.
+    \value WriteUser The file is writable by the user.
+    \value ExeUser The file is executable by the user.
+    \value ReadGroup The file is readable by the group.
+    \value WriteGroup The file is writable by the group.
+    \value ExeGroup The file is executable by the group.
+    \value ReadOther The file is readable by anyone.
+    \value WriteOther The file is writable by anyone.
+    \value ExeOther The file is executable by anyone.
+
+    \warning Because of differences in the platforms supported by Qt,
+    the semantics of ReadUser, WriteUser and ExeUser are
+    platform-dependent: On Unix, the rights of the owner of the file
+    are returned and on Windows the rights of the current user are
+    returned. This behavior might change in a future Qt version.
+
+    Note that Qt does not by default check for permissions on NTFS
+    file systems, as this may decrease the performance of file
+    handling considerably. It is possible to force permission checking
+    on NTFS by including the following code in your source:
+
+    \snippet doc/src/snippets/ntfsp.cpp 0
+
+    Permission checking is then turned on and off by incrementing and
+    decrementing \c qt_ntfs_permission_lookup by 1.
+
+    \snippet doc/src/snippets/ntfsp.cpp 1
+*/
+
+#ifdef QT3_SUPPORT
+/*!
+    \typedef QFile::PermissionSpec
+
+    Use QFile::Permission instead.
+*/
+#endif
+
+#ifdef QT_NO_QOBJECT
+QFile::QFile()
+    : QIODevice(*new QFilePrivate)
+{
+}
+QFile::QFile(const QString &name)
+    : QIODevice(*new QFilePrivate)
+{
+    d_func()->fileName = name;
+}
+QFile::QFile(QFilePrivate &dd)
+    : QIODevice(dd)
+{
+}
+#else
+/*!
+    \internal
+*/
+QFile::QFile()
+    : QIODevice(*new QFilePrivate, 0)
+{
+}
+/*!
+    Constructs a new file object with the given \a parent.
+*/
+QFile::QFile(QObject *parent)
+    : QIODevice(*new QFilePrivate, parent)
+{
+}
+/*!
+    Constructs a new file object to represent the file with the given \a name.
+*/
+QFile::QFile(const QString &name)
+    : QIODevice(*new QFilePrivate, 0)
+{
+    Q_D(QFile);
+    d->fileName = name;
+}
+/*!
+    Constructs a new file object with the given \a parent to represent the
+    file with the specified \a name.
+*/
+QFile::QFile(const QString &name, QObject *parent)
+    : QIODevice(*new QFilePrivate, parent)
+{
+    Q_D(QFile);
+    d->fileName = name;
+}
+/*!
+    \internal
+*/
+QFile::QFile(QFilePrivate &dd, QObject *parent)
+    : QIODevice(dd, parent)
+{
+}
+#endif
+
+/*!
+    Destroys the file object, closing it if necessary.
+*/
+QFile::~QFile()
+{
+    close();
+#ifdef QT_NO_QOBJECT
+    delete d_ptr;
+#endif
+}
+
+/*!
+    Returns the name set by setFileName() or to the QFile
+    constructors.
+
+    \sa setFileName(), QFileInfo::fileName()
+*/
+QString QFile::fileName() const
+{
+    return fileEngine()->fileName(QAbstractFileEngine::DefaultName);
+}
+
+/*!
+    Sets the \a name of the file. The name can have no path, a
+    relative path, or an absolute path.
+
+    Do not call this function if the file has already been opened.
+
+    If the file name has no path or a relative path, the path used
+    will be the application's current directory path
+    \e{at the time of the open()} call.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 0
+
+    Note that the directory separator "/" works for all operating
+    systems supported by Qt.
+
+    \sa fileName(), QFileInfo, QDir
+*/
+void
+QFile::setFileName(const QString &name)
+{
+    Q_D(QFile);
+    if (isOpen()) {
+        qWarning("QFile::setFileName: File (%s) is already opened",
+                 qPrintable(fileName()));
+        close();
+    }
+    if(d->fileEngine) { //get a new file engine later
+        delete d->fileEngine;
+        d->fileEngine = 0;
+    }
+    d->fileName = name;
+}
+
+/*!
+    \fn QString QFile::decodeName(const char *localFileName)
+
+    \overload
+
+    Returns the Unicode version of the given \a localFileName. See
+    encodeName() for details.
+*/
+
+/*!
+    By default, this function converts \a fileName to the local 8-bit
+    encoding determined by the user's locale. This is sufficient for
+    file names that the user chooses. File names hard-coded into the
+    application should only use 7-bit ASCII filename characters.
+
+    \sa decodeName() setEncodingFunction()
+*/
+
+QByteArray
+QFile::encodeName(const QString &fileName)
+{
+    return (*QFilePrivate::encoder)(fileName);
+}
+
+/*!
+    \typedef QFile::EncoderFn
+
+    This is a typedef for a pointer to a function with the following
+    signature:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 1
+
+    \sa setEncodingFunction(), encodeName()
+*/
+
+/*!
+    This does the reverse of QFile::encodeName() using \a localFileName.
+
+    \sa setDecodingFunction(), encodeName()
+*/
+
+QString
+QFile::decodeName(const QByteArray &localFileName)
+{
+    return (*QFilePrivate::decoder)(localFileName);
+}
+
+/*!
+    \fn void QFile::setEncodingFunction(EncoderFn function)
+
+    \nonreentrant
+
+    Sets the \a function for encoding Unicode file names. The
+    default encodes in the locale-specific 8-bit encoding.
+
+    \sa encodeName(), setDecodingFunction()
+*/
+
+void
+QFile::setEncodingFunction(EncoderFn f)
+{
+    if (!f)
+        f = locale_encode;
+    QFilePrivate::encoder = f;
+}
+
+/*!
+    \typedef QFile::DecoderFn
+
+    This is a typedef for a pointer to a function with the following
+    signature:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 2
+
+    \sa setDecodingFunction()
+*/
+
+/*!
+    \fn void QFile::setDecodingFunction(DecoderFn function)
+
+    \nonreentrant
+
+    Sets the \a function for decoding 8-bit file names. The
+    default uses the locale-specific 8-bit encoding.
+
+    \sa setEncodingFunction(), decodeName()
+*/
+
+void
+QFile::setDecodingFunction(DecoderFn f)
+{
+    if (!f)
+        f = locale_decode;
+    QFilePrivate::decoder = f;
+}
+
+/*!
+    \overload
+
+    Returns true if the file specified by fileName() exists; otherwise
+    returns false.
+
+    \sa fileName(), setFileName()
+*/
+
+bool
+QFile::exists() const
+{
+    // 0x1000000 = QAbstractFileEngine::Refresh, forcing an update
+    return (fileEngine()->fileFlags(QAbstractFileEngine::FlagsMask
+                                    | QAbstractFileEngine::FileFlag(0x1000000)) & QAbstractFileEngine::ExistsFlag);
+}
+
+/*!
+    Returns true if the file specified by \a fileName exists; otherwise
+    returns false.
+*/
+
+bool
+QFile::exists(const QString &fileName)
+{
+    return QFileInfo(fileName).exists();
+}
+
+/*!
+    \fn QString QFile::symLinkTarget() const
+    \since 4.2
+    \overload
+
+    Returns the absolute path of the file or directory a symlink (or shortcut
+    on Windows) points to, or a an empty string if the object isn't a symbolic
+    link.
+
+    This name may not represent an existing file; it is only a string.
+    QFile::exists() returns true if the symlink points to an existing file.
+
+    \sa fileName() setFileName()
+*/
+
+/*!
+    \obsolete
+
+    Use symLinkTarget() instead.
+*/
+QString
+QFile::readLink() const
+{
+    return fileEngine()->fileName(QAbstractFileEngine::LinkName);
+}
+
+/*!
+    \fn static QString QFile::symLinkTarget(const QString &fileName)
+    \since 4.2
+
+    Returns the absolute path of the file or directory referred to by the
+    symlink (or shortcut on Windows) specified by \a fileName, or returns an
+    empty string if the \a fileName does not correspond to a symbolic link.
+
+    This name may not represent an existing file; it is only a string.
+    QFile::exists() returns true if the symlink points to an existing file.
+*/
+
+/*!
+    \obsolete
+
+    Use symLinkTarget() instead.
+*/
+QString
+QFile::readLink(const QString &fileName)
+{
+    return QFileInfo(fileName).readLink();
+}
+
+/*!
+    Removes the file specified by fileName(). Returns true if successful;
+    otherwise returns false.
+
+    The file is closed before it is removed.
+
+    \sa setFileName()
+*/
+
+bool
+QFile::remove()
+{
+    Q_D(QFile);
+    if (d->fileName.isEmpty()) {
+        qWarning("QFile::remove: Empty or null file name");
+        return false;
+    }
+    close();
+    if(error() == QFile::NoError) {
+        if(fileEngine()->remove()) {
+            unsetError();
+            return true;
+        }
+#if defined(Q_OS_WIN)
+        d->setError(QFile::RemoveError, GetLastError());
+#else
+        d->setError(QFile::RemoveError, errno);
+#endif
+    }
+    return false;
+}
+
+/*!
+    \overload
+
+    Removes the file specified by the \a fileName given.
+
+    Returns true if successful; otherwise returns false.
+
+    \sa remove()
+*/
+
+bool
+QFile::remove(const QString &fileName)
+{
+    return QFile(fileName).remove();
+}
+
+/*!
+    Renames the file currently specified by fileName() to \a newName.
+    Returns true if successful; otherwise returns false.
+
+    If a file with the name \a newName already exists, rename() returns false
+    (i.e., QFile will not overwrite it).
+
+    The file is closed before it is renamed.
+
+    \sa setFileName()
+*/
+
+bool
+QFile::rename(const QString &newName)
+{
+    Q_D(QFile);
+    if (d->fileName.isEmpty()) {
+        qWarning("QFile::rename: Empty or null file name");
+        return false;
+    }
+    if (QFile(newName).exists()) {
+        // ### Race condition. If a file is moved in after this, it /will/ be
+        // overwritten. On Unix, the proper solution is to use hardlinks:
+        // return ::link(old, new) && ::remove(old);
+        d->setError(QFile::RenameError, tr("Destination file exists"));
+        return false;
+    }
+    close();
+    if(error() == QFile::NoError) {
+        if (fileEngine()->rename(newName)) {
+            unsetError();
+            return true;
+        }
+
+        QFile in(fileName());
+        QFile out(newName);
+        if (in.open(QIODevice::ReadOnly)) {
+            if (out.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+                bool error = false;
+                char block[4096];
+                qint64 read;
+                while ((read = in.read(block, sizeof(block))) > 0) {
+                    if (read != out.write(block, read)) {
+                        d->setError(QFile::RenameError, out.errorString());
+                        error = true;
+                        break;
+                    }
+                }
+                if (read == -1) {
+                    d->setError(QFile::RenameError, in.errorString());
+                    return true;
+                }
+                if(!error)
+                    in.remove();
+                return !error;
+            }
+        }
+        d->setError(QFile::RenameError, out.isOpen() ? in.errorString() : out.errorString());
+    }
+    return false;
+}
+
+/*!
+    \overload
+
+    Renames the file \a oldName to \a newName. Returns true if
+    successful; otherwise returns false.
+
+    If a file with the name \a newName already exists, rename() returns false
+    (i.e., QFile will not overwrite it).
+
+    \sa rename()
+*/
+
+bool
+QFile::rename(const QString &oldName, const QString &newName)
+{
+    return QFile(oldName).rename(newName);
+}
+
+/*!
+
+    Creates a link named \a linkName that points to the file currently specified by
+    fileName().  What a link is depends on the underlying filesystem (be it a
+    shortcut on Windows or a symbolic link on Unix). Returns true if successful;
+    otherwise returns false.
+
+    This function will not overwrite an already existing entity in the file system;
+    in this case, \c link() will return false and set \l{QFile::}{error()} to
+    return \l{QFile::}{RenameError}.
+
+    \note To create a valid link on Windows, \a linkName must have a \c{.lnk} file extension.
+
+    \sa setFileName()
+*/
+
+bool
+QFile::link(const QString &linkName)
+{
+    Q_D(QFile);
+    if (d->fileName.isEmpty()) {
+        qWarning("QFile::link: Empty or null file name");
+        return false;
+    }
+    QFileInfo fi(linkName);
+    if(fileEngine()->link(fi.absoluteFilePath())) {
+        unsetError();
+        return true;
+    }
+    d->setError(QFile::RenameError, errno);
+    return false;
+}
+
+/*!
+    \overload
+
+    Creates a link named \a linkName that points to the file \a fileName. What a link is
+    depends on the underlying filesystem (be it a shortcut on Windows
+    or a symbolic link on Unix). Returns true if successful; otherwise
+    returns false.
+
+    \sa link()
+*/
+
+bool
+QFile::link(const QString &fileName, const QString &linkName)
+{
+    return QFile(fileName).link(linkName);
+}
+
+/*!
+    Copies the file currently specified by fileName() to a file called
+    \a newName.  Returns true if successful; otherwise returns false.
+
+    Note that if a file with the name \a newName already exists,
+    copy() returns false (i.e. QFile will not overwrite it).
+
+    The source file is closed before it is copied.
+
+    \sa setFileName()
+*/
+
+bool
+QFile::copy(const QString &newName)
+{
+    Q_D(QFile);
+    if (d->fileName.isEmpty()) {
+        qWarning("QFile::copy: Empty or null file name");
+        return false;
+    }
+    if (QFile(newName).exists()) {
+        // ### Race condition. If a file is moved in after this, it /will/ be
+        // overwritten. On Unix, the proper solution is to use hardlinks:
+        // return ::link(old, new) && ::remove(old); See also rename().
+        d->setError(QFile::CopyError, tr("Destination file exists"));
+        return false;
+    }
+    close();
+    if(error() == QFile::NoError) {
+        if(fileEngine()->copy(newName)) {
+            unsetError();
+            return true;
+        } else {
+            bool error = false;
+            if(!open(QFile::ReadOnly)) {
+                error = true;
+                d->setError(QFile::CopyError, tr("Cannot open %1 for input").arg(d->fileName));
+            } else {
+                QString fileTemplate = QLatin1String("%1/qt_temp.XXXXXX");
+#ifdef QT_NO_TEMPORARYFILE
+                QFile out(fileTemplate.arg(QFileInfo(newName).path()));
+                if (!out.open(QIODevice::ReadWrite))
+                    error = true;
+#else
+                QTemporaryFile out(fileTemplate.arg(QFileInfo(newName).path()));
+                if (!out.open()) {
+                    out.setFileTemplate(fileTemplate.arg(QDir::tempPath()));
+                    if (!out.open())
+                        error = true;
+                }
+#endif
+                if (error) {
+                    out.close();
+                    d->setError(QFile::CopyError, tr("Cannot open for output"));
+                } else {
+                    char block[4096];
+                    qint64 totalRead = 0;
+                    while(!atEnd()) {
+                        qint64 in = read(block, sizeof(block));
+                        if (in <= 0)
+                            break;
+                        totalRead += in;
+                        if(in != out.write(block, in)) {
+                            d->setError(QFile::CopyError, tr("Failure to write block"));
+                            error = true;
+                            break;
+                        }
+                    }
+
+                    if (totalRead != size()) {
+                        // Unable to read from the source. The error string is
+                        // already set from read().
+                        error = true;
+                    }
+                    if (!error && !out.rename(newName)) {
+                        error = true;
+                        d->setError(QFile::CopyError, tr("Cannot create %1 for output").arg(newName));
+                    }
+#ifndef QT_NO_TEMPORARYFILE
+                    if (!error)
+                        out.setAutoRemove(false);
+#endif
+                }
+            }
+            if(!error) {
+                QFile::setPermissions(newName, permissions());
+                unsetError();
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/*!
+    \overload
+
+    Copies the file \a fileName to \a newName. Returns true if successful;
+    otherwise returns false.
+
+    If a file with the name \a newName already exists, copy() returns false
+    (i.e., QFile will not overwrite it).
+
+    \sa rename()
+*/
+
+bool
+QFile::copy(const QString &fileName, const QString &newName)
+{
+    return QFile(fileName).copy(newName);
+}
+
+/*!
+    Returns true if the file can only be manipulated sequentially;
+    otherwise returns false.
+
+    Most files support random-access, but some special files may not.
+
+    \sa QIODevice::isSequential()
+*/
+bool QFile::isSequential() const
+{
+    Q_D(const QFile);
+    return d->fileEngine && d->fileEngine->isSequential();
+}
+
+/*!
+    Opens the file using OpenMode \a mode, returning true if successful;
+    otherwise false.
+
+    The \a mode must be QIODevice::ReadOnly, QIODevice::WriteOnly, or
+    QIODevice::ReadWrite. It may also have additional flags, such as
+    QIODevice::Text and QIODevice::Unbuffered.
+
+    \note In \l{QIODevice::}{WriteOnly} or \l{QIODevice::}{ReadWrite}
+    mode, if the relevant file does not already exist, this function
+    will try to create a new file before opening it.
+
+    \note Because of limitations in the native API, QFile ignores the
+    Unbuffered flag on Windows.
+
+    \sa QIODevice::OpenMode, setFileName()
+*/
+bool QFile::open(OpenMode mode)
+{
+    Q_D(QFile);
+    if (isOpen()) {
+        qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
+        return false;
+    }
+    if (mode & Append)
+        mode |= WriteOnly;
+
+    unsetError();
+    if ((mode & (ReadOnly | WriteOnly)) == 0) {
+        qWarning("QIODevice::open: File access not specified");
+        return false;
+    }
+    if (fileEngine()->open(mode)) {
+        QIODevice::open(mode);
+        if (mode & Append)
+            seek(size());
+        return true;
+    }
+    QFile::FileError err = fileEngine()->error();
+    if(err == QFile::UnspecifiedError)
+        err = QFile::OpenError;
+    d->setError(err, fileEngine()->errorString());
+    return false;
+}
+
+/*! \fn QFile::open(OpenMode, FILE*)
+
+    Use open(FILE *, OpenMode) instead.
+*/
+
+/*!
+    \overload
+
+    Opens the existing file handle \a fh in the given \a mode.
+    Returns true if successful; otherwise returns false.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 3
+
+    When a QFile is opened using this function, close() does not actually
+    close the file, but only flushes it.
+
+    \bold{Warning:}
+    \list 1
+        \o If \a fh is \c stdin, \c stdout, or \c stderr, you may not be able
+           to seek(). See QIODevice::isSequentialAccess() for more information.
+        \o Since this function opens the file without specifying the file name,
+           you cannot use this QFile with a QFileInfo.
+    \endlist
+
+    \note For Windows CE you may not be able to call seek() and resize().
+    Also, size() is set to \c 0.
+
+    \sa close(), {qmake Variable Reference#CONFIG}{qmake Variable Reference}
+
+    \bold{Note for the Windows Platform}
+
+    \a fh must be opened in binary mode (i.e., the mode string must contain
+    'b', as in "rb" or "wb") when accessing files and other random-access
+    devices. Qt will translate the end-of-line characters if you pass
+    QIODevice::Text to \a mode. Sequential devices, such as stdin and stdout,
+    are unaffected by this limitation.
+
+    You need to enable support for console applications in order to use the
+    stdin, stdout and stderr streams at the console. To do this, add the
+    following declaration to your application's project file:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 4
+*/
+bool QFile::open(FILE *fh, OpenMode mode)
+{
+    Q_D(QFile);
+    if (isOpen()) {
+        qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
+        return false;
+    }
+    if (mode & Append)
+        mode |= WriteOnly;
+    unsetError();
+    if ((mode & (ReadOnly | WriteOnly)) == 0) {
+        qWarning("QFile::open: File access not specified");
+        return false;
+    }
+    if(d->openExternalFile(mode, fh)) {
+        QIODevice::open(mode);
+        if (mode & Append) {
+            seek(size());
+        } else {
+            long pos = ftell(fh);
+            if (pos != -1)
+                seek(pos);
+        }
+        return true;
+    }
+    return false;
+}
+
+/*! \fn QFile::open(OpenMode, int)
+
+    Use open(int, OpenMode) instead.
+*/
+
+/*!
+    \overload
+
+    Opens the existing file descripter \a fd in the given \a mode.
+    Returns true if successful; otherwise returns false.
+
+    When a QFile is opened using this function, close() does not
+    actually close the file.
+
+    The QFile that is opened using this function is automatically set
+    to be in raw mode; this means that the file input/output functions
+    are slow. If you run into performance issues, you should try to
+    use one of the other open functions.
+
+    \warning If \a fd is 0 (\c stdin), 1 (\c stdout), or 2 (\c
+    stderr), you may not be able to seek(). size() is set to \c
+    LLONG_MAX (in \c <climits>).
+
+    \warning For Windows CE you may not be able to call seek(), setSize(),
+    fileTime(). size() is set to \c 0.
+
+    \warning Since this function opens the file without specifying the file name,
+             you cannot use this QFile with a QFileInfo.
+
+    \sa close()
+*/
+bool QFile::open(int fd, OpenMode mode)
+{
+    Q_D(QFile);
+    if (isOpen()) {
+        qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
+        return false;
+    }
+    if (mode & Append)
+        mode |= WriteOnly;
+    unsetError();
+    if ((mode & (ReadOnly | WriteOnly)) == 0) {
+        qWarning("QFile::open: File access not specified");
+        return false;
+    }
+    if(d->openExternalFile(mode, fd)) {
+        QIODevice::open(mode);
+        if (mode & Append)
+            seek(size());
+        return true;
+    }
+    return false;
+}
+
+/*!
+  Returns the file handle of the file.
+
+  This is a small positive integer, suitable for use with C library
+  functions such as fdopen() and fcntl(). On systems that use file
+  descriptors for sockets (i.e. Unix systems, but not Windows) the handle
+  can be used with QSocketNotifier as well.
+
+  If the file is not open, or there is an error, handle() returns -1.
+
+  This function is not supported on Windows CE.
+
+  \sa QSocketNotifier
+*/
+
+int
+QFile::handle() const
+{
+    if (!isOpen())
+        return -1;
+
+    if (QAbstractFileEngine *engine = fileEngine())
+        return engine->handle();
+    return -1;
+}
+
+/*!
+    \enum QFile::MemoryMapFlags
+    \since 4.4
+
+    This enum describes special options that may be used by the map()
+    function.
+
+    \value NoOptions        No options.
+*/
+
+/*!
+    \since 4.4
+    Maps \a size bytes of the file into memory starting at \a offset.  A file
+    should be open for a map to succeed but the file does not need to stay
+    open after the memory has been mapped.  When the QFile is destroyed
+    or a new file is opened with this object, any maps that have not been
+    unmapped will automatically be unmapped.
+
+    Any mapping options can be passed through \a flags.
+
+    Returns a pointer to the memory or 0 if there is an error.
+
+    \note On Windows CE 5.0 the file will be closed before mapping occurs.
+
+    \sa unmap(), QAbstractFileEngine::supportsExtension()
+ */
+uchar *QFile::map(qint64 offset, qint64 size, MemoryMapFlags flags)
+{
+    Q_D(QFile);
+    QAbstractFileEngine *engine = fileEngine();
+    if (engine
+        && engine->supportsExtension(QAbstractFileEngine::MapExtension)) {
+        unsetError();
+        uchar *address = engine->map(offset, size, flags);
+        if (address == 0)
+            d->setError(engine->error(), engine->errorString());
+        return address;
+    }
+    return 0;
+}
+
+/*!
+    \since 4.4
+    Unmaps the memory \a address.
+
+    Returns true if the unmap succeeds; false otherwise.
+
+    \sa map(), QAbstractFileEngine::supportsExtension()
+ */
+bool QFile::unmap(uchar *address)
+{
+    Q_D(QFile);
+    QAbstractFileEngine *engine = fileEngine();
+    if (engine
+        && engine->supportsExtension(QAbstractFileEngine::UnMapExtension)) {
+        unsetError();
+        bool success = engine->unmap(address);
+        if (!success)
+            d->setError(engine->error(), engine->errorString());
+        return success;
+    }
+    return false;
+}
+
+/*!
+    \fn QString QFile::name() const
+
+    Use fileName() instead.
+*/
+
+/*!
+    \fn void QFile::setName(const QString &name)
+
+    Use setFileName() instead.
+*/
+
+/*!
+    Sets the file size (in bytes) \a sz. Returns true if the file if the
+    resize succeeds; false otherwise. If \a sz is larger than the file
+    currently is the new bytes will be set to 0, if \a sz is smaller the
+    file is simply truncated.
+
+    \sa size(), setFileName()
+*/
+
+bool
+QFile::resize(qint64 sz)
+{
+    Q_D(QFile);
+    if (!d->ensureFlushed())
+        return false;
+    if (isOpen() && fileEngine()->pos() > sz)
+        seek(sz);
+    if(fileEngine()->setSize(sz)) {
+        unsetError();
+        return true;
+    }
+    d->setError(QFile::ResizeError, errno);
+    return false;
+}
+
+/*!
+    \overload
+
+    Sets \a fileName to size (in bytes) \a sz. Returns true if the file if
+    the resize succeeds; false otherwise. If \a sz is larger than \a
+    fileName currently is the new bytes will be set to 0, if \a sz is
+    smaller the file is simply truncated.
+
+    \sa resize()
+*/
+
+bool
+QFile::resize(const QString &fileName, qint64 sz)
+{
+    return QFile(fileName).resize(sz);
+}
+
+/*!
+    Returns the complete OR-ed together combination of
+    QFile::Permission for the file.
+
+    \sa setPermissions(), setFileName()
+*/
+
+QFile::Permissions
+QFile::permissions() const
+{
+    QAbstractFileEngine::FileFlags perms = fileEngine()->fileFlags(QAbstractFileEngine::PermsMask) & QAbstractFileEngine::PermsMask;
+    return QFile::Permissions((int)perms); //ewww
+}
+
+/*!
+    \overload
+
+    Returns the complete OR-ed together combination of
+    QFile::Permission for \a fileName.
+*/
+
+QFile::Permissions
+QFile::permissions(const QString &fileName)
+{
+    return QFile(fileName).permissions();
+}
+
+/*!
+    Sets the permissions for the file to the \a permissions specified.
+    Returns true if successful, or false if the permissions cannot be
+    modified.
+
+    \sa permissions(), setFileName()
+*/
+
+bool
+QFile::setPermissions(Permissions permissions)
+{
+    Q_D(QFile);
+    if(fileEngine()->setPermissions(permissions)) {
+        unsetError();
+        return true;
+    }
+    d->setError(QFile::PermissionsError, errno);
+    return false;
+}
+
+/*!
+    \overload
+
+    Sets the permissions for \a fileName file to \a permissions.
+*/
+
+bool
+QFile::setPermissions(const QString &fileName, Permissions permissions)
+{
+    return QFile(fileName).setPermissions(permissions);
+}
+
+static inline qint64 _qfile_writeData(QAbstractFileEngine *engine, QRingBuffer *buffer)
+{
+    qint64 ret = engine->write(buffer->readPointer(), buffer->size());
+    if (ret > 0)
+        buffer->free(ret);
+    return ret;
+}
+
+/*!
+    Flushes any buffered data to the file. Returns true if successful;
+    otherwise returns false.
+*/
+
+bool
+QFile::flush()
+{
+    Q_D(QFile);
+    if (!d->writeBuffer.isEmpty()) {
+        qint64 size = d->writeBuffer.size();
+        if (_qfile_writeData(d->fileEngine ? d->fileEngine : fileEngine(),
+                             &d->writeBuffer) != size) {
+            QFile::FileError err = fileEngine()->error();
+            if(err == QFile::UnspecifiedError)
+                err = QFile::WriteError;
+            d->setError(err, fileEngine()->errorString());
+            return false;
+        }
+    }
+
+    if (!fileEngine()->flush()) {
+        QFile::FileError err = fileEngine()->error();
+        if(err == QFile::UnspecifiedError)
+            err = QFile::WriteError;
+        d->setError(err, fileEngine()->errorString());
+        return false;
+    }
+    return true;
+}
+
+/*!
+  Flushes the file and then closes it.
+
+  \sa QIODevice::close()
+*/
+void
+QFile::close()
+{
+    Q_D(QFile);
+    if(!isOpen())
+        return;
+    flush();
+    QIODevice::close();
+
+    unsetError();
+    if(!fileEngine()->close())
+        d->setError(fileEngine()->error(), fileEngine()->errorString());
+}
+
+/*!
+  Returns the size of the file.
+
+  For regular empty files on Unix (e.g. those in \c /proc), this function
+  returns 0; the contents of such a file are generated on demand in response
+  to you calling read().
+*/
+
+qint64 QFile::size() const
+{
+    Q_D(const QFile);
+    if (!d->ensureFlushed())
+        return 0;
+    return fileEngine()->size();
+}
+
+/*!
+  \reimp
+*/
+
+qint64 QFile::pos() const
+{
+    return QIODevice::pos();
+}
+
+/*!
+  Returns true if the end of the file has been reached; otherwise returns
+  false.
+
+  For regular empty files on Unix (e.g. those in \c /proc), this function
+  returns true, since the file system reports that the size of such a file is
+  0. Therefore, you should not depend on atEnd() when reading data from such a
+  file, but rather call read() until no more data can be read.
+*/
+
+bool QFile::atEnd() const
+{
+    Q_D(const QFile);
+
+    if (!isOpen())
+        return true;
+
+    if (!d->ensureFlushed())
+        return false;
+
+    // If there's buffered data left, we're not at the end.
+    if (!d->buffer.isEmpty())
+        return false;
+
+    // If the file engine knows best, say what it says.
+    if (fileEngine()->supportsExtension(QAbstractFileEngine::AtEndExtension)) {
+        // Check if the file engine supports AtEndExtension, and if it does,
+        // check if the file engine claims to be at the end.
+        return fileEngine()->atEnd();
+    }
+
+    // Fall back to checking how much is available (will stat files).
+    return bytesAvailable() == 0;
+}
+
+/*!
+  \reimp
+*/
+
+bool QFile::seek(qint64 off)
+{
+    Q_D(QFile);
+    if (!isOpen()) {
+        qWarning("QFile::seek: IODevice is not open");
+        return false;
+    }
+
+    if (!d->ensureFlushed())
+        return false;
+
+    if (!fileEngine()->seek(off) || !QIODevice::seek(off)) {
+        QFile::FileError err = fileEngine()->error();
+        if(err == QFile::UnspecifiedError)
+            err = QFile::PositionError;
+        d->setError(err, fileEngine()->errorString());
+        return false;
+    }
+    d->error = NoError;
+    return true;
+}
+
+/*!
+  \reimp
+*/
+qint64 QFile::readLineData(char *data, qint64 maxlen)
+{
+    Q_D(QFile);
+    if (!d->ensureFlushed())
+        return -1;
+
+    if (fileEngine()->supportsExtension(QAbstractFileEngine::FastReadLineExtension))
+        return fileEngine()->readLine(data, maxlen);
+
+    // Fall back to QIODevice's readLine implementation if the engine
+    // cannot do it faster.
+    return QIODevice::readLineData(data, maxlen);
+}
+
+/*!
+  \reimp
+*/
+
+qint64 QFile::readData(char *data, qint64 len)
+{
+    Q_D(QFile);
+    d->error = NoError;
+    if (!d->ensureFlushed())
+        return -1;
+
+    qint64 ret = -1;
+    qint64 read = fileEngine()->read(data, len);
+    if (read != -1)
+        ret = read;
+
+    if(ret < 0) {
+        QFile::FileError err = fileEngine()->error();
+        if(err == QFile::UnspecifiedError)
+            err = QFile::ReadError;
+        d->setError(err, fileEngine()->errorString());
+    }
+    return ret;
+}
+
+/*!
+    \internal
+*/
+bool QFilePrivate::putCharHelper(char c)
+{
+#ifdef QT_NO_QOBJECT
+    return QIODevicePrivate::putCharHelper(c);
+#else
+
+    // Cutoff for code that doesn't only touch the buffer.
+    int writeBufferSize = writeBuffer.size();
+    if ((openMode & QIODevice::Unbuffered) || writeBufferSize + 1 >= QFILE_WRITEBUFFER_SIZE
+#ifdef Q_OS_WIN
+        || ((openMode & QIODevice::Text) && c == '\n' && writeBufferSize + 2 >= QFILE_WRITEBUFFER_SIZE)
+#endif
+        ) {
+        return QIODevicePrivate::putCharHelper(c);
+    }
+
+    if (!(openMode & QIODevice::WriteOnly)) {
+        if (openMode == QIODevice::NotOpen)
+            qWarning("QIODevice::putChar: Closed device");
+        else
+            qWarning("QIODevice::putChar: ReadOnly device");
+        return false;
+    }
+
+    // Make sure the device is positioned correctly.
+    const bool sequential = isSequential();
+    if (pos != devicePos && !sequential && !q_func()->seek(pos))
+        return false;
+
+    lastWasWrite = true;
+
+    int len = 1;
+#ifdef Q_OS_WIN
+    if ((openMode & QIODevice::Text) && c == '\n') {
+        ++len;
+        *writeBuffer.reserve(1) = '\r';
+    }
+#endif
+
+    // Write to buffer.
+    *writeBuffer.reserve(1) = c;
+
+    if (!sequential) {
+        pos += len;
+        devicePos += len;
+        if (!buffer.isEmpty())
+            buffer.skip(len);
+    }
+
+    return true;
+#endif
+}
+
+/*!
+  \reimp
+*/
+
+qint64
+QFile::writeData(const char *data, qint64 len)
+{
+    Q_D(QFile);
+    d->error = NoError;
+    d->lastWasWrite = true;
+    bool buffered = !(d->openMode & Unbuffered);
+
+    // Flush buffered data if this read will overflow.
+    if (buffered && (d->writeBuffer.size() + len) > QFILE_WRITEBUFFER_SIZE) {
+        if (!flush())
+            return -1;
+    }
+
+    // Write directly to the engine if the block size is larger than
+    // the write buffer size.
+    if (!buffered || len > QFILE_WRITEBUFFER_SIZE) {
+        QAbstractFileEngine *fe = d->fileEngine ? d->fileEngine : fileEngine();
+        qint64 ret = fe->write(data, len);
+        if(ret < 0) {
+            QFile::FileError err = fileEngine()->error();
+            if(err == QFile::UnspecifiedError)
+                err = QFile::WriteError;
+            d->setError(err, fileEngine()->errorString());
+        }
+        return ret;
+    }
+
+    // Write to the buffer.
+    char *writePointer = d->writeBuffer.reserve(len);
+    if (len == 1)
+        *writePointer = *data;
+    else
+        ::memcpy(writePointer, data, len);
+    return len;
+}
+
+/*!
+    \internal
+    Returns the QIOEngine for this QFile object.
+*/
+QAbstractFileEngine *QFile::fileEngine() const
+{
+    Q_D(const QFile);
+    if(!d->fileEngine)
+        d->fileEngine = QAbstractFileEngine::create(d->fileName);
+    return d->fileEngine;
+}
+
+/*!
+    Returns the file error status.
+
+    The I/O device status returns an error code. For example, if open()
+    returns false, or a read/write operation returns -1, this function can
+    be called to find out the reason why the operation failed.
+
+    \sa unsetError()
+*/
+
+QFile::FileError
+QFile::error() const
+{
+    Q_D(const QFile);
+    return d->error;
+}
+
+/*!
+    Sets the file's error to QFile::NoError.
+
+    \sa error()
+*/
+void
+QFile::unsetError()
+{
+    Q_D(QFile);
+    d->setError(QFile::NoError);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qfile.h b/src/corelib/io/qfile.h
new file mode 100644
index 0000000..e4ca9cc
--- /dev/null
+++ b/src/corelib/io/qfile.h
@@ -0,0 +1,204 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILE_H
+#define QFILE_H
+
+#include <QtCore/qiodevice.h>
+#include <QtCore/qstring.h>
+#include <stdio.h>
+
+#ifdef open
+#error qfile.h must be included before any header file that defines open
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QAbstractFileEngine;
+class QFilePrivate;
+
+class Q_CORE_EXPORT QFile : public QIODevice
+{
+#ifndef QT_NO_QOBJECT
+    Q_OBJECT
+#endif
+    Q_DECLARE_PRIVATE(QFile)
+
+public:
+
+    enum FileError {
+        NoError = 0,
+        ReadError = 1,
+        WriteError = 2,
+        FatalError = 3,
+        ResourceError = 4,
+        OpenError = 5,
+        AbortError = 6,
+        TimeOutError = 7,
+        UnspecifiedError = 8,
+        RemoveError = 9,
+        RenameError = 10,
+        PositionError = 11,
+        ResizeError = 12,
+        PermissionsError = 13,
+        CopyError = 14
+#ifdef QT3_SUPPORT
+        , ConnectError = 30
+#endif
+    };
+
+    enum Permission {
+        ReadOwner = 0x4000, WriteOwner = 0x2000, ExeOwner = 0x1000,
+        ReadUser  = 0x0400, WriteUser  = 0x0200, ExeUser  = 0x0100,
+        ReadGroup = 0x0040, WriteGroup = 0x0020, ExeGroup = 0x0010,
+        ReadOther = 0x0004, WriteOther = 0x0002, ExeOther = 0x0001
+    };
+    Q_DECLARE_FLAGS(Permissions, Permission)
+
+    QFile();
+    QFile(const QString &name);
+#ifndef QT_NO_QOBJECT
+    explicit QFile(QObject *parent);
+    QFile(const QString &name, QObject *parent);
+#endif
+    ~QFile();
+
+    FileError error() const;
+    void unsetError();
+
+    QString fileName() const;
+    void setFileName(const QString &name);
+
+    typedef QByteArray (*EncoderFn)(const QString &fileName);
+    typedef QString (*DecoderFn)(const QByteArray &localfileName);
+    static QByteArray encodeName(const QString &fileName);
+    static QString decodeName(const QByteArray &localFileName);
+    inline static QString decodeName(const char *localFileName)
+        { return decodeName(QByteArray(localFileName)); };
+    static void setEncodingFunction(EncoderFn);
+    static void setDecodingFunction(DecoderFn);
+
+    bool exists() const;
+    static bool exists(const QString &fileName);
+
+    QString readLink() const;
+    static QString readLink(const QString &fileName);
+    inline QString symLinkTarget() const { return readLink(); }
+    inline static QString symLinkTarget(const QString &fileName) { return readLink(fileName); }
+
+    bool remove();
+    static bool remove(const QString &fileName);
+
+    bool rename(const QString &newName);
+    static bool rename(const QString &oldName, const QString &newName);
+
+    bool link(const QString &newName);
+    static bool link(const QString &oldname, const QString &newName);
+
+    bool copy(const QString &newName);
+    static bool copy(const QString &fileName, const QString &newName);
+
+    bool isSequential() const;
+
+    bool open(OpenMode flags);
+    bool open(FILE *f, OpenMode flags);
+    bool open(int fd, OpenMode flags);
+    virtual void close();
+
+    qint64 size() const;
+    qint64 pos() const;
+    bool seek(qint64 offset);
+    bool atEnd() const;
+    bool flush();
+
+    bool resize(qint64 sz);
+    static bool resize(const QString &filename, qint64 sz);
+
+    Permissions permissions() const;
+    static Permissions permissions(const QString &filename);
+    bool setPermissions(Permissions permissionSpec);
+    static bool setPermissions(const QString &filename, Permissions permissionSpec);
+
+    int handle() const;
+
+    enum MemoryMapFlags {
+        NoOptions = 0
+    };
+
+    uchar *map(qint64 offset, qint64 size, MemoryMapFlags flags = NoOptions);
+    bool unmap(uchar *address);
+
+    virtual QAbstractFileEngine *fileEngine() const;
+
+#ifdef QT3_SUPPORT
+    typedef Permission PermissionSpec;
+    inline QT3_SUPPORT QString name() const { return fileName(); }
+    inline QT3_SUPPORT void setName(const QString &aName) { setFileName(aName); }
+    inline QT3_SUPPORT bool open(OpenMode aFlags, FILE *f) { return open(f, aFlags); }
+    inline QT3_SUPPORT bool open(OpenMode aFlags, int fd) { return open(fd, aFlags); }
+#endif
+
+protected:
+#ifdef QT_NO_QOBJECT
+    QFile(QFilePrivate &dd);
+#else
+    QFile(QFilePrivate &dd, QObject *parent = 0);
+#endif
+
+    qint64 readData(char *data, qint64 maxlen);
+    qint64 writeData(const char *data, qint64 len);
+    qint64 readLineData(char *data, qint64 maxlen);
+
+private:
+    Q_DISABLE_COPY(QFile)
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QFile::Permissions)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QFILE_H
diff --git a/src/corelib/io/qfile_p.h b/src/corelib/io/qfile_p.h
new file mode 100644
index 0000000..ee6f56a
--- /dev/null
+++ b/src/corelib/io/qfile_p.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILE_P_H
+#define QFILE_P_H
+
+//
+//  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.
+//
+
+#include "QtCore/qabstractfileengine.h"
+#include "private/qiodevice_p.h"
+#include "private/qringbuffer_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QFilePrivate : public QIODevicePrivate
+{
+    Q_DECLARE_PUBLIC(QFile)
+
+protected:
+    QFilePrivate();
+    ~QFilePrivate();
+
+    bool openExternalFile(int flags, int fd);
+    bool openExternalFile(int flags, FILE *fh);
+
+    QString fileName;
+    mutable QAbstractFileEngine *fileEngine;
+    bool isOpen;
+
+    bool lastWasWrite;
+    QRingBuffer writeBuffer;
+    inline bool ensureFlushed() const;
+
+    bool putCharHelper(char c);
+    
+    QFile::FileError error;
+    void setError(QFile::FileError err);
+    void setError(QFile::FileError err, const QString &errorString);
+    void setError(QFile::FileError err, int errNum);
+
+private:
+    static QFile::EncoderFn encoder;
+    static QFile::DecoderFn decoder;
+};
+
+QT_END_NAMESPACE
+
+#endif // QFILE_P_H
diff --git a/src/corelib/io/qfileinfo.cpp b/src/corelib/io/qfileinfo.cpp
new file mode 100644
index 0000000..96e0f82
--- /dev/null
+++ b/src/corelib/io/qfileinfo.cpp
@@ -0,0 +1,1427 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qfileinfo.h"
+#include "qdatetime.h"
+#include "qabstractfileengine.h"
+#include "qfsfileengine_p.h"
+#include "qglobal.h"
+#include "qatomic.h"
+#include "qhash.h"
+#include "qdir.h"
+
+QT_BEGIN_NAMESPACE
+
+class QFileInfoPrivate
+{
+public:
+    QFileInfoPrivate(const QFileInfo *copy=0);
+    ~QFileInfoPrivate();
+
+    void initFileEngine(const QString &);
+
+    enum Access {
+        ReadAccess,
+        WriteAccess,
+        ExecuteAccess
+    };
+    bool hasAccess(Access access) const;
+
+    uint getFileFlags(QAbstractFileEngine::FileFlags) const;
+    QDateTime &getFileTime(QAbstractFileEngine::FileTime) const;
+    QString getFileName(QAbstractFileEngine::FileName) const;
+
+    enum { CachedFileFlags=0x01, CachedLinkTypeFlag=0x02, CachedBundleTypeFlag=0x04,
+           CachedMTime=0x10, CachedCTime=0x20, CachedATime=0x40,
+           CachedSize =0x08 };
+    struct Data {
+        inline Data()
+            : ref(1), fileEngine(0), cache_enabled(1)
+        { clear(); }
+        inline Data(const Data &copy)
+            : ref(1), fileEngine(QAbstractFileEngine::create(copy.fileName)),
+              fileName(copy.fileName), cache_enabled(copy.cache_enabled)
+        { clear(); }
+        inline ~Data() { delete fileEngine; }
+        inline void clearFlags() {
+            fileFlags = 0;
+            cachedFlags = 0;
+            if (fileEngine)
+                (void)fileEngine->fileFlags(QFSFileEngine::Refresh);
+        }
+        inline void clear() {
+            fileNames.clear();
+            clearFlags();
+        }
+        mutable QAtomicInt ref;
+
+        QAbstractFileEngine *fileEngine;
+        mutable QString fileName;
+        mutable QHash<int, QString> fileNames;
+
+        mutable uint cachedFlags : 31;
+        mutable uint cache_enabled : 1;
+        mutable uint fileFlags;
+        mutable qint64 fileSize;
+        mutable QDateTime fileTimes[3];
+        inline bool getCachedFlag(uint c) const
+        { return cache_enabled ? (cachedFlags & c) : 0; }
+        inline void setCachedFlag(uint c)
+        { if (cache_enabled) cachedFlags |= c; }
+    } *data;
+    inline void reset() {
+        detach();
+        data->clear();
+    }
+    void detach();
+};
+
+QFileInfoPrivate::QFileInfoPrivate(const QFileInfo *copy)
+{
+    if(copy) {
+        copy->d_func()->data->ref.ref();
+        data = copy->d_func()->data;
+    } else {
+        data = new QFileInfoPrivate::Data;
+        data->clear();
+    }
+}
+
+QFileInfoPrivate::~QFileInfoPrivate()
+{
+    if (!data->ref.deref())
+        delete data;
+    data = 0;
+}
+
+void QFileInfoPrivate::initFileEngine(const QString &file)
+{
+    detach();
+    delete data->fileEngine;
+    data->fileEngine = 0;
+    data->clear();
+    data->fileEngine = QAbstractFileEngine::create(file);
+    data->fileName = file;
+}
+
+bool QFileInfoPrivate::hasAccess(Access access) const
+{
+    if (!(getFileFlags(QAbstractFileEngine::FileInfoAll) & QAbstractFileEngine::LocalDiskFlag)) {
+        switch (access) {
+        case ReadAccess:
+            return getFileFlags(QAbstractFileEngine::ReadUserPerm);
+        case WriteAccess:
+            return getFileFlags(QAbstractFileEngine::WriteUserPerm);
+        case ExecuteAccess:
+            return getFileFlags(QAbstractFileEngine::ExeUserPerm);
+        default:
+            return false;
+        }
+    }
+
+    int mode = 0;
+    switch (access) {
+    case ReadAccess:
+        mode = R_OK;
+        break;
+    case WriteAccess:
+        mode = W_OK;
+        break;
+    case ExecuteAccess:
+        mode = X_OK;
+        break;
+    };
+#ifdef Q_OS_UNIX
+    return QT_ACCESS(QFile::encodeName(data->fileName).data(), mode) == 0;
+#endif
+#ifdef Q_OS_WIN
+    if ((access == ReadAccess && !getFileFlags(QAbstractFileEngine::ReadUserPerm))
+        || (access == WriteAccess && !getFileFlags(QAbstractFileEngine::WriteUserPerm))) {
+        return false;
+    }
+    if (access == ExecuteAccess)
+        return getFileFlags(QAbstractFileEngine::ExeUserPerm);
+
+    QT_WA( {
+        return ::_waccess((TCHAR *)QFSFileEnginePrivate::longFileName(data->fileName).utf16(), mode) == 0;
+    } , {
+        return QT_ACCESS(QFSFileEnginePrivate::win95Name(data->fileName), mode) == 0;
+    } );
+#endif
+    return false;
+}
+
+void QFileInfoPrivate::detach()
+{
+    qAtomicDetach(data);
+}
+
+QString QFileInfoPrivate::getFileName(QAbstractFileEngine::FileName name) const
+{
+    if(data->cache_enabled && data->fileNames.contains((int)name))
+        return data->fileNames.value(name);
+    QString ret = data->fileEngine->fileName(name);
+    if(data->cache_enabled)
+        data->fileNames.insert((int)name, ret);
+    return ret;
+}
+
+uint QFileInfoPrivate::getFileFlags(QAbstractFileEngine::FileFlags request) const
+{
+    // We split the testing into tests for for LinkType, BundleType and the rest.
+    // In order to determine if a file is a symlink or not, we have to lstat().
+    // If we're not interested in that information, we might as well avoid one
+    // extra syscall. Bundle detecton on Mac can be slow, expecially on network
+    // paths, so we separate out that as well.
+
+    QAbstractFileEngine::FileFlags flags;
+    if (!data->getCachedFlag(CachedFileFlags)) {
+        QAbstractFileEngine::FileFlags req = QAbstractFileEngine::FileInfoAll;
+        req &= (~QAbstractFileEngine::LinkType);
+        req &= (~QAbstractFileEngine::BundleType);
+
+        flags = data->fileEngine->fileFlags(req);
+        data->setCachedFlag(CachedFileFlags);
+        data->fileFlags |= uint(flags);
+    } else {
+        flags = QAbstractFileEngine::FileFlags(data->fileFlags & request);
+    }
+
+    if (request & QAbstractFileEngine::LinkType) {
+        if (!data->getCachedFlag(CachedLinkTypeFlag)) {
+            QAbstractFileEngine::FileFlags linkflag;
+            linkflag = data->fileEngine->fileFlags(QAbstractFileEngine::LinkType);
+
+            data->setCachedFlag(CachedLinkTypeFlag);
+            data->fileFlags |= uint(linkflag);
+            flags |= linkflag;
+        }
+    }
+
+    if (request & QAbstractFileEngine::BundleType) {
+        if (!data->getCachedFlag(CachedBundleTypeFlag)) {
+            QAbstractFileEngine::FileFlags bundleflag;
+            bundleflag = data->fileEngine->fileFlags(QAbstractFileEngine::BundleType);
+
+            data->setCachedFlag(CachedBundleTypeFlag);
+            data->fileFlags |= uint(bundleflag);
+            flags |= bundleflag;
+        }
+    }
+
+    // no else branch
+    // if we had it cached, it was caught in the previous else branch
+
+    return flags & request;
+}
+
+QDateTime &QFileInfoPrivate::getFileTime(QAbstractFileEngine::FileTime request) const
+{
+    if (!data->cache_enabled)
+        data->clearFlags();
+    if(request == QAbstractFileEngine::CreationTime) {
+        if(data->getCachedFlag(CachedCTime))
+            return data->fileTimes[request];
+        data->setCachedFlag(CachedCTime);
+        return (data->fileTimes[request] = data->fileEngine->fileTime(request));
+    }
+    if(request == QAbstractFileEngine::ModificationTime) {
+        if(data->getCachedFlag(CachedMTime))
+            return data->fileTimes[request];
+        data->setCachedFlag(CachedMTime);
+        return (data->fileTimes[request] = data->fileEngine->fileTime(request));
+    }
+    if(request == QAbstractFileEngine::AccessTime) {
+        if(data->getCachedFlag(CachedATime))
+            return data->fileTimes[request];
+        data->setCachedFlag(CachedATime);
+        return (data->fileTimes[request] = data->fileEngine->fileTime(request));
+    }
+    return data->fileTimes[0]; //cannot really happen
+}
+
+//************* QFileInfo
+
+/*!
+    \class QFileInfo
+    \reentrant
+    \brief The QFileInfo class provides system-independent file information.
+
+    \ingroup io
+    \ingroup shared
+
+    QFileInfo provides information about a file's name and position
+    (path) in the file system, its access rights and whether it is a
+    directory or symbolic link, etc. The file's size and last
+    modified/read times are also available. QFileInfo can also be
+    used to obtain information about a Qt \l{resource
+    system}{resource}.
+
+    A QFileInfo can point to a file with either a relative or an
+    absolute file path. Absolute file paths begin with the directory
+    separator "/" (or with a drive specification on Windows). Relative
+    file names begin with a directory name or a file name and specify
+    a path relative to the current working directory. An example of an
+    absolute path is the string "/tmp/quartz". A relative path might
+    look like "src/fatlib". You can use the function isRelative() to
+    check whether a QFileInfo is using a relative or an absolute file
+    path. You can call the function makeAbsolute() to convert a
+    relative QFileInfo's path to an absolute path.
+
+    The file that the QFileInfo works on is set in the constructor or
+    later with setFile(). Use exists() to see if the file exists and
+    size() to get its size.
+
+    The file's type is obtained with isFile(), isDir() and
+    isSymLink(). The symLinkTarget() function provides the name of the file
+    the symlink points to.
+
+    On Unix (including Mac OS X), the symlink has the same size() has
+    the file it points to, because Unix handles symlinks
+    transparently; similarly, opening a symlink using QFile
+    effectively opens the link's target. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 0
+
+    On Windows, symlinks (shortcuts) are \c .lnk files. The reported
+    size() is that of the symlink (not the link's target), and
+    opening a symlink using QFile opens the \c .lnk file. For
+    example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 1
+
+    Elements of the file's name can be extracted with path() and
+    fileName(). The fileName()'s parts can be extracted with
+    baseName(), suffix() or completeSuffix(). QFileInfo objects to
+    directories created by Qt classes will not have a trailing file
+    separator. If you wish to use trailing separators in your own file
+    info objects, just append one to the file name given to the constructors
+    or setFile().
+
+    The file's dates are returned by created(), lastModified() and
+    lastRead(). Information about the file's access permissions is
+    obtained with isReadable(), isWritable() and isExecutable(). The
+    file's ownership is available from owner(), ownerId(), group() and
+    groupId(). You can examine a file's permissions and ownership in a
+    single statement using the permission() function.
+
+    \section1 Performance Issues
+
+    Some of QFileInfo's functions query the file system, but for
+    performance reasons, some functions only operate on the
+    file name itself. For example: To return the absolute path of
+    a relative file name, absolutePath() has to query the file system.
+    The path() function, however, can work on the file name directly,
+    and so it is faster.
+
+    \note To speed up performance, QFileInfo caches information about
+    the file.
+
+    To speed up performance, QFileInfo caches information about the
+    file. Because files can be changed by other users or programs, or
+    even by other parts of the same program, there is a function that
+    refreshes the file information: refresh(). If you want to switch
+    off a QFileInfo's caching and force it to access the file system
+    every time you request information from it call setCaching(false).
+
+    \sa QDir, QFile
+*/
+
+/*!
+    Constructs an empty QFileInfo object.
+
+    Note that an empty QFileInfo object contain no file reference.
+
+    \sa setFile()
+*/
+
+QFileInfo::QFileInfo() : d_ptr(new QFileInfoPrivate())
+{
+}
+
+/*!
+    Constructs a new QFileInfo that gives information about the given
+    file. The \a file can also include an absolute or relative path.
+
+    \sa setFile(), isRelative(), QDir::setCurrent(), QDir::isRelativePath()
+*/
+
+QFileInfo::QFileInfo(const QString &file) : d_ptr(new QFileInfoPrivate())
+{
+    d_ptr->initFileEngine(file);
+}
+
+/*!
+    Constructs a new QFileInfo that gives information about file \a
+    file.
+
+    If the \a file has a relative path, the QFileInfo will also have a
+    relative path.
+
+    \sa isRelative()
+*/
+
+QFileInfo::QFileInfo(const QFile &file) : d_ptr(new QFileInfoPrivate())
+{
+    d_ptr->initFileEngine(file.fileName());
+}
+
+/*!
+    Constructs a new QFileInfo that gives information about the given
+    \a file in the directory \a dir.
+
+    If \a dir has a relative path, the QFileInfo will also have a
+    relative path.
+
+    If \a file is an absolute path, then the directory specified
+    by \a dir will be disregarded.
+
+    \sa isRelative()
+*/
+
+QFileInfo::QFileInfo(const QDir &dir, const QString &file) : d_ptr(new QFileInfoPrivate())
+{
+    d_ptr->initFileEngine(dir.filePath(file));
+}
+
+/*!
+    Constructs a new QFileInfo that is a copy of the given \a fileinfo.
+*/
+
+QFileInfo::QFileInfo(const QFileInfo &fileinfo) : d_ptr(new QFileInfoPrivate(&fileinfo))
+{
+
+}
+
+/*!
+    Destroys the QFileInfo and frees its resources.
+*/
+
+
+QFileInfo::~QFileInfo()
+{
+    delete d_ptr;
+    d_ptr = 0;
+}
+
+/*!
+    \fn bool QFileInfo::operator!=(const QFileInfo &fileinfo)
+
+    Returns true if this QFileInfo object refers to a different file
+    than the one specified by \a fileinfo; otherwise returns false.
+
+    \sa operator==()
+*/
+
+/*!
+    \overload
+    \fn bool QFileInfo::operator!=(const QFileInfo &fileinfo) const
+*/
+
+/*!
+    \overload
+*/
+bool QFileInfo::operator==(const QFileInfo &fileinfo) const
+{
+    Q_D(const QFileInfo);
+    // ### Qt 5: understand long and short file names on Windows
+    // ### (GetFullPathName()).
+    if(fileinfo.d_func()->data == d->data)
+        return true;
+    if(!d->data->fileEngine || !fileinfo.d_func()->data->fileEngine)
+        return false;
+    if(d->data->fileEngine->caseSensitive() != fileinfo.d_func()->data->fileEngine->caseSensitive())
+        return false;
+    if(fileinfo.size() == size()) { //if the size isn't the same...
+        QString file1 = canonicalFilePath(),
+                file2 = fileinfo.canonicalFilePath();
+        if(file1.length() == file2.length()) {
+            if(!fileinfo.d_func()->data->fileEngine->caseSensitive()) {
+                for(int i = 0; i < file1.length(); i++) {
+                    if(file1.at(i).toLower() != file2.at(i).toLower())
+                        return false;
+                }
+                return true;
+            }
+            return (file1 == file2);
+        }
+    }
+    return false;
+}
+
+/*!
+    Returns true if this QFileInfo object refers to a file in the same
+    location as \a fileinfo; otherwise returns false.
+
+    Note that the result of comparing two empty QFileInfo objects,
+    containing no file references, is undefined.
+
+    \warning This will not compare two different symbolic links
+    pointing to the same file.
+
+    \warning Long and short file names that refer to the same file on Windows
+    are treated as if they referred to different files.
+
+    \sa operator!=()
+*/
+bool QFileInfo::operator==(const QFileInfo &fileinfo)
+{
+    return const_cast<const QFileInfo *>(this)->operator==(fileinfo);
+}
+
+/*!
+    Makes a copy of the given \a fileinfo and assigns it to this QFileInfo.
+*/
+
+QFileInfo &QFileInfo::operator=(const QFileInfo &fileinfo)
+{
+    Q_D(QFileInfo);
+    qAtomicAssign(d->data, fileinfo.d_func()->data);
+    return *this;
+}
+
+/*!
+    Sets the file that the QFileInfo provides information about to \a
+    file.
+
+    The \a file can also include an absolute or relative file path.
+    Absolute paths begin with the directory separator (e.g. "/" under
+    Unix) or a drive specification (under Windows). Relative file
+    names begin with a directory name or a file name and specify a
+    path relative to the current directory.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 2
+
+    \sa isRelative(), QDir::setCurrent(), QDir::isRelativePath()
+*/
+
+void QFileInfo::setFile(const QString &file)
+{
+    Q_D(QFileInfo);
+    d->initFileEngine(file);
+}
+
+/*!
+    \overload
+
+    Sets the file that the QFileInfo provides information about to \a
+    file.
+
+    If \a file includes a relative path, the QFileInfo will also have
+    a relative path.
+
+    \sa isRelative()
+*/
+
+void QFileInfo::setFile(const QFile &file)
+{
+    Q_D(QFileInfo);
+    d->initFileEngine(file.fileName());
+}
+
+/*!
+    \overload
+
+    Sets the file that the QFileInfo provides information about to \a
+    file in directory \a dir.
+
+    If \a file includes a relative path, the QFileInfo will also
+    have a relative path.
+
+    \sa isRelative()
+*/
+
+void QFileInfo::setFile(const QDir &dir, const QString &file)
+{
+    Q_D(QFileInfo);
+    d->initFileEngine(dir.filePath(file));
+}
+
+/*!
+    Returns an absolute path including the file name.
+
+    The absolute path name consists of the full path and the file
+    name. On Unix this will always begin with the root, '/',
+    directory. On Windows this will always begin 'D:/' where D is a
+    drive letter, except for network shares that are not mapped to a
+    drive letter, in which case the path will begin '//sharename/'.
+    QFileInfo will uppercase drive letters. Note that QDir does not do
+    this. The code snippet below shows this.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp newstuff
+
+    This function returns the same as filePath(), unless isRelative()
+    is true. In contrast to canonicalFilePath(), symbolic links or
+    redundant "." or ".." elements are not necessarily removed.
+
+    If the QFileInfo is empty it returns QDir::currentPath().
+
+    \sa filePath(), canonicalFilePath(), isRelative()
+*/
+QString QFileInfo::absoluteFilePath() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::AbsoluteName);
+}
+
+/*!
+  Returns the canonical path including the file name, i.e. an absolute
+  path without symbolic links or redundant "." or ".." elements.
+
+  If the file does not exist, canonicalFilePath() returns an empty
+  string.
+
+  \sa filePath(), absoluteFilePath(), dir()
+*/
+
+QString QFileInfo::canonicalFilePath() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::CanonicalName);
+}
+
+
+/*!
+    Returns a file's path absolute path. This doesn't include the
+    file name.
+
+    On Unix the absolute path will always begin with the root, '/',
+    directory. On Windows this will always begin 'D:/' where D is a
+    drive letter, except for network shares that are not mapped to a
+    drive letter, in which case the path will begin '//sharename/'.
+
+    In contrast to canonicalPath() symbolic links or redundant "." or
+    ".." elements are not necessarily removed.
+
+    \warning If the QFileInfo object was created with an empty QString,
+              the behavior of this function is undefined.
+
+    \sa absoluteFilePath(), path(), canonicalPath(), fileName(), isRelative()
+*/
+
+QString QFileInfo::absolutePath() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::AbsolutePathName);
+}
+
+/*!
+    Returns the file's path canonical path (excluding the file name),
+    i.e. an absolute path without symbolic links or redundant "." or ".." elements.
+
+    If the file does not exist, canonicalPath() returns an empty string.
+
+    \sa path(), absolutePath()
+*/
+
+QString QFileInfo::canonicalPath() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::CanonicalPathName);
+}
+
+
+/*!
+    Returns the file's path. This doesn't include the file name.
+
+    Note that, if this QFileInfo object is given a path ending in a
+    slash, the name of the file is considered empty and this function
+    will return the entire path.
+
+    \sa filePath(), absolutePath(), canonicalPath(), dir(), fileName(), isRelative()
+*/
+
+QString QFileInfo::path() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::PathName);
+}
+
+/*!
+    \fn bool QFileInfo::isAbsolute() const
+
+    Returns true if the file path name is absolute, otherwise returns
+    false if the path is relative.
+
+    \sa isRelative()
+*/
+
+/*!
+    Returns true if the file path name is relative, otherwise returns
+    false if the path is absolute (e.g. under Unix a path is absolute
+    if it begins with a "/").
+
+    \sa isAbsolute()
+*/
+
+bool QFileInfo::isRelative() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return true;
+    return d->data->fileEngine->isRelativePath();
+}
+
+
+/*!
+    Converts the file's path to an absolute path if it is not already in that form.
+    Returns true to indicate that the path was converted; otherwise returns false
+    to indicate that the path was already absolute.
+
+    \sa filePath(), isRelative()
+*/
+
+bool QFileInfo::makeAbsolute()
+{
+    Q_D(QFileInfo);
+    if(!d->data->fileEngine || !d->data->fileEngine->isRelativePath())
+        return false;
+    QString absFileName = d->getFileName(QAbstractFileEngine::AbsoluteName);
+    d->initFileEngine(absFileName);
+    return true;
+}
+
+/*!
+    Returns true if the file exists; otherwise returns false.
+
+    \note If the file is a symlink that points to a non existing
+     file, false is returned.
+*/
+
+bool QFileInfo::exists() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->getFileFlags(QAbstractFileEngine::ExistsFlag);
+}
+
+/*!
+    Refreshes the information about the file, i.e. reads in information
+    from the file system the next time a cached property is fetched.
+
+   \note On Windows CE, there might be a delay for the file system driver
+    to detect changes on the file.
+*/
+
+void QFileInfo::refresh()
+{
+    Q_D(QFileInfo);
+    d->reset();
+}
+
+/*!
+    Returns the file name, including the path (which may be absolute
+    or relative).
+
+    \sa absoluteFilePath(), canonicalFilePath(), isRelative()
+*/
+
+QString QFileInfo::filePath() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::DefaultName);
+}
+
+/*!
+    Returns the name of the file, excluding the path.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 3
+
+    Note that, if this QFileInfo object is given a path ending in a
+    slash, the name of the file is considered empty.
+
+    \sa isRelative(), filePath(), baseName(), extension()
+*/
+
+QString QFileInfo::fileName() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::BaseName);
+}
+
+/*!
+    \since 4.3
+    Returns the name of the bundle.
+
+    On Mac OS X this returns the proper localized name for a bundle if the
+    path isBundle(). On all other platforms an empty QString is returned.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 4
+
+    \sa isBundle(), filePath(), baseName(), extension()
+*/
+
+QString QFileInfo::bundleName() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::BundleName);
+}
+
+/*!
+    Returns the base name of the file without the path.
+
+    The base name consists of all characters in the file up to (but
+    not including) the \e first '.' character.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 5
+
+
+    The base name of a file is computed equally on all platforms, independent
+    of file naming conventions (e.g., ".bashrc" on Unix has an empty base
+    name, and the suffix is "bashrc").
+
+    \sa fileName(), suffix(), completeSuffix(), completeBaseName()
+*/
+
+QString QFileInfo::baseName() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::BaseName).section(QLatin1Char('.'), 0, 0);
+}
+
+/*!
+    Returns the complete base name of the file without the path.
+
+    The complete base name consists of all characters in the file up
+    to (but not including) the \e last '.' character.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 6
+
+    \sa fileName(), suffix(), completeSuffix(), baseName()
+*/
+
+QString QFileInfo::completeBaseName() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    QString name = d->getFileName(QAbstractFileEngine::BaseName);
+    int index = name.lastIndexOf(QLatin1Char('.'));
+    return (index == -1) ? name : name.left(index);
+}
+
+/*!
+    Returns the complete suffix of the file.
+
+    The complete suffix consists of all characters in the file after
+    (but not including) the first '.'.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 7
+
+    \sa fileName(), suffix(), baseName(), completeBaseName()
+*/
+
+QString QFileInfo::completeSuffix() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    QString fileName = d->getFileName(QAbstractFileEngine::BaseName);
+    int firstDot = fileName.indexOf(QLatin1Char('.'));
+    if (firstDot == -1)
+        return QLatin1String("");
+    return fileName.mid(firstDot + 1);
+}
+
+/*!
+    Returns the suffix of the file.
+
+    The suffix consists of all characters in the file after (but not
+    including) the last '.'.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 8
+
+    The suffix of a file is computed equally on all platforms, independent of
+    file naming conventions (e.g., ".bashrc" on Unix has an empty base name,
+    and the suffix is "bashrc").
+
+    \sa fileName(), completeSuffix(), baseName(), completeBaseName()
+*/
+
+QString QFileInfo::suffix() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    QString fileName = d->getFileName(QAbstractFileEngine::BaseName);
+    int lastDot = fileName.lastIndexOf(QLatin1Char('.'));
+    if (lastDot == -1)
+        return QLatin1String("");
+    return fileName.mid(lastDot + 1);
+}
+
+
+/*!
+  Returns the path of the object's parent directory as a QDir object.
+
+  \bold{Note:} The QDir returned always corresponds to the object's
+  parent directory, even if the QFileInfo represents a directory.
+  
+  For each of the follwing, dir() returns a QDir for
+  \c{"~/examples/191697"}.
+
+  \snippet doc/src/snippets/fileinfo/main.cpp 0
+
+  For each of the follwing, dir() returns a QDir for
+  \c{"."}.
+
+  \snippet doc/src/snippets/fileinfo/main.cpp 1
+
+  \sa absolutePath(), filePath(), fileName(), isRelative(), absoluteDir()
+*/
+
+QDir QFileInfo::dir() const
+{
+    // ### Qt5: Maybe rename this to parentDirectory(), considering what it actually do?
+    return QDir(path());
+}
+
+/*!
+    Returns the file's absolute path as a QDir object.
+
+    \sa dir(), filePath(), fileName(), isRelative()
+*/
+
+QDir QFileInfo::absoluteDir() const
+{
+    return QDir(absolutePath());
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    Use absoluteDir() or the dir() overload that takes no parameters
+    instead.
+*/
+QDir QFileInfo::dir(bool absPath) const
+{
+    if(absPath)
+        return absoluteDir();
+    return dir();
+}
+#endif //QT3_SUPPORT
+
+/*!
+    Returns true if the user can read the file; otherwise returns false.
+
+    \sa isWritable(), isExecutable(), permission()
+*/
+
+bool QFileInfo::isReadable() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->hasAccess(QFileInfoPrivate::ReadAccess);
+}
+
+/*!
+    Returns true if the user can write to the file; otherwise returns false.
+
+    \sa isReadable(), isExecutable(), permission()
+*/
+
+bool QFileInfo::isWritable() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->hasAccess(QFileInfoPrivate::WriteAccess);
+}
+
+/*!
+    Returns true if the file is executable; otherwise returns false.
+
+    \sa isReadable(), isWritable(), permission()
+*/
+
+bool QFileInfo::isExecutable() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->hasAccess(QFileInfoPrivate::ExecuteAccess);
+}
+
+/*!
+    Returns true if this is a `hidden' file; otherwise returns false.
+
+    \bold{Note:} This function returns true for the special entries
+    "." and ".." on Unix, even though QDir::entryList threats them as shown.
+*/
+bool QFileInfo::isHidden() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->getFileFlags(QAbstractFileEngine::HiddenFlag);
+}
+
+/*!
+    Returns true if this object points to a file or to a symbolic
+    link to a file. Returns false if the
+    object points to something which isn't a file, such as a directory.
+
+    \sa isDir(), isSymLink(), isBundle()
+*/
+
+bool QFileInfo::isFile() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->getFileFlags(QAbstractFileEngine::FileType);
+}
+
+/*!
+    Returns true if this object points to a directory or to a symbolic
+    link to a directory; otherwise returns false.
+
+    \sa isFile(), isSymLink(), isBundle()
+*/
+
+bool QFileInfo::isDir() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->getFileFlags(QAbstractFileEngine::DirectoryType);
+}
+
+
+/*!
+    \since 4.3
+    Returns true if this object points to a bundle or to a symbolic
+    link to a bundle on Mac OS X; otherwise returns false.
+
+    \sa isDir(), isSymLink(), isFile()
+*/
+
+bool QFileInfo::isBundle() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->getFileFlags(QAbstractFileEngine::BundleType);
+}
+
+/*!
+    Returns true if this object points to a symbolic link (or to a
+    shortcut on Windows); otherwise returns false.
+
+    On Unix (including Mac OS X), opening a symlink effectively opens
+    the \l{symLinkTarget()}{link's target}. On Windows, it opens the \c
+    .lnk file itself.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 9
+
+    \note If the symlink points to a non existing file, exists() returns
+     false.
+
+    \sa isFile(), isDir(), symLinkTarget()
+*/
+
+bool QFileInfo::isSymLink() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->getFileFlags(QAbstractFileEngine::LinkType);
+}
+
+/*!
+  Returns true if the object points to a directory or to a symbolic
+  link to a directory, and that directory is the root directory; otherwise
+  returns false.
+*/
+
+bool QFileInfo::isRoot() const
+{
+    Q_D(const QFileInfo);
+    if (!d->data->fileEngine)
+        return true;
+    return d->getFileFlags(QAbstractFileEngine::RootFlag);
+}
+
+/*!
+    \fn QString QFileInfo::symLinkTarget() const
+    \since 4.2
+
+    Returns the absolute path to the file or directory a symlink (or shortcut
+    on Windows) points to, or a an empty string if the object isn't a symbolic
+    link.
+
+    This name may not represent an existing file; it is only a string.
+    QFileInfo::exists() returns true if the symlink points to an
+    existing file.
+
+    \sa exists(), isSymLink(), isDir(), isFile()
+*/
+
+/*!
+    \obsolete
+
+    Use symLinkTarget() instead.
+*/
+QString QFileInfo::readLink() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->getFileName(QAbstractFileEngine::LinkName);
+}
+
+/*!
+    Returns the owner of the file. On systems where files
+    do not have owners, or if an error occurs, an empty string is
+    returned.
+
+    This function can be time consuming under Unix (in the order of
+    milliseconds).
+
+    \sa ownerId(), group(), groupId()
+*/
+
+QString QFileInfo::owner() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->data->fileEngine->owner(QAbstractFileEngine::OwnerUser);
+}
+
+/*!
+    Returns the id of the owner of the file.
+
+    On Windows and on systems where files do not have owners this
+    function returns ((uint) -2).
+
+    \sa owner(), group(), groupId()
+*/
+
+uint QFileInfo::ownerId() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return 0;
+    return d->data->fileEngine->ownerId(QAbstractFileEngine::OwnerUser);
+}
+
+/*!
+    Returns the group of the file. On Windows, on systems where files
+    do not have groups, or if an error occurs, an empty string is
+    returned.
+
+    This function can be time consuming under Unix (in the order of
+    milliseconds).
+
+    \sa groupId(), owner(), ownerId()
+*/
+
+QString QFileInfo::group() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QLatin1String("");
+    return d->data->fileEngine->owner(QAbstractFileEngine::OwnerGroup);
+}
+
+/*!
+    Returns the id of the group the file belongs to.
+
+    On Windows and on systems where files do not have groups this
+    function always returns (uint) -2.
+
+    \sa group(), owner(), ownerId()
+*/
+
+uint QFileInfo::groupId() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return 0;
+    return d->data->fileEngine->ownerId(QAbstractFileEngine::OwnerGroup);
+}
+
+/*!
+    Tests for file permissions. The \a permissions argument can be
+    several flags of type QFile::Permissions OR-ed together to check
+    for permission combinations.
+
+    On systems where files do not have permissions this function
+    always returns true.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qfileinfo.cpp 10
+
+    \sa isReadable(), isWritable(), isExecutable()
+*/
+
+bool QFileInfo::permission(QFile::Permissions permissions) const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return false;
+    return d->getFileFlags(QAbstractFileEngine::FileFlags((int)permissions)) == (uint)permissions;
+}
+
+/*!
+    Returns the complete OR-ed together combination of
+    QFile::Permissions for the file.
+*/
+
+QFile::Permissions QFileInfo::permissions() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return 0;
+    return QFile::Permissions(d->getFileFlags(QAbstractFileEngine::PermsMask) & QAbstractFileEngine::PermsMask);
+}
+
+
+/*!
+    Returns the file size in bytes. If the file does not exist or cannot be
+    fetched, 0 is returned.
+
+    \sa exists()
+*/
+
+qint64 QFileInfo::size() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return 0;
+    if(!d->data->getCachedFlag(QFileInfoPrivate::CachedSize)) {
+        d->data->setCachedFlag(QFileInfoPrivate::CachedSize);
+        d->data->fileSize = d->data->fileEngine->size();
+    }
+    return d->data->fileSize;
+}
+
+/*!
+    Returns the date and time when the file was created.
+
+    On most Unix systems, this function returns the time of the last
+    status change. A status change occurs when the file is created,
+    but it also occurs whenever the user writes or sets inode
+    information (for example, changing the file permissions).
+
+    If neither creation time nor "last status change" time are not
+    available, returns the same as lastModified().
+
+    \sa lastModified() lastRead()
+*/
+
+QDateTime QFileInfo::created() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QDateTime();
+    return d->getFileTime(QAbstractFileEngine::CreationTime);
+}
+
+/*!
+    Returns the date and time when the file was last modified.
+
+    \sa created() lastRead()
+*/
+
+QDateTime QFileInfo::lastModified() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QDateTime();
+    return d->getFileTime(QAbstractFileEngine::ModificationTime);
+}
+
+/*!
+    Returns the date and time when the file was last read (accessed).
+
+    On platforms where this information is not available, returns the
+    same as lastModified().
+
+    \sa created() lastModified()
+*/
+
+QDateTime QFileInfo::lastRead() const
+{
+    Q_D(const QFileInfo);
+    if(!d->data->fileEngine)
+        return QDateTime();
+    return d->getFileTime(QAbstractFileEngine::AccessTime);
+}
+
+/*! \internal
+    Detaches all internal data.
+*/
+
+void QFileInfo::detach()
+{
+    Q_D(QFileInfo);
+    d->detach();
+}
+
+/*!
+    Returns true if caching is enabled; otherwise returns false.
+
+    \sa setCaching(), refresh()
+*/
+
+bool QFileInfo::caching() const
+{
+    Q_D(const QFileInfo);
+    return d->data->cache_enabled;
+}
+
+/*!
+    If \a enable is true, enables caching of file information. If \a
+    enable is false caching is disabled.
+
+    When caching is enabled, QFileInfo reads the file information from
+    the file system the first time it's needed, but generally not
+    later.
+
+    Caching is enabled by default.
+
+    \sa refresh(), caching()
+*/
+
+void QFileInfo::setCaching(bool enable)
+{
+    Q_D(QFileInfo);
+    detach();
+    d->data->cache_enabled = enable;
+}
+
+/*!
+    \fn QString QFileInfo::baseName(bool complete)
+
+    Use completeBaseName() or the baseName() overload that takes no
+    parameters instead.
+*/
+
+/*!
+    \fn QString QFileInfo::extension(bool complete = true) const
+
+    Use completeSuffix() or suffix() instead.
+*/
+
+/*!
+    \fn QString QFileInfo::absFilePath() const
+
+    Use absoluteFilePath() instead.
+*/
+
+/*!
+    \fn QString QFileInfo::dirPath(bool absPath) const
+
+    Use absolutePath() if the absolute path is wanted (\a absPath
+    is true) or path() if it's not necessary (\a absPath is false).
+*/
+
+/*!
+    \fn bool QFileInfo::convertToAbs()
+
+    Use makeAbsolute() instead.
+*/
+
+/*!
+    \enum QFileInfo::Permission
+
+    \compat
+
+    \value ReadOwner
+    \value WriteOwner
+    \value ExeOwner
+    \value ReadUser
+    \value WriteUser
+    \value ExeUser
+    \value ReadGroup
+    \value WriteGroup
+    \value ExeGroup
+    \value ReadOther
+    \value WriteOther
+    \value ExeOther
+*/
+
+/*!
+    \fn bool QFileInfo::permission(PermissionSpec permissions) const
+    \compat
+
+    Use permission() instead.
+*/
+
+/*!
+    \typedef QFileInfoList
+    \relates QFileInfo
+
+    Synonym for QList<QFileInfo>.
+*/
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qfileinfo.h b/src/corelib/io/qfileinfo.h
new file mode 100644
index 0000000..97997a3
--- /dev/null
+++ b/src/corelib/io/qfileinfo.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 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILEINFO_H
+#define QFILEINFO_H
+
+#include <QtCore/qfile.h>
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QDir;
+class QDateTime;
+class QFileInfoPrivate;
+
+class Q_CORE_EXPORT QFileInfo
+{
+public:
+    QFileInfo();
+    QFileInfo(const QString &file);
+    QFileInfo(const QFile &file);
+    QFileInfo(const QDir &dir, const QString &file);
+    QFileInfo(const QFileInfo &fileinfo);
+    ~QFileInfo();
+
+    QFileInfo &operator=(const QFileInfo &fileinfo);
+    bool operator==(const QFileInfo &fileinfo); // 5.0 - remove me
+    bool operator==(const QFileInfo &fileinfo) const;
+    inline bool operator!=(const QFileInfo &fileinfo) { return !(operator==(fileinfo)); } // 5.0 - remove me
+    inline bool operator!=(const QFileInfo &fileinfo) const { return !(operator==(fileinfo)); }
+
+    void setFile(const QString &file);
+    void setFile(const QFile &file);
+    void setFile(const QDir &dir, const QString &file);
+    bool exists() const;
+    void refresh();
+
+    QString filePath() const;
+    QString absoluteFilePath() const;
+    QString canonicalFilePath() const;
+    QString fileName() const;
+    QString baseName() const;
+    QString completeBaseName() const;
+    QString suffix() const;
+    QString bundleName() const;
+    QString completeSuffix() const;
+
+    QString path() const;
+    QString absolutePath() const;
+    QString canonicalPath() const;
+    QDir dir() const;
+    QDir absoluteDir() const;
+
+    bool isReadable() const;
+    bool isWritable() const;
+    bool isExecutable() const;
+    bool isHidden() const;
+
+    bool isRelative() const;
+    inline bool isAbsolute() const { return !isRelative(); }
+    bool makeAbsolute();
+
+    bool isFile() const;
+    bool isDir() const;
+    bool isSymLink() const;
+    bool isRoot() const;
+    bool isBundle() const;
+
+    QString readLink() const;
+    inline QString symLinkTarget() const { return readLink(); }
+
+    QString owner() const;
+    uint ownerId() const;
+    QString group() const;
+    uint groupId() const;
+
+    bool permission(QFile::Permissions permissions) const;
+    QFile::Permissions permissions() const;
+
+    qint64 size() const;
+
+    QDateTime created() const;
+    QDateTime lastModified() const;
+    QDateTime lastRead() const;
+
+    void detach();
+
+    bool caching() const;
+    void setCaching(bool on);
+
+#ifdef QT3_SUPPORT
+    enum Permission {
+        ReadOwner = QFile::ReadOwner, WriteOwner = QFile::WriteOwner, ExeOwner = QFile::ExeOwner,
+        ReadUser  = QFile::ReadUser,  WriteUser  = QFile::WriteUser,  ExeUser  = QFile::ExeUser,
+        ReadGroup = QFile::ReadGroup, WriteGroup = QFile::WriteGroup, ExeGroup = QFile::ExeGroup,
+        ReadOther = QFile::ReadOther, WriteOther = QFile::WriteOther, ExeOther = QFile::ExeOther
+    };
+    Q_DECLARE_FLAGS(PermissionSpec, Permission)
+
+    inline QT3_SUPPORT QString baseName(bool complete) {
+        if(complete)
+            return completeBaseName();
+        return baseName();
+    }
+    inline QT3_SUPPORT QString extension(bool complete = true) const {
+        if(complete)
+            return completeSuffix();
+        return suffix();
+    }
+    inline QT3_SUPPORT QString absFilePath() const { return absoluteFilePath(); }
+
+    inline QT3_SUPPORT QString dirPath(bool absPath = false) const {
+        if(absPath)
+            return absolutePath();
+        return path();
+    }
+    QT3_SUPPORT QDir dir(bool absPath) const;
+    inline QT3_SUPPORT bool convertToAbs() { return makeAbsolute(); }
+#if !defined(Q_NO_TYPESAFE_FLAGS)
+    inline QT3_SUPPORT bool permission(PermissionSpec permissions) const
+    { return permission(QFile::Permissions(static_cast<int>(permissions))); }
+#endif
+#endif
+
+protected:
+    QFileInfoPrivate *d_ptr;
+private:
+    Q_DECLARE_PRIVATE(QFileInfo)
+};
+Q_DECLARE_TYPEINFO(QFileInfo, Q_MOVABLE_TYPE);
+
+#ifdef QT3_SUPPORT
+Q_DECLARE_OPERATORS_FOR_FLAGS(QFileInfo::PermissionSpec)
+#endif
+
+typedef QList<QFileInfo> QFileInfoList;
+#ifdef QT3_SUPPORT
+typedef QList<QFileInfo>::Iterator QFileInfoListIterator;
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QFILEINFO_H
diff --git a/src/corelib/io/qfileinfo_p.h b/src/corelib/io/qfileinfo_p.h
new file mode 100644
index 0000000..7d66581
--- /dev/null
+++ b/src/corelib/io/qfileinfo_p.h
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILEINFO_P_H
+#define QFILEINFO_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qfileinfo.h"
+
+QT_BEGIN_NAMESPACE
+
+class QFileInfoPrivate
+{
+public:
+    QFileInfoPrivate(const QFileInfo *copy=0);
+    ~QFileInfoPrivate();
+
+    void initFileEngine(const QString &);
+
+    enum Access {
+        ReadAccess,
+        WriteAccess,
+        ExecuteAccess
+    };
+    bool hasAccess(Access access) const;
+
+    uint getFileFlags(QAbstractFileEngine::FileFlags) const;
+    QDateTime &getFileTime(QAbstractFileEngine::FileTime) const;
+    QString getFileName(QAbstractFileEngine::FileName) const;
+
+    enum {
+        CachedFileFlags = 0x01,
+        CachedLinkTypeFlag = 0x02,
+        CachedBundleTypeFlag= 0x04,
+        CachedMTime = 0x10,
+        CachedCTime = 0x20,
+        CachedATime = 0x40,
+        CachedSize = 0x08
+    };
+
+    struct Data
+    {
+        inline Data()
+            : ref(1), fileEngine(0), cache_enabled(1)
+        {
+            clear();
+        }
+
+        inline Data(const Data &copy)
+            : ref(1), fileEngine(QAbstractFileEngine::create(copy.fileName)),
+              fileName(copy.fileName), cache_enabled(copy.cache_enabled)
+        {
+            clear();
+        }
+
+        inline ~Data()
+        {
+            delete fileEngine;
+        }
+
+        inline void clear()
+        {
+            fileNames.clear();
+            fileFlags = 0;
+            cachedFlags = 0;
+        }
+
+        mutable QAtomicInt ref;
+
+        QAbstractFileEngine *fileEngine;
+        mutable QString fileName;
+        mutable QHash<int, QString> fileNames;
+        mutable uint cachedFlags : 31;
+        mutable uint cache_enabled : 1;
+        mutable uint fileFlags;
+        mutable qint64 fileSize;
+        mutable QDateTime fileTimes[3];
+
+        inline bool getCachedFlag(uint c) const
+        { return cache_enabled ? (cachedFlags & c) : 0; }
+
+        inline void setCachedFlag(uint c)
+        { if (cache_enabled) cachedFlags |= c; }
+    } *data;
+
+    inline void reset() {
+        detach();
+        data->clear();
+    }
+
+    void detach();
+};
+
+
+QT_END_NAMESPACE
+#endif
+
diff --git a/src/corelib/io/qfilesystemwatcher.cpp b/src/corelib/io/qfilesystemwatcher.cpp
new file mode 100644
index 0000000..e073a08
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher.cpp
@@ -0,0 +1,620 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qfilesystemwatcher.h"
+#include "qfilesystemwatcher_p.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <qdatetime.h>
+#include <qdebug.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qmutex.h>
+#include <qset.h>
+#include <qtimer.h>
+
+#if defined(Q_OS_WIN)
+#  include "qfilesystemwatcher_win_p.h"
+#elif defined(Q_OS_LINUX)
+#  include "qfilesystemwatcher_inotify_p.h"
+#  include "qfilesystemwatcher_dnotify_p.h"
+#elif defined(Q_OS_FREEBSD) || defined(Q_OS_MAC)
+#  include "qfilesystemwatcher_kqueue_p.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+enum { PollingInterval = 1000 };
+
+class QPollingFileSystemWatcherEngine : public QFileSystemWatcherEngine
+{
+    Q_OBJECT
+
+    class FileInfo
+    {
+        uint ownerId;
+        uint groupId;
+        QFile::Permissions permissions;
+        QDateTime lastModified;
+        QStringList entries;
+
+    public:
+        FileInfo(const QFileInfo &fileInfo)
+            : ownerId(fileInfo.ownerId()),
+              groupId(fileInfo.groupId()),
+              permissions(fileInfo.permissions()),
+              lastModified(fileInfo.lastModified())
+        { 
+            if (fileInfo.isDir()) {
+                entries = fileInfo.absoluteDir().entryList(QDir::AllEntries);
+            }
+        }
+        FileInfo &operator=(const QFileInfo &fileInfo)
+        {
+            *this = FileInfo(fileInfo);
+            return *this;
+        }
+
+        bool operator!=(const QFileInfo &fileInfo) const
+        {
+            if (fileInfo.isDir() && entries != fileInfo.absoluteDir().entryList(QDir::AllEntries))
+                return true;
+            return (ownerId != fileInfo.ownerId()
+                    || groupId != fileInfo.groupId()
+                    || permissions != fileInfo.permissions()
+                    || lastModified != fileInfo.lastModified());
+        }
+    };
+
+    mutable QMutex mutex;
+    QHash<QString, FileInfo> files, directories;
+
+public:
+    QPollingFileSystemWatcherEngine();
+
+    void run();
+
+    QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
+    QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
+
+    void stop();
+
+private slots:
+    void timeout();
+};
+
+QPollingFileSystemWatcherEngine::QPollingFileSystemWatcherEngine()
+{
+#ifndef QT_NO_THREAD
+    moveToThread(this);
+#endif
+}
+
+void QPollingFileSystemWatcherEngine::run()
+{
+    QTimer timer;
+    connect(&timer, SIGNAL(timeout()), SLOT(timeout()));
+    timer.start(PollingInterval);
+    (void) exec();
+}
+
+QStringList QPollingFileSystemWatcherEngine::addPaths(const QStringList &paths,
+                                                      QStringList *files,
+                                                      QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        QFileInfo fi(path);
+        if (!fi.exists())
+            continue;
+        if (fi.isDir()) {
+            if (!directories->contains(path))
+                directories->append(path);
+            if (!path.endsWith(QLatin1Char('/')))
+                fi = QFileInfo(path + QLatin1Char('/'));
+            this->directories.insert(path, fi);
+        } else {
+            if (!files->contains(path))
+                files->append(path);
+            this->files.insert(path, fi);
+        }
+        it.remove();
+    }
+    start();
+    return p;
+}
+
+QStringList QPollingFileSystemWatcherEngine::removePaths(const QStringList &paths,
+                                                         QStringList *files,
+                                                         QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        if (this->directories.remove(path)) {
+            directories->removeAll(path);
+            it.remove();
+        } else if (this->files.remove(path)) {
+            files->removeAll(path);
+            it.remove();
+        }
+    }
+    if (this->files.isEmpty() && this->directories.isEmpty()) {
+        locker.unlock();
+        stop();
+        wait();
+    }
+    return p;
+}
+
+void QPollingFileSystemWatcherEngine::stop()
+{
+    QMetaObject::invokeMethod(this, "quit");
+}
+
+void QPollingFileSystemWatcherEngine::timeout()
+{
+    QMutexLocker locker(&mutex);
+    QMutableHashIterator<QString, FileInfo> fit(files);
+    while (fit.hasNext()) {
+        QHash<QString, FileInfo>::iterator x = fit.next();
+        QString path = x.key();
+        QFileInfo fi(path);
+        if (!fi.exists()) {
+            fit.remove();
+            emit fileChanged(path, true);
+        } else if (x.value() != fi) {
+            x.value() = fi;
+            emit fileChanged(path, false);
+        }
+    }
+    QMutableHashIterator<QString, FileInfo> dit(directories);
+    while (dit.hasNext()) {
+        QHash<QString, FileInfo>::iterator x = dit.next();
+        QString path = x.key();
+        QFileInfo fi(path);
+        if (!path.endsWith(QLatin1Char('/')))
+            fi = QFileInfo(path + QLatin1Char('/'));
+        if (!fi.exists()) {
+            dit.remove();
+            emit directoryChanged(path, true);
+        } else if (x.value() != fi) {
+            x.value() = fi;
+            emit directoryChanged(path, false);
+        }
+        
+    }
+}
+
+
+
+
+QFileSystemWatcherEngine *QFileSystemWatcherPrivate::createNativeEngine()
+{
+#if defined(Q_OS_WIN)
+    return new QWindowsFileSystemWatcherEngine;
+#elif defined(Q_OS_LINUX)
+    QFileSystemWatcherEngine *eng = QInotifyFileSystemWatcherEngine::create();
+    if(!eng)
+        eng = QDnotifyFileSystemWatcherEngine::create();
+    return eng;
+#elif defined(Q_OS_FREEBSD) || defined(Q_OS_MAC)
+    return QKqueueFileSystemWatcherEngine::create();
+#else
+    return 0;
+#endif
+}
+
+QFileSystemWatcherPrivate::QFileSystemWatcherPrivate()
+    : native(0), poller(0), forced(0)
+{
+}
+
+void QFileSystemWatcherPrivate::init()
+{
+    Q_Q(QFileSystemWatcher);
+    native = createNativeEngine();
+    if (native) {
+        QObject::connect(native,
+                         SIGNAL(fileChanged(QString,bool)),
+                         q,
+                         SLOT(_q_fileChanged(QString,bool)));
+        QObject::connect(native,
+                         SIGNAL(directoryChanged(QString,bool)),
+                         q,
+                         SLOT(_q_directoryChanged(QString,bool)));
+    }
+}
+
+void QFileSystemWatcherPrivate::initForcedEngine(const QString &forceName)
+{
+    if(forced)
+        return;
+
+    Q_Q(QFileSystemWatcher);
+
+#if defined(Q_OS_LINUX)
+    if(forceName == QLatin1String("inotify")) {
+        forced = QInotifyFileSystemWatcherEngine::create();
+    } else if(forceName == QLatin1String("dnotify")) {
+        forced = QDnotifyFileSystemWatcherEngine::create();
+    }
+#else
+    Q_UNUSED(forceName);
+#endif
+
+    if(forced) {
+        QObject::connect(forced,
+                         SIGNAL(fileChanged(QString,bool)),
+                         q,
+                         SLOT(_q_fileChanged(QString,bool)));
+        QObject::connect(forced,
+                         SIGNAL(directoryChanged(QString,bool)),
+                         q,
+                         SLOT(_q_directoryChanged(QString,bool)));
+    }
+}
+
+void QFileSystemWatcherPrivate::initPollerEngine()
+{
+    if(poller)
+        return;
+
+    Q_Q(QFileSystemWatcher);
+    poller = new QPollingFileSystemWatcherEngine; // that was a mouthful
+    QObject::connect(poller,
+                     SIGNAL(fileChanged(QString,bool)),
+                     q,
+                     SLOT(_q_fileChanged(QString,bool)));
+    QObject::connect(poller,
+                     SIGNAL(directoryChanged(QString,bool)),
+                     q,
+                     SLOT(_q_directoryChanged(QString,bool)));
+}
+
+void QFileSystemWatcherPrivate::_q_fileChanged(const QString &path, bool removed)
+{
+    Q_Q(QFileSystemWatcher);
+    if (!files.contains(path)) {
+        // the path was removed after a change was detected, but before we delivered the signal
+        return;
+    }
+    if (removed)
+        files.removeAll(path);
+    emit q->fileChanged(path);
+}
+
+void QFileSystemWatcherPrivate::_q_directoryChanged(const QString &path, bool removed)
+{
+    Q_Q(QFileSystemWatcher);
+    if (!directories.contains(path)) {
+        // perhaps the path was removed after a change was detected, but before we delivered the signal
+        return;
+    }
+    if (removed)
+        directories.removeAll(path);
+    emit q->directoryChanged(path);
+}
+
+
+
+/*!
+    \class QFileSystemWatcher
+    \brief The QFileSystemWatcher class provides an interface for monitoring files and directories for modifications.
+    \ingroup io
+    \since 4.2
+    \reentrant
+
+    QFileSystemWatcher monitors the file system for changes to files
+    and directories by watching a list of specified paths.
+
+    Call addPath() to watch a particular file or directory. Multiple
+    paths can be added using the addPaths() function. Existing paths can
+    be removed by using the removePath() and removePaths() functions.
+
+    QFileSystemWatcher examines each path added to it. Files that have
+    been added to the QFileSystemWatcher can be accessed using the
+    files() function, and directories using the directories() function.
+
+    The fileChanged() signal is emitted when a file has been modified,
+    renamed or removed from disk. Similarly, the directoryChanged()
+    signal is emitted when a directory or its contents is modified or
+    removed.  Note that QFileSystemWatcher stops monitoring files once
+    they have been renamed or removed from disk, and directories once
+    they have been removed from disk.
+
+    \note On systems running a Linux kernel without inotify support,
+    file systems that contain watched paths cannot be unmounted.
+
+    \note Windows CE does not support directory monitoring by
+    default as this depends on the file system driver installed.
+
+    \note The act of monitoring files and directories for
+    modifications consumes system resources. This implies there is a
+    limit to the number of files and directories your process can
+    monitor simultaneously. On Mac OS and all BSD variants, for
+    example, an open file descriptor is required for each monitored
+    file. The system limits the number of open file descriptors to 256
+    by default. This means that addPath() and addPaths() will fail if
+    your process tries to add more than 256 files or directories to
+    the file system monitor. Also note that your process may have
+    other file descriptors open in addition to the ones for files
+    being monitored, and these other open descriptors also count in
+    the total.
+
+    \sa QFile, QDir
+*/
+
+
+/*!
+    Constructs a new file system watcher object with the given \a parent.
+*/
+QFileSystemWatcher::QFileSystemWatcher(QObject *parent)
+    : QObject(*new QFileSystemWatcherPrivate, parent)
+{
+    d_func()->init();
+}
+
+/*!
+    Constructs a new file system watcher object with the given \a parent
+    which monitors the specified \a paths list.
+*/
+QFileSystemWatcher::QFileSystemWatcher(const QStringList &paths, QObject *parent)
+    : QObject(*new QFileSystemWatcherPrivate, parent)
+{
+    d_func()->init();
+    addPaths(paths);
+}
+
+/*!
+    Destroys the file system watcher.
+*/
+QFileSystemWatcher::~QFileSystemWatcher()
+{
+    Q_D(QFileSystemWatcher);
+    if (d->native) {
+        d->native->stop();
+        d->native->wait();
+        delete d->native;
+        d->native = 0;
+    }
+    if (d->poller) {
+        d->poller->stop();
+        d->poller->wait();
+        delete d->poller;
+        d->poller = 0;
+    }
+    if (d->forced) {
+        d->forced->stop();
+        d->forced->wait();
+        delete d->forced;
+        d->forced = 0;
+    }
+}
+
+/*!
+    Adds \a path to the file system watcher if \a path exists. The
+    path is not added if it does not exist, or if it is already being
+    monitored by the file system watcher.
+
+    If \a path specifies a directory, the directoryChanged() signal
+    will be emitted when \a path is modified or removed from disk;
+    otherwise the fileChanged() signal is emitted when \a path is
+    modified, renamed or removed.
+
+    \note There is a system dependent limit to the number of files and
+    directories that can be monitored simultaneously. If this limit
+    has been reached, \a path will not be added to the file system
+    watcher, and a warning message will be printed to \e{stderr}.
+
+    \sa addPaths(), removePath()
+*/
+void QFileSystemWatcher::addPath(const QString &path)
+{
+    if (path.isEmpty()) {
+        qWarning("QFileSystemWatcher::addPath: path is empty");
+        return;
+    }
+    addPaths(QStringList(path));
+}
+
+/*!
+    Adds each path in \a paths to the file system watcher. Paths are
+    not added if they not exist, or if they are already being
+    monitored by the file system watcher.
+
+    If a path specifies a directory, the directoryChanged() signal
+    will be emitted when the path is modified or removed from disk;
+    otherwise the fileChanged() signal is emitted when the path is
+    modified, renamed, or removed.
+
+    \note There is a system dependent limit to the number of files and
+    directories that can be monitored simultaneously. If this limit
+    has been reached, the excess \a paths will not be added to the
+    file system watcher, and a warning message will be printed to
+    \e{stderr} for each path that could not be added.
+
+    \sa addPath(), removePaths()
+*/
+void QFileSystemWatcher::addPaths(const QStringList &paths)
+{
+    Q_D(QFileSystemWatcher);
+    if (paths.isEmpty()) {
+        qWarning("QFileSystemWatcher::addPaths: list is empty");
+        return;
+    }
+
+    QStringList p = paths;
+    QFileSystemWatcherEngine *engine = 0;
+
+    if(!objectName().startsWith(QLatin1String("_qt_autotest_force_engine_"))) {
+        // Normal runtime case - search intelligently for best engine
+        if(d->native) {
+            engine = d->native;
+        } else {
+            d_func()->initPollerEngine();
+            engine = d->poller;
+        }
+
+    } else {
+        // Autotest override case - use the explicitly selected engine only
+        QString forceName = objectName().mid(26);
+        if(forceName == QLatin1String("poller")) {
+            qDebug() << "QFileSystemWatcher: skipping native engine, using only polling engine";
+            d_func()->initPollerEngine();
+            engine = d->poller;
+        } else if(forceName == QLatin1String("native")) {
+            qDebug() << "QFileSystemWatcher: skipping polling engine, using only native engine";
+            engine = d->native;
+        } else {
+            qDebug() << "QFileSystemWatcher: skipping polling and native engine, using only explicit" << forceName << "engine";
+            d_func()->initForcedEngine(forceName);
+            engine = d->forced;
+        }
+    }
+
+    if(engine)
+        p = engine->addPaths(p, &d->files, &d->directories);
+
+    if (!p.isEmpty())
+        qWarning("QFileSystemWatcher: failed to add paths: %s",
+                 qPrintable(p.join(QLatin1String(", "))));
+}
+
+/*!
+    Removes the specified \a path from the file system watcher.
+
+    \sa removePaths(), addPath()
+*/
+void QFileSystemWatcher::removePath(const QString &path)
+{
+    if (path.isEmpty()) {
+        qWarning("QFileSystemWatcher::removePath: path is empty");
+        return;
+    }
+    removePaths(QStringList(path));
+}
+
+/*!
+    Removes the specified \a paths from the file system watcher.
+
+    \sa removePath(), addPaths()
+*/
+void QFileSystemWatcher::removePaths(const QStringList &paths)
+{
+    if (paths.isEmpty()) {
+        qWarning("QFileSystemWatcher::removePaths: list is empty");
+        return;
+    }
+    Q_D(QFileSystemWatcher);
+    QStringList p = paths;
+    if (d->native)
+        p = d->native->removePaths(p, &d->files, &d->directories);
+    if (d->poller)
+        p = d->poller->removePaths(p, &d->files, &d->directories);
+    if (d->forced)
+        p = d->forced->removePaths(p, &d->files, &d->directories);
+}
+
+/*!
+    \fn void QFileSystemWatcher::fileChanged(const QString &path)
+
+    This signal is emitted when the file at the specified \a path is
+    modified, renamed or removed from disk.
+
+    \sa directoryChanged()
+*/
+
+/*!
+    \fn void QFileSystemWatcher::directoryChanged(const QString &path)
+
+    This signal is emitted when the directory at a specified \a path,
+    is modified (e.g., when a file is added, modified or deleted) or
+    removed from disk. Note that if there are several changes during a
+    short period of time, some of the changes might not emit this
+    signal. However, the last change in the sequence of changes will
+    always generate this signal.
+
+    \sa fileChanged()
+*/
+
+/*!
+    \fn QStringList QFileSystemWatcher::directories() const
+
+    Returns a list of paths to directories that are being watched.
+
+    \sa files()
+*/
+
+/*!
+    \fn QStringList QFileSystemWatcher::files() const
+
+    Returns a list of paths to files that are being watched.
+
+    \sa directories()
+*/
+
+QStringList QFileSystemWatcher::directories() const
+{
+    Q_D(const QFileSystemWatcher);
+    return d->directories;
+}
+
+QStringList QFileSystemWatcher::files() const
+{
+    Q_D(const QFileSystemWatcher);
+    return d->files;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qfilesystemwatcher.cpp"
+
+#include "qfilesystemwatcher.moc"
+
+#endif // QT_NO_FILESYSTEMWATCHER
+
diff --git a/src/corelib/io/qfilesystemwatcher.h b/src/corelib/io/qfilesystemwatcher.h
new file mode 100644
index 0000000..b9cea53
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILESYSTEMWATCHER_H
+#define QFILESYSTEMWATCHER_H
+
+#include <QtCore/qobject.h>
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QFileSystemWatcherPrivate;
+
+class Q_CORE_EXPORT QFileSystemWatcher : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QFileSystemWatcher)
+
+public:
+    QFileSystemWatcher(QObject *parent = 0);
+    QFileSystemWatcher(const QStringList &paths, QObject *parent = 0);
+    ~QFileSystemWatcher();
+
+    void addPath(const QString &file);
+    void addPaths(const QStringList &files);
+    void removePath(const QString &file);
+    void removePaths(const QStringList &files);
+
+    QStringList files() const;
+    QStringList directories() const;
+
+Q_SIGNALS:
+    void fileChanged(const QString &path);
+    void directoryChanged(const QString &path);
+
+private:
+    Q_PRIVATE_SLOT(d_func(), void _q_fileChanged(const QString &path, bool removed))
+    Q_PRIVATE_SLOT(d_func(), void _q_directoryChanged(const QString &path, bool removed))
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_FILESYSTEMWATCHER
+#endif // QFILESYSTEMWATCHER_H
diff --git a/src/corelib/io/qfilesystemwatcher_dnotify.cpp b/src/corelib/io/qfilesystemwatcher_dnotify.cpp
new file mode 100644
index 0000000..e87375a
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_dnotify.cpp
@@ -0,0 +1,461 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qfilesystemwatcher.h"
+#include "qfilesystemwatcher_dnotify_p.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <qsocketnotifier.h>
+#include <qcoreapplication.h>
+#include <qfileinfo.h>
+#include <qtimer.h>
+#include <qwaitcondition.h>
+#include <qmutex.h>
+#include <dirent.h>
+#include <qdir.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+
+#ifdef QT_LINUXBASE
+
+/* LSB doesn't standardize these */
+#define F_NOTIFY       1026
+#define DN_ACCESS      0x00000001
+#define DN_MODIFY      0x00000002
+#define DN_CREATE      0x00000004
+#define DN_DELETE      0x00000008
+#define DN_RENAME      0x00000010
+#define DN_ATTRIB      0x00000020
+#define DN_MULTISHOT   0x80000000
+
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static int qfswd_fileChanged_pipe[2];
+static void (*qfswd_old_sigio_handler)(int) = 0;
+static void (*qfswd_old_sigio_action)(int, siginfo_t *, void *) = 0;
+static void qfswd_sigio_monitor(int signum, siginfo_t *i, void *v)
+{
+    ::write(qfswd_fileChanged_pipe[1], &i->si_fd, sizeof(int));
+
+    if (qfswd_old_sigio_handler && qfswd_old_sigio_handler != SIG_IGN)
+        qfswd_old_sigio_handler(signum);
+    if (qfswd_old_sigio_action)
+        qfswd_old_sigio_action(signum, i, v);
+}
+
+class QDnotifySignalThread : public QThread
+{
+Q_OBJECT
+public:
+    QDnotifySignalThread();
+    virtual ~QDnotifySignalThread();
+
+    void startNotify();
+
+    virtual void run();
+
+signals:
+    void fdChanged(int);
+
+protected:
+    virtual bool event(QEvent *);
+
+private slots:
+    void readFromDnotify();
+
+private:
+    QMutex mutex;
+    QWaitCondition wait;
+    bool isExecing;
+};
+
+Q_GLOBAL_STATIC(QDnotifySignalThread, dnotifySignal);
+
+QDnotifySignalThread::QDnotifySignalThread()
+: isExecing(false)
+{
+    moveToThread(this);
+
+    ::pipe(qfswd_fileChanged_pipe);
+    ::fcntl(qfswd_fileChanged_pipe[0], F_SETFL,
+            ::fcntl(qfswd_fileChanged_pipe[0], F_GETFL) | O_NONBLOCK);
+
+    struct sigaction oldAction;
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_sigaction = qfswd_sigio_monitor;
+    action.sa_flags = SA_SIGINFO;
+    ::sigaction(SIGIO, &action, &oldAction);
+    if (!(oldAction.sa_flags & SA_SIGINFO))
+        qfswd_old_sigio_handler = oldAction.sa_handler;
+    else
+        qfswd_old_sigio_action = oldAction.sa_sigaction;
+}
+
+QDnotifySignalThread::~QDnotifySignalThread()
+{
+    if(isRunning()) {
+        quit();
+        QThread::wait();
+    }
+}
+
+bool QDnotifySignalThread::event(QEvent *e)
+{
+    if(e->type() == QEvent::User) {
+        QMutexLocker locker(&mutex);
+        isExecing = true;
+        wait.wakeAll();
+        return true;
+    } else {
+        return QThread::event(e);
+    }
+}
+
+void QDnotifySignalThread::startNotify()
+{
+    // Note: All this fancy waiting for the thread to enter its event
+    // loop is to avoid nasty messages at app shutdown when the
+    // QDnotifySignalThread singleton is deleted
+    start();
+    mutex.lock();
+    while(!isExecing)
+        wait.wait(&mutex);
+    mutex.unlock();
+}
+
+void QDnotifySignalThread::run()
+{
+    QSocketNotifier sn(qfswd_fileChanged_pipe[0], QSocketNotifier::Read, this);
+    connect(&sn, SIGNAL(activated(int)), SLOT(readFromDnotify()));
+
+    QCoreApplication::instance()->postEvent(this, new QEvent(QEvent::User));
+    (void) exec();
+}
+
+void QDnotifySignalThread::readFromDnotify()
+{
+    int fd;
+    int readrv = ::read(qfswd_fileChanged_pipe[0], &fd,sizeof(int));
+    // Only expect EAGAIN or EINTR.  Other errors are assumed to be impossible.
+    if(readrv != -1) {
+        Q_ASSERT(readrv == sizeof(int));
+        Q_UNUSED(readrv);
+
+        if(0 == fd)
+            quit();
+        else
+            emit fdChanged(fd);
+    }
+}
+
+QDnotifyFileSystemWatcherEngine::QDnotifyFileSystemWatcherEngine()
+{
+    QObject::connect(dnotifySignal(), SIGNAL(fdChanged(int)),
+                     this, SLOT(refresh(int)), Qt::DirectConnection);
+}
+
+QDnotifyFileSystemWatcherEngine::~QDnotifyFileSystemWatcherEngine()
+{
+    QMutexLocker locker(&mutex);
+
+    for(QHash<int, Directory>::ConstIterator iter = fdToDirectory.constBegin();
+            iter != fdToDirectory.constEnd();
+            ++iter) {
+        ::close(iter->fd);
+        if(iter->parentFd)
+            ::close(iter->parentFd);
+    }
+}
+
+QDnotifyFileSystemWatcherEngine *QDnotifyFileSystemWatcherEngine::create()
+{
+    return new QDnotifyFileSystemWatcherEngine();
+}
+
+void QDnotifyFileSystemWatcherEngine::run()
+{
+    qFatal("QDnotifyFileSystemWatcherEngine thread should not be run");
+}
+
+QStringList QDnotifyFileSystemWatcherEngine::addPaths(const QStringList &paths, QStringList *files, QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+
+    while (it.hasNext()) {
+        QString path = it.next();
+
+        QFileInfo fi(path);
+
+        if(!fi.exists()) {
+            continue;
+        }
+
+        bool isDir = fi.isDir();
+
+        if (isDir && directories->contains(path)) {
+            continue; // Skip monitored directories
+        } else if(!isDir && files->contains(path)) {
+            continue; // Skip monitored files
+        }
+
+        if(!isDir)
+            path = fi.canonicalPath();
+
+        // Locate the directory entry (creating if needed)
+        int fd = pathToFD[path];
+
+        if(fd == 0) {
+
+            DIR *d = ::opendir(path.toUtf8().constData());
+            if(!d) continue; // Could not open directory
+            DIR *parent = 0;
+
+            QDir parentDir(path);
+            if(!parentDir.isRoot()) {
+                parentDir.cdUp();
+                parent = ::opendir(parentDir.path().toUtf8().constData());
+                if(!parent) {
+                    ::closedir(d);
+                    continue;
+                }
+            }
+
+            fd = ::dirfd(d);
+            int parentFd = parent?::dirfd(parent):0;
+
+            Q_ASSERT(fd);
+            if(::fcntl(fd, F_SETSIG, SIGIO) ||
+               ::fcntl(fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_DELETE |
+                                     DN_RENAME | DN_ATTRIB | DN_MULTISHOT) ||
+               (parent && ::fcntl(parentFd, F_SETSIG, SIGIO)) ||
+               (parent && ::fcntl(parentFd, F_NOTIFY, DN_DELETE | DN_RENAME |
+                                            DN_MULTISHOT))) {
+
+                ::closedir(d);
+                if(parent) ::closedir(parent);
+
+                continue; // Could not set appropriate flags
+            }
+
+            Directory dir;
+            dir.path = path;
+            dir.fd = fd;
+            dir.parentFd = parentFd;
+
+            fdToDirectory.insert(fd, dir);
+            pathToFD.insert(path, fd);
+            if(parentFd)
+                parentToFD.insert(parentFd, fd);
+        }
+
+        Directory &directory = fdToDirectory[fd];
+
+        if(isDir) {
+            directory.isMonitored = true;
+        } else {
+            Directory::File file;
+            file.path = fi.filePath();
+            file.lastWrite = fi.lastModified();
+            directory.files.append(file);
+            pathToFD.insert(fi.filePath(), fd);
+        }
+
+        it.remove();
+
+        if(isDir) {
+            directories->append(path);
+        } else {
+            files->append(fi.filePath());
+        }
+    }
+
+    dnotifySignal()->startNotify();
+
+    return p;
+}
+
+QStringList QDnotifyFileSystemWatcherEngine::removePaths(const QStringList &paths, QStringList *files, QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+
+        QString path = it.next();
+        int fd = pathToFD.take(path);
+
+        if(!fd)
+            continue;
+
+        Directory &directory = fdToDirectory[fd];
+        bool isDir = false;
+        if(directory.path == path) {
+            isDir = true;
+            directory.isMonitored = false;
+        } else {
+            for(int ii = 0; ii < directory.files.count(); ++ii) {
+                if(directory.files.at(ii).path == path) {
+                    directory.files.removeAt(ii);
+                    break;
+                }
+            }
+        }
+
+        if(!directory.isMonitored && directory.files.isEmpty()) {
+            // No longer needed
+            ::close(directory.fd);
+            pathToFD.remove(directory.path);
+            fdToDirectory.remove(fd);
+        }
+
+        if(isDir) {
+            directories->removeAll(path);
+        } else {
+            files->removeAll(path);
+        }
+
+        it.remove();
+    }
+
+    return p;
+}
+
+void QDnotifyFileSystemWatcherEngine::refresh(int fd)
+{
+    QMutexLocker locker(&mutex);
+
+    bool wasParent = false;
+    QHash<int, Directory>::Iterator iter = fdToDirectory.find(fd);
+    if(iter == fdToDirectory.end()) {
+        QHash<int, int>::Iterator pIter = parentToFD.find(fd);
+        if(pIter == parentToFD.end())
+            return;
+
+        iter = fdToDirectory.find(*pIter);
+        if (iter == fdToDirectory.end())
+            return;
+        wasParent = true;
+    }
+
+    Directory &directory = *iter;
+
+    if(!wasParent) {
+        for(int ii = 0; ii < directory.files.count(); ++ii) {
+            Directory::File &file = directory.files[ii];
+            if(file.updateInfo()) {
+                // Emit signal
+                QString filePath = file.path;
+                bool removed = !QFileInfo(filePath).exists();
+
+                if(removed) {
+                    directory.files.removeAt(ii);
+                    --ii;
+                }
+
+                emit fileChanged(filePath, removed);
+            }
+        }
+    }
+
+    if(directory.isMonitored) {
+        // Emit signal
+        bool removed = !QFileInfo(directory.path).exists();
+        QString path = directory.path;
+
+        if(removed)
+            directory.isMonitored = false;
+
+        emit directoryChanged(path, removed);
+    }
+
+    if(!directory.isMonitored && directory.files.isEmpty()) {
+        ::close(directory.fd);
+        if(directory.parentFd) {
+            ::close(directory.parentFd);
+            parentToFD.remove(directory.parentFd);
+        }
+        fdToDirectory.erase(iter);
+    }
+}
+
+void QDnotifyFileSystemWatcherEngine::stop()
+{
+}
+
+bool QDnotifyFileSystemWatcherEngine::Directory::File::updateInfo()
+{
+    QFileInfo fi(path);
+    QDateTime nLastWrite = fi.lastModified();
+    uint nOwnerId = fi.ownerId();
+    uint nGroupId = fi.groupId();
+    QFile::Permissions nPermissions = fi.permissions();
+
+    if(nLastWrite != lastWrite ||
+       nOwnerId != ownerId ||
+       nGroupId != groupId ||
+       nPermissions != permissions) {
+        ownerId = nOwnerId;
+        groupId = nGroupId;
+        permissions = nPermissions;
+        lastWrite = nLastWrite;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+QT_END_NAMESPACE
+
+#include "qfilesystemwatcher_dnotify.moc"
+
+#endif // QT_NO_FILESYSTEMWATCHER
diff --git a/src/corelib/io/qfilesystemwatcher_dnotify_p.h b/src/corelib/io/qfilesystemwatcher_dnotify_p.h
new file mode 100644
index 0000000..81a70ed
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_dnotify_p.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILESYSTEMWATCHER_DNOTIFY_P_H
+#define QFILESYSTEMWATCHER_DNOTIFY_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qfilesystemwatcher_p.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <qmutex.h>
+#include <qhash.h>
+#include <qdatetime.h>
+#include <qfile.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDnotifyFileSystemWatcherEngine : public QFileSystemWatcherEngine
+{
+    Q_OBJECT
+
+public:
+    virtual ~QDnotifyFileSystemWatcherEngine();
+
+    static QDnotifyFileSystemWatcherEngine *create();
+
+    void run();
+
+    QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
+    QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
+
+    void stop();
+
+private Q_SLOTS:
+    void refresh(int);
+
+private:
+    struct Directory {
+        Directory() : fd(0), parentFd(0), isMonitored(false) {}
+        Directory(const Directory &o) : path(o.path),
+                                        fd(o.fd),
+                                        parentFd(o.parentFd),
+                                        isMonitored(o.isMonitored),
+                                        files(o.files) {}
+        QString path;
+        int fd;
+        int parentFd;
+        bool isMonitored;
+
+        struct File {
+            File() : ownerId(0u), groupId(0u), permissions(0u) { }
+            File(const File &o) : path(o.path),
+                                  ownerId(o.ownerId),
+                                  groupId(o.groupId),
+                                  permissions(o.permissions),
+                                  lastWrite(o.lastWrite) {}
+            QString path;
+
+            bool updateInfo();
+
+            uint ownerId;
+            uint groupId;
+            QFile::Permissions permissions;
+            QDateTime lastWrite;
+        };
+
+        QList<File> files;
+    };
+
+    QDnotifyFileSystemWatcherEngine();
+
+    QMutex mutex;
+    QHash<QString, int> pathToFD;
+    QHash<int, Directory> fdToDirectory;
+    QHash<int, int> parentToFD;
+};
+
+
+
+QT_END_NAMESPACE
+#endif // QT_NO_FILESYSTEMWATCHER
+#endif // QFILESYSTEMWATCHER_DNOTIFY_P_H
diff --git a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
new file mode 100644
index 0000000..4445e3c
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp
@@ -0,0 +1,376 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qfilesystemwatcher.h"
+#include "qfilesystemwatcher_inotify_p.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <qdebug.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qsocketnotifier.h>
+#include <qvarlengtharray.h>
+
+#include <sys/syscall.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#if defined(QT_NO_INOTIFY)
+#include <linux/types.h>
+
+#if defined(__i386__)
+# define __NR_inotify_init      291
+# define __NR_inotify_add_watch 292
+# define __NR_inotify_rm_watch  293
+#elif defined(__x86_64__)
+# define __NR_inotify_init      253
+# define __NR_inotify_add_watch 254
+# define __NR_inotify_rm_watch  255
+#elif defined(__powerpc__) || defined(__powerpc64__)
+# define __NR_inotify_init      275
+# define __NR_inotify_add_watch 276
+# define __NR_inotify_rm_watch  277
+#elif defined (__ia64__)
+# define __NR_inotify_init      1277
+# define __NR_inotify_add_watch 1278
+# define __NR_inotify_rm_watch  1279
+#elif defined (__s390__) || defined (__s390x__)
+# define __NR_inotify_init      284
+# define __NR_inotify_add_watch 285
+# define __NR_inotify_rm_watch  286
+#elif defined (__alpha__)
+# define __NR_inotify_init      444
+# define __NR_inotify_add_watch 445
+# define __NR_inotify_rm_watch  446
+#elif defined (__sparc__) || defined (__sparc64__)
+# define __NR_inotify_init      151
+# define __NR_inotify_add_watch 152
+# define __NR_inotify_rm_watch  156
+#elif defined (__arm__)
+# define __NR_inotify_init      316
+# define __NR_inotify_add_watch 317
+# define __NR_inotify_rm_watch  318
+#elif defined (__sh__)
+# define __NR_inotify_init      290
+# define __NR_inotify_add_watch 291
+# define __NR_inotify_rm_watch  292
+#elif defined (__sh64__)
+# define __NR_inotify_init      318
+# define __NR_inotify_add_watch 319
+# define __NR_inotify_rm_watch  320
+#elif defined (__mips__)
+# define __NR_inotify_init      284
+# define __NR_inotify_add_watch 285
+# define __NR_inotify_rm_watch  286
+#elif defined (__hppa__)
+# define __NR_inotify_init      269
+# define __NR_inotify_add_watch 270
+# define __NR_inotify_rm_watch  271
+#elif defined (__avr32__)
+# define __NR_inotify_init	240
+# define __NR_inotify_add_watch	241
+# define __NR_inotify_rm_watch	242
+#elif defined (__mc68000__)
+# define __NR_inotify_init      284
+# define __NR_inotify_add_watch 285
+# define __NR_inotify_rm_watch  286
+#else
+# error "This architecture is not supported. Please talk to qt-bugs@trolltech.com"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifdef QT_LINUXBASE
+// ### the LSB doesn't standardize syscall, need to wait until glib2.4 is standardized
+static inline int syscall(...) { return -1; }
+#endif
+
+static inline int inotify_init()
+{
+    return syscall(__NR_inotify_init);
+}
+
+static inline int inotify_add_watch(int fd, const char *name, __u32 mask)
+{
+    return syscall(__NR_inotify_add_watch, fd, name, mask);
+}
+
+static inline int inotify_rm_watch(int fd, __u32 wd)
+{
+    return syscall(__NR_inotify_rm_watch, fd, wd);
+}
+
+// the following struct and values are documented in linux/inotify.h
+extern "C" {
+
+struct inotify_event {
+        __s32           wd;
+        __u32           mask;
+        __u32           cookie;
+        __u32           len;
+        char            name[0];
+};
+
+#define IN_ACCESS               0x00000001
+#define IN_MODIFY               0x00000002
+#define IN_ATTRIB               0x00000004
+#define IN_CLOSE_WRITE          0x00000008
+#define IN_CLOSE_NOWRITE        0x00000010
+#define IN_OPEN                 0x00000020
+#define IN_MOVED_FROM           0x00000040
+#define IN_MOVED_TO             0x00000080
+#define IN_CREATE               0x00000100
+#define IN_DELETE               0x00000200
+#define IN_DELETE_SELF          0x00000400
+#define IN_MOVE_SELF            0x00000800
+#define IN_UNMOUNT              0x00002000
+#define IN_Q_OVERFLOW           0x00004000
+#define IN_IGNORED              0x00008000
+
+#define IN_CLOSE                (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
+#define IN_MOVE                 (IN_MOVED_FROM | IN_MOVED_TO)
+}
+
+QT_END_NAMESPACE
+
+// --------- inotify.h end ----------
+
+#else /* QT_NO_INOTIFY */
+
+#include <sys/inotify.h>
+
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QInotifyFileSystemWatcherEngine *QInotifyFileSystemWatcherEngine::create()
+{
+    int fd = inotify_init();
+    if (fd <= 0)
+        return 0;
+    return new QInotifyFileSystemWatcherEngine(fd);
+}
+
+QInotifyFileSystemWatcherEngine::QInotifyFileSystemWatcherEngine(int fd)
+    : inotifyFd(fd)
+{
+    fcntl(inotifyFd, F_SETFD, FD_CLOEXEC);
+
+    moveToThread(this);
+}
+
+QInotifyFileSystemWatcherEngine::~QInotifyFileSystemWatcherEngine()
+{
+    foreach (int id, pathToID.values())
+        inotify_rm_watch(inotifyFd, id < 0 ? -id : id);
+
+    ::close(inotifyFd);
+}
+
+void QInotifyFileSystemWatcherEngine::run()
+{
+    QSocketNotifier sn(inotifyFd, QSocketNotifier::Read, this);
+    connect(&sn, SIGNAL(activated(int)), SLOT(readFromInotify()));
+    (void) exec();
+}
+
+QStringList QInotifyFileSystemWatcherEngine::addPaths(const QStringList &paths,
+                                                      QStringList *files,
+                                                      QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        QFileInfo fi(path);
+        bool isDir = fi.isDir();
+        if (isDir) {
+            if (directories->contains(path))
+                continue;
+        } else {
+            if (files->contains(path))
+                continue;
+        }
+
+        int wd = inotify_add_watch(inotifyFd,
+                                   QFile::encodeName(path),
+                                   (isDir
+                                    ? (0
+                                       | IN_ATTRIB
+                                       | IN_MOVE
+                                       | IN_CREATE
+                                       | IN_DELETE
+                                       | IN_DELETE_SELF
+                                       )
+                                    : (0
+                                       | IN_ATTRIB
+                                       | IN_MODIFY
+                                       | IN_MOVE
+                                       | IN_MOVE_SELF
+                                       | IN_DELETE_SELF
+                                       )));
+        if (wd <= 0) {
+            perror("QInotifyFileSystemWatcherEngine::addPaths: inotify_add_watch failed");
+            continue;
+        }
+
+        it.remove();
+
+        int id = isDir ? -wd : wd;
+        if (id < 0) {
+            directories->append(path);
+        } else {
+            files->append(path);
+        }
+
+        pathToID.insert(path, id);
+        idToPath.insert(id, path);
+    }
+
+    start();
+
+    return p;
+}
+
+QStringList QInotifyFileSystemWatcherEngine::removePaths(const QStringList &paths,
+                                                         QStringList *files,
+                                                         QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        int id = pathToID.take(path);
+        QString x = idToPath.take(id);
+        if (x.isEmpty() || x != path)
+            continue;
+
+        int wd = id < 0 ? -id : id;
+        // qDebug() << "removing watch for path" << path << "wd" << wd;
+        inotify_rm_watch(inotifyFd, wd);
+
+        it.remove();
+        if (id < 0) {
+            directories->removeAll(path);
+        } else {
+            files->removeAll(path);
+        }
+    }
+
+    return p;
+}
+
+void QInotifyFileSystemWatcherEngine::stop()
+{
+    QMetaObject::invokeMethod(this, "quit");
+}
+
+void QInotifyFileSystemWatcherEngine::readFromInotify()
+{
+    QMutexLocker locker(&mutex);
+
+    // qDebug() << "QInotifyFileSystemWatcherEngine::readFromInotify";
+
+    int buffSize = 0;
+    ioctl(inotifyFd, FIONREAD, &buffSize);
+    QVarLengthArray<char, 4096> buffer(buffSize);
+    buffSize = read(inotifyFd, buffer.data(), buffSize);
+    const char *at = buffer.data();
+    const char * const end = at + buffSize;
+
+    QMap<int, inotify_event> eventForId;
+    while (at < end) {
+        const inotify_event *event = reinterpret_cast<const inotify_event *>(at);
+
+        if (eventForId.contains(event->wd))
+            eventForId[event->wd].mask |= event->mask;
+        else
+            eventForId.insert(event->wd, *event);
+
+        at += sizeof(inotify_event) + event->len;
+    }
+
+    QMap<int, inotify_event>::const_iterator it = eventForId.constBegin();
+    while (it != eventForId.constEnd()) {
+        inotify_event event = *it;
+        ++it;
+
+        // qDebug() << "inotify event, wd" << event.wd << "mask" << hex << event.mask;
+
+        int id = event.wd;
+        QString path = idToPath.value(id);
+        if (path.isEmpty()) {
+            // perhaps a directory?
+            id = -id;
+            path = idToPath.value(id);
+            if (path.isEmpty())
+                continue;
+        }
+
+        // qDebug() << "event for path" << path;
+
+        if ((event.mask & (IN_DELETE_SELF | IN_MOVE_SELF | IN_UNMOUNT)) != 0) {
+            pathToID.remove(path);
+            idToPath.remove(id);
+            inotify_rm_watch(inotifyFd, event.wd);
+
+            if (id < 0)
+                emit directoryChanged(path, true);
+            else
+                emit fileChanged(path, true);
+        } else {
+            if (id < 0)
+                emit directoryChanged(path, false);
+            else
+                emit fileChanged(path, false);
+        }
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_FILESYSTEMWATCHER
diff --git a/src/corelib/io/qfilesystemwatcher_inotify_p.h b/src/corelib/io/qfilesystemwatcher_inotify_p.h
new file mode 100644
index 0000000..8f3595c
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_inotify_p.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILESYSTEMWATCHER_INOTIFY_P_H
+#define QFILESYSTEMWATCHER_INOTIFY_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qfilesystemwatcher_p.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <qhash.h>
+#include <qmutex.h>
+
+QT_BEGIN_NAMESPACE
+
+class QInotifyFileSystemWatcherEngine : public QFileSystemWatcherEngine
+{
+    Q_OBJECT
+
+public:
+    ~QInotifyFileSystemWatcherEngine();
+
+    static QInotifyFileSystemWatcherEngine *create();
+
+    void run();
+
+    QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
+    QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
+
+    void stop();
+
+private Q_SLOTS:
+    void readFromInotify();
+
+private:
+    QInotifyFileSystemWatcherEngine(int fd);
+    int inotifyFd;
+    QMutex mutex;
+    QHash<QString, int> pathToID;
+    QHash<int, QString> idToPath;
+};
+
+
+QT_END_NAMESPACE
+#endif // QT_NO_FILESYSTEMWATCHER
+#endif // QFILESYSTEMWATCHER_INOTIFY_P_H
diff --git a/src/corelib/io/qfilesystemwatcher_kqueue.cpp b/src/corelib/io/qfilesystemwatcher_kqueue.cpp
new file mode 100644
index 0000000..cdf436e
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_kqueue.cpp
@@ -0,0 +1,334 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qplatformdefs.h>
+
+#include "qfilesystemwatcher.h"
+#include "qfilesystemwatcher_kqueue_p.h"
+
+#include <qdebug.h>
+#include <qfile.h>
+#include <qsocketnotifier.h>
+#include <qvarlengtharray.h>
+
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <fcntl.h>
+
+QT_BEGIN_NAMESPACE
+
+// #define KEVENT_DEBUG
+#ifdef KEVENT_DEBUG
+#  define DEBUG qDebug
+#else
+#  define DEBUG if(false)qDebug
+#endif
+
+QKqueueFileSystemWatcherEngine *QKqueueFileSystemWatcherEngine::create()
+{
+    int kqfd = kqueue();
+    if (kqfd == -1)
+        return 0;
+    return new QKqueueFileSystemWatcherEngine(kqfd);
+}
+
+QKqueueFileSystemWatcherEngine::QKqueueFileSystemWatcherEngine(int kqfd)
+    : kqfd(kqfd)
+{
+    fcntl(kqfd, F_SETFD, FD_CLOEXEC);
+
+    if (pipe(kqpipe) == -1) {
+        perror("QKqueueFileSystemWatcherEngine: cannot create pipe");
+        kqpipe[0] = kqpipe[1] = -1;
+        return;
+    }
+    fcntl(kqpipe[0], F_SETFD, FD_CLOEXEC);
+    fcntl(kqpipe[1], F_SETFD, FD_CLOEXEC);
+
+    struct kevent kev;
+    EV_SET(&kev,
+           kqpipe[0],
+           EVFILT_READ,
+           EV_ADD | EV_ENABLE,
+           0,
+           0,
+           0);
+    if (kevent(kqfd, &kev, 1, 0, 0, 0) == -1) {
+        perror("QKqueueFileSystemWatcherEngine: cannot watch pipe, kevent returned");
+        return;
+    }
+}
+
+QKqueueFileSystemWatcherEngine::~QKqueueFileSystemWatcherEngine()
+{
+    stop();
+    wait();
+
+    close(kqfd);
+    close(kqpipe[0]);
+    close(kqpipe[1]);
+
+    foreach (int id, pathToID.values())
+        ::close(id < 0 ? -id : id);
+}
+
+QStringList QKqueueFileSystemWatcherEngine::addPaths(const QStringList &paths,
+                                                     QStringList *files,
+                                                     QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        int fd;
+#if defined(O_EVTONLY)
+        fd = ::open(QFile::encodeName(path), O_EVTONLY);
+#else
+        fd = ::open(QFile::encodeName(path), O_RDONLY);
+#endif
+        if (fd == -1) {
+            perror("QKqueueFileSystemWatcherEngine::addPaths: open");
+            continue;
+        }
+
+        QT_STATBUF st;
+        if (QT_FSTAT(fd, &st) == -1) {
+            perror("QKqueueFileSystemWatcherEngine::addPaths: fstat");
+            ::close(fd);
+            continue;
+        }
+        int id = (S_ISDIR(st.st_mode)) ? -fd : fd;
+        if (id < 0) {
+            if (directories->contains(path)) {
+                ::close(fd);
+                continue;
+            }
+        } else {
+            if (files->contains(path)) {
+                ::close(fd);
+                continue;
+            }
+        }
+
+        struct kevent kev;
+        EV_SET(&kev,
+               fd,
+               EVFILT_VNODE,
+               EV_ADD | EV_ENABLE | EV_ONESHOT,
+               NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE,
+               0,
+               0);
+        if (kevent(kqfd, &kev, 1, 0, 0, 0) == -1) {
+            perror("QKqueueFileSystemWatcherEngine::addPaths: kevent");
+            ::close(fd);
+            continue;
+        }
+
+        it.remove();
+        if (id < 0) {
+            DEBUG() << "QKqueueFileSystemWatcherEngine: added directory path" << path;
+            directories->append(path);
+        } else {
+            DEBUG() << "QKqueueFileSystemWatcherEngine: added file path" << path;
+            files->append(path);
+        }
+
+        pathToID.insert(path, id);
+        idToPath.insert(id, path);
+    }
+
+    if (!isRunning())
+        start();
+    else
+        write(kqpipe[1], "@", 1);
+
+    return p;
+}
+
+QStringList QKqueueFileSystemWatcherEngine::removePaths(const QStringList &paths,
+                                                        QStringList *files,
+                                                        QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        int id = pathToID.take(path);
+        QString x = idToPath.take(id);
+        if (x.isEmpty() || x != path)
+            continue;
+
+        int fd = id < 0 ? -id : id;
+        struct kevent kev;
+        EV_SET(&kev,
+               fd,
+               EVFILT_VNODE,
+               EV_DELETE,
+               NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE,
+               0,
+               0);
+        if (kevent(kqfd, &kev, 1, 0, 0, 0) == -1) {
+            perror("QKqueueFileSystemWatcherEngine::removeWatch: kevent");
+        }
+        ::close(fd);
+
+        it.remove();
+        if (id < 0)
+            directories->removeAll(path);
+        else
+            files->removeAll(path);
+    }
+
+    if (pathToID.isEmpty()) {
+        stop();
+        locker.unlock();
+        wait();
+        locker.relock();
+    } else {
+        write(kqpipe[1], "@", 1);
+    }
+
+    return p;
+}
+
+void QKqueueFileSystemWatcherEngine::stop()
+{
+    write(kqpipe[1], "q", 1);
+}
+
+void QKqueueFileSystemWatcherEngine::run()
+{
+    static const struct timespec ZeroTimeout = { 0, 0 };
+
+    forever {
+        struct kevent kev;
+        DEBUG() << "QKqueueFileSystemWatcherEngine: waiting for kevents...";
+        int r = kevent(kqfd, 0, 0, &kev, 1, 0);
+        if (r < 0) {
+            perror("QKqueueFileSystemWatcherEngine: error during kevent wait");
+            return;
+        }
+
+        QMutexLocker locker(&mutex);
+        do {
+            int fd = kev.ident;
+
+            DEBUG() << "QKqueueFileSystemWatcherEngine: processing kevent" << kev.ident << kev.filter;
+            if (fd == kqpipe[0]) {
+                char c;
+                if (read(kqpipe[0], &c, 1) != 1) {
+                    perror("QKqueueFileSystemWatcherEngine: error reading from pipe");
+                    return;
+                }
+                switch (c) {
+                case 'q':
+                    DEBUG() << "QKqueueFileSystemWatcherEngine: thread received 'q', exiting...";
+                    return;
+                case '@':
+                    DEBUG() << "QKqueueFileSystemWatcherEngine: thread received '@', continuing...";
+                    break;
+                default:
+                    DEBUG() << "QKqueueFileSystemWatcherEngine: thread received unknow message" << c;
+                    break;
+                }
+            } else {
+                int id = fd;
+                QString path = idToPath.value(id);
+                if (path.isEmpty()) {
+                    // perhaps a directory?
+                    id = -id;
+                    path = idToPath.value(id);
+                    if (path.isEmpty()) {
+                        DEBUG() << "QKqueueFileSystemWatcherEngine: received a kevent for a file we're not watching";
+                        continue;
+                    }
+                }
+                if (kev.filter != EVFILT_VNODE) {
+                    DEBUG() << "QKqueueFileSystemWatcherEngine: received a kevent with the wrong filter";
+                    continue;
+                }
+
+                if ((kev.fflags & (NOTE_DELETE | NOTE_REVOKE | NOTE_RENAME)) != 0) {
+                    DEBUG() << path << "removed, removing watch also";
+
+                    pathToID.remove(path);
+                    idToPath.remove(id);
+                    ::close(fd);
+
+                    if (id < 0)
+                        emit directoryChanged(path, true);
+                    else
+                        emit fileChanged(path, true);
+                } else {
+                    DEBUG() << path << "changed, re-enabling watch";
+
+                    if (id < 0)
+                        emit directoryChanged(path, false);
+                    else
+                        emit fileChanged(path, false);
+
+                    // renable the watch
+                    EV_SET(&kev,
+                           fd,
+                           EVFILT_VNODE,
+                           EV_ADD | EV_ENABLE | EV_ONESHOT,
+                           NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE,
+                           0,
+                           0);
+                    if (kevent(kqfd, &kev, 1, 0, 0, 0) == -1) {
+                        perror("QKqueueFileSystemWatcherEngine::processKqueueEvents: kevent EV_ADD");
+                    }
+                }
+            }
+
+            // are there any more?
+            r = kevent(kqfd, 0, 0, &kev, 1, &ZeroTimeout);
+        } while (r > 0);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qfilesystemwatcher_kqueue_p.h b/src/corelib/io/qfilesystemwatcher_kqueue_p.h
new file mode 100644
index 0000000..789fb3a
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_kqueue_p.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef FILEWATCHER_KQUEUE_P_H
+#define FILEWATCHER_KQUEUE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qfilesystemwatcher_p.h"
+
+#include <QtCore/qhash.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qthread.h>
+#include <QtCore/qvector.h>
+
+struct kevent;
+
+QT_BEGIN_NAMESPACE
+
+class QKqueueFileSystemWatcherEngine : public QFileSystemWatcherEngine
+{
+    Q_OBJECT
+public:
+    ~QKqueueFileSystemWatcherEngine();
+
+    static QKqueueFileSystemWatcherEngine *create();
+
+    QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
+    QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
+
+    void stop();
+
+private:
+    QKqueueFileSystemWatcherEngine(int kqfd);
+
+    void run();
+
+    int kqfd;
+    int kqpipe[2];
+
+    QMutex mutex;
+    QHash<QString, int> pathToID;
+    QHash<int, QString> idToPath;
+};
+
+QT_END_NAMESPACE
+
+#endif // FILEWATCHER_KQUEUE_P_H
diff --git a/src/corelib/io/qfilesystemwatcher_p.h b/src/corelib/io/qfilesystemwatcher_p.h
new file mode 100644
index 0000000..7cc9153
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_p.h
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILESYSTEMWATCHER_P_H
+#define QFILESYSTEMWATCHER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qfilesystemwatcher.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <private/qobject_p.h>
+
+#include <QtCore/qstringlist.h>
+#include <QtCore/qthread.h>
+
+QT_BEGIN_NAMESPACE
+
+class QFileSystemWatcherEngine : public QThread
+{
+    Q_OBJECT
+
+protected:
+    inline QFileSystemWatcherEngine()
+    {
+        moveToThread(this);
+    }
+
+public:
+    // fills \a files and \a directires with the \a paths it could
+    // watch, and returns a list of paths this engine could not watch
+    virtual QStringList addPaths(const QStringList &paths,
+                                 QStringList *files,
+                                 QStringList *directories) = 0;
+    // removes \a paths from \a files and \a directories, and returns
+    // a list of paths this engine does not know about (either addPath
+    // failed or wasn't called)
+    virtual QStringList removePaths(const QStringList &paths,
+                                    QStringList *files,
+                                    QStringList *directories) = 0;
+
+    virtual void stop() = 0;
+
+Q_SIGNALS:
+    void fileChanged(const QString &path, bool removed);
+    void directoryChanged(const QString &path, bool removed);
+};
+
+class QFileSystemWatcherPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QFileSystemWatcher)
+
+    static QFileSystemWatcherEngine *createNativeEngine();
+
+public:
+    QFileSystemWatcherPrivate();
+    void init();
+    void initPollerEngine();
+    void initForcedEngine(const QString &);
+
+    QFileSystemWatcherEngine *native, *poller, *forced;
+    QStringList files, directories;
+
+    // private slots
+    void _q_fileChanged(const QString &path, bool removed);
+    void _q_directoryChanged(const QString &path, bool removed);
+};
+
+
+QT_END_NAMESPACE
+#endif // QT_NO_FILESYSTEMWATCHER
+#endif // QFILESYSTEMWATCHER_P_H
diff --git a/src/corelib/io/qfilesystemwatcher_win.cpp b/src/corelib/io/qfilesystemwatcher_win.cpp
new file mode 100644
index 0000000..74e3e27
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_win.cpp
@@ -0,0 +1,333 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qfilesystemwatcher.h"
+#include "qfilesystemwatcher_win_p.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <qdebug.h>
+#include <qfileinfo.h>
+#include <qstringlist.h>
+#include <qset.h>
+#include <qdatetime.h>
+#include <qdir.h>
+
+QT_BEGIN_NAMESPACE
+
+QWindowsFileSystemWatcherEngine::QWindowsFileSystemWatcherEngine()
+    : msg(0)
+{
+    HANDLE h = QT_WA_INLINE(CreateEventW(0, false, false, 0),
+                                CreateEventA(0, false, false, 0));
+    if (h != INVALID_HANDLE_VALUE) {
+        handles.reserve(MAXIMUM_WAIT_OBJECTS);
+        handles.append(h);
+    }
+}
+
+QWindowsFileSystemWatcherEngine::~QWindowsFileSystemWatcherEngine()
+{
+    if (handles.isEmpty())
+        return;
+
+    stop();
+    wait();
+
+    CloseHandle(handles.at(0));
+    handles[0] = INVALID_HANDLE_VALUE;
+
+    foreach (HANDLE h, handles) {
+        if (h == INVALID_HANDLE_VALUE)
+            continue;
+        FindCloseChangeNotification(h);
+    }
+}
+
+void QWindowsFileSystemWatcherEngine::run()
+{
+    QMutexLocker locker(&mutex);
+    forever {
+        QVector<HANDLE> handlesCopy = handles;
+        locker.unlock();
+        // qDebug() << "QWindowsFileSystemWatcherEngine: waiting on" << handlesCopy.count() << "handles";
+        DWORD r = WaitForMultipleObjects(handlesCopy.count(), handlesCopy.constData(), false, INFINITE);
+        locker.relock();
+        do {
+            if (r == WAIT_OBJECT_0) {
+                int m = msg;
+                msg = 0;
+                if (m == 'q') {
+                    // qDebug() << "thread told to quit";
+                    return;
+                }
+                if (m != '@')  {
+                    qDebug("QWindowsFileSystemWatcherEngine: unknown message '%c' send to thread", char(m));
+                }
+                break;
+            } else if (r > WAIT_OBJECT_0 && r < WAIT_OBJECT_0 + uint(handlesCopy.count())) {
+                int at = r - WAIT_OBJECT_0;
+                Q_ASSERT(at < handlesCopy.count());
+                HANDLE handle = handlesCopy.at(at);
+
+                // When removing a path, FindCloseChangeNotification might actually fire a notification
+                // for some reason, so we must check if the handle exist in the handles vector
+                if (handles.contains(handle)) {
+                    // qDebug("Acknowledged handle: %d, %p", at, handle);
+                    if (!FindNextChangeNotification(handle)) {
+                        qErrnoWarning("QFileSystemWatcher: FindNextChangeNotification failed");
+                    }
+
+                    QHash<QString, PathInfo> &h = pathInfoForHandle[handle];
+                    QMutableHashIterator<QString, PathInfo> it(h);
+                    while (it.hasNext()) {
+                        QHash<QString, PathInfo>::iterator x = it.next();
+                        QString absolutePath = x.value().absolutePath;
+                        QFileInfo fileInfo(x.value().path);
+                        // qDebug() << "checking" << x.key();
+                        if (!fileInfo.exists()) {
+                            // qDebug() << x.key() << "removed!";
+                            if (x.value().isDir)
+                                emit directoryChanged(x.value().path, true);
+                            else
+                                emit fileChanged(x.value().path, true);
+                            h.erase(x);
+
+                            // close the notification handle if the directory has been removed
+                            if (h.isEmpty()) {
+                                // qDebug() << "Thread closing handle" << handle;
+                                FindCloseChangeNotification(handle);    // This one might generate a notification
+
+                                int indexOfHandle = handles.indexOf(handle);
+                                Q_ASSERT(indexOfHandle != -1);
+                                handles.remove(indexOfHandle);
+
+                                handleForDir.remove(absolutePath);
+                                // h is now invalid
+                            }
+                        } else if (x.value().isDir) {
+                            // qDebug() << x.key() << "directory changed!";
+                            emit directoryChanged(x.value().path, false);
+                            x.value() = fileInfo;
+                        } else if (x.value() != fileInfo) {
+                            // qDebug() << x.key() << "file changed!";
+                            emit fileChanged(x.value().path, false);
+                            x.value() = fileInfo;
+                        }
+                    }
+                }
+            } else {
+                // qErrnoWarning("QFileSystemWatcher: error while waiting for change notification");
+                break;  // avoid endless loop
+            }
+            handlesCopy = handles;
+            r = WaitForMultipleObjects(handlesCopy.count(), handlesCopy.constData(), false, 0);
+        } while (r != WAIT_TIMEOUT);
+    }
+}
+
+QStringList QWindowsFileSystemWatcherEngine::addPaths(const QStringList &paths,
+                                                      QStringList *files,
+                                                      QStringList *directories)
+{
+    if (handles.isEmpty() || handles.count() == MAXIMUM_WAIT_OBJECTS)
+        return paths;
+
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        QString normalPath = path;
+        if ((normalPath.endsWith(QLatin1Char('/')) || normalPath.endsWith(QLatin1Char('\\')))
+#ifdef Q_OS_WINCE
+            && normalPath.size() > 1)
+#else
+            )
+#endif
+            normalPath.chop(1);
+        QFileInfo fileInfo(normalPath.toLower());
+        if (!fileInfo.exists())
+            continue;
+
+        bool isDir = fileInfo.isDir();
+        if (isDir) {
+            if (directories->contains(path))
+                continue;
+        } else {
+            if (files->contains(path))
+                continue;
+        }
+
+        const QString absolutePath = isDir ? fileInfo.absoluteFilePath() : fileInfo.absolutePath();
+        const uint flags = isDir
+            ? (FILE_NOTIFY_CHANGE_DIR_NAME
+               | FILE_NOTIFY_CHANGE_FILE_NAME)
+            : (FILE_NOTIFY_CHANGE_DIR_NAME
+               | FILE_NOTIFY_CHANGE_FILE_NAME
+               | FILE_NOTIFY_CHANGE_ATTRIBUTES
+               | FILE_NOTIFY_CHANGE_SIZE
+               | FILE_NOTIFY_CHANGE_LAST_WRITE
+               | FILE_NOTIFY_CHANGE_SECURITY);
+
+        Handle handle = handleForDir.value(absolutePath);
+        if (handle.handle == INVALID_HANDLE_VALUE || handle.flags != flags) {
+            // Volume and folder paths need a trailing slash for proper notification
+            // (e.g. "c:" -> "c:/").
+            const QString effectiveAbsolutePath =
+                isDir ? (absolutePath + QLatin1Char('/')) : absolutePath;
+
+            QT_WA({
+                    handle.handle = FindFirstChangeNotificationW((TCHAR *) QDir::toNativeSeparators(effectiveAbsolutePath).utf16(),
+                                                      false, flags);
+            },{
+                    handle.handle = FindFirstChangeNotificationA(QDir::toNativeSeparators(effectiveAbsolutePath).toLocal8Bit(),
+                                                      false, flags);
+            })
+            handle.flags = flags;
+            if (handle.handle == INVALID_HANDLE_VALUE)
+                continue;
+            // qDebug() << "Added handle" << handle << "for" << absolutePath << "to watch" << fileInfo.absoluteFilePath();
+            handles.append(handle.handle);
+            handleForDir.insert(absolutePath, handle);
+        }
+
+        PathInfo pathInfo;
+        pathInfo.absolutePath = absolutePath;
+        pathInfo.isDir = isDir;
+        pathInfo.path = path;
+        pathInfo = fileInfo;
+        QHash<QString, PathInfo> &h = pathInfoForHandle[handle.handle];
+        if (!h.contains(fileInfo.absoluteFilePath())) {
+            pathInfoForHandle[handle.handle].insert(fileInfo.absoluteFilePath(), pathInfo);
+            if (isDir)
+                directories->append(path);
+            else
+                files->append(path);
+        }
+
+        it.remove();
+    }
+
+    if (!isRunning()) {
+        msg = '@';
+        start();
+    } else {
+        wakeup();
+    }
+
+    return p;
+}
+
+QStringList QWindowsFileSystemWatcherEngine::removePaths(const QStringList &paths,
+                                                         QStringList *files,
+                                                         QStringList *directories)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        QString normalPath = path;
+        if (normalPath.endsWith(QLatin1Char('/')) || normalPath.endsWith(QLatin1Char('\\')))
+            normalPath.chop(1);
+        QFileInfo fileInfo(normalPath.toLower());
+
+        QString absolutePath = fileInfo.absoluteFilePath();
+        Handle handle = handleForDir.value(absolutePath);
+        if (handle.handle == INVALID_HANDLE_VALUE) {
+            // perhaps path is a file?
+            absolutePath = fileInfo.absolutePath();
+            handle = handleForDir.value(absolutePath);
+            if (handle.handle == INVALID_HANDLE_VALUE)
+                continue;
+        }
+
+        QHash<QString, PathInfo> &h = pathInfoForHandle[handle.handle];
+        if (h.remove(fileInfo.absoluteFilePath())) {
+            // ###
+            files->removeAll(path);
+            directories->removeAll(path);
+
+            if (h.isEmpty()) {
+                // qDebug() << "Closing handle" << handle;
+                FindCloseChangeNotification(handle.handle);    // This one might generate a notification
+
+                int indexOfHandle = handles.indexOf(handle.handle);
+                Q_ASSERT(indexOfHandle != -1);
+                handles.remove(indexOfHandle);
+
+                handleForDir.remove(absolutePath);
+                // h is now invalid
+
+                it.remove();
+            }
+        }
+    }
+
+    if (handleForDir.isEmpty()) {
+        stop();
+        locker.unlock();
+        wait();
+        locker.relock();
+    } else {
+        wakeup();
+    }
+
+    return p;
+}
+
+void QWindowsFileSystemWatcherEngine::stop()
+{
+    msg = 'q';
+    SetEvent(handles.at(0));
+}
+
+void QWindowsFileSystemWatcherEngine::wakeup()
+{
+    msg = '@';
+    SetEvent(handles.at(0));
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_FILESYSTEMWATCHER
diff --git a/src/corelib/io/qfilesystemwatcher_win_p.h b/src/corelib/io/qfilesystemwatcher_win_p.h
new file mode 100644
index 0000000..525e32f
--- /dev/null
+++ b/src/corelib/io/qfilesystemwatcher_win_p.h
@@ -0,0 +1,143 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFILESYSTEMWATCHER_WIN_P_H
+#define QFILESYSTEMWATCHER_WIN_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qfilesystemwatcher_p.h"
+
+#ifndef QT_NO_FILESYSTEMWATCHER
+
+#include <windows.h>
+
+#include <QtCore/qdatetime.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qfileinfo.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qvector.h>
+
+QT_BEGIN_NAMESPACE
+
+class QWindowsFileSystemWatcherEngine : public QFileSystemWatcherEngine
+{
+    Q_OBJECT
+
+public:
+    QWindowsFileSystemWatcherEngine();
+    ~QWindowsFileSystemWatcherEngine();
+
+    void run();
+
+    QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
+    QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
+
+    void stop();
+
+private:
+    void wakeup();
+
+    QMutex mutex;
+    QVector<HANDLE> handles;
+    int msg;
+
+    class Handle
+    {
+    public:
+        HANDLE handle;
+        uint flags;
+
+        Handle()
+            : handle(INVALID_HANDLE_VALUE), flags(0u)
+        { }
+        Handle(const Handle &other)
+            : handle(other.handle), flags(other.flags)
+        { }
+    };
+    QHash<QString, Handle> handleForDir;
+
+    class PathInfo {
+    public:
+        QString absolutePath;
+        QString path;
+        bool isDir;
+
+        // fileinfo bits
+        uint ownerId;
+        uint groupId;
+        QFile::Permissions permissions;
+        QDateTime lastModified;
+
+        PathInfo &operator=(const QFileInfo &fileInfo)
+        {
+            ownerId = fileInfo.ownerId();
+            groupId = fileInfo.groupId();
+            permissions = fileInfo.permissions();
+            lastModified = fileInfo.lastModified();
+            return *this;
+        }
+
+        bool operator!=(const QFileInfo &fileInfo) const
+        {
+            return (ownerId != fileInfo.ownerId()
+                    || groupId != fileInfo.groupId()
+                    || permissions != fileInfo.permissions()
+                    || lastModified != fileInfo.lastModified());
+        }
+    };
+    QHash<HANDLE, QHash<QString, PathInfo> > pathInfoForHandle;
+};
+#endif // QT_NO_FILESYSTEMWATCHER
+
+QT_END_NAMESPACE
+
+#endif // QFILESYSTEMWATCHER_WIN_P_H
diff --git a/src/corelib/io/qfsfileengine.cpp b/src/corelib/io/qfsfileengine.cpp
new file mode 100644
index 0000000..61ea7cc
--- /dev/null
+++ b/src/corelib/io/qfsfileengine.cpp
@@ -0,0 +1,873 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qfsfileengine_p.h"
+#include "qfsfileengine_iterator_p.h"
+#include "qdatetime.h"
+#include "qdiriterator.h"
+#include "qset.h"
+
+#ifndef QT_NO_FSFILEENGINE
+
+#if !defined(Q_OS_WINCE)
+#include <errno.h>
+#endif
+#include <stdio.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_OS_WIN
+#  ifndef S_ISREG
+#    define S_ISREG(x)   (((x) & S_IFMT) == S_IFREG)
+#  endif
+#  ifndef S_ISCHR
+#    define S_ISCHR(x)   (((x) & S_IFMT) == S_IFCHR)
+#  endif
+#  ifndef S_ISFIFO
+#    define S_ISFIFO(x) false
+#  endif
+#  ifndef S_ISSOCK
+#    define S_ISSOCK(x) false
+#  endif
+#  ifndef INVALID_FILE_ATTRIBUTES
+#    define INVALID_FILE_ATTRIBUTES (DWORD (-1))
+#  endif
+#endif
+
+
+/*! \class QFSFileEngine
+    \brief The QFSFileEngine class implements Qt's default file engine.
+    \since 4.1
+
+    This class is part of the file engine framework in Qt. If you only want to
+    access files or directories, use QFile, QFileInfo or QDir instead.
+
+    QFSFileEngine is the default file engine for accessing regular files. It
+    is provided for convenience; by subclassing this class, you can alter its
+    behavior slightly, without having to write a complete QAbstractFileEngine
+    subclass. To install your custom file engine, you must also subclass
+    QAbstractFileEngineHandler and create an instance of your handler.
+
+    It can also be useful to create a QFSFileEngine object directly if you
+    need to use the local file system inside QAbstractFileEngine::create(), in
+    order to avoid recursion (as higher-level classes tend to call
+    QAbstractFileEngine::create()).
+*/
+
+//**************** QFSFileEnginePrivate
+QFSFileEnginePrivate::QFSFileEnginePrivate() : QAbstractFileEnginePrivate()
+{
+    init();
+}
+
+/*!
+    \internal
+*/
+void QFSFileEnginePrivate::init()
+{
+    is_sequential = 0;
+    tried_stat = 0;
+#ifdef Q_OS_UNIX
+    need_lstat = 1;
+    is_link = 0;
+#endif
+    openMode = QIODevice::NotOpen;
+    fd = -1;
+    fh = 0;
+    lastIOCommand = IOFlushCommand;
+    lastFlushFailed = false;
+    closeFileHandle = false;
+#ifdef Q_OS_WIN
+    fileAttrib = INVALID_FILE_ATTRIBUTES;
+    fileHandle = INVALID_HANDLE_VALUE;
+    cachedFd = -1;
+#endif
+#ifdef Q_USE_DEPRECATED_MAP_API
+    fileMapHandle = INVALID_HANDLE_VALUE;
+#endif
+}
+
+/*!
+    \internal
+
+    Returns the canonicalized form of \a path (i.e., with all symlinks
+    resolved, and all redundant path elements removed.
+*/
+QString QFSFileEnginePrivate::canonicalized(const QString &path)
+{
+    if (path.isEmpty())
+        return path;
+
+    QFileInfo fi;
+    const QChar slash(QLatin1Char('/'));
+    QString tmpPath = path;
+    int separatorPos = 0;
+    QSet<QString> nonSymlinks;
+    QSet<QString> known;
+
+    known.insert(path);
+    do {
+#ifdef Q_OS_WIN
+        // UNC, skip past the first two elements
+        if (separatorPos == 0 && tmpPath.startsWith(QLatin1String("//")))
+            separatorPos = tmpPath.indexOf(slash, 2);
+        if (separatorPos != -1)
+#endif
+        separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
+        QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
+        if (!nonSymlinks.contains(prefix)) {
+            fi.setFile(prefix);
+            if (fi.isSymLink()) {
+                QString target = fi.symLinkTarget();
+                if (separatorPos != -1) {
+                    if (fi.isDir() && !target.endsWith(slash))
+                        target.append(slash);
+                    target.append(tmpPath.mid(separatorPos));
+                }
+                tmpPath = QDir::cleanPath(target);
+                separatorPos = 0;
+
+                if (known.contains(tmpPath))
+                    return QString();
+                known.insert(tmpPath);
+            } else {
+                nonSymlinks.insert(prefix);
+            }
+        }
+    } while (separatorPos != -1);
+
+    return QDir::cleanPath(tmpPath);
+}
+
+/*!
+    Constructs a QFSFileEngine for the file name \a file.
+*/
+QFSFileEngine::QFSFileEngine(const QString &file) : QAbstractFileEngine(*new QFSFileEnginePrivate)
+{
+    Q_D(QFSFileEngine);
+    d->filePath = QDir::fromNativeSeparators(file);
+    d->nativeInitFileName();
+}
+
+/*!
+    Constructs a QFSFileEngine.
+*/
+QFSFileEngine::QFSFileEngine() : QAbstractFileEngine(*new QFSFileEnginePrivate)
+{
+}
+
+/*!
+    \internal
+*/
+QFSFileEngine::QFSFileEngine(QFSFileEnginePrivate &dd)
+    : QAbstractFileEngine(dd)
+{
+}
+
+/*!
+    Destructs the QFSFileEngine.
+*/
+QFSFileEngine::~QFSFileEngine()
+{
+    Q_D(QFSFileEngine);
+    if (d->closeFileHandle) {
+        if (d->fh) {
+            int ret;
+            do {
+                ret = fclose(d->fh);
+            } while (ret == EOF && errno == EINTR);
+        } else if (d->fd != -1) {
+            int ret;
+            do {
+                ret = QT_CLOSE(d->fd);
+            } while (ret == -1 && errno == EINTR);
+        }
+    }
+    QList<uchar*> keys = d->maps.keys();
+    for (int i = 0; i < keys.count(); ++i)
+        unmap(keys.at(i));
+}
+
+/*!
+    \reimp
+*/
+void QFSFileEngine::setFileName(const QString &file)
+{
+    Q_D(QFSFileEngine);
+    d->init();
+    d->filePath = QDir::fromNativeSeparators(file);
+    d->nativeInitFileName();
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::open(QIODevice::OpenMode openMode)
+{
+    Q_D(QFSFileEngine);
+    if (d->filePath.isEmpty()) {
+        qWarning("QFSFileEngine::open: No file name specified");
+        setError(QFile::OpenError, QLatin1String("No file name specified"));
+        return false;
+    }
+
+    // Append implies WriteOnly.
+    if (openMode & QFile::Append)
+        openMode |= QFile::WriteOnly;
+
+    // WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
+    if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
+        openMode |= QFile::Truncate;
+
+    d->openMode = openMode;
+    d->lastFlushFailed = false;
+    d->tried_stat = 0;
+    d->fh = 0;
+    d->fd = -1;
+
+    return d->nativeOpen(openMode);
+}
+
+/*!
+    Opens the file handle \a fh in \a openMode mode. Returns true on
+    success; otherwise returns false.
+*/
+bool QFSFileEngine::open(QIODevice::OpenMode openMode, FILE *fh)
+{
+    Q_D(QFSFileEngine);
+
+    // Append implies WriteOnly.
+    if (openMode & QFile::Append)
+        openMode |= QFile::WriteOnly;
+
+    // WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
+    if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
+        openMode |= QFile::Truncate;
+
+    d->openMode = openMode;
+    d->lastFlushFailed = false;
+    d->closeFileHandle = false;
+    d->nativeFilePath.clear();
+    d->filePath.clear();
+    d->tried_stat = 0;
+    d->fd = -1;
+
+    return d->openFh(openMode, fh);
+}
+
+/*!
+    Opens the file handle \a fh using the open mode \a flags.
+*/
+bool QFSFileEnginePrivate::openFh(QIODevice::OpenMode openMode, FILE *fh)
+{
+    Q_Q(QFSFileEngine);
+    this->fh = fh;
+    fd = -1;
+
+    // Seek to the end when in Append mode.
+    if (openMode & QIODevice::Append) {
+        int ret;
+        do {
+            ret = QT_FSEEK(fh, 0, SEEK_END);
+        } while (ret == -1 && errno == EINTR);
+
+        if (ret == -1) {
+            q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                        qt_error_string(int(errno)));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/*!
+    Opens the file descriptor \a fd in \a openMode mode. Returns true
+    on success; otherwise returns false.
+*/
+bool QFSFileEngine::open(QIODevice::OpenMode openMode, int fd)
+{
+    Q_D(QFSFileEngine);
+
+    // Append implies WriteOnly.
+    if (openMode & QFile::Append)
+        openMode |= QFile::WriteOnly;
+
+    // WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
+    if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
+        openMode |= QFile::Truncate;
+
+    d->lastFlushFailed = false;
+    d->closeFileHandle = false;
+    d->nativeFilePath.clear();
+    d->filePath.clear();
+    d->fh = 0;
+    d->fd = -1;
+    d->tried_stat = 0;
+
+    return d->openFd(openMode, fd);
+}
+
+
+/*!
+    Opens the file descriptor \a fd to the file engine, using the open mode \a
+    flags.
+*/
+bool QFSFileEnginePrivate::openFd(QIODevice::OpenMode openMode, int fd)
+{
+    Q_Q(QFSFileEngine);
+    this->fd = fd;
+    fh = 0;
+
+    // Seek to the end when in Append mode.
+    if (openMode & QFile::Append) {
+        int ret;
+        do {
+            ret = QT_LSEEK(fd, 0, SEEK_END);
+        } while (ret == -1 && errno == EINTR);
+
+        if (ret == -1) {
+            q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                        qt_error_string(int(errno)));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::close()
+{
+    Q_D(QFSFileEngine);
+    d->openMode = QIODevice::NotOpen;
+    return d->nativeClose();
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::closeFdFh()
+{
+    Q_Q(QFSFileEngine);
+    if (fd == -1 && !fh)
+        return false;
+
+    // Flush the file if it's buffered, and if the last flush didn't fail.
+    bool flushed = !fh || (!lastFlushFailed && q->flush());
+    bool closed = true;
+    tried_stat = 0;
+
+    // Close the file if we created the handle.
+    if (closeFileHandle) {
+        int ret;
+        do {
+            if (fh) {
+                // Close buffered file.
+                ret = fclose(fh) != 0 ? -1 : 0;
+            } else {
+                // Close unbuffered file.
+                ret = QT_CLOSE(fd);
+            }
+        } while (ret == -1 && errno == EINTR);
+
+        // We must reset these guys regardless; calling close again after a
+        // failed close causes crashes on some systems.
+        fh = 0;
+        fd = -1;
+        closed = (ret == 0);
+    }
+
+    // Report errors.
+    if (!flushed || !closed) {
+        if (flushed) {
+            // If not flushed, we want the flush error to fall through.
+            q->setError(QFile::UnspecifiedError, qt_error_string(errno));
+        }
+        return false;
+    }
+
+    return true;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::flush()
+{
+    Q_D(QFSFileEngine);
+    if ((d->openMode & QIODevice::WriteOnly) == 0) {
+        // Nothing in the write buffers, so flush succeeds in doing
+        // nothing.
+        return true;
+    }
+    return d->nativeFlush();
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::flushFh()
+{
+    Q_Q(QFSFileEngine);
+
+    // Never try to flush again if the last flush failed. Otherwise you can
+    // get crashes on some systems (AIX).
+    if (lastFlushFailed)
+        return false;
+
+    int ret = fflush(fh);
+
+    lastFlushFailed = (ret != 0);
+    lastIOCommand = QFSFileEnginePrivate::IOFlushCommand;
+
+    if (ret != 0) {
+        q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError,
+                    qt_error_string(errno));
+        return false;
+    }
+    return true;
+}
+
+/*!
+    \reimp
+*/
+qint64 QFSFileEngine::size() const
+{
+    Q_D(const QFSFileEngine);
+    return d->nativeSize();
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::sizeFdFh() const
+{
+    Q_Q(const QFSFileEngine);
+    // ### Fix this function, it should not stat unless the file is closed.
+    QT_STATBUF st;
+    int ret = 0;
+    const_cast<QFSFileEngine *>(q)->flush();
+    if (fh && nativeFilePath.isEmpty()) {
+        // Buffered stdlib mode.
+        // ### This should really be an ftell
+        ret = QT_FSTAT(QT_FILENO(fh), &st);
+    } else if (fd == -1) {
+        // Stateless stat.
+        ret = QT_STAT(nativeFilePath.constData(), &st);
+    } else {
+        // Unbuffered stdio mode.
+        ret = QT_FSTAT(fd, &st);
+    }
+    if (ret == -1)
+        return 0;
+    return st.st_size;
+}
+
+/*!
+    \reimp
+*/
+qint64 QFSFileEngine::pos() const
+{
+    Q_D(const QFSFileEngine);
+    return d->nativePos();
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::posFdFh() const
+{
+    if (fh)
+        return qint64(QT_FTELL(fh));
+    return QT_LSEEK(fd, 0, SEEK_CUR);
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::seek(qint64 pos)
+{
+    Q_D(QFSFileEngine);
+    return d->nativeSeek(pos);
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::seekFdFh(qint64 pos)
+{
+    Q_Q(QFSFileEngine);
+
+    // On Windows' stdlib implementation, the results of calling fread and
+    // fwrite are undefined if not called either in sequence, or if preceded
+    // with a call to fflush().
+    if (lastIOCommand != QFSFileEnginePrivate::IOFlushCommand && !q->flush())
+        return false;
+
+    if (fh) {
+        // Buffered stdlib mode.
+        int ret;
+        do {
+            ret = QT_FSEEK(fh, QT_OFF_T(pos), SEEK_SET);
+        } while (ret == -1 && errno == EINTR);
+
+        if (ret == -1) {
+            q->setError(QFile::ReadError, qt_error_string(int(errno)));
+            return false;
+        }
+    } else {
+        // Unbuffered stdio mode.
+        if (QT_LSEEK(fd, pos, SEEK_SET) == -1) {
+            qWarning("QFile::at: Cannot set file position %lld", pos);
+            q->setError(QFile::PositionError, qt_error_string(errno));
+            return false;
+        }
+    }
+    return true;
+}
+
+/*!
+    \reimp
+*/
+int QFSFileEngine::handle() const
+{
+    Q_D(const QFSFileEngine);
+    return d->nativeHandle();
+}
+
+/*!
+    \reimp
+*/
+qint64 QFSFileEngine::read(char *data, qint64 maxlen)
+{
+    Q_D(QFSFileEngine);
+
+    // On Windows' stdlib implementation, the results of calling fread and
+    // fwrite are undefined if not called either in sequence, or if preceded
+    // with a call to fflush().
+    if (d->lastIOCommand != QFSFileEnginePrivate::IOReadCommand) {
+        flush();
+        d->lastIOCommand = QFSFileEnginePrivate::IOReadCommand;
+    }
+
+    return d->nativeRead(data, maxlen);
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::readFdFh(char *data, qint64 len)
+{
+    Q_Q(QFSFileEngine);
+
+    // Buffered stdlib mode.
+    if (fh) {
+        qint64 readBytes = 0;
+        qint64 read = 0;
+        int retry = 0;
+
+        // Read in blocks of 4k to avoid platform limitations (Windows
+        // commonly bails out if you read or write too large blocks at once).
+        qint64 bytesToRead;
+        do {
+            if (retry == 1)
+                retry = 2;
+
+            bytesToRead = qMin<qint64>(4096, len - read);
+            do {
+                readBytes = fread(data + read, 1, size_t(bytesToRead), fh);
+            } while (readBytes == 0 && !feof(fh) && errno == EINTR);
+
+            if (readBytes > 0) {
+                read += readBytes;
+            } else if (!retry && feof(fh)) {
+                // Synchronize and try again (just once though).
+                if (++retry == 1)
+                    QT_FSEEK(fh, QT_FTELL(fh), SEEK_SET);
+            }
+        } while (retry == 1 || (readBytes == bytesToRead && read < len));
+
+        // Return the number of bytes read, or if nothing was read, return -1
+        // if an error occurred, or 0 if we detected EOF.
+        if (read == 0) {
+            q->setError(QFile::ReadError, qt_error_string(int(errno)));
+            if (!feof(fh))
+                read = -1;
+        }
+        return read;
+    }
+
+    // Unbuffered stdio mode.
+    qint64 ret = 0;
+    if (len) {
+        int result;
+        qint64 read = 0;
+        errno = 0;
+
+        // Read in blocks of 4k to avoid platform limitations (Windows
+        // commonly bails out if you read or write too large blocks at once).
+        do {
+            qint64 bytesToRead = qMin<qint64>(4096, len - read);
+            do {
+                result = QT_READ(fd, data + read, int(bytesToRead));
+            } while (result == -1 && errno == EINTR);
+            if (result > 0)
+                read += result;
+        } while (result > 0 && read < len);
+
+        // Return the number of bytes read, or if nothing was read, return -1
+        // if an error occurred.
+        if (read > 0) {
+            ret += read;
+        } else if (read == 0 && result < 0) {
+            ret = -1;
+            q->setError(QFile::ReadError, qt_error_string(errno));
+        }
+    }
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+qint64 QFSFileEngine::readLine(char *data, qint64 maxlen)
+{
+    Q_D(QFSFileEngine);
+
+    // On Windows' stdlib implementation, the results of calling fread and
+    // fwrite are undefined if not called either in sequence, or if preceded
+    // with a call to fflush().
+    if (d->lastIOCommand != QFSFileEnginePrivate::IOReadCommand) {
+        flush();
+        d->lastIOCommand = QFSFileEnginePrivate::IOReadCommand;
+    }
+
+    return d->nativeReadLine(data, maxlen);
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::readLineFdFh(char *data, qint64 maxlen)
+{
+    Q_Q(QFSFileEngine);
+    if (!fh)
+        return q->QAbstractFileEngine::readLine(data, maxlen);
+
+    QT_OFF_T oldPos = 0;
+#ifdef Q_OS_WIN
+    bool seq = q->isSequential();
+    if (!seq)
+#endif
+        oldPos = QT_FTELL(fh);
+
+    // QIODevice::readLine() passes maxlen - 1 to QFile::readLineData()
+    // because it has made space for the '\0' at the end of data.  But fgets
+    // does the same, so we'd get two '\0' at the end - passing maxlen + 1
+    // solves this.
+    if (!fgets(data, int(maxlen + 1), fh)) {
+        if (!feof(fh))
+            q->setError(QFile::ReadError, qt_error_string(int(errno)));
+        return -1;              // error
+    }
+
+#ifdef Q_OS_WIN
+    if (seq)
+        return qstrlen(data);
+#endif
+
+    qint64 lineLength = QT_FTELL(fh) - oldPos;
+    return lineLength > 0 ? lineLength : qstrlen(data);
+}
+
+/*!
+    \reimp
+*/
+qint64 QFSFileEngine::write(const char *data, qint64 len)
+{
+    Q_D(QFSFileEngine);
+
+    // On Windows' stdlib implementation, the results of calling fread and
+    // fwrite are undefined if not called either in sequence, or if preceded
+    // with a call to fflush().
+    if (d->lastIOCommand != QFSFileEnginePrivate::IOWriteCommand) {
+        flush();
+        d->lastIOCommand = QFSFileEnginePrivate::IOWriteCommand;
+    }
+
+    return d->nativeWrite(data, len);
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::writeFdFh(const char *data, qint64 len)
+{
+    Q_Q(QFSFileEngine);
+    qint64 result;
+    qint64 written = 0;
+
+    do {
+        // Write blocks of 4k to avoid platform limitations (Windows commonly
+        // bails out if you read or write too large blocks at once).
+        qint64 bytesToWrite = qMin<qint64>(4096, len - written);
+        if (fh) {
+            do {
+                // Buffered stdlib mode.
+                result = qint64(fwrite(data + written, 1, size_t(bytesToWrite), fh));
+            } while (result == 0 && errno == EINTR);
+            if (bytesToWrite > 0 && result == 0)
+                result = -1;
+        } else {
+            do {
+                // Unbuffered stdio mode.
+                result = QT_WRITE(fd, data + written, bytesToWrite);
+            } while (result == -1 && errno == EINTR);
+        }
+        if (result > 0)
+            written += qint64(result);
+    } while (written < len && result > 0);
+
+    // If we read anything, return that with success. Otherwise, set an error,
+    // and return the last return value.
+    if (result > 0)
+        return written;
+    q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
+    return result;
+}
+
+/*!
+    \internal
+*/
+QAbstractFileEngine::Iterator *QFSFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
+{
+    return new QFSFileEngineIterator(filters, filterNames);
+}
+
+/*!
+    \internal
+*/
+QAbstractFileEngine::Iterator *QFSFileEngine::endEntryList()
+{
+    return 0;
+}
+
+/*!
+    \internal
+*/
+QStringList QFSFileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
+{
+    return QAbstractFileEngine::entryList(filters, filterNames);
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::isSequential() const
+{
+    Q_D(const QFSFileEngine);
+    if (d->is_sequential == 0)
+        d->is_sequential = d->nativeIsSequential() ? 1 : 2;
+    return d->is_sequential == 1;
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::isSequentialFdFh() const
+{
+    if (!tried_stat)
+        doStat();
+    if (could_stat) {
+#ifdef Q_OS_UNIX
+        return (st.st_mode & S_IFMT) != S_IFREG;
+        // ### WINDOWS!
+#endif
+    }
+    return true;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
+{
+    Q_D(QFSFileEngine);
+    if (extension == AtEndExtension && d->fh && isSequential())
+        return feof(d->fh);
+
+    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;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::supportsExtension(Extension extension) const
+{
+    Q_D(const QFSFileEngine);
+    if (extension == AtEndExtension && d->fh && isSequential())
+        return true;
+    if (extension == FastReadLineExtension && d->fh)
+        return true;
+    if (extension == FastReadLineExtension && d->fd != -1 && isSequential())
+        return true;
+    if (extension == UnMapExtension || extension == MapExtension)
+        return true;
+    return false;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_FSFILEENGINE
diff --git a/src/corelib/io/qfsfileengine.h b/src/corelib/io/qfsfileengine.h
new file mode 100644
index 0000000..a2b732e
--- /dev/null
+++ b/src/corelib/io/qfsfileengine.h
@@ -0,0 +1,121 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFSFILEENGINE_H
+#define QFSFILEENGINE_H
+
+#include <QtCore/qabstractfileengine.h>
+
+#ifndef QT_NO_FSFILEENGINE
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QFSFileEnginePrivate;
+
+class Q_CORE_EXPORT QFSFileEngine : public QAbstractFileEngine
+{
+    Q_DECLARE_PRIVATE(QFSFileEngine)
+public:
+    QFSFileEngine();
+    explicit QFSFileEngine(const QString &file);
+    ~QFSFileEngine();
+
+    bool open(QIODevice::OpenMode openMode);
+    bool open(QIODevice::OpenMode flags, FILE *fh);
+    bool close();
+    bool flush();
+    qint64 size() const;
+    qint64 pos() const;
+    bool seek(qint64);
+    bool isSequential() const;
+    bool remove();
+    bool copy(const QString &newName);
+    bool rename(const QString &newName);
+    bool link(const QString &newName);
+    bool mkdir(const QString &dirName, bool createParentDirectories) const;
+    bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
+    bool setSize(qint64 size);
+    bool caseSensitive() const;
+    bool isRelativePath() const;
+    QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
+    FileFlags fileFlags(FileFlags type) const;
+    bool setPermissions(uint perms);
+    QString fileName(FileName file) const;
+    uint ownerId(FileOwner) const;
+    QString owner(FileOwner) const;
+    QDateTime fileTime(FileTime time) const;
+    void setFileName(const QString &file);
+    int handle() const;
+
+    Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
+    Iterator *endEntryList();
+
+    qint64 read(char *data, qint64 maxlen);
+    qint64 readLine(char *data, qint64 maxlen);
+    qint64 write(const char *data, qint64 len);
+
+    bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
+    bool supportsExtension(Extension extension) const;
+
+    //FS only!!
+    bool open(QIODevice::OpenMode flags, int fd);
+    static bool setCurrentPath(const QString &path);
+    static QString currentPath(const QString &path = QString());
+    static QString homePath();
+    static QString rootPath();
+    static QString tempPath();
+    static QFileInfoList drives();
+
+protected:
+    QFSFileEngine(QFSFileEnginePrivate &dd);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_FSFILEENGINE
+
+#endif // QFSFILEENGINE_H
diff --git a/src/corelib/io/qfsfileengine_iterator.cpp b/src/corelib/io/qfsfileengine_iterator.cpp
new file mode 100644
index 0000000..c5e23f2
--- /dev/null
+++ b/src/corelib/io/qfsfileengine_iterator.cpp
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qfsfileengine_iterator_p.h"
+#include "qvariant.h"
+
+#ifndef QT_NO_FSFILEENGINE
+
+QT_BEGIN_NAMESPACE
+
+QFSFileEngineIterator::QFSFileEngineIterator(QDir::Filters filters, const QStringList &filterNames)
+    : QAbstractFileEngineIterator(filters, filterNames)
+{
+    newPlatformSpecifics();
+}
+
+QFSFileEngineIterator::~QFSFileEngineIterator()
+{
+    deletePlatformSpecifics();
+}
+
+QString QFSFileEngineIterator::next()
+{
+    if (!hasNext())
+        return QString();
+
+    advance();
+    return currentFilePath();
+}
+
+QString QFSFileEngineIterator::currentFileName() const
+{
+    return currentEntry;
+}
+
+QFileInfo QFSFileEngineIterator::currentFileInfo() const
+{
+    return QAbstractFileEngineIterator::currentFileInfo();
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_FSFILEENGINE
+
diff --git a/src/corelib/io/qfsfileengine_iterator_p.h b/src/corelib/io/qfsfileengine_iterator_p.h
new file mode 100644
index 0000000..7dcdbe2
--- /dev/null
+++ b/src/corelib/io/qfsfileengine_iterator_p.h
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFSFILEENGINE_ITERATOR_P_H
+#define QFSFILEENGINE_ITERATOR_P_H
+
+//
+//  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.
+//
+
+#include "qabstractfileengine.h"
+#include "qdir.h"
+
+#ifndef QT_NO_FSFILEENGINE
+
+QT_BEGIN_NAMESPACE
+
+class QFSFileEngineIteratorPrivate;
+class QFSFileEngineIteratorPlatformSpecificData;
+
+class QFSFileEngineIterator : public QAbstractFileEngineIterator
+{
+public:
+    QFSFileEngineIterator(QDir::Filters filters, const QStringList &filterNames);
+    ~QFSFileEngineIterator();
+
+    QString next();
+    bool hasNext() const;
+
+    QString currentFileName() const;
+    QFileInfo currentFileInfo() const;
+
+private:
+    QFSFileEngineIteratorPlatformSpecificData *platform;
+    friend class QFSFileEngineIteratorPlatformSpecificData;
+    void newPlatformSpecifics();
+    void deletePlatformSpecifics();
+    void advance();
+
+    QString currentEntry;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_FSFILEENGINE
+
+#endif
diff --git a/src/corelib/io/qfsfileengine_iterator_unix.cpp b/src/corelib/io/qfsfileengine_iterator_unix.cpp
new file mode 100644
index 0000000..2284d9b
--- /dev/null
+++ b/src/corelib/io/qfsfileengine_iterator_unix.cpp
@@ -0,0 +1,140 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qfsfileengine_iterator_p.h"
+
+#include <QtCore/qvariant.h>
+
+#ifndef QT_NO_FSFILEENGINE
+
+QT_BEGIN_NAMESPACE
+
+class QFSFileEngineIteratorPlatformSpecificData
+{
+public:
+    inline QFSFileEngineIteratorPlatformSpecificData()
+        : dir(0), dirEntry(0), done(false)
+#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
+          , mt_file(0)
+#endif
+    { }
+
+    DIR *dir;
+    dirent *dirEntry;
+    bool done;
+
+#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
+    // for readdir_r
+    dirent *mt_file;
+#endif
+};
+
+void QFSFileEngineIterator::advance()
+{
+    currentEntry = platform->dirEntry ? QFile::decodeName(QByteArray(platform->dirEntry->d_name)) : QString();
+
+    if (!platform->dir)
+        return;
+
+#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
+    if (::readdir_r(platform->dir, platform->mt_file, &platform->dirEntry) != 0)
+        platform->done = true;
+#else
+    // ### add local lock to prevent breaking reentrancy
+    platform->dirEntry = ::readdir(platform->dir);
+#endif // _POSIX_THREAD_SAFE_FUNCTIONS
+    if (!platform->dirEntry) {
+        ::closedir(platform->dir);
+        platform->dir = 0;
+        platform->done = true;
+#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
+        delete [] platform->mt_file;
+        platform->mt_file = 0;
+#endif
+    }
+}
+
+void QFSFileEngineIterator::newPlatformSpecifics()
+{
+    platform = new QFSFileEngineIteratorPlatformSpecificData;
+}
+
+void QFSFileEngineIterator::deletePlatformSpecifics()
+{
+    if (platform->dir) {
+        ::closedir(platform->dir);
+#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
+        delete [] platform->mt_file;
+        platform->mt_file = 0;
+#endif
+    }
+    delete platform;
+    platform = 0;
+}
+
+bool QFSFileEngineIterator::hasNext() const
+{
+    if (!platform->done && !platform->dir) {
+        QFSFileEngineIterator *that = const_cast<QFSFileEngineIterator *>(this);
+        if ((that->platform->dir = ::opendir(QFile::encodeName(path()).data())) == 0) {
+            that->platform->done = true;
+        } else {
+            // ### Race condition; we should use fpathconf and dirfd().
+            long maxPathName = ::pathconf(QFile::encodeName(path()).data(), _PC_NAME_MAX);
+            if ((int) maxPathName == -1)
+                maxPathName = FILENAME_MAX;
+            maxPathName += sizeof(dirent) + 1;
+#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
+            if (that->platform->mt_file)
+                delete [] that->platform->mt_file;
+            that->platform->mt_file = (dirent *)new char[maxPathName];
+#endif
+
+            that->advance();
+        }
+    }
+    return !platform->done;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_FSFILEENGINE
diff --git a/src/corelib/io/qfsfileengine_iterator_win.cpp b/src/corelib/io/qfsfileengine_iterator_win.cpp
new file mode 100644
index 0000000..3212d73
--- /dev/null
+++ b/src/corelib/io/qfsfileengine_iterator_win.cpp
@@ -0,0 +1,183 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qdebug.h"
+#include "qfsfileengine_iterator_p.h"
+#include "qfsfileengine_p.h"
+#include "qplatformdefs.h"
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qmutex.h>
+#include <private/qmutexpool_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QFSFileEngineIteratorPlatformSpecificData
+{
+public:
+    inline QFSFileEngineIteratorPlatformSpecificData()
+        : uncShareIndex(-1), findFileHandle(INVALID_HANDLE_VALUE),
+          done(false), uncFallback(false)
+    { }
+
+    QFSFileEngineIterator *it;
+
+    QStringList uncShares;
+    int uncShareIndex;
+
+    HANDLE findFileHandle;
+    WIN32_FIND_DATA findData;
+    bool done;
+    bool uncFallback;
+
+    void advance();
+    void saveCurrentFileName();
+};
+
+void QFSFileEngineIteratorPlatformSpecificData::saveCurrentFileName()
+{
+    if (uncFallback) {
+        // Windows share / UNC path
+        it->currentEntry = uncShares.at(uncShareIndex - 1);
+    } else {
+        // Local directory
+        QT_WA({
+            it->currentEntry = QString::fromUtf16((unsigned short *)findData.cFileName);
+        } , {
+            it->currentEntry = QString::fromLocal8Bit((const char *)findData.cFileName);
+        });
+    }
+}
+
+void QFSFileEngineIterator::advance()
+{
+    platform->saveCurrentFileName();
+
+    if (platform->done)
+        return;
+
+    if (platform->uncFallback) {
+        ++platform->uncShareIndex;
+    } else if (platform->findFileHandle != INVALID_HANDLE_VALUE) {
+        QT_WA({
+            if (!FindNextFile(platform->findFileHandle, &platform->findData)) {
+                platform->done = true;        
+                FindClose(platform->findFileHandle);
+            }
+        } , {
+            if (!FindNextFileA(platform->findFileHandle, (WIN32_FIND_DATAA *)&platform->findData)) {
+                platform->done = true;
+                FindClose(platform->findFileHandle);
+            }
+        });
+    }
+}
+
+void QFSFileEngineIterator::newPlatformSpecifics()
+{
+    platform = new QFSFileEngineIteratorPlatformSpecificData;
+    platform->it = this;
+}
+
+void QFSFileEngineIterator::deletePlatformSpecifics()
+{
+    delete platform;
+    platform = 0;
+}
+
+bool QFSFileEngineIterator::hasNext() const
+{
+    if (platform->done)
+        return false;
+    
+    if (platform->uncFallback)
+        return platform->uncShareIndex > 0 && platform->uncShareIndex <= platform->uncShares.size();
+    
+    if (platform->findFileHandle == INVALID_HANDLE_VALUE) {
+        QString path = this->path();
+        // Local directory
+        if (path.endsWith(QLatin1String(".lnk")))
+            path = QFileInfo(path).readLink();
+
+        if (!path.endsWith(QLatin1Char('/')))
+            path.append(QLatin1Char('/'));
+        path.append(QLatin1String("*.*"));
+
+        QT_WA({
+            QString fileName = QFSFileEnginePrivate::longFileName(path);
+            platform->findFileHandle = FindFirstFileW((TCHAR *)fileName.utf16(),
+                                                      &platform->findData);
+        }, {
+            // Cast is safe, since char is at end of WIN32_FIND_DATA
+            platform->findFileHandle = FindFirstFileA(QFSFileEnginePrivate::win95Name(path),
+                                                      (WIN32_FIND_DATAA*)&platform->findData);
+        });
+
+        if (platform->findFileHandle == INVALID_HANDLE_VALUE) {
+            if (path.startsWith(QLatin1String("//"))) {
+                path = this->path();
+                // UNC
+                QStringList parts = QDir::toNativeSeparators(path).split(QLatin1Char('\\'), QString::SkipEmptyParts);
+
+                if (parts.count() == 1 && QFSFileEnginePrivate::uncListSharesOnServer(QLatin1String("\\\\") + parts.at(0),
+                                                                                      &platform->uncShares)) {
+                    if (platform->uncShares.isEmpty()) {
+                        platform->done = true;
+                    } else {
+                        platform->uncShareIndex = 1;
+                    }
+                    platform->uncFallback = true;
+                } else {
+                    platform->done = true;
+                }
+            } else {
+                platform->done = true;        
+            }
+        }
+
+        if (!platform->done && (!platform->uncFallback || !platform->uncShares.isEmpty()))
+            platform->saveCurrentFileName();
+    }
+
+    return !platform->done;
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qfsfileengine_p.h b/src/corelib/io/qfsfileengine_p.h
new file mode 100644
index 0000000..8b6cc53
--- /dev/null
+++ b/src/corelib/io/qfsfileengine_p.h
@@ -0,0 +1,174 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFSFILEENGINE_P_H
+#define QFSFILEENGINE_P_H
+
+//
+//  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.
+//
+
+#include "qplatformdefs.h"
+#include "QtCore/qfsfileengine.h"
+#include "private/qabstractfileengine_p.h"
+#include <qhash.h>
+
+#ifndef QT_NO_FSFILEENGINE
+
+QT_BEGIN_NAMESPACE
+
+#if defined(Q_OS_WINCE_STD) && _WIN32_WCE < 0x600
+#define Q_USE_DEPRECATED_MAP_API 1
+#endif
+
+class QFSFileEnginePrivate : public QAbstractFileEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QFSFileEngine)
+
+public:
+#ifdef Q_WS_WIN
+    static QByteArray win95Name(const QString &path);
+    static QString longFileName(const QString &path);
+#endif
+    static QString canonicalized(const QString &path);
+
+    QString filePath;
+    QByteArray nativeFilePath;
+    QIODevice::OpenMode openMode;
+
+    void nativeInitFileName();
+    bool nativeOpen(QIODevice::OpenMode openMode);
+    bool openFh(QIODevice::OpenMode flags, FILE *fh);
+    bool openFd(QIODevice::OpenMode flags, int fd);
+    bool nativeClose();
+    bool closeFdFh();
+    bool nativeFlush();
+    bool flushFh();
+    qint64 nativeSize() const;
+    qint64 sizeFdFh() const;
+    qint64 nativePos() const;
+    qint64 posFdFh() const;
+    bool nativeSeek(qint64);
+    bool seekFdFh(qint64);
+    qint64 nativeRead(char *data, qint64 maxlen);
+    qint64 readFdFh(char *data, qint64 maxlen);
+    qint64 nativeReadLine(char *data, qint64 maxlen);
+    qint64 readLineFdFh(char *data, qint64 maxlen);
+    qint64 nativeWrite(const char *data, qint64 len);
+    qint64 writeFdFh(const char *data, qint64 len);
+    int nativeHandle() const;
+    bool nativeIsSequential() const;
+    bool isSequentialFdFh() const;
+
+    uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
+    bool unmap(uchar *ptr);
+
+    FILE *fh;
+#ifdef Q_WS_WIN
+    HANDLE fileHandle;
+    QHash<uchar *, QPair<int /*offset*/, HANDLE /*handle*/> > maps;
+    mutable int cachedFd;
+    mutable DWORD fileAttrib;
+#else
+    QHash<uchar *, QPair<int /*offset*/, int /*handle|len*/> > maps;
+    mutable QT_STATBUF st;
+#endif
+    int fd;
+
+#ifdef Q_USE_DEPRECATED_MAP_API
+    void mapHandleClose();
+    HANDLE fileMapHandle;
+#endif
+
+    enum LastIOCommand
+    {
+        IOFlushCommand,
+        IOReadCommand,
+        IOWriteCommand
+    };
+    LastIOCommand  lastIOCommand;
+    bool lastFlushFailed;
+    bool closeFileHandle;
+
+    mutable uint is_sequential : 2;
+    mutable uint could_stat : 1;
+    mutable uint tried_stat : 1;
+#ifdef Q_OS_UNIX
+    mutable uint need_lstat : 1;
+    mutable uint is_link : 1;
+#endif
+    bool doStat() const;
+    bool isSymlink() const;
+
+#if defined(Q_OS_WIN32)
+    int sysOpen(const QString &, int flags);
+#endif
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
+    static void resolveLibs();
+    static bool resolveUNCLibs_NT();
+    static bool resolveUNCLibs_9x();
+    static bool uncListSharesOnServer(const QString &server, QStringList *list);
+#endif
+
+protected:
+    QFSFileEnginePrivate();
+
+    void init();
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
+    QAbstractFileEngine::FileFlags getPermissions() const;
+    QString getLink() const;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_FSFILEENGINE
+
+#endif // QFSFILEENGINE_P_H
diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp
new file mode 100644
index 0000000..0d88b06
--- /dev/null
+++ b/src/corelib/io/qfsfileengine_unix.cpp
@@ -0,0 +1,1021 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qabstractfileengine.h"
+#include "private/qfsfileengine_p.h"
+
+#ifndef QT_NO_FSFILEENGINE
+
+#ifndef QT_NO_REGEXP
+# include "qregexp.h"
+#endif
+#include "qfile.h"
+#include "qdir.h"
+#include "qdatetime.h"
+#include "qdebug.h"
+#include "qvarlengtharray.h"
+
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+#if !defined(QWS) && defined(Q_OS_MAC)
+# include <private/qcore_mac_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \internal
+
+    Returns the stdlib open string corresponding to a QIODevice::OpenMode.
+*/
+static QByteArray openModeToFopenMode(QIODevice::OpenMode flags, const QString &fileName = QString())
+{
+    QByteArray mode;
+    if ((flags & QIODevice::ReadOnly) && !(flags & QIODevice::Truncate)) {
+        mode = "rb";
+        if (flags & QIODevice::WriteOnly) {
+            if (!fileName.isEmpty() &&QFile::exists(fileName))
+                mode = "rb+";
+            else
+                mode = "wb+";
+        }
+    } else if (flags & QIODevice::WriteOnly) {
+        mode = "wb";
+        if (flags & QIODevice::ReadOnly)
+            mode += "+";
+    }
+    if (flags & QIODevice::Append) {
+        mode = "ab";
+        if (flags & QIODevice::ReadOnly)
+            mode += "+";
+    }
+    return mode;
+}
+
+/*!
+    \internal
+
+    Returns the stdio open flags corresponding to a QIODevice::OpenMode.
+*/
+static int openModeToOpenFlags(QIODevice::OpenMode mode)
+{
+    int oflags = QT_OPEN_RDONLY;
+#ifdef QT_LARGEFILE_SUPPORT
+    oflags |= QT_OPEN_LARGEFILE;
+#endif
+
+    if ((mode & QFile::ReadWrite) == QFile::ReadWrite) {
+        oflags = QT_OPEN_RDWR | QT_OPEN_CREAT;
+    } else if (mode & QFile::WriteOnly) {
+        oflags = QT_OPEN_WRONLY | QT_OPEN_CREAT;
+    }
+
+    if (mode & QFile::Append) {
+        oflags |= QT_OPEN_APPEND;
+    } else if (mode & QFile::WriteOnly) {
+        if ((mode & QFile::Truncate) || !(mode & QFile::ReadOnly))
+            oflags |= QT_OPEN_TRUNC;
+    }
+
+#ifdef O_CLOEXEC
+    // supported on Linux >= 2.6.23; avoids one extra system call
+    // and avoids a race condition: if another thread forks, we could
+    // end up leaking a file descriptor...
+    oflags |= O_CLOEXEC;
+#endif
+    return oflags;
+}
+
+/*!
+    \internal
+
+    Sets the file descriptor to close on exec. That is, the file
+    descriptor is not inherited by child processes.
+*/
+static bool setCloseOnExec(int fd)
+{
+    return fd != -1 && fcntl(fd, F_SETFD, FD_CLOEXEC) != -1;
+}
+
+/*!
+    \internal
+*/
+void QFSFileEnginePrivate::nativeInitFileName()
+{
+    nativeFilePath = QFile::encodeName(filePath);
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode)
+{
+    Q_Q(QFSFileEngine);
+
+    if (openMode & QIODevice::Unbuffered) {
+        int flags = openModeToOpenFlags(openMode);
+
+        // Try to open the file in unbuffered mode.
+        do {
+            fd = QT_OPEN(nativeFilePath.constData(), flags, 0666);
+        } while (fd == -1 && errno == EINTR);
+
+        // On failure, return and report the error.
+        if (fd == -1) {
+            q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                        qt_error_string(errno));
+            return false;
+        }
+
+        QT_STATBUF statBuf;
+        if (QT_FSTAT(fd, &statBuf) != -1) {
+            if ((statBuf.st_mode & S_IFMT) == S_IFDIR) {
+                q->setError(QFile::OpenError, QLatin1String("file to open is a directory"));
+                QT_CLOSE(fd);
+                return false;
+            }
+        }
+
+#ifndef O_CLOEXEC
+        // not needed on Linux >= 2.6.23
+        setCloseOnExec(fd);     // ignore failure
+#endif
+
+        // Seek to the end when in Append mode.
+        if (flags & QFile::Append) {
+            int ret;
+            do {
+                ret = QT_LSEEK(fd, 0, SEEK_END);
+            } while (ret == -1 && errno == EINTR);
+
+            if (ret == -1) {
+                q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                            qt_error_string(int(errno)));
+                return false;
+            }
+        }
+
+        fh = 0;
+    } else {
+        QByteArray fopenMode = openModeToFopenMode(openMode, filePath);
+
+        // Try to open the file in buffered mode.
+        do {
+            fh = QT_FOPEN(nativeFilePath.constData(), fopenMode.constData());
+        } while (!fh && errno == EINTR);
+
+        // On failure, return and report the error.
+        if (!fh) {
+            q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                        qt_error_string(int(errno)));
+            return false;
+        }
+
+        QT_STATBUF statBuf;
+        if (QT_FSTAT(fileno(fh), &statBuf) != -1) {
+            if ((statBuf.st_mode & S_IFMT) == S_IFDIR) {
+                q->setError(QFile::OpenError, QLatin1String("file to open is a directory"));
+                fclose(fh);
+                return false;
+            }
+        }
+
+        setCloseOnExec(fileno(fh)); // ignore failure
+
+        // Seek to the end when in Append mode.
+        if (openMode & QIODevice::Append) {
+            int ret;
+            do {
+                ret = QT_FSEEK(fh, 0, SEEK_END);
+            } while (ret == -1 && errno == EINTR);
+
+            if (ret == -1) {
+                q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
+                            qt_error_string(int(errno)));
+                return false;
+            }
+        }
+
+        fd = -1;
+    }
+
+    closeFileHandle = true;
+    return true;
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeClose()
+{
+    return closeFdFh();
+}
+
+/*!
+    \internal
+
+*/
+bool QFSFileEnginePrivate::nativeFlush()
+{
+    return fh ? flushFh() : fd != -1;
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativeRead(char *data, qint64 len)
+{
+    Q_Q(QFSFileEngine);
+
+    if (fh && nativeIsSequential()) {
+        size_t readBytes = 0;
+        int oldFlags = fcntl(QT_FILENO(fh), F_GETFL);
+        for (int i = 0; i < 2; ++i) {
+            // Unix: Make the underlying file descriptor non-blocking
+            int v = 1;
+            if ((oldFlags & O_NONBLOCK) == 0)
+                fcntl(QT_FILENO(fh), F_SETFL, oldFlags | O_NONBLOCK, &v, sizeof(v));
+
+            // Cross platform stdlib read
+            size_t read = 0;
+            do {
+                read = fread(data + readBytes, 1, size_t(len - readBytes), fh);
+            } while (read == 0 && !feof(fh) && errno == EINTR);
+            if (read > 0) {
+                readBytes += read;
+                break;
+            } else {
+                if (readBytes)
+                    break;
+                readBytes = read;
+            }
+
+            // Unix: Restore the blocking state of the underlying socket
+            if ((oldFlags & O_NONBLOCK) == 0) {
+                int v = 1;
+                fcntl(QT_FILENO(fh), F_SETFL, oldFlags, &v, sizeof(v));
+                if (readBytes == 0) {
+                    int readByte = 0;
+                    do {
+                        readByte = fgetc(fh);
+                    } while (readByte == -1 && errno == EINTR);
+                    if (readByte != -1) {
+                        *data = uchar(readByte);
+                        readBytes += 1;
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+        // Unix: Restore the blocking state of the underlying socket
+        if ((oldFlags & O_NONBLOCK) == 0) {
+            int v = 1;
+            fcntl(QT_FILENO(fh), F_SETFL, oldFlags, &v, sizeof(v));
+        }
+        if (readBytes == 0 && !feof(fh)) {
+            // if we didn't read anything and we're not at EOF, it must be an error
+            q->setError(QFile::ReadError, qt_error_string(int(errno)));
+            return -1;
+        }
+        return readBytes;
+    }
+
+    return readFdFh(data, len);
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativeReadLine(char *data, qint64 maxlen)
+{
+    return readLineFdFh(data, maxlen);
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativeWrite(const char *data, qint64 len)
+{
+    return writeFdFh(data, len);
+}
+
+/*!
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativePos() const
+{
+    return posFdFh();
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeSeek(qint64 pos)
+{
+    return seekFdFh(pos);
+}
+
+/*!
+    \internal
+*/
+int QFSFileEnginePrivate::nativeHandle() const
+{
+    return fh ? fileno(fh) : fd;
+}
+
+/*!
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeIsSequential() const
+{
+    return isSequentialFdFh();
+}
+
+bool QFSFileEngine::remove()
+{
+    Q_D(QFSFileEngine);
+    return unlink(d->nativeFilePath.constData()) == 0;
+}
+
+bool QFSFileEngine::copy(const QString &)
+{
+    // ### Add copy code for Unix here
+    return false;
+}
+
+bool QFSFileEngine::rename(const QString &newName)
+{
+    Q_D(QFSFileEngine);
+    return ::rename(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;
+}
+
+bool QFSFileEngine::link(const QString &newName)
+{
+    Q_D(QFSFileEngine);
+    return ::symlink(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;
+}
+
+qint64 QFSFileEnginePrivate::nativeSize() const
+{
+    return sizeFdFh();
+}
+
+bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
+{
+    QString dirName = name;
+    if (createParentDirectories) {
+        dirName = QDir::cleanPath(dirName);
+        for(int oldslash = -1, slash=0; slash != -1; oldslash = slash) {
+            slash = dirName.indexOf(QDir::separator(), oldslash+1);
+            if (slash == -1) {
+                if (oldslash == dirName.length())
+                    break;
+                slash = dirName.length();
+            }
+            if (slash) {
+                QByteArray chunk = QFile::encodeName(dirName.left(slash));
+                QT_STATBUF st;
+                if (QT_STAT(chunk, &st) != -1) {
+                    if ((st.st_mode & S_IFMT) != S_IFDIR)
+                        return false;
+                } else if (::mkdir(chunk, 0777) != 0) {
+                        return false;
+                }
+            }
+        }
+        return true;
+    }
+#if defined(Q_OS_DARWIN)  // Mac X doesn't support trailing /'s
+    if (dirName[dirName.length() - 1] == QLatin1Char('/'))
+        dirName = dirName.left(dirName.length() - 1);
+#endif
+    return (::mkdir(QFile::encodeName(dirName), 0777) == 0);
+}
+
+bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
+{
+    QString dirName = name;
+    if (recurseParentDirectories) {
+        dirName = QDir::cleanPath(dirName);
+        for(int oldslash = 0, slash=dirName.length(); slash > 0; oldslash = slash) {
+            QByteArray chunk = QFile::encodeName(dirName.left(slash));
+            QT_STATBUF st;
+            if (QT_STAT(chunk, &st) != -1) {
+                if ((st.st_mode & S_IFMT) != S_IFDIR)
+                    return false;
+                if (::rmdir(chunk) != 0)
+                    return oldslash != 0;
+            } else {
+                return false;
+            }
+            slash = dirName.lastIndexOf(QDir::separator(), oldslash-1);
+        }
+        return true;
+    }
+    return ::rmdir(QFile::encodeName(dirName)) == 0;
+}
+
+bool QFSFileEngine::caseSensitive() const
+{
+    return true;
+}
+
+bool QFSFileEngine::setCurrentPath(const QString &path)
+{
+    int r;
+    r = ::chdir(QFile::encodeName(path));
+    return r >= 0;
+}
+
+QString QFSFileEngine::currentPath(const QString &)
+{
+    QString result;
+    QT_STATBUF st;
+    if (QT_STAT(".", &st) == 0) {
+#if defined(__GLIBC__) && !defined(PATH_MAX)
+        char *currentName = ::get_current_dir_name();
+        if (currentName) {
+            result = QFile::decodeName(QByteArray(currentName));
+            ::free(currentName);
+        }
+#else
+        char currentName[PATH_MAX+1];
+        if (::getcwd(currentName, PATH_MAX))
+            result = QFile::decodeName(QByteArray(currentName));
+#endif
+#if defined(QT_DEBUG)
+        if (result.isNull())
+            qWarning("QDir::currentPath: getcwd() failed");
+#endif
+    } else {
+#if defined(QT_DEBUG)
+        qWarning("QDir::currentPath: stat(\".\") failed");
+#endif
+    }
+    return result;
+}
+
+QString QFSFileEngine::homePath()
+{
+    QString home = QFile::decodeName(qgetenv("HOME"));
+    if (home.isNull())
+        home = rootPath();
+    return home;
+}
+
+QString QFSFileEngine::rootPath()
+{
+    return QString::fromLatin1("/");
+}
+
+QString QFSFileEngine::tempPath()
+{
+    QString temp = QFile::decodeName(qgetenv("TMPDIR"));
+    if (temp.isEmpty())
+        temp = QString::fromLatin1("/tmp/");
+    return temp;
+}
+
+QFileInfoList QFSFileEngine::drives()
+{
+    QFileInfoList ret;
+    ret.append(rootPath());
+    return ret;
+}
+
+bool QFSFileEnginePrivate::doStat() const
+{
+    if (tried_stat == 0) {
+        QFSFileEnginePrivate *that = const_cast<QFSFileEnginePrivate*>(this);
+        if (fh && nativeFilePath.isEmpty()) {
+            // ### actually covers two cases: d->fh and when the file is not open
+            that->could_stat = (QT_FSTAT(fileno(fh), &st) == 0);
+        } else if (fd == -1) {
+            // ### actually covers two cases: d->fh and when the file is not open
+            that->could_stat = (QT_STAT(nativeFilePath.constData(), &st) == 0);
+        } else {
+            that->could_stat = (QT_FSTAT(fd, &st) == 0);
+        }
+	that->tried_stat = 1;
+    }
+    return could_stat;
+}
+
+bool QFSFileEnginePrivate::isSymlink() const
+{
+    if (need_lstat) {
+        QFSFileEnginePrivate *that = const_cast<QFSFileEnginePrivate *>(this);
+        that->need_lstat = false;
+        QT_STATBUF st;          // don't clobber our main one
+        that->is_link = (QT_LSTAT(nativeFilePath.constData(), &st) == 0) ? S_ISLNK(st.st_mode) : false;
+    }
+    return is_link;
+}
+
+#if !defined(QWS) && defined(Q_OS_MAC)
+static bool _q_isMacHidden(const QString &path)
+{
+    OSErr err = noErr;
+
+    FSRef fsRef;
+
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
+        err = FSPathMakeRefWithOptions(reinterpret_cast<const UInt8 *>(QFile::encodeName(QDir::cleanPath(path)).constData()),
+                                        kFSPathMakeRefDoNotFollowLeafSymlink, &fsRef, 0);
+    } else
+#endif
+    {
+        QFileInfo fi(path);
+        FSRef parentRef;
+        err = FSPathMakeRef(reinterpret_cast<const UInt8 *>(fi.absoluteDir().absolutePath().toUtf8().constData()),
+                            &parentRef, 0);
+        if (err == noErr) {
+            QString fileName = fi.fileName();
+            err = FSMakeFSRefUnicode(&parentRef, fileName.length(),
+                                     reinterpret_cast<const UniChar *>(fileName.unicode()),
+                                     kTextEncodingUnknown, &fsRef);
+        }
+    }
+    if (err != noErr)
+        return false;
+
+    FSCatalogInfo catInfo;
+    err = FSGetCatalogInfo(&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL);
+    if (err != noErr)
+        return false;
+
+    FileInfo * const fileInfo = reinterpret_cast<FileInfo*>(&catInfo.finderInfo);
+    bool result = (fileInfo->finderFlags & kIsInvisible);
+    return result;
+}
+#endif
+
+/*!
+    \reimp
+*/
+QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(FileFlags type) const
+{
+    Q_D(const QFSFileEngine);
+    // Force a stat, so that we're guaranteed to get up-to-date results
+    if (type & QAbstractFileEngine::FileFlag(QAbstractFileEngine::Refresh)) {
+        d->tried_stat = 0;
+        d->need_lstat = 1;
+    }
+
+    QAbstractFileEngine::FileFlags ret = 0;
+    bool exists = d->doStat();
+    if (!exists && !d->isSymlink())
+        return ret;
+
+    if (exists && (type & PermsMask)) {
+        if (d->st.st_mode & S_IRUSR)
+            ret |= ReadOwnerPerm;
+        if (d->st.st_mode & S_IWUSR)
+            ret |= WriteOwnerPerm;
+        if (d->st.st_mode & S_IXUSR)
+            ret |= ExeOwnerPerm;
+        if (d->st.st_mode & S_IRUSR)
+            ret |= ReadUserPerm;
+        if (d->st.st_mode & S_IWUSR)
+            ret |= WriteUserPerm;
+        if (d->st.st_mode & S_IXUSR)
+            ret |= ExeUserPerm;
+        if (d->st.st_mode & S_IRGRP)
+            ret |= ReadGroupPerm;
+        if (d->st.st_mode & S_IWGRP)
+            ret |= WriteGroupPerm;
+        if (d->st.st_mode & S_IXGRP)
+            ret |= ExeGroupPerm;
+        if (d->st.st_mode & S_IROTH)
+            ret |= ReadOtherPerm;
+        if (d->st.st_mode & S_IWOTH)
+            ret |= WriteOtherPerm;
+        if (d->st.st_mode & S_IXOTH)
+            ret |= ExeOtherPerm;
+    }
+    if (type & TypesMask) {
+#if !defined(QWS) && defined(Q_OS_MAC)
+        bool foundAlias = false;
+        {
+            FSRef fref;
+            if (FSPathMakeRef((const UInt8 *)QFile::encodeName(QDir::cleanPath(d->filePath)).data(),
+                             &fref, NULL) == noErr) {
+                Boolean isAlias, isFolder;
+                if (FSIsAliasFile(&fref, &isAlias, &isFolder) == noErr && isAlias) {
+                    foundAlias = true;
+                    ret |= LinkType;
+                }
+            }
+        }
+        if (!foundAlias)
+#endif
+        {
+            if ((type & LinkType) && d->isSymlink())
+                ret |= LinkType;
+            if (exists && (d->st.st_mode & S_IFMT) == S_IFREG)
+                ret |= FileType;
+            else if (exists && (d->st.st_mode & S_IFMT) == S_IFDIR)
+                ret |= DirectoryType;
+#if !defined(QWS) && defined(Q_OS_MAC)
+            if((ret & DirectoryType) && (type & BundleType)) {
+                QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(d->filePath),
+                                                                      kCFURLPOSIXPathStyle, true);
+                UInt32 type, creator;
+                if(CFBundleGetPackageInfoInDirectory(url, &type, &creator))
+                    ret |= BundleType;
+            }
+#endif
+        }
+    }
+    if (type & FlagsMask) {
+        ret |= LocalDiskFlag;
+        if (exists)
+            ret |= ExistsFlag;
+        if (fileName(BaseName)[0] == QLatin1Char('.')
+#if !defined(QWS) && defined(Q_OS_MAC)
+            || _q_isMacHidden(d->filePath)
+#endif
+        )
+            ret |= HiddenFlag;
+        if (d->filePath == QLatin1String("/"))
+            ret |= RootFlag;
+    }
+    return ret;
+}
+
+QString QFSFileEngine::fileName(FileName file) const
+{
+    Q_D(const QFSFileEngine);
+    if (file == BundleName) {
+#if !defined(QWS) && defined(Q_OS_MAC)
+        QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(d->filePath),
+                                                              kCFURLPOSIXPathStyle, true);
+        if(CFDictionaryRef dict = CFBundleCopyInfoDictionaryForURL(url)) {
+            if(CFTypeRef name = (CFTypeRef)CFDictionaryGetValue(dict, kCFBundleNameKey)) {
+                if(CFGetTypeID(name) == CFStringGetTypeID())
+                    return QCFString::toQString((CFStringRef)name);
+            }
+        }
+#endif
+        return QString();
+    } else if (file == BaseName) {
+        int slash = d->filePath.lastIndexOf(QLatin1Char('/'));
+        if (slash != -1)
+            return d->filePath.mid(slash + 1);
+    } else if (file == PathName) {
+        int slash = d->filePath.lastIndexOf(QLatin1Char('/'));
+        if (slash == -1)
+            return QLatin1String(".");
+        else if (!slash)
+            return QLatin1String("/");
+        return d->filePath.left(slash);
+    } else if (file == AbsoluteName || file == AbsolutePathName) {
+        QString ret;
+        if (d->filePath.isEmpty() || !d->filePath.startsWith(QLatin1Char('/')))
+            ret = QDir::currentPath();
+        if (!d->filePath.isEmpty() && d->filePath != QLatin1String(".")) {
+            if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
+                ret += QLatin1Char('/');
+            ret += d->filePath;
+        }
+        if (ret == QLatin1String("/"))
+            return ret;
+        bool isDir = ret.endsWith(QLatin1Char('/'));
+        ret = QDir::cleanPath(ret);
+        if (isDir)
+            ret += QLatin1String("/");
+        if (file == AbsolutePathName) {
+            int slash = ret.lastIndexOf(QLatin1Char('/'));
+            if (slash == -1)
+                return QDir::currentPath();
+            else if (!slash)
+                return QLatin1String("/");
+            return ret.left(slash);
+        }
+        return ret;
+    } else if (file == CanonicalName || file == CanonicalPathName) {
+        if (!(fileFlags(ExistsFlag) & ExistsFlag))
+            return QString();
+
+        QString ret = QFSFileEnginePrivate::canonicalized(fileName(AbsoluteName));
+        if (!ret.isEmpty() && file == CanonicalPathName) {
+            int slash = ret.lastIndexOf(QLatin1Char('/'));
+            if (slash == -1)
+                ret = QDir::currentPath();
+            else if (slash == 0)
+                ret = QLatin1String("/");
+            ret = ret.left(slash);
+        }
+        return ret;
+    } else if (file == LinkName) {
+        if (d->isSymlink()) {
+#if defined(__GLIBC__) && !defined(PATH_MAX)
+#define PATH_CHUNK_SIZE 256
+            char *s = 0;
+            int len = -1;
+            int size = PATH_CHUNK_SIZE;
+
+            while (1) {
+                s = (char *) ::realloc(s, size);
+                if (s == 0) {
+                    len = -1;
+                    break;
+                }
+                len = ::readlink(d->nativeFilePath.constData(), s, size);
+                if (len < 0) {
+                    ::free(s);
+                    break;
+                }
+                if (len < size) {
+                    break;
+                }
+                size *= 2;
+            }
+#else
+            char s[PATH_MAX+1];
+            int len = readlink(d->nativeFilePath.constData(), s, PATH_MAX);
+#endif
+            if (len > 0) {
+                QString ret;
+                if (S_ISDIR(d->st.st_mode) && s[0] != '/') {
+                    QDir parent(d->filePath);
+                    parent.cdUp();
+                    ret = parent.path();
+                    if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
+                        ret += QLatin1Char('/');
+                }
+                s[len] = '\0';
+                ret += QFile::decodeName(QByteArray(s));
+#if defined(__GLIBC__) && !defined(PATH_MAX)
+		::free(s);
+#endif
+
+                if (!ret.startsWith(QLatin1Char('/'))) {
+                    if (d->filePath.startsWith(QLatin1Char('/'))) {
+                        ret.prepend(d->filePath.left(d->filePath.lastIndexOf(QLatin1Char('/')))
+                                    + QLatin1Char('/'));
+                    } else {
+                        ret.prepend(QDir::currentPath() + QLatin1Char('/'));
+                    }
+                }
+                ret = QDir::cleanPath(ret);
+                if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
+                    ret.chop(1);
+                return ret;
+            }
+        }
+#if !defined(QWS) && defined(Q_OS_MAC)
+        {
+            FSRef fref;
+            if (FSPathMakeRef((const UInt8 *)QFile::encodeName(QDir::cleanPath(d->filePath)).data(), &fref, 0) == noErr) {
+                Boolean isAlias, isFolder;
+                if (FSResolveAliasFile(&fref, true, &isFolder, &isAlias) == noErr && isAlias) {
+                    AliasHandle alias;
+                    if (FSNewAlias(0, &fref, &alias) == noErr && alias) {
+                        CFStringRef cfstr;
+                        if (FSCopyAliasInfo(alias, 0, 0, &cfstr, 0, 0) == noErr)
+                            return QCFString::toQString(cfstr);
+                    }
+                }
+            }
+        }
+#endif
+        return QString();
+    }
+    return d->filePath;
+}
+
+bool QFSFileEngine::isRelativePath() const
+{
+    Q_D(const QFSFileEngine);
+    int len = d->filePath.length();
+    if (len == 0)
+        return true;
+    return d->filePath[0] != QLatin1Char('/');
+}
+
+uint QFSFileEngine::ownerId(FileOwner own) const
+{
+    Q_D(const QFSFileEngine);
+    static const uint nobodyID = (uint) -2;
+    if (d->doStat()) {
+        if (own == OwnerUser)
+            return d->st.st_uid;
+        else
+            return d->st.st_gid;
+    }
+    return nobodyID;
+}
+
+QString QFSFileEngine::owner(FileOwner own) const
+{
+#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
+    int size_max = sysconf(_SC_GETPW_R_SIZE_MAX);
+    if (size_max == -1)
+        size_max = 1024;
+    QVarLengthArray<char, 1024> buf(size_max);
+#endif
+
+    if (own == OwnerUser) {
+        struct passwd *pw = 0;
+#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
+        struct passwd entry;
+        getpwuid_r(ownerId(own), &entry, buf.data(), buf.size(), &pw);
+#else
+        pw = getpwuid(ownerId(own));
+#endif
+        if (pw)
+            return QFile::decodeName(QByteArray(pw->pw_name));
+    } else if (own == OwnerGroup) {
+        struct group *gr = 0;
+#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
+        size_max = sysconf(_SC_GETGR_R_SIZE_MAX);
+        if (size_max == -1)
+            size_max = 1024;
+        buf.resize(size_max);
+        struct group entry;
+        // Some large systems have more members than the POSIX max size
+        // Loop over by doubling the buffer size (upper limit 250k)
+        for (unsigned size = size_max; size < 256000; size += size)
+        {
+            buf.resize(size);
+            // ERANGE indicates that the buffer was too small
+            if (!getgrgid_r(ownerId(own), &entry, buf.data(), buf.size(), &gr)
+                || errno != ERANGE)
+                break;
+        }
+
+#else
+        gr = getgrgid(ownerId(own));
+#endif
+        if (gr)
+            return QFile::decodeName(QByteArray(gr->gr_name));
+    }
+    return QString();
+}
+
+bool QFSFileEngine::setPermissions(uint perms)
+{
+    Q_D(QFSFileEngine);
+    mode_t mode = 0;
+    if (perms & ReadOwnerPerm)
+        mode |= S_IRUSR;
+    if (perms & WriteOwnerPerm)
+        mode |= S_IWUSR;
+    if (perms & ExeOwnerPerm)
+        mode |= S_IXUSR;
+    if (perms & ReadUserPerm)
+        mode |= S_IRUSR;
+    if (perms & WriteUserPerm)
+        mode |= S_IWUSR;
+    if (perms & ExeUserPerm)
+        mode |= S_IXUSR;
+    if (perms & ReadGroupPerm)
+        mode |= S_IRGRP;
+    if (perms & WriteGroupPerm)
+        mode |= S_IWGRP;
+    if (perms & ExeGroupPerm)
+        mode |= S_IXGRP;
+    if (perms & ReadOtherPerm)
+        mode |= S_IROTH;
+    if (perms & WriteOtherPerm)
+        mode |= S_IWOTH;
+    if (perms & ExeOtherPerm)
+        mode |= S_IXOTH;
+    if (d->fd != -1)
+        return !fchmod(d->fd, mode);
+    return !::chmod(d->nativeFilePath.constData(), mode);
+}
+
+bool QFSFileEngine::setSize(qint64 size)
+{
+    Q_D(QFSFileEngine);
+    if (d->fd != -1)
+        return !QT_FTRUNCATE(d->fd, size);
+    return !QT_TRUNCATE(d->nativeFilePath.constData(), size);
+}
+
+QDateTime QFSFileEngine::fileTime(FileTime time) const
+{
+    Q_D(const QFSFileEngine);
+    QDateTime ret;
+    if (d->doStat()) {
+        if (time == CreationTime)
+            ret.setTime_t(d->st.st_ctime ? d->st.st_ctime : d->st.st_mtime);
+        else if (time == ModificationTime)
+            ret.setTime_t(d->st.st_mtime);
+        else if (time == AccessTime)
+            ret.setTime_t(d->st.st_atime);
+    }
+    return ret;
+}
+
+uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
+{
+    Q_Q(QFSFileEngine);
+    Q_UNUSED(flags);
+    if (offset < 0) {
+        q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
+        return 0;
+    }
+    if (openMode == QIODevice::NotOpen) {
+        q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
+        return 0;
+    }
+    int access = 0;
+    if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
+    if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;
+
+    int pagesSize = getpagesize();
+    int realOffset = offset / pagesSize;
+    int extra = offset % pagesSize;
+
+    void *mapAddress = mmap((void*)0, (size_t)size + extra,
+                   access, MAP_SHARED, nativeHandle(), realOffset * pagesSize);
+    if (MAP_FAILED != mapAddress) {
+        uchar *address = extra + static_cast<uchar*>(mapAddress);
+        maps[address] = QPair<int,int>(extra, size);
+        return address;
+    }
+
+    switch(errno) {
+    case EBADF:
+        q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
+        break;
+    case ENFILE:
+    case ENOMEM:
+        q->setError(QFile::ResourceError, qt_error_string(int(errno)));
+        break;
+    case EINVAL:
+        // size are out of bounds
+    default:
+        q->setError(QFile::UnspecifiedError, qt_error_string(int(errno)));
+        break;
+    }
+    return 0;
+}
+
+bool QFSFileEnginePrivate::unmap(uchar *ptr)
+{
+    Q_Q(QFSFileEngine);
+    if (!maps.contains(ptr)) {
+        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
+        return false;
+    }
+
+    uchar *start = ptr - maps[ptr].first;
+    int len = maps[ptr].second;
+    if (-1 == munmap(start, len)) {
+        q->setError(QFile::UnspecifiedError, qt_error_string(errno));
+        return false;
+    }
+    maps.remove(ptr);
+    return true;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_FSFILEENGINE
diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp
new file mode 100644
index 0000000..522be20
--- /dev/null
+++ b/src/corelib/io/qfsfileengine_win.cpp
@@ -0,0 +1,2242 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+#define _POSIX_
+#include "qplatformdefs.h"
+#include "qabstractfileengine.h"
+#include "private/qfsfileengine_p.h"
+#include <qdebug.h>
+
+#include "qfile.h"
+#include "qdir.h"
+#include "qtemporaryfile.h"
+#ifndef QT_NO_REGEXP
+# include "qregexp.h"
+#endif
+#include "private/qmutexpool_p.h"
+#include "qvarlengtharray.h"
+#include "qdatetime.h"
+#include "qt_windows.h"
+
+#if !defined(Q_OS_WINCE)
+#  include <sys/types.h>
+#  include <direct.h>
+#else
+#  include <types.h>
+#endif
+#include <objbase.h>
+#include <shlobj.h>
+#include <initguid.h>
+#include <accctrl.h>
+#include <ctype.h>
+#include <limits.h>
+#define SECURITY_WIN32
+#ifdef Q_CC_MINGW
+// A workaround for a certain version of MinGW, the define UNICODE_STRING.
+#include <subauth.h>
+#endif
+#include <security.h>
+
+#ifndef _INTPTR_T_DEFINED
+#ifdef  _WIN64
+typedef __int64             intptr_t;
+#else
+#ifdef _W64
+typedef _W64 int            intptr_t;
+#else
+typedef INT_PTR intptr_t;
+#endif
+#endif
+#define _INTPTR_T_DEFINED
+#endif
+
+#ifndef INVALID_FILE_ATTRIBUTES
+#  define INVALID_FILE_ATTRIBUTES (DWORD (-1))
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static QString readLink(const QString &link);
+
+Q_CORE_EXPORT int qt_ntfs_permission_lookup = 0;
+
+#if defined(Q_OS_WINCE)
+static QString qfsPrivateCurrentDir = QLatin1String("");
+// As none of the functions we try to resolve do exist on Windows CE
+// we use QT_NO_LIBRARY to shorten everything up a little bit.
+#define QT_NO_LIBRARY 1
+#endif
+
+#if !defined(QT_NO_LIBRARY)
+QT_BEGIN_INCLUDE_NAMESPACE
+typedef DWORD (WINAPI *PtrGetNamedSecurityInfoW)(LPWSTR, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID*, PSID*, PACL*, PACL*, PSECURITY_DESCRIPTOR*);
+static PtrGetNamedSecurityInfoW ptrGetNamedSecurityInfoW = 0;
+typedef DECLSPEC_IMPORT BOOL (WINAPI *PtrLookupAccountSidW)(LPCWSTR, PSID, LPWSTR, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE);
+static PtrLookupAccountSidW ptrLookupAccountSidW = 0;
+typedef DECLSPEC_IMPORT BOOL (WINAPI *PtrAllocateAndInitializeSid)(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*);
+static PtrAllocateAndInitializeSid ptrAllocateAndInitializeSid = 0;
+typedef VOID (WINAPI *PtrBuildTrusteeWithSidW)(PTRUSTEE_W, PSID);
+static PtrBuildTrusteeWithSidW ptrBuildTrusteeWithSidW = 0;
+typedef VOID (WINAPI *PtrBuildTrusteeWithNameW)(PTRUSTEE_W, unsigned short*);
+static PtrBuildTrusteeWithNameW ptrBuildTrusteeWithNameW = 0;
+typedef DWORD (WINAPI *PtrGetEffectiveRightsFromAclW)(PACL, PTRUSTEE_W, OUT PACCESS_MASK);
+static PtrGetEffectiveRightsFromAclW ptrGetEffectiveRightsFromAclW = 0;
+typedef DECLSPEC_IMPORT PVOID (WINAPI *PtrFreeSid)(PSID);
+static PtrFreeSid ptrFreeSid = 0;
+static TRUSTEE_W currentUserTrusteeW;
+
+typedef BOOL (WINAPI *PtrOpenProcessToken)(HANDLE, DWORD, PHANDLE );
+static PtrOpenProcessToken ptrOpenProcessToken = 0;
+typedef BOOL (WINAPI *PtrGetUserProfileDirectoryW)( HANDLE, LPWSTR, LPDWORD);
+static PtrGetUserProfileDirectoryW ptrGetUserProfileDirectoryW = 0;
+typedef BOOL (WINAPI *PtrSetFilePointerEx)(HANDLE, LARGE_INTEGER, PLARGE_INTEGER, DWORD);
+static PtrSetFilePointerEx ptrSetFilePointerEx = 0;
+QT_END_INCLUDE_NAMESPACE
+
+
+void QFSFileEnginePrivate::resolveLibs()
+{
+    static bool triedResolve = false;
+    if(!triedResolve) {
+        // need to resolve the security info functions
+
+        // protect initialization
+#ifndef QT_NO_THREAD
+        QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));
+        // check triedResolve again, since another thread may have already
+        // done the initialization
+        if(triedResolve) {
+            // another thread did initialize the security function pointers,
+            // so we shouldn't do it again.
+            return;
+        }
+#endif
+
+        triedResolve = true;
+#if !defined(Q_OS_WINCE)
+        if(QSysInfo::WindowsVersion & QSysInfo::WV_NT_based) {
+            HINSTANCE advapiHnd = LoadLibraryW(L"advapi32");
+            if (advapiHnd) {
+                ptrGetNamedSecurityInfoW = (PtrGetNamedSecurityInfoW)GetProcAddress(advapiHnd, "GetNamedSecurityInfoW");
+                ptrLookupAccountSidW = (PtrLookupAccountSidW)GetProcAddress(advapiHnd, "LookupAccountSidW");
+                ptrAllocateAndInitializeSid = (PtrAllocateAndInitializeSid)GetProcAddress(advapiHnd, "AllocateAndInitializeSid");
+                ptrBuildTrusteeWithSidW = (PtrBuildTrusteeWithSidW)GetProcAddress(advapiHnd, "BuildTrusteeWithSidW");
+                ptrBuildTrusteeWithNameW = (PtrBuildTrusteeWithNameW)GetProcAddress(advapiHnd, "BuildTrusteeWithNameW");
+                ptrGetEffectiveRightsFromAclW = (PtrGetEffectiveRightsFromAclW)GetProcAddress(advapiHnd, "GetEffectiveRightsFromAclW");
+                ptrFreeSid = (PtrFreeSid)GetProcAddress(advapiHnd, "FreeSid");
+            }
+            if (ptrBuildTrusteeWithNameW) {
+                HINSTANCE versionHnd = LoadLibraryW(L"version");
+                if (versionHnd) {
+                    typedef DWORD (WINAPI *PtrGetFileVersionInfoSizeW)(LPWSTR lptstrFilename,LPDWORD lpdwHandle);
+                    PtrGetFileVersionInfoSizeW ptrGetFileVersionInfoSizeW = (PtrGetFileVersionInfoSizeW)GetProcAddress(versionHnd, "GetFileVersionInfoSizeW");
+                    typedef BOOL (WINAPI *PtrGetFileVersionInfoW)(LPWSTR lptstrFilename,DWORD dwHandle,DWORD dwLen,LPVOID lpData);
+                    PtrGetFileVersionInfoW ptrGetFileVersionInfoW = (PtrGetFileVersionInfoW)GetProcAddress(versionHnd, "GetFileVersionInfoW");
+                    typedef BOOL (WINAPI *PtrVerQueryValueW)(const LPVOID pBlock,LPWSTR lpSubBlock,LPVOID *lplpBuffer,PUINT puLen);
+                    PtrVerQueryValueW ptrVerQueryValueW = (PtrVerQueryValueW)GetProcAddress(versionHnd, "VerQueryValueW");
+                    if(ptrGetFileVersionInfoSizeW && ptrGetFileVersionInfoW && ptrVerQueryValueW) {
+                        DWORD fakeHandle;
+                        DWORD versionSize = ptrGetFileVersionInfoSizeW(L"secur32.dll", &fakeHandle);
+                        if(versionSize) {
+                            LPVOID versionData;
+                            versionData = malloc(versionSize);
+                            if(ptrGetFileVersionInfoW(L"secur32.dll", 0, versionSize, versionData)) {
+                                UINT puLen;
+                                VS_FIXEDFILEINFO *pLocalInfo;
+                                if(ptrVerQueryValueW(versionData, L"\\", (void**)&pLocalInfo, &puLen)) {
+                                    WORD wVer1, wVer2, wVer3, wVer4;
+                                    wVer1 = HIWORD(pLocalInfo->dwFileVersionMS);
+                                    wVer2 = LOWORD(pLocalInfo->dwFileVersionMS);
+                                    wVer3 = HIWORD(pLocalInfo->dwFileVersionLS);
+                                    wVer4 = LOWORD(pLocalInfo->dwFileVersionLS);
+                                    // It will not work with secur32.dll version 5.0.2195.2862
+                                    if(!(wVer1 == 5 && wVer2 == 0 && wVer3 == 2195 && (wVer4 == 2862 || wVer4 == 4587))) {
+                                        HINSTANCE userHnd = LoadLibraryW(L"secur32");
+                                        if (userHnd) {
+                                            typedef BOOL (WINAPI *PtrGetUserNameExW)(EXTENDED_NAME_FORMAT nameFormat, ushort* lpBuffer, LPDWORD nSize);
+                                            PtrGetUserNameExW ptrGetUserNameExW = (PtrGetUserNameExW)GetProcAddress(userHnd, "GetUserNameExW");
+                                            if(ptrGetUserNameExW) {
+                                                static TCHAR buffer[258];
+                                                DWORD bufferSize = 257;
+                                                ptrGetUserNameExW(NameSamCompatible, (ushort*)buffer, &bufferSize);
+                                                ptrBuildTrusteeWithNameW(&currentUserTrusteeW, (ushort*)buffer);
+                                            }
+                                            FreeLibrary(userHnd);
+                                        }
+                                    }
+                                }
+                            }
+                            free(versionData);
+                        }
+                    }
+                    FreeLibrary(versionHnd);
+                }
+            }
+            ptrOpenProcessToken = (PtrOpenProcessToken)GetProcAddress(advapiHnd, "OpenProcessToken");
+	        HINSTANCE userenvHnd = LoadLibraryW(L"userenv");
+            if (userenvHnd) {
+                ptrGetUserProfileDirectoryW = (PtrGetUserProfileDirectoryW)GetProcAddress(userenvHnd, "GetUserProfileDirectoryW");
+            }
+            HINSTANCE kernelHnd = LoadLibraryW(L"kernel32");
+            if (kernelHnd)
+                ptrSetFilePointerEx = (PtrSetFilePointerEx)GetProcAddress(kernelHnd, "SetFilePointerEx");
+        }
+#endif
+    }
+}
+#endif // QT_NO_LIBRARY
+
+// UNC functions NT
+typedef DWORD (WINAPI *PtrNetShareEnum_NT)(LPWSTR, DWORD, LPBYTE*, DWORD, LPDWORD, LPDWORD, LPDWORD);
+static PtrNetShareEnum_NT ptrNetShareEnum_NT = 0;
+typedef DWORD (WINAPI *PtrNetApiBufferFree_NT)(LPVOID);
+static PtrNetApiBufferFree_NT ptrNetApiBufferFree_NT = 0;
+typedef struct _SHARE_INFO_1_NT {
+    LPWSTR shi1_netname;
+    DWORD shi1_type;
+    LPWSTR shi1_remark;
+} SHARE_INFO_1_NT;
+
+
+bool QFSFileEnginePrivate::resolveUNCLibs_NT()
+{
+    static bool triedResolve = false;
+    if (!triedResolve) {
+#ifndef QT_NO_THREAD
+        QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));
+        if (triedResolve) {
+            return ptrNetShareEnum_NT && ptrNetApiBufferFree_NT;
+        }
+#endif
+        triedResolve = true;
+#if !defined(Q_OS_WINCE)
+        HINSTANCE hLib = LoadLibraryW(L"Netapi32");
+        if (hLib) {
+            ptrNetShareEnum_NT = (PtrNetShareEnum_NT)GetProcAddress(hLib, "NetShareEnum");
+            if (ptrNetShareEnum_NT)
+                ptrNetApiBufferFree_NT = (PtrNetApiBufferFree_NT)GetProcAddress(hLib, "NetApiBufferFree");
+        }
+#endif
+    }
+    return ptrNetShareEnum_NT && ptrNetApiBufferFree_NT;
+}
+
+// UNC functions 9x
+typedef DWORD (WINAPI *PtrNetShareEnum_9x)(const char FAR *, short, char FAR *, unsigned short, unsigned short FAR *, unsigned short FAR *);
+static PtrNetShareEnum_9x ptrNetShareEnum_9x = 0;
+#ifdef LM20_NNLEN
+# define LM20_NNLEN_9x LM20_NNLEN
+#else
+# define LM20_NNLEN_9x 12
+#endif
+typedef struct _SHARE_INFO_1_9x {
+  char shi1_netname[LM20_NNLEN_9x+1];
+  char shi1_pad1;
+  unsigned short shi1_type;
+  char FAR* shi1_remark;
+} SHARE_INFO_1_9x;
+
+bool QFSFileEnginePrivate::resolveUNCLibs_9x()
+{
+    static bool triedResolve = false;
+    if (!triedResolve) {
+#ifndef QT_NO_THREAD
+        QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));
+        if (triedResolve) {
+            return ptrNetShareEnum_9x;
+        }
+#endif
+        triedResolve = true;
+#if !defined(Q_OS_WINCE)
+        HINSTANCE hLib = LoadLibraryA("Svrapi");
+        if (hLib)
+            ptrNetShareEnum_9x = (PtrNetShareEnum_9x)GetProcAddress(hLib, "NetShareEnum");
+#endif
+    }
+    return ptrNetShareEnum_9x;
+}
+
+bool QFSFileEnginePrivate::uncListSharesOnServer(const QString &server, QStringList *list)
+{
+    if (resolveUNCLibs_NT()) {
+        SHARE_INFO_1_NT *BufPtr, *p;
+        DWORD res;
+        DWORD er=0,tr=0,resume=0, i;
+        do {
+            res = ptrNetShareEnum_NT((wchar_t*)server.utf16(), 1, (LPBYTE *)&BufPtr, DWORD(-1), &er, &tr, &resume);
+            if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA) {
+                p=BufPtr;
+                for (i = 1; i <= er; ++i) {
+                    if (list && p->shi1_type == 0)
+                        list->append(QString::fromUtf16((unsigned short *)p->shi1_netname));
+                    p++;
+                }
+            }
+            ptrNetApiBufferFree_NT(BufPtr);
+        } while (res==ERROR_MORE_DATA);
+        return res == ERROR_SUCCESS;
+
+    } else if (resolveUNCLibs_9x()) {
+        SHARE_INFO_1_9x *pBuf = 0;
+        short cbBuffer;
+        unsigned short nEntriesRead = 0;
+        unsigned short nTotalEntries = 0;
+        short numBuffs = 20;
+        DWORD nStatus = 0;
+        do {
+            cbBuffer = numBuffs * sizeof(SHARE_INFO_1_9x);
+            pBuf = (SHARE_INFO_1_9x *)malloc(cbBuffer);
+            if (pBuf) {
+                nStatus = ptrNetShareEnum_9x(server.toLocal8Bit().constData(), 1, (char FAR *)pBuf, cbBuffer, &nEntriesRead, &nTotalEntries);
+                if ((nStatus == ERROR_SUCCESS)) {
+                    for (int i = 0; i < nEntriesRead; ++i) {
+                        if (list && pBuf[i].shi1_type == 0)
+                            list->append(QString::fromLocal8Bit(pBuf[i].shi1_netname));
+                    }
+                    free(pBuf);
+                    break;
+                }
+                free(pBuf);
+                numBuffs *=2;
+            }
+        } while (nStatus == ERROR_MORE_DATA);
+        return nStatus == ERROR_SUCCESS;
+    }
+    return false;
+}
+
+static bool isUncRoot(const QString &server)
+{
+    QString localPath = QDir::toNativeSeparators(server);
+    QStringList parts = localPath.split(QLatin1Char('\\'), QString::SkipEmptyParts);
+    return localPath.startsWith(QLatin1String("\\\\")) && parts.count() <= 1;
+}
+
+static bool isUncPath(const QString &path)
+{
+    // Starts with // or \\, but not \\. or //.
+    return (path.startsWith(QLatin1String("//"))
+            || path.startsWith(QLatin1String("\\\\")))
+        && (path.size() > 2 && path.at(2) != QLatin1Char('.'));
+}
+
+static bool isRelativePath(const QString &path)
+{
+    return !(path.startsWith(QLatin1Char('/'))
+           || (path.length() >= 2
+           && ((path.at(0).isLetter() && path.at(1) == QLatin1Char(':'))
+           || (path.at(0) == QLatin1Char('/') && path.at(1) == QLatin1Char('/'))))); // drive, e.g. a:
+}
+
+static QString fixIfRelativeUncPath(const QString &path)
+{
+    if (isRelativePath(path)) {
+        QString currentPath = QDir::currentPath() + QLatin1Char('/');
+        if (currentPath.startsWith(QLatin1String("//")))
+            return QString(path).prepend(currentPath);
+    }
+    return path;
+}
+
+// can be //server or //server/share
+static bool uncShareExists(const QString &server)
+{
+    QStringList parts = server.split(QLatin1Char('\\'), QString::SkipEmptyParts);
+    if (parts.count()) {
+        QStringList shares;
+        if (QFSFileEnginePrivate::uncListSharesOnServer(QLatin1String("\\\\") + parts.at(0), &shares)) {
+            if (parts.count() >= 2)
+                return shares.contains(parts.at(1), Qt::CaseInsensitive);
+            else
+                return true;
+        }
+    }
+    return false;
+}
+
+#if !defined(Q_OS_WINCE)
+// If you change this function, remember to also change the UNICODE version
+static QString nativeAbsoluteFilePathA(const QString &path)
+{
+    QString ret;
+    QVarLengthArray<char, MAX_PATH> buf(MAX_PATH);
+    char *fileName = 0;
+    QByteArray ba = path.toLocal8Bit();
+    DWORD retLen = GetFullPathNameA(ba.constData(), buf.size(), buf.data(), &fileName);
+    if (retLen > (DWORD)buf.size()) {
+        buf.resize(retLen);
+        retLen = GetFullPathNameA(ba.constData(), buf.size(), buf.data(), &fileName);
+    }
+    if (retLen != 0)
+        ret = QString::fromLocal8Bit(buf.data(), retLen);
+    return ret;
+}
+#endif
+
+// If you change this function, remember to also change the NON-UNICODE version
+static QString nativeAbsoluteFilePathW(const QString &path)
+{
+    QString ret;
+#if !defined(Q_OS_WINCE)
+    QVarLengthArray<wchar_t, MAX_PATH> buf(MAX_PATH);
+    wchar_t *fileName = 0;
+    DWORD retLen = GetFullPathNameW((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);
+    if (retLen > (DWORD)buf.size()) {
+        buf.resize(retLen);
+        retLen = GetFullPathNameW((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);
+    }
+    if (retLen != 0)
+        ret = QString::fromUtf16((unsigned short *)buf.data(), retLen);
+#else
+    if (path.startsWith(QLatin1String("/")) || path.startsWith(QLatin1String("\\")))
+        ret = QDir::toNativeSeparators(path);
+    else
+        ret = QDir::toNativeSeparators(QDir::cleanPath(qfsPrivateCurrentDir + QLatin1Char('/') + path));
+#endif
+    return ret;
+}
+
+static QString nativeAbsoluteFilePath(const QString &path)
+{
+    QString absPath = QT_WA_INLINE(nativeAbsoluteFilePathW(path), nativeAbsoluteFilePathA(path));
+    // This is really ugly, but GetFullPathName strips off whitespace at the end.
+    // If you for instance write ". " in the lineedit of QFileDialog,
+    // (which is an invalid filename) this function will strip the space off and viola,
+    // the file is later reported as existing. Therefore, we re-add the whitespace that
+    // was at the end of path in order to keep the filename invalid.
+    int i = path.size() - 1;
+    while (i >= 0 && path.at(i) == QLatin1Char(' ')) --i;
+    int extraws = path.size() - 1 - i;
+    if (extraws >= 0) {
+        while (extraws) {
+            absPath.append(QLatin1Char(' '));
+            --extraws;
+        }
+    }
+    return absPath;
+}
+
+QByteArray QFSFileEnginePrivate::win95Name(const QString &path)
+{
+    QString ret(path);
+    if(path.length() > 1 && path[0] == QLatin1Char('/') && path[1] == QLatin1Char('/')) {
+        // Win95 cannot handle slash-slash needs slosh-slosh.
+        ret[0] = QLatin1Char('\\');
+        ret[1] = QLatin1Char('\\');
+        int n = ret.indexOf(QLatin1Char('/'));
+        if(n >= 0)
+            ret[n] = QLatin1Char('\\');
+    } else if(path.length() > 3 && path[2] == QLatin1Char('/') && path[3] == QLatin1Char('/')) {
+        ret[2] = QLatin1Char('\\');
+        ret.remove(3, 1);
+        int n = ret.indexOf(QLatin1Char('/'));
+        if(n >= 0)
+            ret[n] = QLatin1Char('\\');
+    }
+    return ret.toLocal8Bit();
+}
+
+/*!
+    \internal
+*/
+QString QFSFileEnginePrivate::longFileName(const QString &path)
+{
+    if (path.startsWith(QLatin1String("\\\\.\\")))
+        return path;
+
+    QString absPath = nativeAbsoluteFilePath(path);
+#if !defined(Q_OS_WINCE)
+    QString prefix = QLatin1String("\\\\?\\");
+    if (isUncPath(absPath)) {
+        prefix = QLatin1String("\\\\?\\UNC\\");
+        absPath.remove(0, 2);
+    }
+    return prefix + absPath;
+#else
+    return absPath;
+#endif
+}
+
+/*
+    \internal
+*/
+void QFSFileEnginePrivate::nativeInitFileName()
+{
+    QT_WA({
+        QString path = longFileName(QDir::toNativeSeparators(fixIfRelativeUncPath(filePath)));
+        nativeFilePath = QByteArray((const char *)path.utf16(), path.size() * 2 + 1);
+    }, {
+        QString path = fixIfRelativeUncPath(filePath);
+        nativeFilePath = win95Name(path).replace('/', '\\');
+    });
+}
+
+/*
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode)
+{
+    Q_Q(QFSFileEngine);
+
+    // All files are opened in share mode (both read and write).
+    DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+
+    int accessRights = 0;
+    if (openMode & QIODevice::ReadOnly)
+        accessRights |= GENERIC_READ;
+    if (openMode & QIODevice::WriteOnly)
+        accessRights |= GENERIC_WRITE;
+
+    SECURITY_ATTRIBUTES securityAtts = { sizeof(SECURITY_ATTRIBUTES), NULL, FALSE };
+
+    // WriteOnly can create files, ReadOnly cannot.
+    DWORD creationDisp = (openMode & QIODevice::WriteOnly)
+                         ? OPEN_ALWAYS : OPEN_EXISTING;
+
+    // Create the file handle.
+    QT_WA({
+        fileHandle = CreateFileW((TCHAR *)nativeFilePath.constData(),
+                                 accessRights,
+                                 shareMode,
+                                 &securityAtts,
+                                 creationDisp,
+                                 FILE_ATTRIBUTE_NORMAL,
+                                 NULL);
+    }, {
+        fileHandle = CreateFileA(nativeFilePath.constData(),
+                                 accessRights,
+                                 shareMode,
+                                 &securityAtts,
+                                 creationDisp,
+                                 FILE_ATTRIBUTE_NORMAL,
+                                 NULL);
+    });
+
+    // Bail out on error.
+    if (fileHandle == INVALID_HANDLE_VALUE) {
+        q->setError(QFile::OpenError, qt_error_string());
+        return false;
+    }
+
+    // Truncate the file after successfully opening it if Truncate is passed.
+    if (openMode & QIODevice::Truncate)
+        q->setSize(0);
+
+    return true;
+}
+
+/*
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeClose()
+{
+    Q_Q(QFSFileEngine);
+    if (fh || fd != -1) {
+        // stdlib / stdio mode.
+        return closeFdFh();
+    }
+
+    // Windows native mode.
+    bool ok = true;
+    if ((fileHandle == INVALID_HANDLE_VALUE || !CloseHandle(fileHandle))
+#ifdef Q_USE_DEPRECATED_MAP_API
+            && (fileMapHandle == INVALID_HANDLE_VALUE || !CloseHandle(fileMapHandle))
+#endif
+        ) {
+        q->setError(QFile::UnspecifiedError, qt_error_string());
+        ok = false;
+    }
+    fileHandle = INVALID_HANDLE_VALUE;
+    cachedFd = -1;              // gets closed by CloseHandle above
+
+    return ok;
+}
+
+/*
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeFlush()
+{
+    if (fh) {
+        // Buffered stdlib mode.
+        return flushFh();
+    }
+    if (fd != -1) {
+        // Unbuffered stdio mode; always succeeds (no buffer).
+        return true;
+    }
+
+    // Windows native mode; flushing is
+    // unnecessary. FlushFileBuffers(), the equivalent of sync() or
+    // fsync() on Unix, does a low-level flush to the disk, and we
+    // don't expose an API for this.
+    return true;
+}
+
+/*
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativeSize() const
+{
+    Q_Q(const QFSFileEngine);
+    QFSFileEngine *thatQ = const_cast<QFSFileEngine *>(q);
+
+    // ### Don't flush; for buffered files, we should get away with ftell.
+    thatQ->flush();
+
+    // Buffered stdlib mode.
+    if (fh) {
+        QT_OFF_T oldPos = QT_FTELL(fh);
+        QT_FSEEK(fh, 0, SEEK_END);
+        QT_OFF_T fileSize = QT_FTELL(fh);
+        QT_FSEEK(fh, oldPos, SEEK_SET);
+        return qint64(fileSize);
+    }
+
+    // Not-open mode, where the file name is known: We'll check the
+    // file system directly.
+    if (openMode == QIODevice::NotOpen && !nativeFilePath.isEmpty()) {
+        bool ok = false;
+        WIN32_FILE_ATTRIBUTE_DATA attribData;
+        QT_WA({
+            ok = ::GetFileAttributesExW((TCHAR *)nativeFilePath.constData(),
+                                        GetFileExInfoStandard, &attribData);
+        } , {
+            ok = ::GetFileAttributesExA(nativeFilePath.constData(),
+                                        GetFileExInfoStandard, &attribData);
+        });
+        if (ok) {
+            qint64 size = attribData.nFileSizeHigh;
+            size <<= 32;
+            size += attribData.nFileSizeLow;
+            return size;
+        }
+        thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+        return 0;
+    }
+
+    // Unbuffed stdio mode.
+    if(fd != -1) {
+#if !defined(Q_OS_WINCE)
+        HANDLE handle = (HANDLE)_get_osfhandle(fd);
+        if (handle != INVALID_HANDLE_VALUE) {
+            BY_HANDLE_FILE_INFORMATION fileInfo;
+            if (GetFileInformationByHandle(handle, &fileInfo)) {
+                qint64 size = fileInfo.nFileSizeHigh;
+                size <<= 32;
+                size += fileInfo.nFileSizeLow;
+                return size;
+            }
+        }
+#endif
+        thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+        return 0;
+    }
+
+    // Windows native mode.
+    if (fileHandle == INVALID_HANDLE_VALUE)
+        return 0;
+
+    BY_HANDLE_FILE_INFORMATION fileInfo;
+    if (!GetFileInformationByHandle(fileHandle, &fileInfo)) {
+        thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+        return 0;
+    }
+
+    qint64 size = fileInfo.nFileSizeHigh;
+    size <<= 32;
+    size += fileInfo.nFileSizeLow;
+    return size;
+}
+
+/*
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativePos() const
+{
+    Q_Q(const QFSFileEngine);
+    QFSFileEngine *thatQ = const_cast<QFSFileEngine *>(q);
+
+    if (fh || fd != -1) {
+        // stdlib / stido mode.
+        return posFdFh();
+    }
+
+    // Windows native mode.
+    if (fileHandle == INVALID_HANDLE_VALUE)
+        return 0;
+
+#if !defined(QT_NO_LIBRARY)
+    QFSFileEnginePrivate::resolveLibs();
+    if (!ptrSetFilePointerEx) {
+#endif
+        DWORD newFilePointer = SetFilePointer(fileHandle, 0, NULL, FILE_CURRENT);
+        if (newFilePointer == 0xFFFFFFFF) {
+            thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+            return 0;
+        }
+
+        // Note: returns <4GB; does not work with large files. This is the
+        // case for MOC, UIC, qmake and other bootstrapped tools, and for
+        // Win9x/ME.
+        return qint64(newFilePointer);
+#if !defined(QT_NO_LIBRARY)
+    }
+
+    // This approach supports large files.
+    LARGE_INTEGER currentFilePos;
+    LARGE_INTEGER offset;
+    offset.LowPart = 0;
+    offset.HighPart = 0;
+    if (!ptrSetFilePointerEx(fileHandle, offset, &currentFilePos, FILE_CURRENT)) {
+        thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+        return 0;
+    }
+
+    return qint64(currentFilePos.QuadPart);
+#endif
+}
+
+/*
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeSeek(qint64 pos)
+{
+    Q_Q(const QFSFileEngine);
+    QFSFileEngine *thatQ = const_cast<QFSFileEngine *>(q);
+
+    if (fh || fd != -1) {
+        // stdlib / stdio mode.
+        return seekFdFh(pos);
+    }
+
+#if !defined(QT_NO_LIBRARY)
+    QFSFileEnginePrivate::resolveLibs();
+    if (!ptrSetFilePointerEx) {
+#endif
+        LONG seekToPos = LONG(pos); // <- lossy
+        DWORD newFilePointer = SetFilePointer(fileHandle, seekToPos, NULL, FILE_BEGIN);
+        if (newFilePointer == 0xFFFFFFFF) {
+            thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+            return false;
+        }
+
+        // Note: does not work with large files. This is the case for MOC,
+        // UIC, qmake and other bootstrapped tools, and for Win9x/ME.
+        return true;
+#if !defined(QT_NO_LIBRARY)
+    }
+
+    // This approach supports large files.
+    LARGE_INTEGER currentFilePos;
+    LARGE_INTEGER offset;
+    offset.LowPart = (unsigned int)(quint64(pos) & Q_UINT64_C(0xffffffff));
+    offset.HighPart = (unsigned int)((quint64(pos) >> 32) & Q_UINT64_C(0xffffffff));
+    if (ptrSetFilePointerEx(fileHandle, offset, &currentFilePos, FILE_BEGIN) == 0) {
+        thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+        return false;
+    }
+    return true;
+#endif
+}
+
+/*
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativeRead(char *data, qint64 maxlen)
+{
+    Q_Q(QFSFileEngine);
+
+    if (fh || fd != -1) {
+        // stdio / stdlib mode.
+        if (fh && nativeIsSequential() && feof(fh)) {
+            q->setError(QFile::ReadError, qt_error_string(int(errno)));
+            return -1;
+        }
+
+        return readFdFh(data, maxlen);
+    }
+
+    // Windows native mode.
+    if (fileHandle == INVALID_HANDLE_VALUE)
+        return -1;
+
+    DWORD bytesToRead = DWORD(maxlen); // <- lossy
+
+    // Reading on Windows fails with ERROR_NO_SYSTEM_RESOURCES when
+    // the chunks are too large, so we limit the block size to 32MB.
+    static const DWORD maxBlockSize = 32 * 1024 * 1024;
+
+    qint64 totalRead = 0;
+    do {
+        DWORD blockSize = qMin<DWORD>(bytesToRead, maxBlockSize);
+        DWORD bytesRead;
+        if (!ReadFile(fileHandle, data + totalRead, blockSize, &bytesRead, NULL)) {
+            if (totalRead == 0) {
+                // Note: only return failure if the first ReadFile fails.
+                q->setError(QFile::ReadError, qt_error_string());
+                return -1;
+            }
+            break;
+        }
+        if (bytesRead == 0)
+            break;
+        totalRead += bytesRead;
+        bytesToRead -= bytesRead;
+    } while (totalRead < maxlen);
+    return qint64(totalRead);
+}
+
+/*
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativeReadLine(char *data, qint64 maxlen)
+{
+    Q_Q(QFSFileEngine);
+
+    if (fh || fd != -1) {
+        // stdio / stdlib mode.
+        return readLineFdFh(data, maxlen);
+    }
+
+    // Windows native mode.
+    if (fileHandle == INVALID_HANDLE_VALUE)
+        return -1;
+
+    // ### No equivalent in Win32?
+    return q->QAbstractFileEngine::readLine(data, maxlen);
+}
+
+/*
+    \internal
+*/
+qint64 QFSFileEnginePrivate::nativeWrite(const char *data, qint64 len)
+{
+    Q_Q(QFSFileEngine);
+
+    if (fh || fd != -1) {
+        // stdio / stdlib mode.
+        return writeFdFh(data, len);
+    }
+
+    // Windows native mode.
+    if (fileHandle == INVALID_HANDLE_VALUE)
+        return -1;
+
+    qint64 bytesToWrite = DWORD(len); // <- lossy
+
+    // Writing on Windows fails with ERROR_NO_SYSTEM_RESOURCES when
+    // the chunks are too large, so we limit the block size to 32MB.
+    static const DWORD maxBlockSize = 32 * 1024 * 1024;
+
+    qint64 totalWritten = 0;
+    do {
+        DWORD blockSize = qMin<DWORD>(bytesToWrite, maxBlockSize);
+        DWORD bytesWritten;
+        if (!WriteFile(fileHandle, data + totalWritten, blockSize, &bytesWritten, NULL)) {
+            if (totalWritten == 0) {
+                // Note: Only return error if the first WriteFile failed.
+                q->setError(QFile::WriteError, qt_error_string());
+                return -1;
+            }
+            break;
+        }
+        if (bytesWritten == 0)
+            break;
+        totalWritten += bytesWritten;
+        bytesToWrite -= bytesWritten;
+    } while (totalWritten < len);
+    return qint64(totalWritten);
+}
+
+/*
+    \internal
+*/
+int QFSFileEnginePrivate::nativeHandle() const
+{
+    if (fh || fd != -1)
+        return fh ? QT_FILENO(fh) : fd;
+#ifndef Q_OS_WINCE
+    if (cachedFd != -1)
+        return cachedFd;
+
+    int flags = 0;
+    if (openMode & QIODevice::Append)
+        flags |= _O_APPEND;
+    if (!(openMode & QIODevice::WriteOnly))
+        flags |= _O_RDONLY;
+    cachedFd = _open_osfhandle((intptr_t) fileHandle, flags);
+    return cachedFd;
+#else
+    return -1;
+#endif
+}
+
+/*
+    \internal
+*/
+bool QFSFileEnginePrivate::nativeIsSequential() const
+{
+#if !defined(Q_OS_WINCE)
+    // stdlib / Windows native mode.
+    if (fh || fileHandle != INVALID_HANDLE_VALUE) {
+        if (fh == stdin || fh == stdout || fh == stderr)
+            return true;
+
+        HANDLE handle = fileHandle;
+        if (fileHandle == INVALID_HANDLE_VALUE) {
+            // Rare case: using QFile::open(FILE*) to open a pipe.
+            handle = (HANDLE)_get_osfhandle(QT_FILENO(fh));
+            return false;
+        }
+
+        DWORD fileType = GetFileType(handle);
+        return fileType == FILE_TYPE_PIPE;
+    }
+
+    // stdio mode.
+    if (fd != -1)
+        return isSequentialFdFh();
+#endif
+    return false;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::remove()
+{
+    Q_D(QFSFileEngine);
+    QT_WA({
+        return ::DeleteFileW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16()) != 0;
+    } , {
+        return ::DeleteFileA(QFSFileEnginePrivate::win95Name(d->filePath)) != 0;
+    });
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::copy(const QString &copyName)
+{
+    Q_D(QFSFileEngine);
+    QT_WA({
+        return ::CopyFileW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
+                           (TCHAR*)QFSFileEnginePrivate::longFileName(copyName).utf16(), true) != 0;
+    } , {
+        return ::CopyFileA(QFSFileEnginePrivate::win95Name(d->filePath),
+                           QFSFileEnginePrivate::win95Name(copyName), true) != 0;
+    });
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::rename(const QString &newName)
+{
+    Q_D(QFSFileEngine);
+    QT_WA({
+        return ::MoveFileW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
+                           (TCHAR*)QFSFileEnginePrivate::longFileName(newName).utf16()) != 0;
+    } , {
+        return ::MoveFileA(QFSFileEnginePrivate::win95Name(d->filePath),
+                           QFSFileEnginePrivate::win95Name(newName)) != 0;
+    });
+}
+
+static inline bool mkDir(const QString &path)
+{
+#if defined(Q_OS_WINCE)
+    // Unfortunately CreateDirectory returns true for paths longer than
+    // 256, but does not create a directory. It starts to fail, when
+    // path length > MAX_PATH, which is 260 usually on CE.
+    // This only happens on a Windows Mobile device. Windows CE seems
+    // not to be affected by this.
+    static int platformId = 0;
+    if (platformId == 0) {
+        wchar_t platformString[64];
+        if (SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(platformString)/sizeof(*platformString),platformString,0)) {
+            if (0 == wcscmp(platformString, L"PocketPC") || 0 == wcscmp(platformString, L"Smartphone"))
+                platformId = 1;
+            else
+                platformId = 2;
+        }
+    }
+    if (platformId == 1 && QFSFileEnginePrivate::longFileName(path).size() > 256)
+        return false;
+#endif
+    QT_WA({
+        return ::CreateDirectoryW((TCHAR*)QFSFileEnginePrivate::longFileName(path).utf16(), 0);
+    } , {
+        return ::CreateDirectoryA(QFSFileEnginePrivate::win95Name(QFileInfo(path).absoluteFilePath()), 0);
+    });
+}
+
+/*!
+    \reimp
+*/
+static inline bool rmDir(const QString &path)
+{
+    QT_WA({
+        return ::RemoveDirectoryW((TCHAR*)QFSFileEnginePrivate::longFileName(path).utf16());
+    } , {
+        return ::RemoveDirectoryA(QFSFileEnginePrivate::win95Name(QFileInfo(path).absoluteFilePath()));
+    });
+}
+
+/*!
+    \reimp
+*/
+static inline bool isDirPath(const QString &dirPath, bool *existed)
+{
+    QString path = dirPath;
+    if (path.length() == 2 &&path.at(1) == QLatin1Char(':'))
+        path += QLatin1Char('\\');
+
+    DWORD fileAttrib = INVALID_FILE_ATTRIBUTES;
+    QT_WA({
+        fileAttrib = ::GetFileAttributesW((TCHAR*)QFSFileEnginePrivate::longFileName(path).utf16());
+    } , {
+        fileAttrib = ::GetFileAttributesA(QFSFileEnginePrivate::win95Name(QFileInfo(path).absoluteFilePath()));
+    });
+
+    if (existed)
+        *existed = fileAttrib != INVALID_FILE_ATTRIBUTES;
+
+    if (fileAttrib == INVALID_FILE_ATTRIBUTES)
+        return false;
+
+    return fileAttrib & FILE_ATTRIBUTE_DIRECTORY;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
+{
+    QString dirName = name;
+    if (createParentDirectories) {
+        dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));
+        // We spefically search for / so \ would break it..
+        int oldslash = -1;
+        if (dirName.startsWith(QLatin1String("\\\\"))) {
+            // Don't try to create the root path of a UNC path;
+            // CreateDirectory() will just return ERROR_INVALID_NAME.
+            for (int i = 0; i < dirName.size(); ++i) {
+                if (dirName.at(i) != QDir::separator()) {
+                    oldslash = i;
+                    break;
+                }
+            }
+            if (oldslash != -1)
+                oldslash = dirName.indexOf(QDir::separator(), oldslash);
+        }
+        for (int slash=0; slash != -1; oldslash = slash) {
+            slash = dirName.indexOf(QDir::separator(), oldslash+1);
+            if (slash == -1) {
+                if(oldslash == dirName.length())
+                    break;
+                slash = dirName.length();
+            }
+            if (slash) {
+                QString chunk = dirName.left(slash);
+                bool existed = false;
+                if (!isDirPath(chunk, &existed) && !existed) {
+                    if (!mkDir(chunk))
+                        return false;
+                }
+            }
+        }
+        return true;
+    }
+    return mkDir(name);
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
+{
+    QString dirName = name;
+    if (recurseParentDirectories) {
+        dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));
+        for (int oldslash = 0, slash=dirName.length(); slash > 0; oldslash = slash) {
+            QString chunk = dirName.left(slash);
+            if (chunk.length() == 2 && chunk.at(0).isLetter() && chunk.at(1) == QLatin1Char(':'))
+                break;
+            if (!isDirPath(chunk, 0))
+                return false;
+            if (!rmDir(chunk))
+                return oldslash != 0;
+            slash = dirName.lastIndexOf(QDir::separator(), oldslash-1);
+        }
+        return true;
+    }
+    return rmDir(name);
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::caseSensitive() const
+{
+    return false;
+}
+
+/*!
+    Sets the current path (e.g., for QDir), to \a path. Returns true if the
+    new path exists; otherwise this function does nothing, and returns false.
+
+    \sa currentPath()
+*/
+bool QFSFileEngine::setCurrentPath(const QString &path)
+{
+    if (!QDir(path).exists())
+        return false;
+
+#if !defined(Q_OS_WINCE)
+    int r;
+    QT_WA({
+        r = ::SetCurrentDirectoryW((WCHAR*)path.utf16());
+    } , {
+        r = ::SetCurrentDirectoryA(QFSFileEnginePrivate::win95Name(path));
+    });
+    return r != 0;
+#else
+	qfsPrivateCurrentDir = QFSFileEnginePrivate::longFileName(path);
+	return true;
+#endif
+}
+
+/*!
+    Returns the canonicalized form of the current path used by the file
+    engine for the drive specified by \a fileName.
+
+    On Windows, each drive has its own current directory, so a different
+    path is returned for file names that include different drive names
+    (e.g. A: or C:).
+
+    \sa setCurrentPath()
+*/
+QString QFSFileEngine::currentPath(const QString &fileName)
+{
+#if !defined(Q_OS_WINCE)
+    QString ret;
+    //if filename is a drive: then get the pwd of that drive
+    if (fileName.length() >= 2 &&
+        fileName.at(0).isLetter() && fileName.at(1) == QLatin1Char(':')) {
+        int drv = fileName.toUpper().at(0).toLatin1() - 'A' + 1;
+        if (_getdrive() != drv) {
+            QT_WA({
+                TCHAR buf[PATH_MAX];
+                ::_wgetdcwd(drv, buf, PATH_MAX);
+                ret.setUtf16((ushort*)buf, uint(::wcslen(buf)));
+            }, {
+                char buf[PATH_MAX];
+                ::_getdcwd(drv, buf, PATH_MAX);
+                ret = QString::fromLatin1(buf);
+            });
+        }
+    }
+    if (ret.isEmpty()) {
+        //just the pwd
+        QT_WA({
+            DWORD size = 0;
+            WCHAR currentName[PATH_MAX];
+            size = ::GetCurrentDirectoryW(PATH_MAX, currentName);
+            if (size !=0) {
+                if (size > PATH_MAX) {
+                    WCHAR * newCurrentName = new WCHAR[size];
+                    if (::GetCurrentDirectoryW(PATH_MAX, newCurrentName) != 0)
+                        ret = QString::fromUtf16((ushort*)newCurrentName);
+                    delete [] newCurrentName;
+                } else {
+                    ret = QString::fromUtf16((ushort*)currentName);
+                }
+            }
+        } , {
+            DWORD size = 0;
+            char currentName[PATH_MAX];
+            size = ::GetCurrentDirectoryA(PATH_MAX, currentName);
+            if (size !=0)
+                ret = QString::fromLocal8Bit(currentName);
+        });
+    }
+    if (ret.length() >= 2 && ret[1] == QLatin1Char(':'))
+        ret[0] = ret.at(0).toUpper(); // Force uppercase drive letters.
+    return QDir::fromNativeSeparators(ret);
+#else
+	Q_UNUSED(fileName);
+	if (qfsPrivateCurrentDir.isEmpty())
+		qfsPrivateCurrentDir = QCoreApplication::applicationDirPath();
+
+    return QDir::fromNativeSeparators(qfsPrivateCurrentDir);
+#endif
+}
+
+/*!
+    Returns the home path of the current user.
+
+    \sa rootPath()
+*/
+QString QFSFileEngine::homePath()
+{
+    QString ret;
+#if !defined(QT_NO_LIBRARY)
+    QT_WA (
+    {
+        QFSFileEnginePrivate::resolveLibs();
+		if (ptrOpenProcessToken && ptrGetUserProfileDirectoryW) {
+			HANDLE hnd = ::GetCurrentProcess();
+			HANDLE token = 0;
+			BOOL ok = ::ptrOpenProcessToken(hnd, TOKEN_QUERY, &token);
+			if (ok) {
+				DWORD dwBufferSize = 0;
+				// First call, to determine size of the strings (with '\0').
+				ok = ::ptrGetUserProfileDirectoryW(token, NULL, &dwBufferSize);
+				if (!ok && dwBufferSize != 0) {		// We got the required buffer size
+					wchar_t *userDirectory = new wchar_t[dwBufferSize];
+					// Second call, now we can fill the allocated buffer.
+					ok = ::ptrGetUserProfileDirectoryW(token, userDirectory, &dwBufferSize);
+					if (ok)
+						ret = QString::fromUtf16((ushort*)userDirectory);
+
+					delete [] userDirectory;
+				}
+				::CloseHandle(token);
+			}
+		}
+    }
+    ,
+    {
+        // GetUserProfileDirectory is only available from NT 4.0,
+		// so fall through for Win98 and friends version.
+    })
+#endif
+    if(ret.isEmpty() || !QFile::exists(ret)) {
+        ret = QString::fromLocal8Bit(qgetenv("USERPROFILE").constData());
+        if(ret.isEmpty() || !QFile::exists(ret)) {
+            ret = QString::fromLocal8Bit(qgetenv("HOMEDRIVE").constData()) + QString::fromLocal8Bit(qgetenv("HOMEPATH").constData());
+            if(ret.isEmpty() || !QFile::exists(ret)) {
+                ret = QString::fromLocal8Bit(qgetenv("HOME").constData());
+                if(ret.isEmpty() || !QFile::exists(ret)) {
+#if defined(Q_OS_WINCE)
+                    ret = QString::fromLatin1("\\My Documents");
+                    if (!QFile::exists(ret))
+#endif
+                    ret = rootPath();
+                }
+            }
+        }
+    }
+    return QDir::fromNativeSeparators(ret);
+}
+
+/*!
+    Returns the root path.
+
+    \sa homePath()
+*/
+QString QFSFileEngine::rootPath()
+{
+#if defined(Q_OS_WINCE)
+    QString ret = QString::fromLatin1("/");
+#elif defined(Q_FS_FAT)
+    QString ret = QString::fromLatin1(qgetenv("SystemDrive").constData());
+    if(ret.isEmpty())
+        ret = QLatin1String("c:");
+    ret += QLatin1String("/");
+#elif defined(Q_OS_OS2EMX)
+    char dir[4];
+    _abspath(dir, QLatin1String("/"), _MAX_PATH);
+    QString ret(dir);
+#endif
+    return ret;
+}
+
+/*!
+    Returns the temporary path (i.e., a path in which it is safe to store
+    temporary files).
+*/
+QString QFSFileEngine::tempPath()
+{
+    QString ret;
+    int success;
+    QT_WA({
+        wchar_t tempPath[MAX_PATH];
+        success = GetTempPathW(MAX_PATH, tempPath);
+        ret = QString::fromUtf16((ushort*)tempPath);
+    } , {
+        char tempPath[MAX_PATH];
+        success = GetTempPathA(MAX_PATH, tempPath);
+        ret = QString::fromLocal8Bit(tempPath);
+    });
+    if (ret.isEmpty() || !success) {
+#if !defined(Q_OS_WINCE)
+        ret = QString::fromLatin1("c:/tmp");
+#else
+        ret = QString::fromLatin1("\\Temp");
+#endif
+    } else {
+        ret = QDir::fromNativeSeparators(ret);
+        while (ret.at(ret.length()-1) == QLatin1Char('/'))
+            ret = ret.left(ret.length()-1);
+    }
+    return ret;
+}
+
+/*!
+    Returns the list of drives in the file system as a list of QFileInfo
+    objects. On unix, Mac OS X and Windows CE, only the root path is returned.
+    On Windows, this function returns all drives (A:\, C:\, D:\, etc.).
+*/
+QFileInfoList QFSFileEngine::drives()
+{
+    QFileInfoList ret;
+#if !defined(Q_OS_WINCE)
+#if defined(Q_OS_WIN32)
+    quint32 driveBits = (quint32) GetLogicalDrives() & 0x3ffffff;
+#elif defined(Q_OS_OS2EMX)
+    quint32 driveBits, cur;
+    if(DosQueryCurrentDisk(&cur,&driveBits) != NO_ERROR)
+	exit(1);
+    driveBits &= 0x3ffffff;
+#endif
+    char driveName[4];
+
+    qstrcpy(driveName, "A:/");
+
+    while(driveBits) {
+	if(driveBits & 1)
+	    ret.append(QString::fromLatin1(driveName).toUpper());
+	driveName[0]++;
+	driveBits = driveBits >> 1;
+    }
+    return ret;
+#else
+    ret.append(QString::fromLatin1("/").toUpper());
+    return ret;
+#endif
+}
+
+bool QFSFileEnginePrivate::doStat() const
+{
+    if (!tried_stat) {
+        tried_stat = true;
+        could_stat = false;
+
+        if (filePath.isEmpty())
+            return could_stat;
+        QString fname = filePath.endsWith(QLatin1String(".lnk")) ? readLink(filePath) : filePath;
+        fname = fixIfRelativeUncPath(fname);
+
+        UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
+
+        if (fd != -1) {
+#if !defined(Q_OS_WINCE)
+            HANDLE fh = (HANDLE)_get_osfhandle(fd);
+            if (fh != INVALID_HANDLE_VALUE) {
+                BY_HANDLE_FILE_INFORMATION fileInfo;
+                if (GetFileInformationByHandle(fh, &fileInfo)) {
+                    could_stat = true;
+                    fileAttrib = fileInfo.dwFileAttributes;
+                }
+            }
+#else
+            DWORD tmpAttributes = GetFileAttributesW((TCHAR*)QFSFileEnginePrivate::longFileName(fname).utf16());
+            if (tmpAttributes != -1) {
+                fileAttrib = tmpAttributes;
+                could_stat = true;
+            } else {
+                return false;
+            }
+#endif
+        } else {
+            QT_WA({
+                fileAttrib = GetFileAttributesW((TCHAR*)QFSFileEnginePrivate::longFileName(fname).utf16());
+            } , {
+                fileAttrib = GetFileAttributesA(QFSFileEnginePrivate::win95Name(QFileInfo(fname).absoluteFilePath()));
+            });
+            could_stat = fileAttrib != INVALID_FILE_ATTRIBUTES;
+            if (!could_stat) {
+#if !defined(Q_OS_WINCE)
+                if (!fname.isEmpty() && fname.at(0).isLetter() && fname.mid(1, fname.length()) == QLatin1String(":/")) {
+                    // an empty drive ??
+                    DWORD drivesBitmask = ::GetLogicalDrives();
+                    int drivebit = 1 << (fname.at(0).toUpper().unicode() - QLatin1Char('A').unicode());
+                    if (drivesBitmask & drivebit) {
+                        fileAttrib = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM;
+                        could_stat = true;
+                    }
+                } else {
+#endif
+                    QString path = QDir::toNativeSeparators(fname);
+                    bool is_dir = false;
+                    if (path.startsWith(QLatin1String("\\\\"))) {
+                        // UNC - stat doesn't work for all cases (Windows bug)
+                        int s = path.indexOf(path.at(0),2);
+                        if (s > 0) {
+                            // "\\server\..."
+                            s = path.indexOf(path.at(0),s+1);
+                            if (s > 0) {
+                                // "\\server\share\..."
+                                if (s == path.size() - 1) {
+                                    // "\\server\share\"
+                                    is_dir = true;
+                                } else {
+                                    // "\\server\share\notfound"
+                                }
+                            } else {
+                                // "\\server\share"
+                                is_dir = true;
+                            }
+                        } else {
+                            // "\\server"
+                            is_dir = true;
+                        }
+                    }
+                    if (is_dir && uncShareExists(path)) {
+                        // looks like a UNC dir, is a dir.
+                        fileAttrib = FILE_ATTRIBUTE_DIRECTORY;
+                        could_stat = true;
+                    }
+#if !defined(Q_OS_WINCE)
+                }
+#endif
+            }
+        }
+        SetErrorMode(oldmode);
+    }
+    return could_stat;
+}
+
+
+static QString readLink(const QString &link)
+{
+#if !defined(Q_OS_WINCE)
+#if !defined(QT_NO_LIBRARY)
+    QString ret;
+    QT_WA({
+        bool neededCoInit = false;
+        IShellLink *psl;                            // pointer to IShellLink i/f
+        HRESULT hres;
+        WIN32_FIND_DATA wfd;
+        TCHAR szGotPath[MAX_PATH];
+        // Get pointer to the IShellLink interface.
+        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+                                    IID_IShellLink, (LPVOID *)&psl);
+
+        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
+            neededCoInit = true;
+            CoInitialize(NULL);
+            hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+                                        IID_IShellLink, (LPVOID *)&psl);
+        }
+        if(SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.
+            IPersistFile *ppf;
+            hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
+            if(SUCCEEDED(hres))  {
+                hres = ppf->Load((LPOLESTR)link.utf16(), STGM_READ);
+                //The original path of the link is retrieved. If the file/folder
+                //was moved, the return value still have the old path.
+                if(SUCCEEDED(hres)) {
+                    if (psl->GetPath(szGotPath, MAX_PATH, &wfd, SLGP_UNCPRIORITY) == NOERROR)
+                        ret = QString::fromUtf16((ushort*)szGotPath);
+                }
+                ppf->Release();
+            }
+            psl->Release();
+        }
+        if(neededCoInit)
+            CoUninitialize();
+    } , {
+	    bool neededCoInit = false;
+        IShellLinkA *psl;                            // pointer to IShellLink i/f
+        HRESULT hres;
+        WIN32_FIND_DATAA wfd;
+        char szGotPath[MAX_PATH];
+        // Get pointer to the IShellLink interface.
+
+        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+                                    IID_IShellLinkA, (LPVOID *)&psl);
+
+        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
+            neededCoInit = true;
+            CoInitialize(NULL);
+            hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+                                        IID_IShellLinkA, (LPVOID *)&psl);
+        }
+        if(SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.
+            IPersistFile *ppf;
+            hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
+            if(SUCCEEDED(hres))  {
+                hres = ppf->Load((LPOLESTR)QFileInfo(link).absoluteFilePath().utf16(), STGM_READ);
+                //The original path of the link is retrieved. If the file/folder
+                //was moved, the return value still have the old path.
+                 if(SUCCEEDED(hres)) {
+                    if (psl->GetPath((char*)szGotPath, MAX_PATH, &wfd, SLGP_UNCPRIORITY) == NOERROR)
+                        ret = QString::fromLocal8Bit(szGotPath);
+                }
+                ppf->Release();
+            }
+            psl->Release();
+        }
+        if(neededCoInit)
+            CoUninitialize();
+    });
+    return ret;
+#else
+    Q_UNUSED(link);
+    return QString();
+#endif // QT_NO_LIBRARY
+#else
+    wchar_t target[MAX_PATH];
+    QString result;
+    if (SHGetShortcutTarget((wchar_t*)QFileInfo(link).absoluteFilePath().replace(QLatin1Char('/'),QLatin1Char('\\')).utf16(), target, MAX_PATH)) {
+        result = QString::fromUtf16(reinterpret_cast<const ushort *> (target));
+        if (result.startsWith(QLatin1Char('"')))
+            result.remove(0,1);
+        if (result.endsWith(QLatin1Char('"')))
+            result.remove(result.size()-1,1);
+    }
+    return result;
+#endif // Q_OS_WINCE
+}
+
+/*!
+    \internal
+*/
+QString QFSFileEnginePrivate::getLink() const
+{
+    return readLink(filePath);
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::link(const QString &newName)
+{
+#if !defined(Q_OS_WINCE)
+#if !defined(QT_NO_LIBRARY)
+    bool ret = false;
+
+    QString linkName = newName;
+    //### assume that they add .lnk
+
+    QT_WA({
+        HRESULT hres;
+        IShellLink *psl;
+        bool neededCoInit = false;
+
+        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
+        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
+                neededCoInit = true;
+                CoInitialize(NULL);
+                hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
+        }
+        if (SUCCEEDED(hres)) {
+            hres = psl->SetPath((wchar_t *)fileName(AbsoluteName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
+            if (SUCCEEDED(hres)) {
+                hres = psl->SetWorkingDirectory((wchar_t *)fileName(AbsolutePathName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
+                if (SUCCEEDED(hres)) {
+                    IPersistFile *ppf;
+                    hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
+                    if (SUCCEEDED(hres)) {
+                        hres = ppf->Save((TCHAR*)linkName.utf16(), TRUE);
+                        if (SUCCEEDED(hres))
+                             ret = true;
+                        ppf->Release();
+                    }
+                }
+            }
+            psl->Release();
+        }
+        if(neededCoInit)
+                CoUninitialize();
+    } , {
+        // the SetPath() call _sometimes_ changes the current path and when it does it sometimes
+        // does not let us change it back unless we call currentPath() many times.
+        QString cwd = currentPath();
+        HRESULT hres;
+        IShellLinkA *psl;
+        bool neededCoInit = false;
+
+        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
+        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
+            neededCoInit = true;
+            CoInitialize(NULL);
+            hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
+        }
+        if (SUCCEEDED(hres)) {
+            currentPath();
+            hres = psl->SetPath((char *)QString::fromLocal8Bit(QFSFileEnginePrivate::win95Name(fileName(AbsoluteName))).utf16());
+            currentPath();
+            if (SUCCEEDED(hres)) {
+                hres = psl->SetWorkingDirectory((char *)QString::fromLocal8Bit(QFSFileEnginePrivate::win95Name(fileName(AbsolutePathName))).utf16());
+                currentPath();
+                if (SUCCEEDED(hres)) {
+                    IPersistFile *ppf;
+                    hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
+                    if (SUCCEEDED(hres)) {
+                        currentPath();
+                        hres = ppf->Save((LPCOLESTR)linkName.utf16(), TRUE);
+                        currentPath();
+                        if (SUCCEEDED(hres))
+                            ret = true;
+                        ppf->Release();
+                    }
+                }
+                psl->Release();
+            }
+        }
+        if(neededCoInit)
+            CoUninitialize();
+        setCurrentPath(cwd);
+    });
+    return ret;
+#else
+    Q_UNUSED(newName);
+    return false;
+#endif // QT_NO_LIBRARY
+#else
+    QString linkName = newName;
+    if (!linkName.endsWith(QLatin1String(".lnk")))
+        linkName += QLatin1String(".lnk");
+    QString orgName = fileName(AbsoluteName).replace(QLatin1Char('/'), QLatin1Char('\\'));
+    // Need to append on our own
+    orgName.prepend(QLatin1Char('"'));
+    orgName.append(QLatin1Char('"'));
+    return SUCCEEDED(SHCreateShortcut((wchar_t*)linkName.utf16(), (wchar_t*)orgName.utf16()));
+#endif // Q_OS_WINCE
+}
+
+/*!
+    \internal
+*/
+QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions() const
+{
+    QAbstractFileEngine::FileFlags ret = 0;
+
+#if !defined(QT_NO_LIBRARY)
+    if((qt_ntfs_permission_lookup > 0) && ((QSysInfo::WindowsVersion&QSysInfo::WV_NT_based) > QSysInfo::WV_NT)) {
+	PSID pOwner = 0;
+	PSID pGroup = 0;
+	PACL pDacl;
+        PSECURITY_DESCRIPTOR pSD;
+        ACCESS_MASK access_mask;
+
+        enum { ReadMask = 0x00000001, WriteMask = 0x00000002, ExecMask = 0x00000020 };
+        resolveLibs();
+        if(ptrGetNamedSecurityInfoW && ptrAllocateAndInitializeSid && ptrBuildTrusteeWithSidW && ptrGetEffectiveRightsFromAclW && ptrFreeSid) {
+
+            QString fname = filePath.endsWith(QLatin1String(".lnk")) ? readLink(filePath) : filePath;
+            DWORD res = ptrGetNamedSecurityInfoW((wchar_t*)fname.utf16(), SE_FILE_OBJECT,
+						 OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
+						 &pOwner, &pGroup, &pDacl, 0, &pSD);
+
+            if(res == ERROR_SUCCESS) {
+                TRUSTEE_W trustee;
+                { //user
+                    if(ptrGetEffectiveRightsFromAclW(pDacl, &currentUserTrusteeW, &access_mask) != ERROR_SUCCESS)
+                        access_mask = (ACCESS_MASK)-1;
+		    if(access_mask & ReadMask)
+			ret |= QAbstractFileEngine::ReadUserPerm;
+		    if(access_mask & WriteMask)
+			ret |= QAbstractFileEngine::WriteUserPerm;
+		    if(access_mask & ExecMask)
+			ret |= QAbstractFileEngine::ExeUserPerm;
+                }
+                { //owner
+                    ptrBuildTrusteeWithSidW(&trustee, pOwner);
+                    if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
+                        access_mask = (ACCESS_MASK)-1;
+		    if(access_mask & ReadMask)
+			ret |= QAbstractFileEngine::ReadOwnerPerm;
+		    if(access_mask & WriteMask)
+			ret |= QAbstractFileEngine::WriteOwnerPerm;
+		    if(access_mask & ExecMask)
+			ret |= QAbstractFileEngine::ExeOwnerPerm;
+                }
+                { //group
+                    ptrBuildTrusteeWithSidW(&trustee, pGroup);
+                    if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
+                        access_mask = (ACCESS_MASK)-1;
+		    if(access_mask & ReadMask)
+			ret |= QAbstractFileEngine::ReadGroupPerm;
+		    if(access_mask & WriteMask)
+			ret |= QAbstractFileEngine::WriteGroupPerm;
+		    if(access_mask & ExecMask)
+			ret |= QAbstractFileEngine::ExeGroupPerm;
+                }
+                { //other (world)
+                    // Create SID for Everyone (World)
+                    SID_IDENTIFIER_AUTHORITY worldAuth = { SECURITY_WORLD_SID_AUTHORITY };
+                    PSID pWorld = 0;
+                    if(ptrAllocateAndInitializeSid(&worldAuth, 1, SECURITY_WORLD_RID, 0,0,0,0,0,0,0, &pWorld)) {
+                        ptrBuildTrusteeWithSidW(&trustee, pWorld);
+                        if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
+                            access_mask = (ACCESS_MASK)-1; // ###
+			if(access_mask & ReadMask)
+			    ret |= QAbstractFileEngine::ReadOtherPerm;
+			if(access_mask & WriteMask)
+			    ret |= QAbstractFileEngine::WriteOtherPerm;
+			if(access_mask & ExecMask)
+			    ret |= QAbstractFileEngine::ExeOtherPerm;
+                    }
+                    ptrFreeSid(pWorld);
+                }
+                LocalFree(pSD);
+            }
+        }
+    } else
+#endif
+           {
+	//### what to do with permissions if we don't use ntfs or are not on a NT system
+	// for now just add all permissions and what about exe missions ??
+	// also qt_ntfs_permission_lookup is now not set by defualt ... should it ?
+    	ret |= QAbstractFileEngine::ReadOtherPerm | QAbstractFileEngine::ReadGroupPerm
+	    | QAbstractFileEngine::ReadOwnerPerm | QAbstractFileEngine::ReadUserPerm
+	    | QAbstractFileEngine::WriteUserPerm | QAbstractFileEngine::WriteOwnerPerm
+	    | QAbstractFileEngine::WriteGroupPerm | QAbstractFileEngine::WriteOtherPerm;
+    }
+
+    if (doStat()) {
+        if (ret & (QAbstractFileEngine::WriteOwnerPerm | QAbstractFileEngine::WriteUserPerm |
+            QAbstractFileEngine::WriteGroupPerm | QAbstractFileEngine::WriteOtherPerm)) {
+            if (fileAttrib & FILE_ATTRIBUTE_READONLY)
+                ret &= ~(QAbstractFileEngine::WriteOwnerPerm | QAbstractFileEngine::WriteUserPerm |
+                QAbstractFileEngine::WriteGroupPerm | QAbstractFileEngine::WriteOtherPerm);
+        }
+
+        QString ext = filePath.right(4).toLower();
+        if (ext == QLatin1String(".exe") || ext == QLatin1String(".com") || ext == QLatin1String(".bat") ||
+            ext == QLatin1String(".pif") || ext == QLatin1String(".cmd") || (fileAttrib & FILE_ATTRIBUTE_DIRECTORY))
+            ret |= QAbstractFileEngine::ExeOwnerPerm | QAbstractFileEngine::ExeGroupPerm |
+            QAbstractFileEngine::ExeOtherPerm | QAbstractFileEngine::ExeUserPerm;
+    }
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(QAbstractFileEngine::FileFlags type) const
+{
+    Q_D(const QFSFileEngine);
+    QAbstractFileEngine::FileFlags ret = 0;
+    // Force a stat, so that we're guaranteed to get up-to-date results
+    if (type & QAbstractFileEngine::FileFlag(QAbstractFileEngine::Refresh)) {
+        d->tried_stat = 0;
+    }
+
+    if (type & PermsMask) {
+        ret |= d->getPermissions();
+        // ### Workaround pascals ### above. Since we always set all properties to true
+        // we need to disable read and exec access if the file does not exists
+        if (d->doStat())
+            ret |= ExistsFlag;
+        else
+            ret &= 0x2222;
+    }
+    if (type & TypesMask) {
+        if (d->filePath.endsWith(QLatin1String(".lnk"))) {
+            ret |= LinkType;
+            QString l = readLink(d->filePath);
+            if (!l.isEmpty()) {
+                if (isDirPath(l, 0))
+                    ret |= DirectoryType;
+                else
+                    ret |= FileType;
+            }
+        } else if (d->doStat()) {
+            if (d->fileAttrib & FILE_ATTRIBUTE_DIRECTORY) {
+                ret |= DirectoryType;
+            } else {
+                ret |= FileType;
+            }
+        }
+    }
+    if (type & FlagsMask) {
+        if(d->doStat()) {
+            ret |= QAbstractFileEngine::FileFlags(ExistsFlag | LocalDiskFlag);
+            if (d->fileAttrib & FILE_ATTRIBUTE_HIDDEN)
+                ret |= HiddenFlag;
+            if (d->filePath == QLatin1String("/") || (d->filePath.at(0).isLetter() && d->filePath.mid(1,d->filePath.length()) == QLatin1String(":/"))
+                || isUncRoot(d->filePath)) {
+                ret |= RootFlag;
+                ret &= ~HiddenFlag;
+            }
+        }
+    }
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+QString QFSFileEngine::fileName(FileName file) const
+{
+    Q_D(const QFSFileEngine);
+    if(file == BaseName) {
+        int slash = d->filePath.lastIndexOf(QLatin1Char('/'));
+        if(slash == -1) {
+            int colon = d->filePath.lastIndexOf(QLatin1Char(':'));
+            if(colon != -1)
+                return d->filePath.mid(colon + 1);
+            return d->filePath;
+        }
+        return d->filePath.mid(slash + 1);
+    } else if(file == PathName) {
+        if(!d->filePath.size())
+            return d->filePath;
+
+        int slash = d->filePath.lastIndexOf(QLatin1Char('/'));
+        if(slash == -1) {
+            if(d->filePath.length() >= 2 && d->filePath.at(1) == QLatin1Char(':'))
+                return d->filePath.left(2);
+            return QString::fromLatin1(".");
+        } else {
+            if(!slash)
+                return QString::fromLatin1("/");
+            if(slash == 2 && d->filePath.length() >= 2 && d->filePath.at(1) == QLatin1Char(':'))
+                slash++;
+            return d->filePath.left(slash);
+        }
+    } else if(file == AbsoluteName || file == AbsolutePathName) {
+        QString ret;
+
+        if (!isRelativePath()) {
+#if !defined(Q_OS_WINCE)
+            if (d->filePath.size() > 2 && d->filePath.at(1) == QLatin1Char(':')
+                && d->filePath.at(2) != QLatin1Char('/') || // It's a drive-relative path, so Z:a.txt -> Z:\currentpath\a.txt
+                d->filePath.startsWith(QLatin1Char('/'))    // It's a absolute path to the current drive, so \a.txt -> Z:\a.txt
+                ) {
+                ret = QDir::fromNativeSeparators(nativeAbsoluteFilePath(d->filePath));
+            } else {
+                ret = d->filePath;
+            }
+#else
+                ret = d->filePath;
+#endif
+        } else {
+            ret = QDir::cleanPath(QDir::currentPath() + QLatin1Char('/') + d->filePath);
+        }
+
+        // The path should be absolute at this point.
+        // From the docs :
+        // Absolute paths begin with the directory separator "/"
+        // (optionally preceded by a drive specification under Windows).
+        if (ret.at(0) != QLatin1Char('/')) {
+            Q_ASSERT(ret.length() >= 2);
+            Q_ASSERT(ret.at(0).isLetter());
+            Q_ASSERT(ret.at(1) == QLatin1Char(':'));
+
+            // Force uppercase drive letters.
+            ret[0] = ret.at(0).toUpper();
+        }
+
+        if (file == AbsolutePathName) {
+            int slash = ret.lastIndexOf(QLatin1Char('/'));
+            if (slash < 0)
+                return ret;
+            else if (ret.at(0) != QLatin1Char('/') && slash == 2)
+                return ret.left(3);      // include the slash
+            else
+                return ret.left(slash > 0 ? slash : 1);
+        }
+        return ret;
+    } else if(file == CanonicalName || file == CanonicalPathName) {
+        if (!(fileFlags(ExistsFlag) & ExistsFlag))
+            return QString();
+
+        QString ret = QFSFileEnginePrivate::canonicalized(fileName(AbsoluteName));
+        if (!ret.isEmpty() && file == CanonicalPathName) {
+            int slash = ret.lastIndexOf(QLatin1Char('/'));
+            if (slash == -1)
+                ret = QDir::currentPath();
+            else if (slash == 0)
+                ret = QLatin1String("/");
+            ret = ret.left(slash);
+        }
+        return ret;
+    } else if(file == LinkName) {
+        return QDir::fromNativeSeparators(d->getLink());
+    } else if(file == BundleName) {
+        return QString();
+    }
+    return d->filePath;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::isRelativePath() const
+{
+    Q_D(const QFSFileEngine);
+    return !(d->filePath.startsWith(QLatin1Char('/'))
+        || (d->filePath.length() >= 2
+        && ((d->filePath.at(0).isLetter() && d->filePath.at(1) == QLatin1Char(':'))
+        || (d->filePath.at(0) == QLatin1Char('/') && d->filePath.at(1) == QLatin1Char('/')))));                // drive, e.g. a:
+}
+
+/*!
+    \reimp
+*/
+uint QFSFileEngine::ownerId(FileOwner /*own*/) const
+{
+    static const uint nobodyID = (uint) -2;
+    return nobodyID;
+}
+
+/*!
+    \reimp
+*/
+QString QFSFileEngine::owner(FileOwner own) const
+{
+#if !defined(QT_NO_LIBRARY)
+    Q_D(const QFSFileEngine);
+    if((qt_ntfs_permission_lookup > 0) && ((QSysInfo::WindowsVersion&QSysInfo::WV_NT_based) > QSysInfo::WV_NT)) {
+	PSID pOwner = 0;
+	PSECURITY_DESCRIPTOR pSD;
+	QString name;
+	QFSFileEnginePrivate::resolveLibs();
+
+	if(ptrGetNamedSecurityInfoW && ptrLookupAccountSidW) {
+	    if(ptrGetNamedSecurityInfoW((wchar_t*)d->filePath.utf16(), SE_FILE_OBJECT,
+					 own == OwnerGroup ? GROUP_SECURITY_INFORMATION : OWNER_SECURITY_INFORMATION,
+					 NULL, &pOwner, NULL, NULL, &pSD) == ERROR_SUCCESS) {
+		DWORD lowner = 0, ldomain = 0;
+		SID_NAME_USE use;
+		// First call, to determine size of the strings (with '\0').
+		ptrLookupAccountSidW(NULL, pOwner, NULL, &lowner, NULL, &ldomain, (SID_NAME_USE*)&use);
+		wchar_t *owner = new wchar_t[lowner];
+		wchar_t *domain = new wchar_t[ldomain];
+		// Second call, size is without '\0'
+		if(ptrLookupAccountSidW(NULL, pOwner, (LPWSTR)owner, &lowner,
+					 (LPWSTR)domain, &ldomain, (SID_NAME_USE*)&use)) {
+		    name = QString::fromUtf16((ushort*)owner);
+		}
+		LocalFree(pSD);
+		delete [] owner;
+		delete [] domain;
+	    }
+	}
+	return name;
+    }
+#else
+    Q_UNUSED(own);
+#endif
+    return QString(QLatin1String(""));
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::setPermissions(uint perms)
+{
+    Q_D(QFSFileEngine);
+    bool ret = false;
+    int mode = 0;
+
+    if (perms & QFile::ReadOwner || perms & QFile::ReadUser || perms & QFile::ReadGroup || perms & QFile::ReadOther)
+        mode |= _S_IREAD;
+    if (perms & QFile::WriteOwner || perms & QFile::WriteUser || perms & QFile::WriteGroup || perms & QFile::WriteOther)
+        mode |= _S_IWRITE;
+
+    if (mode == 0) // not supported
+        return false;
+
+#if !defined(Q_OS_WINCE)
+   QT_WA({
+        ret = ::_wchmod((TCHAR*)d->filePath.utf16(), mode) == 0;
+   } , {
+        ret = ::_chmod(d->filePath.toLocal8Bit(), mode) == 0;
+   });
+#else
+    ret = ::_wchmod((TCHAR*)d->longFileName(d->filePath).utf16(), mode);
+#endif
+   return ret;
+}
+
+/*!
+    \reimp
+*/
+bool QFSFileEngine::setSize(qint64 size)
+{
+    Q_D(QFSFileEngine);
+
+    if (d->fileHandle != INVALID_HANDLE_VALUE || d->fd != -1) {
+        // resize open file
+        HANDLE fh = d->fileHandle;
+#if !defined(Q_OS_WINCE)
+        if (fh == INVALID_HANDLE_VALUE)
+            fh = (HANDLE)_get_osfhandle(d->fd);
+#endif
+        if (fh == INVALID_HANDLE_VALUE)
+            return false;
+        qint64 currentPos = pos();
+
+        if (seek(size) && SetEndOfFile(fh)) {
+            seek(qMin(currentPos, size));
+            return true;
+        }
+
+        seek(currentPos);
+        return false;
+    }
+
+    if (!d->nativeFilePath.isEmpty()) {
+        // resize file on disk
+        QFile file(d->filePath);
+        if (file.open(QFile::ReadWrite)) {
+            return file.resize(size);
+        }
+    }
+    return false;
+}
+
+
+static inline QDateTime fileTimeToQDateTime(const FILETIME *time)
+{
+    QDateTime ret;
+    if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based || QSysInfo::WindowsVersion & QSysInfo::WV_CE_based) {
+        // SystemTimeToTzSpecificLocalTime is not available on Win98/ME so we have to pull it off ourselves.
+        SYSTEMTIME systime;
+        FILETIME ftime;
+        systime.wYear = 1970;
+        systime.wMonth = 1;
+        systime.wDay = 1;
+        systime.wHour = 0;
+        systime.wMinute = 0;
+        systime.wSecond = 0;
+        systime.wMilliseconds = 0;
+        systime.wDayOfWeek = 4;
+        SystemTimeToFileTime(&systime, &ftime);
+        unsigned __int64 acttime = (unsigned __int64)time->dwHighDateTime << 32 | time->dwLowDateTime;
+        FileTimeToSystemTime(time, &systime);
+        unsigned __int64 time1970 = (unsigned __int64)ftime.dwHighDateTime << 32 | ftime.dwLowDateTime;
+        unsigned __int64 difftime = acttime - time1970;
+        difftime /= 10000000;
+        ret.setTime_t((unsigned int)difftime);
+    } else {
+#ifndef Q_OS_WINCE
+        SYSTEMTIME sTime, lTime;
+        FileTimeToSystemTime(time, &sTime);
+        SystemTimeToTzSpecificLocalTime(0, &sTime, &lTime);
+        ret.setDate(QDate(lTime.wYear, lTime.wMonth, lTime.wDay));
+        ret.setTime(QTime(lTime.wHour, lTime.wMinute, lTime.wSecond, lTime.wMilliseconds));
+#endif
+    }
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+QDateTime QFSFileEngine::fileTime(FileTime time) const
+{
+    Q_D(const QFSFileEngine);
+    QDateTime ret;
+    if (d->fd != -1) {
+#if !defined(Q_OS_WINCE)
+        HANDLE fh = (HANDLE)_get_osfhandle(d->fd);
+        if (fh != INVALID_HANDLE_VALUE) {
+            FILETIME creationTime, lastAccessTime, lastWriteTime;
+            if (GetFileTime(fh, &creationTime, &lastAccessTime, &lastWriteTime)) {
+                if(time == CreationTime)
+                    ret = fileTimeToQDateTime(&creationTime);
+                else if(time == ModificationTime)
+                    ret = fileTimeToQDateTime(&lastWriteTime);
+                else if(time == AccessTime)
+                    ret = fileTimeToQDateTime(&lastAccessTime);
+            }
+        }
+#endif
+    } else {
+        bool ok = false;
+        WIN32_FILE_ATTRIBUTE_DATA attribData;
+        QT_WA({
+            ok = ::GetFileAttributesExW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(), GetFileExInfoStandard, &attribData);
+        } , {
+            ok = ::GetFileAttributesExA(QFSFileEnginePrivate::win95Name(QFileInfo(d->filePath).absoluteFilePath()), GetFileExInfoStandard, &attribData);
+        });
+        if (ok) {
+            if(time == CreationTime)
+                ret = fileTimeToQDateTime(&attribData.ftCreationTime);
+            else if(time == ModificationTime)
+                ret = fileTimeToQDateTime(&attribData.ftLastWriteTime);
+            else if(time == AccessTime)
+                ret = fileTimeToQDateTime(&attribData.ftLastAccessTime);
+        }
+    }
+    return ret;
+}
+
+uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
+                                 QFile::MemoryMapFlags flags)
+{
+    Q_Q(QFSFileEngine);
+    Q_UNUSED(flags);
+    if (openMode == QFile::NotOpen) {
+        q->setError(QFile::PermissionsError, qt_error_string());
+	return 0;
+    }
+    if (offset == 0 && size == 0) {
+        q->setError(QFile::UnspecifiedError, qt_error_string());
+	return 0;
+    }
+
+
+    // get handle to the file
+    HANDLE handle = fileHandle;
+#ifndef Q_OS_WINCE
+    if (handle == INVALID_HANDLE_VALUE && fh)
+        handle = (HANDLE)_get_osfhandle(QT_FILENO(fh));
+#else
+    #ifdef Q_USE_DEPRECATED_MAP_API
+    nativeClose();
+    if (fileMapHandle == INVALID_HANDLE_VALUE) {
+        fileMapHandle = CreateFileForMappingW((TCHAR *)nativeFilePath.constData(),
+                GENERIC_READ | (openMode & QIODevice::WriteOnly ? GENERIC_WRITE : 0),
+                0,
+                NULL,
+                OPEN_EXISTING,
+                FILE_ATTRIBUTE_NORMAL,
+                NULL);
+    }
+    handle = fileMapHandle;
+    #endif
+    if (handle == INVALID_HANDLE_VALUE && fh)
+        return 0;
+#endif
+
+    // first create the file mapping handle
+    HANDLE mapHandle = 0;
+    DWORD protection = (openMode & QIODevice::WriteOnly) ? PAGE_READWRITE : PAGE_READONLY;
+    QT_WA({
+    mapHandle = ::CreateFileMappingW(handle, 0, protection,
+             0, 0, 0);
+    },{
+    mapHandle = ::CreateFileMappingA(handle, 0, protection,
+             0, 0, 0);
+    });
+    if (mapHandle == NULL) {
+        q->setError(QFile::PermissionsError, qt_error_string());
+#ifdef Q_USE_DEPRECATED_MAP_API
+        mapHandleClose();
+#endif
+	return 0;
+    }
+
+    // setup args to map
+    DWORD access = 0;
+    if (openMode & QIODevice::ReadOnly) access = FILE_MAP_READ;
+    if (openMode & QIODevice::WriteOnly) access = FILE_MAP_WRITE;
+
+    DWORD offsetHi = offset >> 32;
+    DWORD offsetLo = offset & Q_UINT64_C(0xffffffff);
+    SYSTEM_INFO sysinfo;
+    ::GetSystemInfo(&sysinfo);
+    int mask = sysinfo.dwAllocationGranularity - 1;
+    int extra = offset & mask;
+    if (extra)
+        offsetLo &= ~mask;
+
+    // attempt to create the map
+    LPVOID mapAddress = MapViewOfFile(mapHandle, access,
+                                      offsetHi, offsetLo, size + extra);
+    if (mapAddress) {
+        uchar *address = extra + static_cast<uchar*>(mapAddress);
+        maps[address] = QPair<int, HANDLE>(extra, mapHandle);
+        return address;
+    }
+
+    switch(GetLastError()) {
+    case ERROR_ACCESS_DENIED:
+        q->setError(QFile::PermissionsError, qt_error_string());
+	break;
+    case ERROR_INVALID_PARAMETER:
+        // size are out of bounds
+    default:
+        q->setError(QFile::UnspecifiedError, qt_error_string());
+    }
+    CloseHandle(mapHandle);
+#ifdef Q_USE_DEPRECATED_MAP_API
+    mapHandleClose();
+#endif
+    return 0;
+}
+
+bool QFSFileEnginePrivate::unmap(uchar *ptr)
+{
+    Q_Q(QFSFileEngine);
+    if (!maps.contains(ptr)) {
+        q->setError(QFile::PermissionsError, qt_error_string());
+        return false;
+    }
+    uchar *start = ptr - maps[ptr].first;
+    if (!UnmapViewOfFile(start)) {
+        q->setError(QFile::PermissionsError, qt_error_string());
+        return false;
+    }
+
+    if (!CloseHandle((HANDLE)maps[ptr].second)) {
+        q->setError(QFile::UnspecifiedError, qt_error_string());
+        return false;
+    }
+    maps.remove(ptr);
+
+#ifdef Q_USE_DEPRECATED_MAP_API
+    mapHandleClose();
+#endif
+    return true;
+}
+
+#ifdef Q_USE_DEPRECATED_MAP_API
+void QFSFileEnginePrivate::mapHandleClose()
+{
+    if (maps.isEmpty()) {
+        CloseHandle(fileMapHandle);
+        fileMapHandle = INVALID_HANDLE_VALUE;
+    }
+}
+#endif
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qiodevice.cpp b/src/corelib/io/qiodevice.cpp
new file mode 100644
index 0000000..c739054
--- /dev/null
+++ b/src/corelib/io/qiodevice.cpp
@@ -0,0 +1,1748 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+//#define QIODEVICE_DEBUG
+
+#include "qbytearray.h"
+#include "qdebug.h"
+#include "qiodevice_p.h"
+#include "qfile.h"
+#include "qstringlist.h"
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef QIODEVICE_DEBUG
+void debugBinaryString(const QByteArray &input)
+{
+    QByteArray tmp;
+    int startOffset = 0;
+    for (int i = 0; i < input.size(); ++i) {
+        tmp += input[i];
+
+        if ((i % 16) == 15 || i == (input.size() - 1)) {
+            printf("\n%15d:", startOffset);
+            startOffset += tmp.size();
+
+            for (int j = 0; j < tmp.size(); ++j)
+                printf(" %02x", int(uchar(tmp[j])));
+            for (int j = tmp.size(); j < 16 + 1; ++j)
+                printf("   ");
+            for (int j = 0; j < tmp.size(); ++j)
+                printf("%c", isprint(int(uchar(tmp[j]))) ? tmp[j] : '.');
+            tmp.clear();
+        }
+    }
+    printf("\n\n");
+}
+
+void debugBinaryString(const char *data, qint64 maxlen)
+{
+    debugBinaryString(QByteArray(data, maxlen));
+}
+#endif
+
+#ifndef QIODEVICE_BUFFERSIZE
+#define QIODEVICE_BUFFERSIZE Q_INT64_C(16384)
+#endif
+
+#define Q_VOID
+
+#define CHECK_MAXLEN(function, returnType) \
+    do { \
+        if (maxSize < 0) { \
+            qWarning("QIODevice::"#function": Called with maxSize < 0"); \
+            return returnType; \
+        } \
+    } while (0)
+
+#define CHECK_WRITABLE(function, returnType) \
+   do { \
+       if ((d->openMode & WriteOnly) == 0) { \
+           if (d->openMode == NotOpen) \
+               return returnType; \
+           qWarning("QIODevice::"#function": ReadOnly device"); \
+           return returnType; \
+       } \
+   } while (0)
+
+#define CHECK_READABLE(function, returnType) \
+   do { \
+       if ((d->openMode & ReadOnly) == 0) { \
+           if (d->openMode == NotOpen) \
+               return returnType; \
+           qWarning("QIODevice::"#function": WriteOnly device"); \
+           return returnType; \
+       } \
+   } while (0)
+
+/*! \internal
+ */
+QIODevicePrivate::QIODevicePrivate()
+    : openMode(QIODevice::NotOpen), buffer(QIODEVICE_BUFFERSIZE),
+      pos(0), devicePos(0), accessMode(Unset)
+{
+}
+
+/*! \internal
+ */
+QIODevicePrivate::~QIODevicePrivate()
+{
+}
+
+/*!
+    \class QIODevice
+    \reentrant
+
+    \brief The QIODevice class is the base interface class of all I/O
+    devices in Qt.
+
+    \ingroup io
+
+    QIODevice provides both a common implementation and an abstract
+    interface for devices that support reading and writing of blocks
+    of data, such as QFile, QBuffer and QTcpSocket. QIODevice is
+    abstract and can not be instantiated, but it is common to use the
+    interface it defines to provide device-independent I/O features.
+    For example, Qt's XML classes operate on a QIODevice pointer,
+    allowing them to be used with various devices (such as files and
+    buffers).
+
+    Before accessing the device, open() must be called to set the
+    correct OpenMode (such as ReadOnly or ReadWrite). You can then
+    write to the device with write() or putChar(), and read by calling
+    either read(), readLine(), or readAll(). Call close() when you are
+    done with the device.
+
+    QIODevice distinguishes between two types of devices:
+    random-access devices and sequential devices.
+
+    \list
+    \o Random-access devices support seeking to arbitrary
+    positions using seek(). The current position in the file is
+    available by calling pos(). QFile and QBuffer are examples of
+    random-access devices.
+
+    \o Sequential devices don't support seeking to arbitrary
+    positions. The data must be read in one pass. The functions
+    pos() and size() don't work for sequential devices.
+    QTcpSocket and QProcess are examples of sequential devices.
+    \endlist
+
+    You can use isSequential() to determine the type of device.
+
+    QIODevice emits readyRead() when new data is available for
+    reading; for example, if new data has arrived on the network or if
+    additional data is appended to a file that you are reading
+    from. You can call bytesAvailable() to determine the number of
+    bytes that are currently available for reading. It's common to use
+    bytesAvailable() together with the readyRead() signal when
+    programming with asynchronous devices such as QTcpSocket, where
+    fragments of data can arrive at arbitrary points in
+    time. QIODevice emits the bytesWritten() signal every time a
+    payload of data has been written to the device. Use bytesToWrite()
+    to determine the current amount of data waiting to be written.
+
+    Certain subclasses of QIODevice, such as QTcpSocket and QProcess,
+    are asynchronous. This means that I/O functions such as write()
+    or read() always return immediately, while communication with the
+    device itself may happen when control goes back to the event loop.
+    QIODevice provides functions that allow you to force these
+    operations to be performed immediately, while blocking the
+    calling thread and without entering the event loop. This allows
+    QIODevice subclasses to be used without an event loop, or in
+    a separate thread:
+
+    \list
+    \o waitForReadyRead() - This function suspends operation in the
+    calling thread until new data is available for reading.
+
+    \o waitForBytesWritten() - This function suspends operation in the
+    calling thread until one payload of data has been written to the
+    device.
+
+    \o waitFor....() - Subclasses of QIODevice implement blocking
+    functions for device-specific operations. For example, QProcess
+    has a function called waitForStarted() which suspends operation in
+    the calling thread until the process has started.
+    \endlist
+
+    Calling these functions from the main, GUI thread, may cause your
+    user interface to freeze. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qiodevice.cpp 0
+
+    By subclassing QIODevice, you can provide the same interface to
+    your own I/O devices. Subclasses of QIODevice are only required to
+    implement the protected readData() and writeData() functions.
+    QIODevice uses these functions to implement all its convenience
+    functions, such as getChar(), readLine() and write(). QIODevice
+    also handles access control for you, so you can safely assume that
+    the device is opened in write mode if writeData() is called.
+
+    Some subclasses, such as QFile and QTcpSocket, are implemented
+    using a memory buffer for intermediate storing of data. This
+    reduces the number of required device accessing calls, which are
+    often very slow. Buffering makes functions like getChar() and
+    putChar() fast, as they can operate on the memory buffer instead
+    of directly on the device itself. Certain I/O operations, however,
+    don't work well with a buffer. For example, if several users open
+    the same device and read it character by character, they may end
+    up reading the same data when they meant to read a separate chunk
+    each. For this reason, QIODevice allows you to bypass any
+    buffering by passing the Unbuffered flag to open(). When
+    subclassing QIODevice, remember to bypass any buffer you may use
+    when the device is open in Unbuffered mode.
+
+    \sa QBuffer QFile QTcpSocket
+*/
+
+/*!
+    \typedef QIODevice::Offset
+    \compat
+
+    Use \c qint64 instead.
+*/
+
+/*!
+    \typedef QIODevice::Status
+    \compat
+
+    Use QIODevice::OpenMode instead, or see the documentation for
+    specific devices.
+*/
+
+/*!
+    \enum QIODevice::OpenModeFlag
+
+    This enum is used with open() to describe the mode in which a device
+    is opened. It is also returned by openMode().
+
+    \value NotOpen   The device is not open.
+    \value ReadOnly  The device is open for reading.
+    \value WriteOnly The device is open for writing.
+    \value ReadWrite The device is open for reading and writing.
+    \value Append    The device is opened in append mode, so that all data is
+                     written to the end of the file.
+    \value Truncate  If possible, the device is truncated before it is opened.
+                     All earlier contents of the device are lost.
+    \value Text      When reading, the end-of-line terminators are
+                     translated to '\n'. When writing, the end-of-line
+                     terminators are translated to the local encoding, for
+                     example '\r\n' for Win32.
+    \value Unbuffered Any buffer in the device is bypassed.
+
+    Certain flags, such as \c Unbuffered and \c Truncate, are
+    meaningless when used with some subclasses. Some of these
+    restrictions are implied by the type of device that is represented
+    by a subclass; for example, access to a QBuffer is always
+    unbuffered. In other cases, the restriction may be due to the
+    implementation, or may be imposed by the underlying platform; for
+    example, QTcpSocket does not support \c Unbuffered mode, and
+    limitations in the native API prevent QFile from supporting \c
+    Unbuffered on Windows.
+*/
+
+/*!     \fn QIODevice::bytesWritten(qint64 bytes)
+
+    This signal is emitted every time a payload of data has been
+    written to the device. The \a bytes argument is set to the number
+    of bytes that were written in this payload.
+
+    bytesWritten() is not emitted recursively; if you reenter the event loop
+    or call waitForBytesWritten() inside a slot connected to the
+    bytesWritten() signal, the signal will not be reemitted (although
+    waitForBytesWritten() may still return true).
+
+    \sa readyRead()
+*/
+
+/*!
+    \fn QIODevice::readyRead()
+
+    This signal is emitted once every time new data is available for
+    reading from the device. It will only be emitted again once new
+    data is available, such as when a new payload of network data has
+    arrived on your network socket, or when a new block of data has
+    been appended to your device.
+
+    readyRead() is not emitted recursively; if you reenter the event loop or
+    call waitForReadyRead() inside a slot connected to the readyRead() signal,
+    the signal will not be reemitted (although waitForReadyRead() may still
+    return true).
+
+    Note for developers implementing classes derived from QIODevice:
+    you should always emit readyRead() when new data has arrived (do not
+    emit it only because there's data still to be read in your
+    buffers). Do not emit readyRead() in other conditions.
+
+    \sa bytesWritten()
+*/
+
+/*! \fn QIODevice::aboutToClose()
+
+    This signal is emitted when the device is about to close. Connect
+    this signal if you have operations that need to be performed
+    before the device closes (e.g., if you have data in a separate
+    buffer that needs to be written to the device).
+*/
+
+/*!
+    \fn QIODevice::readChannelFinished()
+    \since 4.4
+
+    This signal is emitted when the input (reading) stream is closed
+    in this device. It is emitted as soon as the closing is detected,
+    which means that there might still be data available for reading
+    with read().
+
+    \sa atEnd(), read()
+*/
+
+#ifdef QT_NO_QOBJECT
+QIODevice::QIODevice()
+    : d_ptr(new QIODevicePrivate)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*! \internal
+*/
+QIODevice::QIODevice(QIODevicePrivate &dd)
+    : d_ptr(&dd)
+{
+    d_ptr->q_ptr = this;
+}
+#else
+
+/*!
+    Constructs a QIODevice object.
+*/
+
+QIODevice::QIODevice()
+    : QObject(*new QIODevicePrivate, 0)
+{
+#if defined QIODEVICE_DEBUG
+    QFile *file = qobject_cast<QFile *>(this);
+    printf("%p QIODevice::QIODevice(\"%s\") %s\n", this, className(),
+           qPrintable(file ? file->fileName() : QString()));
+#endif
+}
+
+/*!
+    Constructs a QIODevice object with the given \a parent.
+*/
+
+QIODevice::QIODevice(QObject *parent)
+    : QObject(*new QIODevicePrivate, parent)
+{
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::QIODevice(%p \"%s\")\n", this, parent, className());
+#endif
+}
+
+/*! \internal
+*/
+QIODevice::QIODevice(QIODevicePrivate &dd, QObject *parent)
+    : QObject(dd, parent)
+{
+}
+#endif
+
+
+/*!
+    Destructs the QIODevice object.
+*/
+QIODevice::~QIODevice()
+{
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::~QIODevice()\n", this);
+#endif
+}
+
+/*!
+    Returns true if this device is sequential; otherwise returns
+    false.
+
+    Sequential devices, as opposed to a random-access devices, have no
+    concept of a start, an end, a size, or a current position, and they
+    do not support seeking. You can only read from the device when it
+    reports that data is available. The most common example of a
+    sequential device is a network socket. On Unix, special files such
+    as /dev/zero and fifo pipes are sequential.
+
+    Regular files, on the other hand, do support random access. They
+    have both a size and a current position, and they also support
+    seeking backwards and forwards in the data stream. Regular files
+    are non-sequential.
+
+    \sa bytesAvailable()
+*/
+bool QIODevice::isSequential() const
+{
+    return false;
+}
+
+/*!
+    Returns the mode in which the device has been opened;
+    i.e. ReadOnly or WriteOnly.
+
+    \sa OpenMode
+*/
+QIODevice::OpenMode QIODevice::openMode() const
+{
+    return d_func()->openMode;
+}
+
+/*!
+    Sets the OpenMode of the device to \a openMode. Call this
+    function to set the open mode if the flags change after the device
+    has been opened.
+
+    \sa openMode() OpenMode
+*/
+void QIODevice::setOpenMode(OpenMode openMode)
+{
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::setOpenMode(0x%x)\n", this, int(openMode));
+#endif
+    d_func()->openMode = openMode;
+    d_func()->accessMode = QIODevicePrivate::Unset;
+}
+
+/*!
+    If \a enabled is true, this function sets the \l Text flag on the device;
+    otherwise the \l Text flag is removed. This feature is useful for classes
+    that provide custom end-of-line handling on a QIODevice.
+
+    \sa open(), setOpenMode()
+ */
+void QIODevice::setTextModeEnabled(bool enabled)
+{
+    Q_D(QIODevice);
+    if (enabled)
+        d->openMode |= Text;
+    else
+        d->openMode &= ~Text;
+}
+
+/*!
+    Returns true if the \l Text flag is enabled; otherwise returns false.
+
+    \sa setTextModeEnabled()
+*/
+bool QIODevice::isTextModeEnabled() const
+{
+    return d_func()->openMode & Text;
+}
+
+/*!
+    Returns true if the device is open; otherwise returns false. A
+    device is open if it can be read from and/or written to. By
+    default, this function returns false if openMode() returns
+    \c NotOpen.
+
+    \sa openMode() OpenMode
+*/
+bool QIODevice::isOpen() const
+{
+    return d_func()->openMode != NotOpen;
+}
+
+/*!
+    Returns true if data can be read from the device; otherwise returns
+    false. Use bytesAvailable() to determine how many bytes can be read.
+
+    This is a convenience function which checks if the OpenMode of the
+    device contains the ReadOnly flag.
+
+    \sa openMode() OpenMode
+*/
+bool QIODevice::isReadable() const
+{
+    return (openMode() & ReadOnly) != 0;
+}
+
+/*!
+    Returns true if data can be written to the device; otherwise returns
+    false.
+
+    This is a convenience function which checks if the OpenMode of the
+    device contains the WriteOnly flag.
+
+    \sa openMode() OpenMode
+*/
+bool QIODevice::isWritable() const
+{
+    return (openMode() & WriteOnly) != 0;
+}
+
+/*!
+    Opens the device and sets its OpenMode to \a mode. Returns true if successful;
+    otherwise returns false. This function should be called from any
+    reimplementations of open() or other functions that open the device.
+
+    \sa openMode() OpenMode
+*/
+bool QIODevice::open(OpenMode mode)
+{
+    Q_D(QIODevice);
+    d->openMode = mode;
+    d->pos = (mode & Append) ? size() : qint64(0);
+    d->buffer.clear();
+    d->accessMode = QIODevicePrivate::Unset;
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::open(0x%x)\n", this, quint32(mode));
+#endif
+    return true;
+}
+
+/*!
+    First emits aboutToClose(), then closes the device and sets its
+    OpenMode to NotOpen. The error string is also reset.
+
+    \sa setOpenMode() OpenMode
+*/
+void QIODevice::close()
+{
+    Q_D(QIODevice);
+    if (d->openMode == NotOpen)
+        return;
+
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::close()\n", this);
+#endif
+
+#ifndef QT_NO_QOBJECT
+    emit aboutToClose();
+#endif
+    d->openMode = NotOpen;
+    d->errorString.clear();
+    d->pos = 0;
+    d->buffer.clear();
+}
+
+/*!
+    For random-access devices, this function returns the position that
+    data is written to or read from. For sequential devices or closed
+    devices, where there is no concept of a "current position", 0 is
+    returned.
+
+    The current read/write position of the device is maintained internally by
+    QIODevice, so reimplementing this function is not necessary. When
+    subclassing QIODevice, use QIODevice::seek() to notify QIODevice about
+    changes in the device position.
+
+    \sa isSequential(), seek()
+*/
+qint64 QIODevice::pos() const
+{
+    Q_D(const QIODevice);
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::pos() == %d\n", this, int(d->pos));
+#endif
+    return d->pos;
+}
+
+/*!
+    For open random-access devices, this function returns the size of the
+    device. For open sequential devices, bytesAvailable() is returned.
+
+    If the device is closed, the size returned will not reflect the actual
+    size of the device.
+
+    \sa isSequential(), pos()
+*/
+qint64 QIODevice::size() const
+{
+    return d_func()->isSequential() ?  bytesAvailable() : qint64(0);
+}
+
+/*!
+    For random-access devices, this function sets the current position
+    to \a pos, returning true on success, or false if an error occurred.
+    For sequential devices, the default behavior is to do nothing and
+    return false.
+
+    When subclassing QIODevice, you must call QIODevice::seek() at the
+    start of your function to ensure integrity with QIODevice's
+    built-in buffer. The base implementation always returns true.
+
+    \sa pos(), isSequential()
+*/
+bool QIODevice::seek(qint64 pos)
+{
+    if (d_func()->openMode == NotOpen) {
+        qWarning("QIODevice::seek: The device is not open");
+        return false;
+    }
+    if (pos < 0) {
+        qWarning("QIODevice::seek: Invalid pos: %d", int(pos));
+        return false;
+    }
+
+    Q_D(QIODevice);
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::seek(%d), before: d->pos = %d, d->buffer.size() = %d\n",
+           this, int(pos), int(d->pos), d->buffer.size());
+#endif
+
+    qint64 offset = pos - d->pos;
+    if (!d->isSequential()) {
+        d->pos = pos;
+        d->devicePos = pos;
+    }
+
+    if (offset > 0 && !d->buffer.isEmpty()) {
+        // When seeking forwards, we need to pop bytes off the front of the
+        // buffer.
+        do {
+            int bytesToSkip = int(qMin<qint64>(offset, INT_MAX));
+            d->buffer.skip(bytesToSkip);
+            offset -= bytesToSkip;
+        } while (offset > 0);
+    } else if (offset < 0) {
+        // When seeking backwards, an operation that is only allowed for
+        // random-access devices, the buffer is cleared. The next read
+        // operation will then refill the buffer. We can optimize this, if we
+        // find that seeking backwards becomes a significant performance hit.
+        d->buffer.clear();
+    }
+#if defined QIODEVICE_DEBUG
+    printf("%p \tafter: d->pos == %d, d->buffer.size() == %d\n", this, int(d->pos),
+           d->buffer.size());
+#endif
+    return true;
+}
+
+/*!
+    Returns true if the current read and write position is at the end
+    of the device (i.e. there is no more data available for reading on
+    the device); otherwise returns false.
+
+    For some devices, atEnd() can return true even though there is more data
+    to read. This special case only applies to devices that generate data in
+    direct response to you calling read() (e.g., \c /dev or \c /proc files on
+    Unix and Mac OS X, or console input / \c stdin on all platforms).
+
+    \sa bytesAvailable(), read(), isSequential()
+*/
+bool QIODevice::atEnd() const
+{
+    Q_D(const QIODevice);
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::atEnd() returns %s, d->openMode == %d, d->pos == %d\n", this, (d->openMode == NotOpen || d->pos == size()) ? "true" : "false",
+           int(d->openMode), int(d->pos));
+#endif
+    return d->openMode == NotOpen || (d->buffer.isEmpty() && bytesAvailable() == 0);
+}
+
+/*!
+    Seeks to the start of input for random-access devices. Returns
+    true on success; otherwise returns false (for example, if the
+    device is not open).
+
+    Note that when using a QTextStream on a QFile, calling reset() on
+    the QFile will not have the expected result because QTextStream
+    buffers the file. Use the QTextStream::seek() function instead.
+
+    \sa seek()
+*/
+bool QIODevice::reset()
+{
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::reset()\n", this);
+#endif
+    return seek(0);
+}
+
+/*!
+    Returns the number of bytes that are available for reading. This
+    function is commonly used with sequential devices to determine the
+    number of bytes to allocate in a buffer before reading.
+
+    Subclasses that reimplement this function must call the base
+    implementation in order to include the size of QIODevices' buffer. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qiodevice.cpp 1
+
+    \sa bytesToWrite(), readyRead(), isSequential()
+*/
+qint64 QIODevice::bytesAvailable() const
+{
+    Q_D(const QIODevice);
+    if (!d->isSequential())
+        return qMax(size() - d->pos, qint64(0));
+    return d->buffer.size();
+}
+
+/*!
+    For buffered devices, this function returns the number of bytes
+    waiting to be written. For devices with no buffer, this function
+    returns 0.
+
+    \sa bytesAvailable(), bytesWritten(), isSequential()
+*/
+qint64 QIODevice::bytesToWrite() const
+{
+    return qint64(0);
+}
+
+/*!
+    Reads at most \a maxSize bytes from the device into \a data, and
+    returns the number of bytes read. If an error occurs, such as when
+    attempting to read from a device opened in WriteOnly mode, this
+    function returns -1.
+
+    0 is returned when no more data is available for reading. However,
+    reading past the end of the stream is considered an error, so this
+    function returns -1 in those cases (that is, reading on a closed
+    socket or after a process has died).
+
+    \sa readData() readLine() write()
+*/
+qint64 QIODevice::read(char *data, qint64 maxSize)
+{
+    Q_D(QIODevice);
+    CHECK_READABLE(read, qint64(-1));
+    CHECK_MAXLEN(read, qint64(-1));
+
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::read(%p, %d), d->pos = %d, d->buffer.size() = %d\n",
+           this, data, int(maxSize), int(d->pos), int(d->buffer.size()));
+#endif
+    const bool sequential = d->isSequential();
+
+    // Short circuit for getChar()
+    if (maxSize == 1) {
+        int chint = d->buffer.getChar();
+        if (chint != -1) {
+            char c = char(uchar(chint));
+            if (c == '\r' && (d->openMode & Text)) {
+                d->buffer.ungetChar(c);
+            } else {
+                if (data)
+                    *data = c;
+                if (!sequential)
+                    ++d->pos;
+#if defined QIODEVICE_DEBUG
+                printf("%p \tread 0x%hhx (%c) returning 1 (shortcut)\n", this,
+                       int(c), isprint(c) ? c : '?');
+#endif
+                return qint64(1);
+            }
+        }
+    }
+
+    qint64 readSoFar = 0;
+    bool moreToRead = true;
+    do {
+        int lastReadChunkSize = 0;
+
+        // Try reading from the buffer.
+        if (!d->buffer.isEmpty()) {
+            lastReadChunkSize = d->buffer.read(data + readSoFar, maxSize - readSoFar);
+            readSoFar += lastReadChunkSize;
+            if (!sequential)
+                d->pos += lastReadChunkSize;
+#if defined QIODEVICE_DEBUG
+            printf("%p \treading %d bytes from buffer into position %d\n", this, lastReadChunkSize,
+                   int(readSoFar) - lastReadChunkSize);
+#endif
+        } else if ((d->openMode & Unbuffered) == 0 && maxSize < QIODEVICE_BUFFERSIZE) {
+            // In buffered mode, we try to fill up the QIODevice buffer before
+            // we do anything else.
+            int bytesToBuffer = qMax(maxSize - readSoFar, QIODEVICE_BUFFERSIZE);
+            char *writePointer = d->buffer.reserve(bytesToBuffer);
+
+            // Make sure the device is positioned correctly.
+            if (d->pos != d->devicePos && !sequential && !seek(d->pos))
+                return qint64(-1);
+            qint64 readFromDevice = readData(writePointer, bytesToBuffer);
+            d->buffer.chop(bytesToBuffer - (readFromDevice < 0 ? 0 : int(readFromDevice)));
+
+            if (readFromDevice > 0) {
+                if (!sequential)
+                    d->devicePos += readFromDevice;
+#if defined QIODEVICE_DEBUG
+                printf("%p \treading %d from device into buffer\n", this, int(readFromDevice));
+#endif
+
+                if (readFromDevice < bytesToBuffer)
+                    d->buffer.truncate(readFromDevice < 0 ? 0 : int(readFromDevice));
+                if (!d->buffer.isEmpty()) {
+                    lastReadChunkSize = d->buffer.read(data + readSoFar, maxSize - readSoFar);
+                    readSoFar += lastReadChunkSize;
+                    if (!sequential)
+                        d->pos += lastReadChunkSize;
+#if defined QIODEVICE_DEBUG
+                    printf("%p \treading %d bytes from buffer at position %d\n", this,
+                           lastReadChunkSize, int(readSoFar));
+#endif
+                }
+            }
+        }
+
+        // If we need more, try reading from the device.
+        if (readSoFar < maxSize) {
+            // Make sure the device is positioned correctly.
+            if (d->pos != d->devicePos && !sequential && !seek(d->pos))
+                return qint64(-1);
+            qint64 readFromDevice = readData(data + readSoFar, maxSize - readSoFar);
+#if defined QIODEVICE_DEBUG
+            printf("%p \treading %d bytes from device (total %d)\n", this, int(readFromDevice), int(readSoFar));
+#endif
+            if (readFromDevice == -1 && readSoFar == 0) {
+                // error and we haven't read anything: return immediately
+                return -1;
+            }
+            if (readFromDevice <= 0) {
+                moreToRead = false;
+            } else {
+                // see if we read as much data as we asked for
+                if (readFromDevice < maxSize - readSoFar)
+                    moreToRead = false;
+
+                lastReadChunkSize += int(readFromDevice);
+                readSoFar += readFromDevice;
+                if (!sequential) {
+                    d->pos += readFromDevice;
+                    d->devicePos += readFromDevice;
+                }
+            }
+        } else {
+            moreToRead = false;
+        }
+
+        if (readSoFar && d->openMode & Text) {
+            char *readPtr = data + readSoFar - lastReadChunkSize;
+            const char *endPtr = data + readSoFar;
+
+            if (readPtr < endPtr) {
+                // optimization to avoid initial self-assignment
+                while (*readPtr != '\r') {
+                    if (++readPtr == endPtr)
+                        return readSoFar;
+                }
+
+                char *writePtr = readPtr;
+
+                while (readPtr < endPtr) {
+                    char ch = *readPtr++;
+                    if (ch != '\r')
+                        *writePtr++ = ch;
+                    else
+                        --readSoFar;
+                }
+
+                // Make sure we get more data if there is room for more. This
+                // is very important for when someone seeks to the start of a
+                // '\r\n' and reads one character - they should get the '\n'.
+                moreToRead = (readPtr != writePtr);
+            }
+        }
+    } while (moreToRead);
+
+#if defined QIODEVICE_DEBUG
+    printf("%p \treturning %d, d->pos == %d, d->buffer.size() == %d\n", this,
+           int(readSoFar), int(d->pos), d->buffer.size());
+    debugBinaryString(data, readSoFar);
+#endif
+    return readSoFar;
+}
+
+/*!
+    \overload
+
+    Reads at most \a maxSize bytes from the device, and returns the
+    data read as a QByteArray.
+
+    This function has no way of reporting errors; returning an empty
+    QByteArray() can mean either that no data was currently available
+    for reading, or that an error occurred.
+*/
+QByteArray QIODevice::read(qint64 maxSize)
+{
+    Q_D(QIODevice);
+    CHECK_MAXLEN(read, QByteArray());
+    QByteArray tmp;
+    qint64 readSoFar = 0;
+    char buffer[4096];
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::read(%d), d->pos = %d, d->buffer.size() = %d\n",
+           this, int(maxSize), int(d->pos), int(d->buffer.size()));
+#else
+    Q_UNUSED(d);
+#endif
+
+    do {
+        qint64 bytesToRead = qMin(int(maxSize - readSoFar), int(sizeof(buffer)));
+        qint64 readBytes = read(buffer, bytesToRead);
+        if (readBytes <= 0)
+            break;
+        tmp.append(buffer, (int) readBytes);
+        readSoFar += readBytes;
+    } while (readSoFar < maxSize && bytesAvailable() > 0);
+
+    return tmp;
+}
+
+/*!
+    \overload
+
+    Reads all available data from the device, and returns it as a
+    QByteArray.
+
+    This function has no way of reporting errors; returning an empty
+    QByteArray() can mean either that no data was currently available
+    for reading, or that an error occurred.
+*/
+QByteArray QIODevice::readAll()
+{
+    Q_D(QIODevice);
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::readAll(), d->pos = %d, d->buffer.size() = %d\n",
+           this, int(d->pos), int(d->buffer.size()));
+#endif
+
+    QByteArray tmp;
+    if (d->isSequential() || size() == 0) {
+        // Read it in chunks, bytesAvailable() is unreliable for sequential
+        // devices.
+        const int chunkSize = 4096;
+        qint64 totalRead = 0;
+        forever {
+            tmp.resize(tmp.size() + chunkSize);
+            qint64 readBytes = read(tmp.data() + totalRead, chunkSize);
+            tmp.chop(chunkSize - (readBytes < 0 ? 0 : readBytes));
+            if (readBytes <= 0)
+                return tmp;
+            totalRead += readBytes;
+        }
+    } else {
+        // Read it all in one go.
+        tmp.resize(int(bytesAvailable()));
+        qint64 readBytes = read(tmp.data(), tmp.size());
+        tmp.resize(readBytes < 0 ? 0 : int(readBytes));
+    }
+    return tmp;
+}
+
+/*!
+    This function reads a line of ASCII characters from the device, up
+    to a maximum of \a maxSize - 1 bytes, stores the characters in \a
+    data, and returns the number of bytes read. If a line could not be
+    read but no error ocurred, this function returns 0. If an error
+    occurs, this function returns what it could the length of what
+    could be read, or -1 if nothing was read.
+
+    A terminating '\0' byte is always appended to \a data, so \a
+    maxSize must be larger than 1.
+
+    Data is read until either of the following conditions are met:
+
+    \list
+    \o The first '\n' character is read.
+    \o \a maxSize - 1 bytes are read.
+    \o The end of the device data is detected.
+    \endlist
+
+    For example, the following code reads a line of characters from a
+    file:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qiodevice.cpp 2
+
+    The newline character ('\n') is included in the buffer. If a
+    newline is not encountered before maxSize - 1 bytes are read, a
+    newline will not be inserted into the buffer. On windows newline
+    characters are replaced with '\n'.
+
+    This function calls readLineData(), which is implemented using
+    repeated calls to getChar(). You can provide a more efficient
+    implementation by reimplementing readLineData() in your own
+    subclass.
+
+    \sa getChar(), read(), write()
+*/
+qint64 QIODevice::readLine(char *data, qint64 maxSize)
+{
+    Q_D(QIODevice);
+    if (maxSize < 2) {
+        qWarning("QIODevice::readLine: Called with maxSize < 2");
+        return qint64(-1);
+    }
+
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::readLine(%p, %d), d->pos = %d, d->buffer.size() = %d\n",
+           this, data, int(maxSize), int(d->pos), int(d->buffer.size()));
+#endif
+
+    // Leave room for a '\0'
+    --maxSize;
+
+    const bool sequential = d->isSequential();
+
+    qint64 readSoFar = 0;
+    if (!d->buffer.isEmpty()) {
+        readSoFar = d->buffer.readLine(data, maxSize);
+        if (!sequential)
+            d->pos += readSoFar;
+#if defined QIODEVICE_DEBUG
+        printf("%p \tread from buffer: %d bytes, last character read: %hhx\n", this,
+               int(readSoFar), data[int(readSoFar) - 1]);
+        if (readSoFar)
+            debugBinaryString(data, int(readSoFar));
+#endif
+        if (readSoFar && data[readSoFar - 1] == '\n') {
+            if (d->openMode & Text) {
+                // QRingBuffer::readLine() isn't Text aware.
+                if (readSoFar > 1 && data[readSoFar - 2] == '\r') {
+                    --readSoFar;
+                    data[readSoFar - 1] = '\n';
+                }
+            }
+            data[readSoFar] = '\0';
+            return readSoFar;
+        }
+    }
+
+    if (d->pos != d->devicePos && !sequential && !seek(d->pos))
+        return qint64(-1);
+    d->baseReadLineDataCalled = false;
+    qint64 readBytes = readLineData(data + readSoFar, maxSize - readSoFar);
+#if defined QIODEVICE_DEBUG
+    printf("%p \tread from readLineData: %d bytes, readSoFar = %d bytes\n", this,
+           int(readBytes), int(readSoFar));
+    if (readBytes > 0) {
+        debugBinaryString(data, int(readSoFar + readBytes));
+    }
+#endif
+    if (readBytes < 0) {
+        data[readSoFar] = '\0';
+        return readSoFar ? readSoFar : -1;
+    }
+    readSoFar += readBytes;
+    if (!d->baseReadLineDataCalled && !sequential) {
+        d->pos += readBytes;
+        // If the base implementation was not called, then we must
+        // assume the device position is invalid and force a seek.
+        d->devicePos = qint64(-1);
+    }
+    data[readSoFar] = '\0';
+
+    if (d->openMode & Text) {
+        if (readSoFar > 1 && data[readSoFar - 1] == '\n' && data[readSoFar - 2] == '\r') {
+            data[readSoFar - 2] = '\n';
+            data[readSoFar - 1] = '\0';
+            --readSoFar;
+        }
+    }
+
+#if defined QIODEVICE_DEBUG
+    printf("%p \treturning %d, d->pos = %d, d->buffer.size() = %d, size() = %d\n",
+           this, int(readSoFar), int(d->pos), d->buffer.size(), int(size()));
+    debugBinaryString(data, int(readSoFar));
+#endif
+    return readSoFar;
+}
+
+/*!
+    \overload
+
+    Reads a line from the device, but no more than \a maxSize characters,
+    and returns the result as a QByteArray.
+
+    This function has no way of reporting errors; returning an empty
+    QByteArray() can mean either that no data was currently available
+    for reading, or that an error occurred.
+*/
+QByteArray QIODevice::readLine(qint64 maxSize)
+{
+    Q_D(QIODevice);
+    CHECK_MAXLEN(readLine, QByteArray());
+    QByteArray tmp;
+    const int BufferGrowth = 4096;
+    qint64 readSoFar = 0;
+    qint64 readBytes = 0;
+
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::readLine(%d), d->pos = %d, d->buffer.size() = %d\n",
+           this, int(maxSize), int(d->pos), int(d->buffer.size()));
+#else
+    Q_UNUSED(d);
+#endif
+
+    do {
+        if (maxSize != 0)
+            tmp.resize(int(readSoFar + qMin(int(maxSize), BufferGrowth)));
+        else
+            tmp.resize(int(readSoFar + BufferGrowth));
+        readBytes = readLine(tmp.data() + readSoFar, tmp.size() - readSoFar);
+        if (readBytes <= 0)
+            break;
+
+        readSoFar += readBytes;
+    } while ((!maxSize || readSoFar < maxSize) &&
+             readSoFar + 1 == tmp.size() &&   // +1 due to the ending null
+             tmp.at(readSoFar - 1) != '\n');
+
+    if (readSoFar == 0 && readBytes == -1)
+        tmp.clear();            // return Null if we found an error
+    else
+        tmp.resize(int(readSoFar));
+    return tmp;
+}
+
+/*!
+    Reads up to \a maxSize characters into \a data and returns the
+    number of characters read.
+
+    This function is called by readLine(), and provides its base
+    implementation, using getChar(). Buffered devices can improve the
+    performance of readLine() by reimplementing this function.
+
+    readLine() appends a '\0' byte to \a data; readLineData() does not
+    need to do this.
+
+    If you reimplement this function, be careful to return the correct
+    value: it should return the number of bytes read in this line,
+    including the terminating newline, or 0 if there is no line to be
+    read at this point. If an error occurs, it should return -1 if and
+    only if no bytes were read. Reading past EOF is considered an error.
+*/
+qint64 QIODevice::readLineData(char *data, qint64 maxSize)
+{
+    Q_D(QIODevice);
+    qint64 readSoFar = 0;
+    char c;
+    int lastReadReturn = 0;
+    d->baseReadLineDataCalled = true;
+
+    while (readSoFar < maxSize && (lastReadReturn = read(&c, 1)) == 1) {
+        *data++ = c;
+        ++readSoFar;
+        if (c == '\n')
+            break;
+    }
+
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::readLineData(%p, %d), d->pos = %d, d->buffer.size() = %d, returns %d\n",
+           this, data, int(maxSize), int(d->pos), int(d->buffer.size()), int(readSoFar));
+#endif
+    if (lastReadReturn != 1 && readSoFar == 0)
+        return isSequential() ? lastReadReturn : -1;
+    return readSoFar;
+}
+
+/*!
+    Returns true if a complete line of data can be read from the device;
+    otherwise returns false.
+
+    Note that unbuffered devices, which have no way of determining what
+    can be read, always return false.
+
+    This function is often called in conjunction with the readyRead()
+    signal.
+
+    Subclasses that reimplement this function must call the base
+    implementation in order to include the contents of the QIODevice's buffer. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qiodevice.cpp 3
+
+    \sa readyRead(), readLine()
+*/
+bool QIODevice::canReadLine() const
+{
+    return d_func()->buffer.canReadLine();
+}
+
+/*!
+    Writes at most \a maxSize bytes of data from \a data to the
+    device. Returns the number of bytes that were actually written, or
+    -1 if an error occurred.
+
+    \sa read() writeData()
+*/
+qint64 QIODevice::write(const char *data, qint64 maxSize)
+{
+    Q_D(QIODevice);
+    CHECK_WRITABLE(write, qint64(-1));
+    CHECK_MAXLEN(write, qint64(-1));
+
+    const bool sequential = d->isSequential();
+    // Make sure the device is positioned correctly.
+    if (d->pos != d->devicePos && !sequential && !seek(d->pos))
+        return qint64(-1);
+
+#ifdef Q_OS_WIN
+    if (d->openMode & Text) {
+        const char *endOfData = data + maxSize;
+        const char *startOfBlock = data;
+
+        qint64 writtenSoFar = 0;
+
+        forever {
+            const char *endOfBlock = startOfBlock;
+            while (endOfBlock < endOfData && *endOfBlock != '\n')
+                ++endOfBlock;
+
+            qint64 blockSize = endOfBlock - startOfBlock;
+            if (blockSize > 0) {
+                qint64 ret = writeData(startOfBlock, blockSize);
+                if (ret <= 0) {
+                    if (writtenSoFar && !sequential)
+                        d->buffer.skip(writtenSoFar);
+                    return writtenSoFar ? writtenSoFar : ret;
+                }
+                if (!sequential) {
+                    d->pos += ret;
+                    d->devicePos += ret;
+                }
+                writtenSoFar += ret;
+            }
+
+            if (endOfBlock == endOfData)
+                break;
+
+            qint64 ret = writeData("\r\n", 2);
+            if (ret <= 0) {
+                if (writtenSoFar && !sequential)
+                    d->buffer.skip(writtenSoFar);
+                return writtenSoFar ? writtenSoFar : ret;
+            }
+            if (!sequential) {
+                d->pos += ret;
+                d->devicePos += ret;
+            }
+            ++writtenSoFar;
+
+            startOfBlock = endOfBlock + 1;
+        }
+
+        if (writtenSoFar && !sequential)
+            d->buffer.skip(writtenSoFar);
+        return writtenSoFar;
+    }
+#endif
+
+    qint64 written = writeData(data, maxSize);
+    if (written > 0) {
+        if (!sequential) {
+            d->pos += written;
+            d->devicePos += written;
+        }
+        if (!d->buffer.isEmpty() && !sequential)
+            d->buffer.skip(written);
+    }
+    return written;
+}
+
+/*!
+    \since 4.5
+
+    \overload
+ 
+    Writes data from a zero-terminated string of 8-bit characters to the
+    device. Returns the number of bytes that were actually written, or
+    -1 if an error occurred. This is equivalent to
+    \code
+    ...
+    QIODevice::write(data, qstrlen(data));
+    ...
+    \endcode
+
+    \sa read() writeData()
+*/
+qint64 QIODevice::write(const char *data)
+{
+    return write(data, qstrlen(data));
+}
+
+/*! \fn qint64 QIODevice::write(const QByteArray &byteArray)
+
+    \overload
+
+    Writes the content of \a byteArray to the device. Returns the number of
+    bytes that were actually written, or -1 if an error occurred.
+
+    \sa read() writeData()
+*/
+
+/*!
+    Puts the character \a c back into the device, and decrements the
+    current position unless the position is 0. This function is
+    usually called to "undo" a getChar() operation, such as when
+    writing a backtracking parser.
+
+    If \a c was not previously read from the device, the behavior is
+    undefined.
+*/
+void QIODevice::ungetChar(char c)
+{
+    Q_D(QIODevice);
+    CHECK_READABLE(read, Q_VOID);
+
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevice::ungetChar(0x%hhx '%c')\n", this, c, isprint(c) ? c : '?');
+#endif
+
+    d->buffer.ungetChar(c);
+    if (!d->isSequential())
+        --d->pos;
+}
+
+/*! \fn bool QIODevice::putChar(char c)
+
+    Writes the character \a c to the device. Returns true on success;
+    otherwise returns false.
+
+    \sa write() getChar() ungetChar()
+*/
+bool QIODevice::putChar(char c)
+{
+    return d_func()->putCharHelper(c);
+}
+
+/*!
+    \internal
+*/
+bool QIODevicePrivate::putCharHelper(char c)
+{
+    return q_func()->write(&c, 1) == 1;
+}
+
+/*! \fn bool QIODevice::getChar(char *c)
+
+    Reads one character from the device and stores it in \a c. If \a c
+    is 0, the character is discarded. Returns true on success;
+    otherwise returns false.
+
+    \sa read() putChar() ungetChar()
+*/
+bool QIODevice::getChar(char *c)
+{
+    Q_D(QIODevice);
+    const OpenMode openMode = d->openMode;
+    if (!(openMode & ReadOnly)) {
+        if (openMode == NotOpen)
+            qWarning("QIODevice::getChar: Closed device");
+        else
+            qWarning("QIODevice::getChar: WriteOnly device");
+        return false;
+    }
+
+    // Shortcut for QIODevice::read(c, 1)
+    QRingBuffer *buffer = &d->buffer;
+    const int chint = buffer->getChar();
+    if (chint != -1) {
+        char ch = char(uchar(chint));
+        if ((openMode & Text) && ch == '\r') {
+            buffer->ungetChar(ch);
+        } else {
+            if (c)
+                *c = ch;
+            if (!d->isSequential())
+                ++d->pos;
+            return true;
+        }
+    }
+
+    // Fall back to read().
+    char ch;
+    if (read(&ch, 1) == 1) {
+        if (c)
+            *c = ch;
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \since 4.1
+
+    Reads at most \a maxSize bytes from the device into \a data, without side
+    effects (i.e., if you call read() after peek(), you will get the same
+    data).  Returns the number of bytes read. If an error occurs, such as
+    when attempting to peek a device opened in WriteOnly mode, this function
+    returns -1.
+
+    0 is returned when no more data is available for reading.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qiodevice.cpp 4
+
+    \sa read()
+*/
+qint64 QIODevice::peek(char *data, qint64 maxSize)
+{
+    qint64 readBytes = read(data, maxSize);
+    int i = readBytes;
+    while (i > 0)
+        ungetChar(data[i-- - 1]);
+    return readBytes;
+}
+
+/*!
+    \since 4.1
+    \overload
+
+    Peeks at most \a maxSize bytes from the device, returning the data peeked
+    as a QByteArray.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qiodevice.cpp 5
+
+    This function has no way of reporting errors; returning an empty
+    QByteArray() can mean either that no data was currently available
+    for peeking, or that an error occurred.
+
+    \sa read()
+*/
+QByteArray QIODevice::peek(qint64 maxSize)
+{
+    QByteArray result = read(maxSize);
+    int i = result.size();
+    const char *data = result.constData();
+    while (i > 0)
+        ungetChar(data[i-- - 1]);
+    return result;
+}
+
+/*!
+    Blocks until data is available for reading and the readyRead()
+    signal has been emitted, or until \a msecs milliseconds have
+    passed. If msecs is -1, this function will not time out.
+
+    Returns true if data is available for reading; otherwise returns
+    false (if the operation timed out or if an error occurred).
+
+    This function can operate without an event loop. It is
+    useful when writing non-GUI applications and when performing
+    I/O operations in a non-GUI thread.
+
+    If called from within a slot connected to the readyRead() signal,
+    readyRead() will not be reemitted.
+
+    Reimplement this function to provide a blocking API for a custom
+    device. The default implementation does nothing, and returns false.
+
+    \warning Calling this function from the main (GUI) thread
+    might cause your user interface to freeze.
+
+    \sa waitForBytesWritten()
+*/
+bool QIODevice::waitForReadyRead(int msecs)
+{
+    Q_UNUSED(msecs);
+    return false;
+}
+
+/*!
+    For buffered devices, this function waits until a payload of
+    buffered written data has been written to the device and the
+    bytesWritten() signal has been emitted, or until \a msecs
+    milliseconds have passed. If msecs is -1, this function will
+    not time out. For unbuffered devices, it returns immediately.
+
+    Returns true if a payload of data was written to the device;
+    otherwise returns false (i.e. if the operation timed out, or if an
+    error occurred).
+
+    This function can operate without an event loop. It is
+    useful when writing non-GUI applications and when performing
+    I/O operations in a non-GUI thread.
+
+    If called from within a slot connected to the bytesWritten() signal,
+    bytesWritten() will not be reemitted.
+
+    Reimplement this function to provide a blocking API for a custom
+    device. The default implementation does nothing, and returns false.
+
+    \warning Calling this function from the main (GUI) thread
+    might cause your user interface to freeze.
+
+    \sa waitForReadyRead()
+*/
+bool QIODevice::waitForBytesWritten(int msecs)
+{
+    Q_UNUSED(msecs);
+    return false;
+}
+
+/*!
+    Sets the human readable description of the last device error that
+    occurred to \a str.
+
+    \sa errorString()
+*/
+void QIODevice::setErrorString(const QString &str)
+{
+    d_func()->errorString = str;
+}
+
+/*!
+    Returns a human-readable description of the last device error that
+    occurred.
+
+    \sa setErrorString()
+*/
+QString QIODevice::errorString() const
+{
+    Q_D(const QIODevice);
+    if (d->errorString.isEmpty()) {
+#ifdef QT_NO_QOBJECT
+        return QLatin1String(QT_TRANSLATE_NOOP(QIODevice, "Unknown error"));
+#else
+        return tr("Unknown error");
+#endif
+    }
+    return d->errorString;
+}
+
+/*!
+    \fn qint64 QIODevice::readData(char *data, qint64 maxSize)
+
+    Reads up to \a maxSize bytes from the device into \a data, and
+    returns the number of bytes read or -1 if an error occurred. If
+    there are no bytes to be read, this function should return -1 if
+    there can never be more bytes available (for example: socket
+    closed, pipe closed, sub-process finished).
+
+    This function is called by QIODevice. Reimplement this function
+    when creating a subclass of QIODevice.
+
+    \sa read() readLine() writeData()
+*/
+
+/*!
+    \fn qint64 QIODevice::writeData(const char *data, qint64 maxSize)
+
+    Writes up to \a maxSize bytes from \a data to the device. Returns
+    the number of bytes written, or -1 if an error occurred.
+
+    This function is called by QIODevice. Reimplement this function
+    when creating a subclass of QIODevice.
+
+    \sa read() write()
+*/
+
+/*!
+    \fn QIODevice::Offset QIODevice::status() const
+
+    For device specific error handling, please refer to the
+    individual device documentation.
+
+    \sa qobject_cast()
+*/
+
+/*!
+    \fn QIODevice::Offset QIODevice::at() const
+
+    Use pos() instead.
+*/
+
+/*!
+    \fn bool QIODevice::at(Offset offset)
+
+    Use seek(\a offset) instead.
+*/
+
+/*! \fn int QIODevice::flags() const
+
+    Use openMode() instead.
+*/
+
+/*! \fn int QIODevice::getch()
+
+    Use getChar() instead.
+*/
+
+/*!
+    \fn bool QIODevice::isAsynchronous() const
+
+    This functionality is no longer available. This function always
+    returns true.
+*/
+
+/*!
+    \fn bool QIODevice::isBuffered() const
+
+    Use !(openMode() & QIODevice::Unbuffered) instead.
+*/
+
+/*!
+    \fn bool QIODevice::isCombinedAccess() const
+
+    Use openMode() instead.
+*/
+
+/*!
+    \fn bool QIODevice::isDirectAccess() const
+
+    Use !isSequential() instead.
+*/
+
+/*!
+    \fn bool QIODevice::isInactive() const
+
+    Use isOpen(), isReadable(), or isWritable() instead.
+*/
+
+/*!
+    \fn bool QIODevice::isRaw() const
+
+    Use openMode() instead.
+*/
+
+/*!
+    \fn bool QIODevice::isSequentialAccess() const
+
+    Use isSequential() instead.
+*/
+
+/*!
+    \fn bool QIODevice::isSynchronous() const
+
+    This functionality is no longer available. This function always
+    returns false.
+*/
+
+/*!
+    \fn bool QIODevice::isTranslated() const
+
+    Use openMode() instead.
+*/
+
+/*!
+    \fn bool QIODevice::mode() const
+
+    Use openMode() instead.
+*/
+
+/*! \fn int QIODevice::putch(int ch)
+
+    Use putChar(\a ch) instead.
+*/
+
+/*! \fn int QIODevice::ungetch(int ch)
+
+    Use ungetChar(\a ch) instead.
+*/
+
+/*!
+    \fn quint64 QIODevice::readBlock(char *data, quint64 size)
+
+    Use read(\a data, \a size) instead.
+*/
+
+/*! \fn int QIODevice::state() const
+
+    Use isOpen() instead.
+*/
+
+/*!
+    \fn qint64 QIODevice::writeBlock(const char *data, quint64 size)
+
+    Use write(\a data, \a size) instead.
+*/
+
+/*!
+    \fn qint64 QIODevice::writeBlock(const QByteArray &data)
+
+    Use write(\a data) instead.
+*/
+
+#if defined QT3_SUPPORT
+QIODevice::Status QIODevice::status() const
+{
+#if !defined(QT_NO_QOBJECT)
+    const QFile *f = qobject_cast<const QFile *>(this);
+    if (f) return (int) f->error();
+#endif
+    return isOpen() ? 0 /* IO_Ok */ : 8 /* IO_UnspecifiedError */;
+}
+
+/*!
+    For device specific error handling, please refer to the
+    individual device documentation.
+
+    \sa qobject_cast()
+*/
+void QIODevice::resetStatus()
+{
+#if !defined(QT_NO_QOBJECT)
+    QFile *f = qobject_cast<QFile *>(this);
+    if (f) f->unsetError();
+#endif
+}
+#endif
+
+#if !defined(QT_NO_DEBUG_STREAM)
+QDebug operator<<(QDebug debug, QIODevice::OpenMode modes)
+{
+    debug << "OpenMode(";
+    QStringList modeList;
+    if (modes == QIODevice::NotOpen) {
+        modeList << QLatin1String("NotOpen");
+    } else {
+        if (modes & QIODevice::ReadOnly)
+            modeList << QLatin1String("ReadOnly");
+        if (modes & QIODevice::WriteOnly)
+            modeList << QLatin1String("WriteOnly");
+        if (modes & QIODevice::Append)
+            modeList << QLatin1String("Append");
+        if (modes & QIODevice::Truncate)
+            modeList << QLatin1String("Truncate");
+        if (modes & QIODevice::Text)
+            modeList << QLatin1String("Text");
+        if (modes & QIODevice::Unbuffered)
+            modeList << QLatin1String("Unbuffered");
+    }
+    qSort(modeList);
+    debug << modeList.join(QLatin1String("|"));
+    debug << ")";
+    return debug;
+}
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qiodevice.h b/src/corelib/io/qiodevice.h
new file mode 100644
index 0000000..76d47ca
--- /dev/null
+++ b/src/corelib/io/qiodevice.h
@@ -0,0 +1,253 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIODEVICE_H
+#define QIODEVICE_H
+
+#ifndef QT_NO_QOBJECT
+#include <QtCore/qobject.h>
+#else
+#include <QtCore/qobjectdefs.h>
+#endif
+#include <QtCore/qstring.h>
+
+#ifdef open
+#error qiodevice.h must be included before any header file that defines open
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QByteArray;
+class QIODevicePrivate;
+
+class Q_CORE_EXPORT QIODevice
+#ifndef QT_NO_QOBJECT
+    : public QObject
+#endif
+{
+#ifndef QT_NO_QOBJECT
+    Q_OBJECT
+#endif
+public:
+    enum OpenModeFlag {
+        NotOpen = 0x0000,
+        ReadOnly = 0x0001,
+        WriteOnly = 0x0002,
+        ReadWrite = ReadOnly | WriteOnly,
+        Append = 0x0004,
+        Truncate = 0x0008,
+        Text = 0x0010,
+        Unbuffered = 0x0020
+    };
+    Q_DECLARE_FLAGS(OpenMode, OpenModeFlag)
+
+    QIODevice();
+#ifndef QT_NO_QOBJECT
+    explicit QIODevice(QObject *parent);
+#endif
+    virtual ~QIODevice();
+
+    OpenMode openMode() const;
+
+    void setTextModeEnabled(bool enabled);
+    bool isTextModeEnabled() const;
+
+    bool isOpen() const;
+    bool isReadable() const;
+    bool isWritable() const;
+    virtual bool isSequential() const;
+
+    virtual bool open(OpenMode mode);
+    virtual void close();
+
+    // ### Qt 5: pos() and seek() should not be virtual, and
+    // ### seek() should call a virtual seekData() function.
+    virtual qint64 pos() const;
+    virtual qint64 size() const;
+    virtual bool seek(qint64 pos);
+    virtual bool atEnd() const;
+    virtual bool reset();
+
+    virtual qint64 bytesAvailable() const;
+    virtual qint64 bytesToWrite() const;
+
+    qint64 read(char *data, qint64 maxlen);
+    QByteArray read(qint64 maxlen);
+    QByteArray readAll();
+    qint64 readLine(char *data, qint64 maxlen);
+    QByteArray readLine(qint64 maxlen = 0);
+    virtual bool canReadLine() const;
+
+    qint64 write(const char *data, qint64 len);
+    qint64 write(const char *data);
+    inline qint64 write(const QByteArray &data)
+    { return write(data.constData(), data.size()); }
+
+    qint64 peek(char *data, qint64 maxlen);
+    QByteArray peek(qint64 maxlen);
+
+    virtual bool waitForReadyRead(int msecs);
+    virtual bool waitForBytesWritten(int msecs);
+
+    void ungetChar(char c);
+    bool putChar(char c);
+    bool getChar(char *c);
+
+    QString errorString() const;
+
+#ifndef QT_NO_QOBJECT
+Q_SIGNALS:
+    void readyRead();
+    void bytesWritten(qint64 bytes);
+    void aboutToClose();
+    void readChannelFinished();
+#endif
+
+protected:
+#ifdef QT_NO_QOBJECT
+    QIODevice(QIODevicePrivate &dd);
+#else
+    QIODevice(QIODevicePrivate &dd, QObject *parent = 0);
+#endif
+    virtual qint64 readData(char *data, qint64 maxlen) = 0;
+    virtual qint64 readLineData(char *data, qint64 maxlen);
+    virtual qint64 writeData(const char *data, qint64 len) = 0;
+
+    void setOpenMode(OpenMode openMode);
+
+    void setErrorString(const QString &errorString);
+
+#ifdef QT_NO_QOBJECT
+    QIODevicePrivate *d_ptr;
+#endif
+
+private:
+    Q_DECLARE_PRIVATE(QIODevice)
+    Q_DISABLE_COPY(QIODevice)
+
+#ifdef QT3_SUPPORT
+public:
+    typedef qint64 Offset;
+
+    inline QT3_SUPPORT int flags() const { return static_cast<int>(openMode()); }
+    inline QT3_SUPPORT int mode() const { return static_cast<int>(openMode()); }
+    inline QT3_SUPPORT int state() const;
+
+    inline QT3_SUPPORT bool isDirectAccess() const { return !isSequential(); }
+    inline QT3_SUPPORT bool isSequentialAccess() const { return isSequential(); }
+    inline QT3_SUPPORT bool isCombinedAccess() const { return false; }
+    inline QT3_SUPPORT bool isBuffered() const { return true; }
+    inline QT3_SUPPORT bool isRaw() const { return false; }
+    inline QT3_SUPPORT bool isSynchronous() const { return true; }
+    inline QT3_SUPPORT bool isAsynchronous() const { return false; }
+    inline QT3_SUPPORT bool isTranslated() const { return (openMode() & Text) != 0; }
+    inline QT3_SUPPORT bool isInactive() const { return !isOpen(); }
+
+    typedef int Status;
+    QT3_SUPPORT Status status() const;
+    QT3_SUPPORT void resetStatus();
+
+    inline QT3_SUPPORT Offset at() const { return pos(); }
+    inline QT3_SUPPORT bool at(Offset offset) { return seek(offset); }
+
+    inline QT3_SUPPORT qint64 readBlock(char *data, quint64 maxlen) { return read(data, maxlen); }
+    inline QT3_SUPPORT qint64 writeBlock(const char *data, quint64 len) { return write(data, len); }
+    inline QT3_SUPPORT qint64 writeBlock(const QByteArray &data) { return write(data); }
+
+    inline QT3_SUPPORT int getch() { char c; return getChar(&c) ? int(uchar(c)) : -1; }
+    inline QT3_SUPPORT int putch(int c) { return putChar(c) ? int(uchar(c)) : -1; }
+    inline QT3_SUPPORT int ungetch(int c) { ungetChar(uchar(c)); return c; }
+#endif
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QIODevice::OpenMode)
+
+#ifdef QT3_SUPPORT
+static QT3_SUPPORT_VARIABLE const uint IO_Direct = 0x0100;
+static QT3_SUPPORT_VARIABLE const uint IO_Sequential = 0x0200;
+static QT3_SUPPORT_VARIABLE const uint IO_Combined = 0x0300;
+static QT3_SUPPORT_VARIABLE const uint IO_TypeMask = 0x0300;
+
+static QT3_SUPPORT_VARIABLE const uint IO_Raw = 0x0000;
+static QT3_SUPPORT_VARIABLE const uint IO_Async = 0x0000;
+
+#define IO_ReadOnly QIODevice::ReadOnly
+#define IO_WriteOnly QIODevice::WriteOnly
+#define IO_ReadWrite QIODevice::ReadWrite
+#define IO_Append QIODevice::Append
+#define IO_Truncate QIODevice::Truncate
+#define IO_Translate QIODevice::Text
+#define IO_ModeMask 0x00ff
+
+static QT3_SUPPORT_VARIABLE const uint IO_Open = 0x1000;
+static QT3_SUPPORT_VARIABLE const uint IO_StateMask = 0xf000;
+
+static QT3_SUPPORT_VARIABLE const uint IO_Ok = 0;
+static QT3_SUPPORT_VARIABLE const uint IO_ReadError = 1;
+static QT3_SUPPORT_VARIABLE const uint IO_WriteError = 2;
+static QT3_SUPPORT_VARIABLE const uint IO_FatalError = 3;
+static QT3_SUPPORT_VARIABLE const uint IO_ResourceError = 4;
+static QT3_SUPPORT_VARIABLE const uint IO_OpenError = 5;
+static QT3_SUPPORT_VARIABLE const uint IO_ConnectError = 5;
+static QT3_SUPPORT_VARIABLE const uint IO_AbortError = 6;
+static QT3_SUPPORT_VARIABLE const uint IO_TimeOutError = 7;
+static QT3_SUPPORT_VARIABLE const uint IO_UnspecifiedError	= 8;
+
+inline QT3_SUPPORT int QIODevice::state() const
+{
+    return isOpen() ? 0x1000 : 0;
+}
+#endif
+
+#if !defined(QT_NO_DEBUG_STREAM)
+class QDebug;
+Q_CORE_EXPORT QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QIODEVICE_H
diff --git a/src/corelib/io/qiodevice_p.h b/src/corelib/io/qiodevice_p.h
new file mode 100644
index 0000000..b996225
--- /dev/null
+++ b/src/corelib/io/qiodevice_p.h
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIODEVICE_P_H
+#define QIODEVICE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qiodevice.h"
+#include "QtCore/qbytearray.h"
+#include "QtCore/qobjectdefs.h"
+#include "QtCore/qstring.h"
+#include "private/qringbuffer_p.h"
+#ifndef QT_NO_QOBJECT
+#include "private/qobject_p.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class Q_CORE_EXPORT QIODevicePrivate
+#ifndef QT_NO_QOBJECT
+    : public QObjectPrivate
+#endif
+{
+    Q_DECLARE_PUBLIC(QIODevice)
+
+public:
+    QIODevicePrivate();
+    virtual ~QIODevicePrivate();
+
+    QIODevice::OpenMode openMode;
+    QString errorString;
+
+    QRingBuffer buffer;
+    qint64 pos;
+    qint64 devicePos;
+    bool baseReadLineDataCalled;
+
+    virtual bool putCharHelper(char c);
+
+    enum AccessMode {
+        Unset,
+        Sequential,
+        RandomAccess
+    };
+    mutable AccessMode accessMode;
+    inline bool isSequential() const
+    {
+        if (accessMode == Unset)
+            accessMode = q_func()->isSequential() ? Sequential : RandomAccess;
+        return accessMode == Sequential;
+    }
+    
+
+#ifdef QT_NO_QOBJECT
+    QIODevice *q_ptr;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QIODEVICE_P_H
diff --git a/src/corelib/io/qprocess.cpp b/src/corelib/io/qprocess.cpp
new file mode 100644
index 0000000..759d473
--- /dev/null
+++ b/src/corelib/io/qprocess.cpp
@@ -0,0 +1,1918 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+//#define QPROCESS_DEBUG
+
+#if defined QPROCESS_DEBUG
+#include <qdebug.h>
+#include <qstring.h>
+#include <ctype.h>
+#if !defined(Q_OS_WINCE)
+#include <errno.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+/*
+    Returns a human readable representation of the first \a len
+    characters in \a data.
+*/
+static QByteArray qt_prettyDebug(const char *data, int len, int maxSize)
+{
+    if (!data) return "(null)";
+    QByteArray out;
+    for (int i = 0; i < len && i < maxSize; ++i) {
+        char c = data[i];
+        if (isprint(c)) {
+            out += c;
+        } else switch (c) {
+        case '\n': out += "\\n"; break;
+        case '\r': out += "\\r"; break;
+        case '\t': out += "\\t"; break;
+        default:
+            char buf[5];
+            qsnprintf(buf, sizeof(buf), "\\%3o", c);
+            buf[4] = '\0';
+            out += QByteArray(buf);
+        }
+    }
+
+    if (len < maxSize)
+        out += "...";
+
+    return out;
+}
+
+QT_END_NAMESPACE
+
+#endif
+
+#include "qprocess.h"
+#include "qprocess_p.h"
+
+#include <qbytearray.h>
+#include <qdatetime.h>
+#include <qcoreapplication.h>
+#include <qsocketnotifier.h>
+#include <qtimer.h>
+
+#ifdef Q_WS_WIN
+#include <private/qwineventnotifier_p.h>
+#endif
+
+#ifndef QT_NO_PROCESS
+
+QT_BEGIN_NAMESPACE
+
+static QHash<QString, QString> environmentHashFromList(const QStringList &environment)
+{
+    QHash<QString, QString> result;
+    QStringList::ConstIterator it = environment.constBegin(),
+                              end = environment.constEnd();
+    for ( ; it != end; ++it) {
+        int equals = it->indexOf(QLatin1Char('='));
+
+        QString name = *it;
+        QString value;
+        if (equals != -1) {
+            name.truncate(equals);
+#ifdef Q_OS_WIN
+            name = name.toUpper();
+#endif
+            value = it->mid(equals + 1);
+        }
+        result.insert(name, value);
+    }
+
+    return result;
+}
+
+void QProcessPrivate::Channel::clear()
+{
+    switch (type) {
+    case PipeSource:
+        Q_ASSERT(process);
+        process->stdinChannel.type = Normal;
+        process->stdinChannel.process = 0;
+        break;
+    case PipeSink:
+        Q_ASSERT(process);
+        process->stdoutChannel.type = Normal;
+        process->stdoutChannel.process = 0;
+        break;
+    }
+
+    type = Normal;
+    file.clear();
+    process = 0;
+}
+
+/*!
+    \class QProcess
+
+    \brief The QProcess class is used to start external programs and
+    to communicate with them.
+
+    \ingroup io
+    \ingroup misc
+    \mainclass
+    \reentrant
+
+    To start a process, pass the name and command line arguments of
+    the program you want to run as arguments to start(). For example:
+
+    \snippet doc/src/snippets/qprocess/qprocess-simpleexecution.cpp 0
+    \dots
+    \snippet doc/src/snippets/qprocess/qprocess-simpleexecution.cpp 1
+    \snippet doc/src/snippets/qprocess/qprocess-simpleexecution.cpp 2
+
+    QProcess then enters the \l Starting state, and when the program
+    has started, QProcess enters the \l Running state and emits
+    started().
+
+    QProcess allows you to treat a process as a sequential I/O
+    device. You can write to and read from the process just as you
+    would access a network connection using QTcpSocket. You can then
+    write to the process's standard input by calling write(), and
+    read the standard output by calling read(), readLine(), and
+    getChar(). Because it inherits QIODevice, QProcess can also be
+    used as an input source for QXmlReader, or for generating data to
+    be uploaded using QFtp.
+
+    \note On Windows CE, reading and writing to a process is not supported.
+
+    When the process exits, QProcess reenters the \l NotRunning state
+    (the initial state), and emits finished().
+
+    The finished() signal provides the exit code and exit status of
+    the process as arguments, and you can also call exitCode() to
+    obtain the exit code of the last process that finished, and
+    exitStatus() to obtain its exit status. If an error occurs at
+    any point in time, QProcess will emit the error() signal. You
+    can also call error() to find the type of error that occurred
+    last, and state() to find the current process state.
+
+    \section1 Communicating via Channels
+
+    Processes have two predefined output channels: The standard
+    output channel (\c stdout) supplies regular console output, and
+    the standard error channel (\c stderr) usually supplies the
+    errors that are printed by the process. These channels represent
+    two separate streams of data. You can toggle between them by
+    calling setReadChannel(). QProcess emits readyRead() when data is
+    available on the current read channel. It also emits
+    readyReadStandardOutput() when new standard output data is
+    available, and when new standard error data is available,
+    readyReadStandardError() is emitted. Instead of calling read(),
+    readLine(), or getChar(), you can explicitly read all data from
+    either of the two channels by calling readAllStandardOutput() or
+    readAllStandardError().
+
+    The terminology for the channels can be misleading. Be aware that
+    the process's output channels correspond to QProcess's
+    \e read channels, whereas the process's input channels correspond
+    to QProcess's \e write channels. This is because what we read
+    using QProcess is the process's output, and what we write becomes
+    the process's input.
+
+    QProcess can merge the two output channels, so that standard
+    output and standard error data from the running process both use
+    the standard output channel. Call setProcessChannelMode() with
+    MergedChannels before starting the process to activative
+    this feature. You also have the option of forwarding the output of
+    the running process to the calling, main process, by passing
+    ForwardedChannels as the argument.
+
+    Certain processes need special environment settings in order to
+    operate. You can set environment variables for your process by
+    calling setEnvironment(). To set a working directory, call
+    setWorkingDirectory(). By default, processes are run in the
+    current working directory of the calling process.
+
+    \section1 Synchronous Process API
+
+    QProcess provides a set of functions which allow it to be used
+    without an event loop, by suspending the calling thread until
+    certain signals are emitted:
+
+    \list
+    \o waitForStarted() blocks until the process has started.
+
+    \o waitForReadyRead() blocks until new data is
+    available for reading on the current read channel.
+
+    \o waitForBytesWritten() blocks until one payload of
+    data has been written to the process.
+
+    \o waitForFinished() blocks until the process has finished.
+    \endlist
+
+    Calling these functions from the main thread (the thread that
+    calls QApplication::exec()) may cause your user interface to
+    freeze.
+
+    The following example runs \c gzip to compress the string "Qt
+    rocks!", without an event loop:
+
+    \snippet doc/src/snippets/process/process.cpp 0
+
+    \section1 Notes for Windows Users 
+
+    Some Windows commands (for example, \c dir) are not provided by
+    separate applications, but by the command interpreter itself.
+    If you attempt to use QProcess to execute these commands directly,
+    it won't work. One possible solution is to execute the command
+    interpreter itself (\c{cmd.exe} on some Windows systems), and ask
+    the interpreter to execute the desired command.
+
+    \sa QBuffer, QFile, QTcpSocket
+*/
+
+/*!
+    \enum QProcess::ProcessChannel
+
+    This enum describes the process channels used by the running process.
+    Pass one of these values to setReadChannel() to set the
+    current read channel of QProcess.
+
+    \value StandardOutput The standard output (stdout) of the running
+           process.
+
+    \value StandardError The standard error (stderr) of the running
+           process.
+
+    \sa setReadChannel()
+*/
+
+/*!
+    \enum QProcess::ProcessChannelMode
+
+    This enum describes the process channel modes of QProcess. Pass
+    one of these values to setProcessChannelMode() to set the
+    current read channel mode.
+
+    \value SeparateChannels QProcess manages the output of the
+    running process, keeping standard output and standard error data
+    in separate internal buffers. You can select the QProcess's
+    current read channel by calling setReadChannel(). This is the
+    default channel mode of QProcess.
+
+    \value MergedChannels QProcess merges the output of the running
+    process into the standard output channel (\c stdout). The
+    standard error channel (\c stderr) will not receive any data. The
+    standard output and standard error data of the running process
+    are interleaved.
+
+    \value ForwardedChannels QProcess forwards the output of the
+    running process onto the main process. Anything the child process
+    writes to its standard output and standard error will be written
+    to the standard output and standard error of the main process.
+
+    \sa setReadChannelMode()
+*/
+
+/*!
+    \enum QProcess::ProcessError
+
+    This enum describes the different types of errors that are
+    reported by QProcess.
+
+    \value FailedToStart The process failed to start. Either the
+    invoked program is missing, or you may have insufficient
+    permissions to invoke the program.
+
+    \value Crashed The process crashed some time after starting
+    successfully.
+
+    \value Timedout The last waitFor...() function timed out. The
+    state of QProcess is unchanged, and you can try calling
+    waitFor...() again.
+
+    \value WriteError An error occurred when attempting to write to the
+    process. For example, the process may not be running, or it may
+    have closed its input channel.
+
+    \value ReadError An error occurred when attempting to read from
+    the process. For example, the process may not be running.
+
+    \value UnknownError An unknown error occurred. This is the default
+    return value of error().
+
+    \sa error()
+*/
+
+/*!
+    \enum QProcess::ProcessState
+
+    This enum describes the different states of QProcess.
+
+    \value NotRunning The process is not running.
+
+    \value Starting The process is starting, but the program has not
+    yet been invoked.
+
+    \value Running The process is running and is ready for reading and
+    writing.
+
+    \sa state()
+*/
+
+/*!
+    \enum QProcess::ExitStatus
+
+    This enum describes the different exit statuses of QProcess.
+
+    \value NormalExit The process exited normally.
+
+    \value CrashExit The process crashed.
+
+    \sa exitStatus()
+*/
+
+/*!
+    \fn void QProcess::error(QProcess::ProcessError error)
+
+    This signal is emitted when an error occurs with the process. The
+    specified \a error describes the type of error that occurred.
+*/
+
+/*!
+    \fn void QProcess::started()
+
+    This signal is emitted by QProcess when the process has started,
+    and state() returns \l Running.
+*/
+
+/*!
+    \fn void QProcess::stateChanged(QProcess::ProcessState newState)
+
+    This signal is emitted whenever the state of QProcess changes. The
+    \a newState argument is the state QProcess changed to.
+*/
+
+/*!
+    \fn void QProcess::finished(int exitCode)
+    \obsolete
+    \overload
+
+    Use finished(int exitCode, QProcess::ExitStatus status) instead.
+*/
+
+/*!
+    \fn void QProcess::finished(int exitCode, QProcess::ExitStatus exitStatus)
+
+    This signal is emitted when the process finishes. \a exitCode is the exit
+    code of the process, and \a exitStatus is the exit status.  After the
+    process has finished, the buffers in QProcess are still intact. You can
+    still read any data that the process may have written before it finished.
+
+    \sa exitStatus()
+*/
+
+/*!
+    \fn void QProcess::readyReadStandardOutput()
+
+    This signal is emitted when the process has made new data
+    available through its standard output channel (\c stdout). It is
+    emitted regardless of the current \l{readChannel()}{read channel}.
+
+    \sa readAllStandardOutput(), readChannel()
+*/
+
+/*!
+    \fn void QProcess::readyReadStandardError()
+
+    This signal is emitted when the process has made new data
+    available through its standard error channel (\c stderr). It is
+    emitted regardless of the current \l{readChannel()}{read
+    channel}.
+
+    \sa readAllStandardError(), readChannel()
+*/
+
+/*! \internal
+*/
+QProcessPrivate::QProcessPrivate()
+{
+    processChannel = QProcess::StandardOutput;
+    processChannelMode = QProcess::SeparateChannels;
+    processError = QProcess::UnknownError;
+    processState = QProcess::NotRunning;
+    pid = 0;
+    sequenceNumber = 0;
+    exitCode = 0;
+    exitStatus = QProcess::NormalExit;
+    environment = 0;
+    startupSocketNotifier = 0;
+    deathNotifier = 0;
+    notifier = 0;
+    pipeWriter = 0;
+    childStartedPipe[0] = INVALID_Q_PIPE;
+    childStartedPipe[1] = INVALID_Q_PIPE;
+    deathPipe[0] = INVALID_Q_PIPE;
+    deathPipe[1] = INVALID_Q_PIPE;
+    exitCode = 0;
+    crashed = false;
+    dying = false;
+    emittedReadyRead = false;
+    emittedBytesWritten = false;
+#ifdef Q_WS_WIN
+    pipeWriter = 0;
+    processFinishedNotifier = 0;
+#endif // Q_WS_WIN
+#ifdef Q_OS_UNIX
+    serial = 0;
+#endif
+}
+
+/*! \internal
+*/
+QProcessPrivate::~QProcessPrivate()
+{
+    delete environment;
+    if (stdinChannel.process)
+        stdinChannel.process->stdoutChannel.clear();
+    if (stdoutChannel.process)
+        stdoutChannel.process->stdinChannel.clear();
+}
+
+/*! \internal
+*/
+void QProcessPrivate::cleanup()
+{
+    q_func()->setProcessState(QProcess::NotRunning);
+#ifdef Q_OS_WIN
+    if (pid) {
+        CloseHandle(pid->hThread);
+        CloseHandle(pid->hProcess);
+        delete pid;
+        pid = 0;
+    }
+    if (processFinishedNotifier) {
+        processFinishedNotifier->setEnabled(false);
+        qDeleteInEventHandler(processFinishedNotifier);
+        processFinishedNotifier = 0;
+    }
+
+#endif
+    pid = 0;
+    sequenceNumber = 0;
+    dying = false;
+
+    if (stdoutChannel.notifier) {
+        stdoutChannel.notifier->setEnabled(false);
+        qDeleteInEventHandler(stdoutChannel.notifier);
+        stdoutChannel.notifier = 0;
+    }
+    if (stderrChannel.notifier) {
+        stderrChannel.notifier->setEnabled(false);
+        qDeleteInEventHandler(stderrChannel.notifier);
+        stderrChannel.notifier = 0;
+    }
+    if (stdinChannel.notifier) {
+        stdinChannel.notifier->setEnabled(false);
+        qDeleteInEventHandler(stdinChannel.notifier);
+        stdinChannel.notifier = 0;
+    }
+    if (startupSocketNotifier) {
+        startupSocketNotifier->setEnabled(false);
+        qDeleteInEventHandler(startupSocketNotifier);
+        startupSocketNotifier = 0;
+    }
+    if (deathNotifier) {
+        deathNotifier->setEnabled(false);
+        qDeleteInEventHandler(deathNotifier);
+        deathNotifier = 0;
+    }
+    if (notifier) {
+        qDeleteInEventHandler(notifier);
+        notifier = 0;
+    }
+    destroyPipe(stdoutChannel.pipe);
+    destroyPipe(stderrChannel.pipe);
+    destroyPipe(stdinChannel.pipe);
+    destroyPipe(childStartedPipe);
+    destroyPipe(deathPipe);
+#ifdef Q_OS_UNIX
+    serial = 0;
+#endif
+}
+
+/*! \internal
+*/
+bool QProcessPrivate::_q_canReadStandardOutput()
+{
+    Q_Q(QProcess);
+    qint64 available = bytesAvailableFromStdout();
+    if (available == 0) {
+        if (stdoutChannel.notifier)
+            stdoutChannel.notifier->setEnabled(false);
+        destroyPipe(stdoutChannel.pipe);
+#if defined QPROCESS_DEBUG
+        qDebug("QProcessPrivate::canReadStandardOutput(), 0 bytes available");
+#endif
+        return false;
+    }
+
+    char *ptr = outputReadBuffer.reserve(available);
+    qint64 readBytes = readFromStdout(ptr, available);
+    if (readBytes == -1) {
+        processError = QProcess::ReadError;
+        q->setErrorString(QProcess::tr("Error reading from process"));
+        emit q->error(processError);
+#if defined QPROCESS_DEBUG
+        qDebug("QProcessPrivate::canReadStandardOutput(), failed to read from the process");
+#endif
+        return false;
+    }
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::canReadStandardOutput(), read %d bytes from the process' output",
+            int(readBytes));
+#endif
+
+    if (stdoutChannel.closed) {
+        outputReadBuffer.chop(readBytes);
+        return false;
+    }
+
+    outputReadBuffer.chop(available - readBytes);
+
+    bool didRead = false;
+    if (readBytes == 0) {
+        if (stdoutChannel.notifier)
+            stdoutChannel.notifier->setEnabled(false);
+    } else if (processChannel == QProcess::StandardOutput) {
+        didRead = true;
+        if (!emittedReadyRead) {
+            emittedReadyRead = true;
+            emit q->readyRead();
+            emittedReadyRead = false;
+        }
+    }
+    emit q->readyReadStandardOutput();
+    return didRead;
+}
+
+/*! \internal
+*/
+bool QProcessPrivate::_q_canReadStandardError()
+{
+    Q_Q(QProcess);
+    qint64 available = bytesAvailableFromStderr();
+    if (available == 0) {
+        if (stderrChannel.notifier)
+            stderrChannel.notifier->setEnabled(false);
+        destroyPipe(stderrChannel.pipe);
+        return false;
+    }
+
+    char *ptr = errorReadBuffer.reserve(available);
+    qint64 readBytes = readFromStderr(ptr, available);
+    if (readBytes == -1) {
+        processError = QProcess::ReadError;
+        q->setErrorString(QProcess::tr("Error reading from process"));
+        emit q->error(processError);
+        return false;
+    }
+    if (stderrChannel.closed) {
+        errorReadBuffer.chop(readBytes);
+        return false;
+    }
+
+    errorReadBuffer.chop(available - readBytes);
+
+    bool didRead = false;
+    if (readBytes == 0) {
+        if (stderrChannel.notifier)
+            stderrChannel.notifier->setEnabled(false);
+    } else if (processChannel == QProcess::StandardError) {
+        didRead = true;
+        if (!emittedReadyRead) {
+            emittedReadyRead = true;
+            emit q->readyRead();
+            emittedReadyRead = false;
+        }
+    }
+    emit q->readyReadStandardError();
+    return didRead;
+}
+
+/*! \internal
+*/
+bool QProcessPrivate::_q_canWrite()
+{
+    Q_Q(QProcess);
+    if (stdinChannel.notifier)
+        stdinChannel.notifier->setEnabled(false);
+
+    if (writeBuffer.isEmpty()) {
+#if defined QPROCESS_DEBUG
+        qDebug("QProcessPrivate::canWrite(), not writing anything (empty write buffer).");
+#endif
+        return false;
+    }
+
+    qint64 written = writeToStdin(writeBuffer.readPointer(),
+                                      writeBuffer.nextDataBlockSize());
+    if (written < 0) {
+        destroyPipe(stdinChannel.pipe);
+        processError = QProcess::WriteError;
+        q->setErrorString(QProcess::tr("Error writing to process"));
+#if defined(QPROCESS_DEBUG) && !defined(Q_OS_WINCE)
+        qDebug("QProcessPrivate::canWrite(), failed to write (%s)", strerror(errno));
+#endif
+        emit q->error(processError);
+        return false;
+    }
+
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::canWrite(), wrote %d bytes to the process input", int(written));
+#endif
+
+    writeBuffer.free(written);
+    if (!emittedBytesWritten) {
+        emittedBytesWritten = true;
+        emit q->bytesWritten(written);
+        emittedBytesWritten = false;
+    }
+    if (stdinChannel.notifier && !writeBuffer.isEmpty())
+        stdinChannel.notifier->setEnabled(true);
+    if (writeBuffer.isEmpty() && stdinChannel.closed)
+        closeWriteChannel();
+    return true;
+}
+
+/*! \internal
+*/
+bool QProcessPrivate::_q_processDied()
+{
+    Q_Q(QProcess);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::_q_processDied()");
+#endif
+#ifdef Q_OS_UNIX
+    if (!waitForDeadChild())
+        return false;
+#endif
+#ifdef Q_OS_WIN
+    if (processFinishedNotifier)
+        processFinishedNotifier->setEnabled(false);
+#endif
+
+    // the process may have died before it got a chance to report that it was
+    // either running or stopped, so we will call _q_startupNotification() and
+    // give it a chance to emit started() or error(FailedToStart).
+    if (processState == QProcess::Starting) {
+        if (!_q_startupNotification())
+            return true;
+    }
+
+    if (dying) {
+        // at this point we know the process is dead. prevent
+        // reentering this slot recursively by calling waitForFinished()
+        // or opening a dialog inside slots connected to the readyRead
+        // signals emitted below.
+        return true;
+    }
+    dying = true;
+
+    // in case there is data in the pipe line and this slot by chance
+    // got called before the read notifications, call these two slots
+    // so the data is made available before the process dies.
+    _q_canReadStandardOutput();
+    _q_canReadStandardError();
+
+    findExitCode();
+
+    if (crashed) {
+        exitStatus = QProcess::CrashExit;
+        processError = QProcess::Crashed;
+        q->setErrorString(QProcess::tr("Process crashed"));
+        emit q->error(processError);
+    }
+
+    bool wasRunning = (processState == QProcess::Running);
+
+    cleanup();
+
+    if (wasRunning) {
+        // we received EOF now:
+        emit q->readChannelFinished();
+        // in the future:
+        //emit q->standardOutputClosed();
+        //emit q->standardErrorClosed();
+
+        emit q->finished(exitCode);
+        emit q->finished(exitCode, exitStatus);
+    }
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::_q_processDied() process is dead");
+#endif
+    return true;
+}
+
+/*! \internal
+*/
+bool QProcessPrivate::_q_startupNotification()
+{
+    Q_Q(QProcess);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::startupNotification()");
+#endif
+
+    if (startupSocketNotifier)
+        startupSocketNotifier->setEnabled(false);
+    if (processStarted()) {
+        q->setProcessState(QProcess::Running);
+        emit q->started();
+        return true;
+    }
+
+    q->setProcessState(QProcess::NotRunning);
+    processError = QProcess::FailedToStart;
+    emit q->error(processError);
+#ifdef Q_OS_UNIX
+    // make sure the process manager removes this entry
+    waitForDeadChild();
+    findExitCode();
+#endif
+    cleanup();
+    return false;
+}
+
+/*! \internal
+*/
+void QProcessPrivate::closeWriteChannel()
+{
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::closeWriteChannel()");
+#endif
+    if (stdinChannel.notifier) {
+        extern void qDeleteInEventHandler(QObject *o);
+        stdinChannel.notifier->setEnabled(false);
+        if (stdinChannel.notifier) {
+            qDeleteInEventHandler(stdinChannel.notifier);
+            stdinChannel.notifier = 0;
+        } 
+    }
+#ifdef Q_OS_WIN
+    // ### Find a better fix, feeding the process little by little
+    // instead.
+    flushPipeWriter();
+#endif
+    destroyPipe(stdinChannel.pipe);
+}
+
+/*!
+    Constructs a QProcess object with the given \a parent.
+*/
+QProcess::QProcess(QObject *parent)
+    : QIODevice(*new QProcessPrivate, parent)
+{
+#if defined QPROCESS_DEBUG
+    qDebug("QProcess::QProcess(%p)", parent);
+#endif
+}
+
+/*!
+    Destructs the QProcess object, i.e., killing the process.
+
+    Note that this function will not return until the process is
+    terminated.
+*/
+QProcess::~QProcess()
+{
+    Q_D(QProcess);
+    if (d->processState != NotRunning) {
+        qWarning("QProcess: Destroyed while process is still running.");
+        kill();
+        waitForFinished();
+    }
+#ifdef Q_OS_UNIX
+    // make sure the process manager removes this entry
+    d->findExitCode();
+#endif
+    d->cleanup();
+}
+
+/*!
+    \obsolete
+    Returns the read channel mode of the QProcess. This function is
+    equivalent to processChannelMode()
+
+    \sa processChannelMode()
+*/
+QProcess::ProcessChannelMode QProcess::readChannelMode() const
+{
+    return processChannelMode();
+}
+
+/*!
+    \obsolete
+
+    Use setProcessChannelMode(\a mode) instead.
+
+    \sa setProcessChannelMode()
+*/
+void QProcess::setReadChannelMode(ProcessChannelMode mode)
+{
+    setProcessChannelMode(mode);
+}
+
+/*!
+    \since 4.2
+
+    Returns the channel mode of the QProcess standard output and
+    standard error channels.
+
+    \sa setReadChannelMode(), ProcessChannelMode, setReadChannel()
+*/
+QProcess::ProcessChannelMode QProcess::processChannelMode() const
+{
+    Q_D(const QProcess);
+    return d->processChannelMode;
+}
+
+/*!
+    \since 4.2
+
+    Sets the channel mode of the QProcess standard output and standard
+    error channels to the \a mode specified.
+    This mode will be used the next time start() is called. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 0
+
+    \sa readChannelMode(), ProcessChannelMode, setReadChannel()
+*/
+void QProcess::setProcessChannelMode(ProcessChannelMode mode)
+{
+    Q_D(QProcess);
+    d->processChannelMode = mode;
+}
+
+/*!
+    Returns the current read channel of the QProcess.
+
+    \sa setReadChannel()
+*/
+QProcess::ProcessChannel QProcess::readChannel() const
+{
+    Q_D(const QProcess);
+    return d->processChannel;
+}
+
+/*!
+    Sets the current read channel of the QProcess to the given \a
+    channel. The current input channel is used by the functions
+    read(), readAll(), readLine(), and getChar(). It also determines
+    which channel triggers QProcess to emit readyRead().
+
+    \sa readChannel()
+*/
+void QProcess::setReadChannel(ProcessChannel channel)
+{
+    Q_D(QProcess);
+    if (d->processChannel != channel) {
+        QByteArray buf = d->buffer.readAll();
+        if (d->processChannel == QProcess::StandardOutput) {
+            for (int i = buf.size() - 1; i >= 0; --i)
+                d->outputReadBuffer.ungetChar(buf.at(i));
+        } else {
+            for (int i = buf.size() - 1; i >= 0; --i)
+                d->errorReadBuffer.ungetChar(buf.at(i));
+        }
+    }
+    d->processChannel = channel;
+}
+
+/*!
+    Closes the read channel \a channel. After calling this function,
+    QProcess will no longer receive data on the channel. Any data that
+    has already been received is still available for reading.
+
+    Call this function to save memory, if you are not interested in
+    the output of the process.
+
+    \sa closeWriteChannel(), setReadChannel()
+*/
+void QProcess::closeReadChannel(ProcessChannel channel)
+{
+    Q_D(QProcess);
+
+    if (channel == StandardOutput)
+        d->stdoutChannel.closed = true;
+    else
+        d->stderrChannel.closed = true;
+}
+
+/*!
+    Schedules the write channel of QProcess to be closed. The channel
+    will close once all data has been written to the process. After
+    calling this function, any attempts to write to the process will
+    fail.
+
+    Closing the write channel is necessary for programs that read
+    input data until the channel has been closed. For example, the
+    program "more" is used to display text data in a console on both
+    Unix and Windows. But it will not display the text data until
+    QProcess's write channel has been closed. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 1
+
+    The write channel is implicitly opened when start() is called.
+
+    \sa closeReadChannel()
+*/
+void QProcess::closeWriteChannel()
+{
+    Q_D(QProcess);
+    d->stdinChannel.closed = true; // closing
+    if (d->writeBuffer.isEmpty())
+        d->closeWriteChannel();
+}
+
+/*!
+    \since 4.2
+
+    Redirects the process' standard input to the file indicated by \a
+    fileName. When an input redirection is in place, the QProcess
+    object will be in read-only mode (calling write() will result in
+    error).
+
+    If the file \a fileName does not exist at the moment start() is
+    called or is not readable, starting the process will fail.
+
+    Calling setStandardInputFile() after the process has started has no
+    effect.
+
+    \sa setStandardOutputFile(), setStandardErrorFile(),
+        setStandardOutputProcess()
+*/
+void QProcess::setStandardInputFile(const QString &fileName)
+{
+    Q_D(QProcess);
+    d->stdinChannel = fileName;
+}
+
+/*!
+    \since 4.2
+
+    Redirects the process' standard output to the file \a
+    fileName. When the redirection is in place, the standard output
+    read channel is closed: reading from it using read() will always
+    fail, as will readAllStandardOutput().
+
+    If the file \a fileName doesn't exist at the moment start() is
+    called, it will be created. If it cannot be created, the starting
+    will fail.
+
+    If the file exists and \a mode is QIODevice::Truncate, the file
+    will be truncated. Otherwise (if \a mode is QIODevice::Append),
+    the file will be appended to.
+
+    Calling setStandardOutputFile() after the process has started has
+    no effect.
+
+    \sa setStandardInputFile(), setStandardErrorFile(),
+        setStandardOutputProcess()
+*/
+void QProcess::setStandardOutputFile(const QString &fileName, OpenMode mode)
+{
+    Q_ASSERT(mode == Append || mode == Truncate);
+    Q_D(QProcess);
+
+    d->stdoutChannel = fileName;
+    d->stdoutChannel.append = mode == Append;
+}
+
+/*!
+    \since 4.2
+
+    Redirects the process' standard error to the file \a
+    fileName. When the redirection is in place, the standard error
+    read channel is closed: reading from it using read() will always
+    fail, as will readAllStandardError(). The file will be appended to
+    if \a mode is Append, otherwise, it will be truncated.
+
+    See setStandardOutputFile() for more information on how the file
+    is opened.
+
+    Note: if setProcessChannelMode() was called with an argument of
+    QProcess::MergedChannels, this function has no effect.
+
+    \sa setStandardInputFile(), setStandardOutputFile(),
+        setStandardOutputProcess()
+*/
+void QProcess::setStandardErrorFile(const QString &fileName, OpenMode mode)
+{
+    Q_ASSERT(mode == Append || mode == Truncate);
+    Q_D(QProcess);
+
+    d->stderrChannel = fileName;
+    d->stderrChannel.append = mode == Append;
+}
+
+/*!
+    \since 4.2
+
+    Pipes the standard output stream of this process to the \a
+    destination process' standard input.
+
+    The following shell command:
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 2
+
+    Can be accomplished with QProcesses with the following code:
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 3
+*/
+void QProcess::setStandardOutputProcess(QProcess *destination)
+{
+    QProcessPrivate *dfrom = d_func();
+    QProcessPrivate *dto = destination->d_func();
+    dfrom->stdoutChannel.pipeTo(dto);
+    dto->stdinChannel.pipeFrom(dfrom);
+}
+
+/*!
+    If QProcess has been assigned a working directory, this function returns
+    the working directory that the QProcess will enter before the program has
+    started. Otherwise, (i.e., no directory has been assigned,) an empty
+    string is returned, and QProcess will use the application's current
+    working directory instead.
+
+    \sa setWorkingDirectory()
+*/
+QString QProcess::workingDirectory() const
+{
+    Q_D(const QProcess);
+    return d->workingDirectory;
+}
+
+/*!
+    Sets the working directory to \a dir. QProcess will start the
+    process in this directory. The default behavior is to start the
+    process in the working directory of the calling process.
+
+    \sa workingDirectory(), start()
+*/
+void QProcess::setWorkingDirectory(const QString &dir)
+{
+    Q_D(QProcess);
+    d->workingDirectory = dir;
+}
+
+/*!
+    Returns the native process identifier for the running process, if
+    available.  If no process is currently running, 0 is returned.
+*/
+Q_PID QProcess::pid() const
+{
+    Q_D(const QProcess);
+    return d->pid;
+}
+
+/*! \reimp
+
+    This function operates on the current read channel.
+
+    \sa readChannel(), setReadChannel()
+*/
+bool QProcess::canReadLine() const
+{
+    Q_D(const QProcess);
+    const QRingBuffer *readBuffer = (d->processChannel == QProcess::StandardError)
+                                    ? &d->errorReadBuffer
+                                    : &d->outputReadBuffer;
+    return readBuffer->canReadLine() || QIODevice::canReadLine();
+}
+
+/*!
+    Closes all communication with the process and kills it. After calling this
+    function, QProcess will no longer emit readyRead(), and data can no
+    longer be read or written.
+*/
+void QProcess::close()
+{
+    emit aboutToClose();
+    while (waitForBytesWritten(-1))
+        ;
+    kill();
+    waitForFinished(-1);
+    QIODevice::close();
+}
+
+/*! \reimp
+
+   Returns true if the process is not running, and no more data is available
+   for reading; otherwise returns false.
+*/
+bool QProcess::atEnd() const
+{
+    Q_D(const QProcess);
+    const QRingBuffer *readBuffer = (d->processChannel == QProcess::StandardError)
+                                    ? &d->errorReadBuffer
+                                    : &d->outputReadBuffer;
+    return QIODevice::atEnd() && (!isOpen() || readBuffer->isEmpty());
+}
+
+/*! \reimp
+*/
+bool QProcess::isSequential() const
+{
+    return true;
+}
+
+/*! \reimp
+*/
+qint64 QProcess::bytesAvailable() const
+{
+    Q_D(const QProcess);
+    const QRingBuffer *readBuffer = (d->processChannel == QProcess::StandardError)
+                                    ? &d->errorReadBuffer
+                                    : &d->outputReadBuffer;
+#if defined QPROCESS_DEBUG
+    qDebug("QProcess::bytesAvailable() == %i (%s)", readBuffer->size(),
+           (d->processChannel == QProcess::StandardError) ? "stderr" : "stdout");
+#endif
+    return readBuffer->size() + QIODevice::bytesAvailable();
+}
+
+/*! \reimp
+*/
+qint64 QProcess::bytesToWrite() const
+{
+    Q_D(const QProcess);
+    qint64 size = d->writeBuffer.size();
+#ifdef Q_OS_WIN
+    size += d->pipeWriterBytesToWrite();
+#endif
+    return size;
+}
+
+/*!
+    Returns the type of error that occurred last.
+
+    \sa state()
+*/
+QProcess::ProcessError QProcess::error() const
+{
+    Q_D(const QProcess);
+    return d->processError;
+}
+
+/*!
+    Returns the current state of the process.
+
+    \sa stateChanged(), error()
+*/
+QProcess::ProcessState QProcess::state() const
+{
+    Q_D(const QProcess);
+    return d->processState;
+}
+
+/*!
+    Sets the environment that QProcess will use when starting a process to the
+    \a environment specified which consists of a list of key=value pairs.
+
+    For example, the following code adds the \c{C:\\BIN} directory to the list of
+    executable paths (\c{PATHS}) on Windows:
+
+    \snippet doc/src/snippets/qprocess-environment/main.cpp 0
+
+    \sa environment(), systemEnvironment(), setEnvironmentHash()
+*/
+void QProcess::setEnvironment(const QStringList &environment)
+{
+    setEnvironmentHash(environmentHashFromList(environment));
+}
+
+/*!
+    Returns the environment that QProcess will use when starting a
+    process, or an empty QStringList if no environment has been set
+    using setEnvironment() or setEnvironmentHash(). If no environment
+    has been set, the environment of the calling process will be used.
+
+    \note The environment settings are ignored on Windows CE,
+    as there is no concept of an environment.
+
+    \sa environmentHash(), setEnvironment(), systemEnvironment()
+*/
+QStringList QProcess::environment() const
+{
+    Q_D(const QProcess);
+
+    QStringList result;
+    if (!d->environment)
+        return result;
+
+    QHash<QString, QString>::ConstIterator it = d->environment->constBegin(),
+                                          end = d->environment->constEnd();
+    for ( ; it != end; ++it) {
+        QString data = it.key();
+        data.reserve(data.length() + it.value().length() + 1);
+        data.append(QLatin1Char('='));
+        data.append(it.value());
+        result << data;
+    }
+    return result;
+}
+
+/*!
+    \since 4.5
+    Sets the environment that QProcess will use when starting a process to the
+    \a environment hash map.
+
+    For example, the following code adds the \c{C:\\BIN} directory to the list of
+    executable paths (\c{PATHS}) on Windows and sets \c{TMPDIR}:
+
+    \snippet doc/src/snippets/qprocess-environment/main.cpp 1
+
+    \sa environment(), systemEnvironmentHash(), setEnvironment()
+*/
+void QProcess::setEnvironmentHash(const QHash<QString, QString> &environment)
+{
+    Q_D(QProcess);
+    if (!d->environment)
+        d->environment = new QHash<QString, QString>(environment);
+    else
+        *d->environment = environment;
+}
+
+/*!
+    \since 4.5
+    Returns the environment that QProcess will use when starting a
+    process, or an empty QHash if no environment has been set using
+    setEnvironment() or setEnvironmentHash(). If no environment has
+    been set, the environment of the calling process will be used.
+
+    \note The environment settings are ignored on Windows CE,
+    as there is no concept of an environment.
+
+    \sa setEnvironmentHash(), setEnvironment(), systemEnvironmentHash()
+*/
+QHash<QString, QString> QProcess::environmentHash() const
+{
+    Q_D(const QProcess);
+    if (d->environment)
+        return *d->environment;
+    return QHash<QString, QString>();
+}
+
+/*!
+    Blocks until the process has started and the started() signal has
+    been emitted, or until \a msecs milliseconds have passed.
+
+    Returns true if the process was started successfully; otherwise
+    returns false (if the operation timed out or if an error
+    occurred).
+
+    This function can operate without an event loop. It is
+    useful when writing non-GUI applications and when performing
+    I/O operations in a non-GUI thread.
+
+    \warning Calling this function from the main (GUI) thread
+    might cause your user interface to freeze.
+
+    If msecs is -1, this function will not time out.
+
+    \sa started(), waitForReadyRead(), waitForBytesWritten(), waitForFinished()
+*/
+bool QProcess::waitForStarted(int msecs)
+{
+    Q_D(QProcess);
+    if (d->processState == QProcess::Starting) {
+        if (!d->waitForStarted(msecs))
+            return false;
+        setProcessState(QProcess::Running);
+        emit started();
+    }
+    return d->processState == QProcess::Running;
+}
+
+/*! \reimp
+*/
+bool QProcess::waitForReadyRead(int msecs)
+{
+    Q_D(QProcess);
+
+    if (d->processState == QProcess::NotRunning)
+        return false;
+    if (d->processChannel == QProcess::StandardOutput && d->stdoutChannel.closed)
+        return false;
+    if (d->processChannel == QProcess::StandardError && d->stderrChannel.closed)
+        return false;
+    return d->waitForReadyRead(msecs);
+}
+
+/*! \reimp
+*/
+bool QProcess::waitForBytesWritten(int msecs)
+{
+    Q_D(QProcess);
+    if (d->processState == QProcess::NotRunning)
+        return false;
+    if (d->processState == QProcess::Starting) {
+        QTime stopWatch;
+        stopWatch.start();
+        bool started = waitForStarted(msecs);
+        if (!started)
+            return false;
+        if (msecs != -1)
+            msecs -= stopWatch.elapsed();
+    }
+
+    return d->waitForBytesWritten(msecs);
+}
+
+/*!
+    Blocks until the process has finished and the finished() signal
+    has been emitted, or until \a msecs milliseconds have passed.
+
+    Returns true if the process finished; otherwise returns false (if
+    the operation timed out or if an error occurred).
+
+    This function can operate without an event loop. It is
+    useful when writing non-GUI applications and when performing
+    I/O operations in a non-GUI thread.
+
+    \warning Calling this function from the main (GUI) thread
+    might cause your user interface to freeze.
+
+    If msecs is -1, this function will not time out.
+
+    \sa finished(), waitForStarted(), waitForReadyRead(), waitForBytesWritten()
+*/
+bool QProcess::waitForFinished(int msecs)
+{
+    Q_D(QProcess);
+    if (d->processState == QProcess::NotRunning)
+        return false;
+    if (d->processState == QProcess::Starting) {
+        QTime stopWatch;
+        stopWatch.start();
+        bool started = waitForStarted(msecs);
+        if (!started)
+            return false;
+        if (msecs != -1)
+            msecs -= stopWatch.elapsed();
+    }
+
+    return d->waitForFinished(msecs);
+}
+
+/*!
+    Sets the current state of the QProcess to the \a state specified.
+
+    \sa state()
+*/
+void QProcess::setProcessState(ProcessState state)
+{
+    Q_D(QProcess);
+    if (d->processState == state)
+        return;
+    d->processState = state;
+    emit stateChanged(state);
+}
+
+/*!
+  This function is called in the child process context just before the
+    program is executed on Unix or Mac OS X (i.e., after \e fork(), but before
+    \e execve()). Reimplement this function to do last minute initialization
+    of the child process. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 4
+
+    You cannot exit the process (by calling exit(), for instance) from
+    this function. If you need to stop the program before it starts
+    execution, your workaround is to emit finished() and then call
+    exit().
+
+    \warning This function is called by QProcess on Unix and Mac OS X
+    only. On Windows, it is not called.
+*/
+void QProcess::setupChildProcess()
+{
+}
+
+/*! \reimp
+*/
+qint64 QProcess::readData(char *data, qint64 maxlen)
+{
+    Q_D(QProcess);
+    QRingBuffer *readBuffer = (d->processChannel == QProcess::StandardError)
+                              ? &d->errorReadBuffer
+                              : &d->outputReadBuffer;
+
+    if (maxlen == 1 && !readBuffer->isEmpty()) {
+        int c = readBuffer->getChar();
+        if (c == -1) {
+#if defined QPROCESS_DEBUG
+            qDebug("QProcess::readData(%p \"%s\", %d) == -1",
+                   data, qt_prettyDebug(data, 1, maxlen).constData(), 1);
+#endif
+            return -1;
+        }
+        *data = (char) c;
+#if defined QPROCESS_DEBUG
+        qDebug("QProcess::readData(%p \"%s\", %d) == 1",
+               data, qt_prettyDebug(data, 1, maxlen).constData(), 1);
+#endif
+        return 1;
+    }
+
+    qint64 bytesToRead = qint64(qMin(readBuffer->size(), (int)maxlen));
+    qint64 readSoFar = 0;
+    while (readSoFar < bytesToRead) {
+        const char *ptr = readBuffer->readPointer();
+        int bytesToReadFromThisBlock = qMin<qint64>(bytesToRead - readSoFar,
+                                            readBuffer->nextDataBlockSize());
+        memcpy(data + readSoFar, ptr, bytesToReadFromThisBlock);
+        readSoFar += bytesToReadFromThisBlock;
+        readBuffer->free(bytesToReadFromThisBlock);
+    }
+
+#if defined QPROCESS_DEBUG
+    qDebug("QProcess::readData(%p \"%s\", %lld) == %lld",
+           data, qt_prettyDebug(data, readSoFar, 16).constData(), maxlen, readSoFar);
+#endif
+    if (!readSoFar && d->processState == QProcess::NotRunning)
+        return -1;              // EOF
+    return readSoFar;
+}
+
+/*! \reimp
+*/
+qint64 QProcess::writeData(const char *data, qint64 len)
+{
+    Q_D(QProcess);
+
+#if defined(Q_OS_WINCE)
+    Q_UNUSED(data);
+    Q_UNUSED(len);
+    d->processError = QProcess::WriteError;
+    setErrorString(tr("Error writing to process"));
+    emit error(d->processError);
+    return -1;
+#endif
+
+    if (d->stdinChannel.closed) {
+#if defined QPROCESS_DEBUG
+    qDebug("QProcess::writeData(%p \"%s\", %lld) == 0 (write channel closing)",
+           data, qt_prettyDebug(data, len, 16).constData(), len);
+#endif
+        return 0;
+    }
+
+    if (len == 1) {
+        d->writeBuffer.putChar(*data);
+        if (d->stdinChannel.notifier)
+            d->stdinChannel.notifier->setEnabled(true);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcess::writeData(%p \"%s\", %lld) == 1 (written to buffer)",
+           data, qt_prettyDebug(data, len, 16).constData(), len);
+#endif
+        return 1;
+    }
+
+    char *dest = d->writeBuffer.reserve(len);
+    memcpy(dest, data, len);
+    if (d->stdinChannel.notifier)
+        d->stdinChannel.notifier->setEnabled(true);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcess::writeData(%p \"%s\", %lld) == %lld (written to buffer)",
+           data, qt_prettyDebug(data, len, 16).constData(), len, len);
+#endif
+    return len;
+}
+
+/*!
+    Regardless of the current read channel, this function returns all
+    data available from the standard output of the process as a
+    QByteArray.
+
+    \sa readyReadStandardOutput(), readAllStandardError(), readChannel(), setReadChannel()
+*/
+QByteArray QProcess::readAllStandardOutput()
+{
+    ProcessChannel tmp = readChannel();
+    setReadChannel(StandardOutput);
+    QByteArray data = readAll();
+    setReadChannel(tmp);
+    return data;
+}
+
+/*!
+    Regardless of the current read channel, this function returns all
+    data available from the standard error of the process as a
+    QByteArray.
+
+    \sa readyReadStandardError(), readAllStandardOutput(), readChannel(), setReadChannel()
+*/
+QByteArray QProcess::readAllStandardError()
+{
+    ProcessChannel tmp = readChannel();
+    setReadChannel(StandardError);
+    QByteArray data = readAll();
+    setReadChannel(tmp);
+    return data;
+}
+
+/*!
+    Starts the program \a program in a new process, passing the
+    command line arguments in \a arguments. The OpenMode is set to \a
+    mode. QProcess will immediately enter the Starting state. If the
+    process starts successfully, QProcess will emit started();
+    otherwise, error() will be emitted.
+
+    Note that arguments that contain spaces are not passed to the
+    process as separate arguments.
+
+    \bold{Windows:} Arguments that contain spaces are wrapped in quotes.
+
+    \note Processes are started asynchronously, which means the started()
+    and error() signals may be delayed. Call waitForStarted() to make
+    sure the process has started (or has failed to start) and those signals
+    have been emitted.
+
+    \sa pid(), started(), waitForStarted()
+*/
+void QProcess::start(const QString &program, const QStringList &arguments, OpenMode mode)
+{
+    Q_D(QProcess);
+    if (d->processState != NotRunning) {
+        qWarning("QProcess::start: Process is already running");
+        return;
+    }
+
+#if defined QPROCESS_DEBUG
+    qDebug() << "QProcess::start(" << program << "," << arguments << "," << mode << ")";
+#endif
+
+    d->outputReadBuffer.clear();
+    d->errorReadBuffer.clear();
+
+    if (d->stdinChannel.type != QProcessPrivate::Channel::Normal)
+        mode &= ~WriteOnly;     // not open for writing
+    if (d->stdoutChannel.type != QProcessPrivate::Channel::Normal &&
+        (d->stderrChannel.type != QProcessPrivate::Channel::Normal ||
+         d->processChannelMode == MergedChannels))
+        mode &= ~ReadOnly;      // not open for reading
+    if (mode == 0)
+        mode = Unbuffered;
+    QIODevice::open(mode);
+
+    d->stdinChannel.closed = false;
+    d->stdoutChannel.closed = false;
+    d->stderrChannel.closed = false;
+
+    d->program = program;
+    d->arguments = arguments;
+
+    d->exitCode = 0;
+    d->exitStatus = NormalExit;
+    d->processError = QProcess::UnknownError;
+    d->errorString.clear();
+    d->startProcess();
+}
+
+
+static QStringList parseCombinedArgString(const QString &program)
+{
+    QStringList args;
+    QString tmp;
+    int quoteCount = 0;
+    bool inQuote = false;
+
+    // handle quoting. tokens can be surrounded by double quotes
+    // "hello world". three consecutive double quotes represent
+    // the quote character itself.
+    for (int i = 0; i < program.size(); ++i) {
+        if (program.at(i) == QLatin1Char('"')) {
+            ++quoteCount;
+            if (quoteCount == 3) {
+                // third consecutive quote
+                quoteCount = 0;
+                tmp += program.at(i);
+            }
+            continue;
+        }
+        if (quoteCount) {
+            if (quoteCount == 1)
+                inQuote = !inQuote;
+            quoteCount = 0;
+        }
+        if (!inQuote && program.at(i).isSpace()) {
+            if (!tmp.isEmpty()) {
+                args += tmp;
+                tmp.clear();
+            }
+        } else {
+            tmp += program.at(i);
+        }
+    }
+    if (!tmp.isEmpty())
+        args += tmp;
+
+    return args;
+}
+
+/*!
+    \overload
+
+    Starts the program \a program in a new process. \a program is a
+    single string of text containing both the program name and its
+    arguments. The arguments are separated by one or more
+    spaces. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 5
+
+    The \a program string can also contain quotes, to ensure that arguments
+    containing spaces are correctly supplied to the new process. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 6
+
+    Note that, on Windows, quotes need to be both escaped and quoted.
+    For example, the above code would be specified in the following
+    way to ensure that \c{"My Documents"} is used as the argument to
+    the \c dir executable:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 7
+
+    The OpenMode is set to \a mode.
+*/
+void QProcess::start(const QString &program, OpenMode mode)
+{
+    QStringList args = parseCombinedArgString(program);
+
+    QString prog = args.first();
+    args.removeFirst();
+
+    start(prog, args, mode);
+}
+
+/*!
+    Attempts to terminate the process.
+
+    The process may not exit as a result of calling this function (it is given
+    the chance to prompt the user for any unsaved files, etc).
+
+    On Windows, terminate() posts a WM_CLOSE message to all toplevel windows
+    of the process and then to the main thread of the process itself. On Unix
+    and Mac OS X the SIGTERM signal is sent.
+
+    Console applications on Windows that do not run an event loop, or whose
+    event loop does not handle the WM_CLOSE message, can only be terminated by
+    calling kill().
+
+    \sa kill()
+*/
+void QProcess::terminate()
+{
+    Q_D(QProcess);
+    d->terminateProcess();
+}
+
+/*!
+    Kills the current process, causing it to exit immediately.
+
+    On Windows, kill() uses TerminateProcess, and on Unix and Mac OS X, the
+    SIGKILL signal is sent to the process.
+
+    \sa terminate()
+*/
+void QProcess::kill()
+{
+    Q_D(QProcess);
+    d->killProcess();
+}
+
+/*!
+    Returns the exit code of the last process that finished.
+*/
+int QProcess::exitCode() const
+{
+    Q_D(const QProcess);
+    return d->exitCode;
+}
+
+/*!
+    \since 4.1
+
+    Returns the exit status of the last process that finished.
+
+    On Windows, if the process was terminated with TerminateProcess()
+    from another application this function will still return NormalExit
+    unless the exit code is less than 0.
+*/
+QProcess::ExitStatus QProcess::exitStatus() const
+{
+    Q_D(const QProcess);
+    return d->exitStatus;
+}
+
+/*!
+    Starts the program \a program with the arguments \a arguments in a
+    new process, waits for it to finish, and then returns the exit
+    code of the process. Any data the new process writes to the
+    console is forwarded to the calling process.
+
+    The environment and working directory are inherited by the calling
+    process.
+
+    On Windows, arguments that contain spaces are wrapped in quotes.
+*/
+int QProcess::execute(const QString &program, const QStringList &arguments)
+{
+    QProcess process;
+    process.setReadChannelMode(ForwardedChannels);
+    process.start(program, arguments);
+    process.waitForFinished(-1);
+    return process.exitCode();
+}
+
+/*!
+    \overload
+
+    Starts the program \a program in a new process. \a program is a
+    single string of text containing both the program name and its
+    arguments. The arguments are separated by one or more spaces.
+*/
+int QProcess::execute(const QString &program)
+{
+    QProcess process;
+    process.setReadChannelMode(ForwardedChannels);
+    process.start(program);
+    process.waitForFinished(-1);
+    return process.exitCode();
+}
+
+/*!
+    Starts the program \a program with the arguments \a arguments in a
+    new process, and detaches from it. Returns true on success;
+    otherwise returns false. If the calling process exits, the
+    detached process will continue to live.
+
+    Note that arguments that contain spaces are not passed to the
+    process as separate arguments.
+
+    \bold{Unix:} The started process will run in its own session and act
+    like a daemon.
+
+    \bold{Windows:} Arguments that contain spaces are wrapped in quotes.
+    The started process will run as a regular standalone process.
+
+    The process will be started in the directory \a workingDirectory.
+
+    If the function is successful then *\a pid is set to the process
+    identifier of the started process.
+*/
+bool QProcess::startDetached(const QString &program,
+			     const QStringList &arguments,
+			     const QString &workingDirectory,
+                             qint64 *pid)
+{
+    return QProcessPrivate::startDetached(program,
+					  arguments,
+					  workingDirectory,
+					  pid);
+}
+
+/*!
+    Starts the program \a program with the given \a arguments in a
+    new process, and detaches from it. Returns true on success;
+    otherwise returns false. If the calling process exits, the
+    detached process will continue to live.
+
+    Note that arguments that contain spaces are not passed to the
+    process as separate arguments.
+
+    \bold{Unix:} The started process will run in its own session and act
+    like a daemon.
+
+    \bold{Windows:} Arguments that contain spaces are wrapped in quotes.
+    The started process will run as a regular standalone process.
+*/
+bool QProcess::startDetached(const QString &program,
+			     const QStringList &arguments)
+{
+    return QProcessPrivate::startDetached(program, arguments);
+}
+
+/*!
+    \overload
+
+    Starts the program \a program in a new process. \a program is a
+    single string of text containing both the program name and its
+    arguments. The arguments are separated by one or more spaces.
+
+    The \a program string can also contain quotes, to ensure that arguments
+    containing spaces are correctly supplied to the new process.
+*/
+bool QProcess::startDetached(const QString &program)
+{
+    QStringList args = parseCombinedArgString(program);
+
+    QString prog = args.first();
+    args.removeFirst();
+
+    return QProcessPrivate::startDetached(prog, args);
+}
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#ifdef Q_OS_MAC
+# include <crt_externs.h>
+# define environ (*_NSGetEnviron())
+#elif defined(Q_OS_WINCE)
+  static char *qt_wince_environ[] = { 0 };
+#define environ qt_wince_environ
+#elif !defined(Q_OS_WIN)
+  extern char **environ;
+#endif
+QT_END_INCLUDE_NAMESPACE
+
+/*!
+    \since 4.1
+
+    Returns the environment of the calling process as a list of
+    key=value pairs. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qprocess.cpp 8
+
+    \sa systemEnvironmentHash(), environment(), setEnvironment()
+*/
+QStringList QProcess::systemEnvironment()
+{
+    QStringList tmp;
+    char *entry = 0;
+    int count = 0;
+    while ((entry = environ[count++]))
+        tmp << QString::fromLocal8Bit(entry);
+    return tmp;
+}
+
+/*!
+    \since 4.5
+
+    Returns the environment of the calling process as a QHash.
+
+    \sa systemEnvironment(), environmentHash(), setEnvironmentHash()
+*/
+QHash<QString, QString> QProcess::systemEnvironmentHash()
+{
+    return environmentHashFromList(systemEnvironment());
+}
+
+/*!
+    \typedef Q_PID
+    \relates QProcess
+
+    Typedef for the identifiers used to represent processes on the underlying
+    platform. On Unix, this corresponds to \l qint64; on Windows, it
+    corresponds to \c{_PROCESS_INFORMATION*}.
+
+    \sa QProcess::pid()
+*/
+
+QT_END_NAMESPACE
+
+#include "moc_qprocess.cpp"
+
+#endif // QT_NO_PROCESS
+
diff --git a/src/corelib/io/qprocess.h b/src/corelib/io/qprocess.h
new file mode 100644
index 0000000..bf9a5a6
--- /dev/null
+++ b/src/corelib/io/qprocess.h
@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROCESS_H
+#define QPROCESS_H
+
+#include <QtCore/qiodevice.h>
+#include <QtCore/qstringlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_PROCESS
+
+template <class Key, class T> class QHash;
+
+#if (!defined(Q_OS_WIN32) && !defined(Q_OS_WINCE)) || defined(qdoc)
+typedef qint64 Q_PID;
+#else
+QT_END_NAMESPACE
+typedef struct _PROCESS_INFORMATION *Q_PID;
+QT_BEGIN_NAMESPACE
+#endif
+
+class QProcessPrivate;
+
+class Q_CORE_EXPORT QProcess : public QIODevice
+{
+    Q_OBJECT
+public:
+    enum ProcessError {
+        FailedToStart, //### file not found, resource error
+        Crashed,
+        Timedout,
+        ReadError,
+        WriteError,
+        UnknownError
+    };
+    enum ProcessState {
+        NotRunning,
+        Starting,
+        Running
+    };
+    enum ProcessChannel {
+        StandardOutput,
+        StandardError
+    };
+    enum ProcessChannelMode {
+        SeparateChannels,
+        MergedChannels,
+        ForwardedChannels
+    };
+    enum ExitStatus {
+        NormalExit,
+        CrashExit
+    };
+
+    explicit QProcess(QObject *parent = 0);
+    virtual ~QProcess();
+
+    void start(const QString &program, const QStringList &arguments, OpenMode mode = ReadWrite);
+    void start(const QString &program, OpenMode mode = ReadWrite);
+
+    ProcessChannelMode readChannelMode() const;
+    void setReadChannelMode(ProcessChannelMode mode);
+    ProcessChannelMode processChannelMode() const;
+    void setProcessChannelMode(ProcessChannelMode mode);
+
+    ProcessChannel readChannel() const;
+    void setReadChannel(ProcessChannel channel);
+
+    void closeReadChannel(ProcessChannel channel);
+    void closeWriteChannel();
+
+    void setStandardInputFile(const QString &fileName);
+    void setStandardOutputFile(const QString &fileName, OpenMode mode = Truncate);
+    void setStandardErrorFile(const QString &fileName, OpenMode mode = Truncate);
+    void setStandardOutputProcess(QProcess *destination);
+
+    QString workingDirectory() const;
+    void setWorkingDirectory(const QString &dir);
+
+    void setEnvironment(const QStringList &environment);
+    QStringList environment() const;
+    void setEnvironmentHash(const QHash<QString, QString> &environment);
+    QHash<QString, QString> environmentHash() const;
+
+    QProcess::ProcessError error() const;
+    QProcess::ProcessState state() const;
+
+    // #### Qt 5: Q_PID is a pointer on Windows and a value on Unix
+    Q_PID pid() const;
+
+    bool waitForStarted(int msecs = 30000);
+    bool waitForReadyRead(int msecs = 30000);
+    bool waitForBytesWritten(int msecs = 30000);
+    bool waitForFinished(int msecs = 30000);
+
+    QByteArray readAllStandardOutput();
+    QByteArray readAllStandardError();
+
+    int exitCode() const;
+    QProcess::ExitStatus exitStatus() const;
+
+    // QIODevice
+    qint64 bytesAvailable() const;
+    qint64 bytesToWrite() const;
+    bool isSequential() const;
+    bool canReadLine() const;
+    void close();
+    bool atEnd() const;
+
+    static int execute(const QString &program, const QStringList &arguments);
+    static int execute(const QString &program);
+
+    static bool startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory,
+                              qint64 *pid = 0);
+    static bool startDetached(const QString &program, const QStringList &arguments);
+    static bool startDetached(const QString &program);
+
+    static QStringList systemEnvironment();
+    static QHash<QString, QString> systemEnvironmentHash();
+
+public Q_SLOTS:
+    void terminate();
+    void kill();
+
+Q_SIGNALS:
+    void started();
+    void finished(int exitCode);
+    void finished(int exitCode, QProcess::ExitStatus exitStatus);
+    void error(QProcess::ProcessError error);
+    void stateChanged(QProcess::ProcessState state);
+
+    void readyReadStandardOutput();
+    void readyReadStandardError();
+
+protected:
+    void setProcessState(ProcessState state);
+
+    virtual void setupChildProcess();
+
+    // QIODevice
+    qint64 readData(char *data, qint64 maxlen);
+    qint64 writeData(const char *data, qint64 len);
+
+private:
+    Q_DECLARE_PRIVATE(QProcess)
+    Q_DISABLE_COPY(QProcess)
+
+    Q_PRIVATE_SLOT(d_func(), bool _q_canReadStandardOutput())
+    Q_PRIVATE_SLOT(d_func(), bool _q_canReadStandardError())
+    Q_PRIVATE_SLOT(d_func(), bool _q_canWrite())
+    Q_PRIVATE_SLOT(d_func(), bool _q_startupNotification())
+    Q_PRIVATE_SLOT(d_func(), bool _q_processDied())
+    Q_PRIVATE_SLOT(d_func(), void _q_notified())
+    friend class QProcessManager;
+};
+
+#endif // QT_NO_PROCESS
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPROCESS_H
diff --git a/src/corelib/io/qprocess_p.h b/src/corelib/io/qprocess_p.h
new file mode 100644
index 0000000..f67fd2d
--- /dev/null
+++ b/src/corelib/io/qprocess_p.h
@@ -0,0 +1,230 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROCESS_P_H
+#define QPROCESS_P_H
+
+//
+//  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.
+//
+
+#include "QtCore/qprocess.h"
+#include "QtCore/qstringlist.h"
+#include "private/qringbuffer_p.h"
+#include "private/qiodevice_p.h"
+
+#ifdef Q_OS_WIN
+#include "QtCore/qt_windows.h"
+typedef HANDLE Q_PIPE;
+#define INVALID_Q_PIPE INVALID_HANDLE_VALUE
+#else
+typedef int Q_PIPE;
+#define INVALID_Q_PIPE -1
+#endif
+
+#ifndef QT_NO_PROCESS
+
+QT_BEGIN_NAMESPACE
+
+class QSocketNotifier;
+class QWindowsPipeWriter;
+class QWinEventNotifier;
+class QTimer;
+
+class QProcessPrivate : public QIODevicePrivate
+{
+public:
+    Q_DECLARE_PUBLIC(QProcess)
+
+    struct Channel {
+        enum ProcessChannelType {
+            Normal = 0,
+            PipeSource = 1,
+            PipeSink = 2,
+            Redirect = 3
+            // if you add "= 4" here, increase the number of bits below
+        };
+
+        Channel() : process(0), notifier(0), type(Normal), closed(false), append(false)
+        {
+            pipe[0] = INVALID_Q_PIPE;
+            pipe[1] = INVALID_Q_PIPE;
+        }
+
+        void clear();
+
+        Channel &operator=(const QString &fileName)
+        {
+            clear();
+            file = fileName;
+            type = fileName.isEmpty() ? Normal : Redirect;
+            return *this;
+        }
+
+        void pipeTo(QProcessPrivate *other)
+        {
+            clear();
+            process = other;
+            type = PipeSource;
+        }
+
+        void pipeFrom(QProcessPrivate *other)
+        {
+            clear();
+            process = other;
+            type = PipeSink;
+        }
+
+        QString file;
+        QProcessPrivate *process;
+        QSocketNotifier *notifier;
+        Q_PIPE pipe[2];
+
+        unsigned type : 2;
+        bool closed : 1;
+        bool append : 1;
+    };
+
+    QProcessPrivate();
+    virtual ~QProcessPrivate();
+
+    // private slots
+    bool _q_canReadStandardOutput();
+    bool _q_canReadStandardError();
+    bool _q_canWrite();
+    bool _q_startupNotification();
+    bool _q_processDied();
+    void _q_notified();
+
+    QProcess::ProcessChannel processChannel;
+    QProcess::ProcessChannelMode processChannelMode;
+    QProcess::ProcessError processError;
+    QProcess::ProcessState processState;
+    QString workingDirectory;
+    Q_PID pid;
+    int sequenceNumber;
+
+    bool dying;
+    bool emittedReadyRead;
+    bool emittedBytesWritten;
+
+    Channel stdinChannel;
+    Channel stdoutChannel;
+    Channel stderrChannel;
+    bool createChannel(Channel &channel);
+    void closeWriteChannel();
+
+    QString program;
+    QStringList arguments;
+    QHash<QString, QString> *environment;
+
+    QRingBuffer outputReadBuffer;
+    QRingBuffer errorReadBuffer;
+    QRingBuffer writeBuffer;
+
+    Q_PIPE childStartedPipe[2];
+    Q_PIPE deathPipe[2];
+    void destroyPipe(Q_PIPE pipe[2]);
+
+    QSocketNotifier *startupSocketNotifier;
+    QSocketNotifier *deathNotifier;
+
+    // the wonderful windows notifier
+    QTimer *notifier;
+    QWindowsPipeWriter *pipeWriter;
+    QWinEventNotifier *processFinishedNotifier;
+
+    void startProcess();
+#ifdef Q_OS_UNIX
+    void execChild(const char *workingDirectory, char **path, char **argv, char **envp);
+#endif
+    bool processStarted();
+    void terminateProcess();
+    void killProcess();
+    void findExitCode();
+#ifdef Q_OS_UNIX
+    bool waitForDeadChild();
+#endif
+#ifdef Q_OS_WIN
+    void flushPipeWriter();
+    qint64 pipeWriterBytesToWrite() const;
+#endif
+
+    static bool startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory = QString(),
+                              qint64 *pid = 0);
+
+    int exitCode;
+    QProcess::ExitStatus exitStatus;
+    bool crashed;
+#ifdef Q_OS_UNIX
+    int serial;
+#endif
+
+    bool waitForStarted(int msecs = 30000);
+    bool waitForReadyRead(int msecs = 30000);
+    bool waitForBytesWritten(int msecs = 30000);
+    bool waitForFinished(int msecs = 30000);
+    bool waitForWrite(int msecs = 30000);
+
+    qint64 bytesAvailableFromStdout() const;
+    qint64 bytesAvailableFromStderr() const;
+    qint64 readFromStdout(char *data, qint64 maxlen);
+    qint64 readFromStderr(char *data, qint64 maxlen);
+    qint64 writeToStdin(const char *data, qint64 maxlen);
+
+    void cleanup();
+#ifdef Q_OS_UNIX
+    static void initializeProcessManager();
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PROCESS
+
+#endif // QPROCESS_P_H
diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp
new file mode 100644
index 0000000..5537c9d
--- /dev/null
+++ b/src/corelib/io/qprocess_unix.cpp
@@ -0,0 +1,1386 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+//#define QPROCESS_DEBUG
+#include "qdebug.h"
+
+#ifndef QT_NO_PROCESS
+
+#if defined QPROCESS_DEBUG
+#include "qstring.h"
+#include <ctype.h>
+
+/*
+    Returns a human readable representation of the first \a len
+    characters in \a data.
+*/
+QT_BEGIN_NAMESPACE
+static QByteArray qt_prettyDebug(const char *data, int len, int maxSize)
+{
+    if (!data) return "(null)";
+    QByteArray out;
+    for (int i = 0; i < len; ++i) {
+        char c = data[i];
+        if (isprint(c)) {
+            out += c;
+        } else switch (c) {
+        case '\n': out += "\\n"; break;
+        case '\r': out += "\\r"; break;
+        case '\t': out += "\\t"; break;
+        default:
+            QString tmp;
+            tmp.sprintf("\\%o", c);
+            out += tmp.toLatin1();
+        }
+    }
+
+    if (len < maxSize)
+        out += "...";
+
+    return out;
+}
+QT_END_NAMESPACE
+#endif
+
+#include "qplatformdefs.h"
+
+#include "qprocess.h"
+#include "qprocess_p.h"
+
+#ifdef Q_OS_MAC
+#include <private/qcore_mac_p.h>
+#endif
+
+#include <private/qcoreapplication_p.h>
+#include <private/qthread_p.h>
+#include <qdatetime.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qlist.h>
+#include <qmap.h>
+#include <qmutex.h>
+#include <qsemaphore.h>
+#include <qsocketnotifier.h>
+#include <qthread.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_OS_INTEGRITY
+static inline char *strdup(const char *data)
+{
+    return qstrdup(data);
+}
+#endif
+
+static qint64 qt_native_read(int fd, char *data, qint64 maxlen)
+{
+    qint64 ret = 0;
+    do {
+        ret = ::read(fd, data, maxlen);
+    } while (ret == -1 && errno == EINTR);
+    return ret;
+}
+
+static qint64 qt_native_write(int fd, const char *data, qint64 len)
+{
+    qint64 ret = 0;
+    do {
+        ret = ::write(fd, data, len);
+    } while (ret == -1 && errno == EINTR);
+    return ret;
+}
+
+static void qt_native_close(int fd)
+{
+    int ret;
+    do {
+        ret = ::close(fd);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static void qt_native_sigaction(int signum, const struct sigaction *act,
+                                struct sigaction *oldact)
+{
+    int ret;
+    do {
+        ret = ::sigaction(signum, act, oldact);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static void qt_native_dup2(int oldfd, int newfd)
+{
+    int ret;
+    do {
+        ret = ::dup2(oldfd, newfd);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static void qt_native_chdir(const char *path)
+{
+    int ret;
+    do {
+        ret = ::chdir(path);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static void qt_native_execve(const char *filename, char *const argv[],
+                              char *const envp[])
+{
+    int ret;
+    do {
+        ret = ::execve(filename, argv, envp);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static void qt_native_execv(const char *path, char *const argv[])
+{
+    int ret;
+    do {
+        ret = ::execv(path, argv);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static void qt_native_execvp(const char *file, char *const argv[])
+{
+    int ret;
+    do {
+        ret = ::execvp(file, argv);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static int qt_qprocess_deadChild_pipe[2];
+static void (*qt_sa_old_sigchld_handler)(int) = 0;
+static void qt_sa_sigchld_handler(int signum)
+{
+    qt_native_write(qt_qprocess_deadChild_pipe[1], "", 1);
+#if defined (QPROCESS_DEBUG)
+    fprintf(stderr, "*** SIGCHLD\n");
+#endif
+
+    if (qt_sa_old_sigchld_handler && qt_sa_old_sigchld_handler != SIG_IGN)
+        qt_sa_old_sigchld_handler(signum);
+}
+
+struct QProcessInfo {
+    QProcess *process;
+    int deathPipe;
+    int exitResult;
+    pid_t pid;
+    int serialNumber;
+};
+
+class QProcessManager : public QThread
+{
+    Q_OBJECT
+public:
+    QProcessManager();
+    ~QProcessManager();
+
+    void run();
+    void catchDeadChildren();
+    void add(pid_t pid, QProcess *process);
+    void remove(QProcess *process);
+    void lock();
+    void unlock();
+
+private:
+    QMutex mutex;
+    QMap<int, QProcessInfo *> children;
+};
+
+Q_GLOBAL_STATIC(QProcessManager, processManager)
+
+QProcessManager::QProcessManager()
+{
+#if defined (QPROCESS_DEBUG)
+    qDebug() << "QProcessManager::QProcessManager()";
+#endif
+    // initialize the dead child pipe and make it non-blocking. in the
+    // extremely unlikely event that the pipe fills up, we do not under any
+    // circumstances want to block.
+    ::pipe(qt_qprocess_deadChild_pipe);
+    ::fcntl(qt_qprocess_deadChild_pipe[0], F_SETFD, FD_CLOEXEC);
+    ::fcntl(qt_qprocess_deadChild_pipe[1], F_SETFD, FD_CLOEXEC);
+    ::fcntl(qt_qprocess_deadChild_pipe[0], F_SETFL,
+	    ::fcntl(qt_qprocess_deadChild_pipe[0], F_GETFL) | O_NONBLOCK);
+    ::fcntl(qt_qprocess_deadChild_pipe[1], F_SETFL,
+	    ::fcntl(qt_qprocess_deadChild_pipe[1], F_GETFL) | O_NONBLOCK);
+
+    // set up the SIGCHLD handler, which writes a single byte to the dead
+    // child pipe every time a child dies.
+    struct sigaction oldAction;
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_handler = qt_sa_sigchld_handler;
+    action.sa_flags = SA_NOCLDSTOP;
+    qt_native_sigaction(SIGCHLD, &action, &oldAction);
+    if (oldAction.sa_handler != qt_sa_sigchld_handler)
+	qt_sa_old_sigchld_handler = oldAction.sa_handler;
+}
+
+QProcessManager::~QProcessManager()
+{
+    // notify the thread that we're shutting down.
+    qt_native_write(qt_qprocess_deadChild_pipe[1], "@", 1);
+    qt_native_close(qt_qprocess_deadChild_pipe[1]);
+    wait();
+
+    // on certain unixes, closing the reading end of the pipe will cause
+    // select in run() to block forever, rather than return with EBADF.
+    qt_native_close(qt_qprocess_deadChild_pipe[0]);
+
+    qt_qprocess_deadChild_pipe[0] = -1;
+    qt_qprocess_deadChild_pipe[1] = -1;
+
+    qDeleteAll(children.values());
+    children.clear();
+
+    struct sigaction oldAction;
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_handler = qt_sa_old_sigchld_handler;
+    action.sa_flags = SA_NOCLDSTOP;
+    qt_native_sigaction(SIGCHLD, &action, &oldAction);
+    if (oldAction.sa_handler != qt_sa_sigchld_handler) {
+        qt_native_sigaction(SIGCHLD, &oldAction, 0);
+    }
+}
+
+void QProcessManager::run()
+{
+    forever {
+        fd_set readset;
+        FD_ZERO(&readset);
+        FD_SET(qt_qprocess_deadChild_pipe[0], &readset);
+
+#if defined (QPROCESS_DEBUG)
+        qDebug() << "QProcessManager::run() waiting for children to die";
+#endif
+
+        // block forever, or until activity is detected on the dead child
+        // pipe. the only other peers are the SIGCHLD signal handler, and the
+        // QProcessManager destructor.
+        int nselect = select(qt_qprocess_deadChild_pipe[0] + 1, &readset, 0, 0, 0);
+        if (nselect < 0) {
+            if (errno == EINTR)
+                continue;
+            break;
+        }
+
+        // empty only one byte from the pipe, even though several SIGCHLD
+        // signals may have been delivered in the meantime, to avoid race
+        // conditions.
+        char c;
+        if (qt_native_read(qt_qprocess_deadChild_pipe[0], &c, 1) < 0 || c == '@')
+            break;
+
+        // catch any and all children that we can.
+        catchDeadChildren();
+    }
+}
+
+void QProcessManager::catchDeadChildren()
+{
+    QMutexLocker locker(&mutex);
+
+    // try to catch all children whose pid we have registered, and whose
+    // deathPipe is still valid (i.e, we have not already notified it).
+    QMap<int, QProcessInfo *>::Iterator it = children.begin();
+    while (it != children.end()) {
+        // notify all children that they may have died. they need to run
+        // waitpid() in their own thread.
+        QProcessInfo *info = it.value();
+        qt_native_write(info->deathPipe, "", 1);
+
+#if defined (QPROCESS_DEBUG)
+        qDebug() << "QProcessManager::run() sending death notice to" << info->process;
+#endif
+        ++it;
+    }
+}
+
+static QBasicAtomicInt idCounter = Q_BASIC_ATOMIC_INITIALIZER(1);
+
+void QProcessManager::add(pid_t pid, QProcess *process)
+{
+#if defined (QPROCESS_DEBUG)
+    qDebug() << "QProcessManager::add() adding pid" << pid << "process" << process;
+#endif
+
+    // insert a new info structure for this process
+    QProcessInfo *info = new QProcessInfo;
+    info->process = process;
+    info->deathPipe = process->d_func()->deathPipe[1];
+    info->exitResult = 0;
+    info->pid = pid;
+
+    int serial = idCounter.fetchAndAddRelaxed(1);
+    process->d_func()->serial = serial;
+    children.insert(serial, info);
+}
+
+void QProcessManager::remove(QProcess *process)
+{
+    QMutexLocker locker(&mutex);
+
+    int serial = process->d_func()->serial;
+    QProcessInfo *info = children.value(serial);
+    if (!info)
+        return;
+
+#if defined (QPROCESS_DEBUG)
+    qDebug() << "QProcessManager::remove() removing pid" << info->pid << "process" << info->process;
+#endif
+
+    children.remove(serial);
+    delete info;
+}
+
+void QProcessManager::lock()
+{
+    mutex.lock();
+}
+
+void QProcessManager::unlock()
+{
+    mutex.unlock();
+}
+
+static void qt_create_pipe(int *pipe)
+{
+    if (pipe[0] != -1)
+        qt_native_close(pipe[0]);
+    if (pipe[1] != -1)
+        qt_native_close(pipe[1]);
+#ifdef Q_OS_IRIX
+    if (::socketpair(AF_UNIX, SOCK_STREAM, 0, pipe) == -1) {
+        qWarning("QProcessPrivate::createPipe: Cannot create pipe %p: %s",
+                 pipe, qPrintable(qt_error_string(errno)));
+    }
+#else
+    if (::pipe(pipe) != 0) {
+        qWarning("QProcessPrivate::createPipe: Cannot create pipe %p: %s",
+                 pipe, qPrintable(qt_error_string(errno)));
+    }
+#endif
+    ::fcntl(pipe[0], F_SETFD, FD_CLOEXEC);
+    ::fcntl(pipe[1], F_SETFD, FD_CLOEXEC);
+}
+
+void QProcessPrivate::destroyPipe(int *pipe)
+{
+    if (pipe[1] != -1) {
+        qt_native_close(pipe[1]);
+        pipe[1] = -1;
+    }
+    if (pipe[0] != -1) {
+        qt_native_close(pipe[0]);
+        pipe[0] = -1;
+    }
+}
+
+/*
+    Create the pipes to a QProcessPrivate::Channel.
+
+    This function must be called in order: stdin, stdout, stderr
+*/
+bool QProcessPrivate::createChannel(Channel &channel)
+{
+    Q_Q(QProcess);
+
+    if (&channel == &stderrChannel && processChannelMode == QProcess::MergedChannels) {
+        channel.pipe[0] = -1;
+        channel.pipe[1] = -1;
+        return true;
+    }
+
+    if (channel.type == Channel::Normal) {
+        // we're piping this channel to our own process
+        qt_create_pipe(channel.pipe);
+
+        // create the socket notifiers
+        if (threadData->eventDispatcher) {
+            if (&channel == &stdinChannel) {
+                channel.notifier = new QSocketNotifier(channel.pipe[1],
+                                                       QSocketNotifier::Write, q);
+                channel.notifier->setEnabled(false);
+                QObject::connect(channel.notifier, SIGNAL(activated(int)),
+                                 q, SLOT(_q_canWrite()));
+            } else {
+                channel.notifier = new QSocketNotifier(channel.pipe[0],
+                                                       QSocketNotifier::Read, q);
+                const char *receiver;
+                if (&channel == &stdoutChannel)
+                    receiver = SLOT(_q_canReadStandardOutput());
+                else
+                    receiver = SLOT(_q_canReadStandardError());
+                QObject::connect(channel.notifier, SIGNAL(activated(int)),
+                                 q, receiver);
+            }
+        }
+
+        return true;
+    } else if (channel.type == Channel::Redirect) {
+        // we're redirecting the channel to/from a file
+        QByteArray fname = QFile::encodeName(channel.file);
+
+        if (&channel == &stdinChannel) {
+            // try to open in read-only mode
+            channel.pipe[1] = -1;
+            if ( (channel.pipe[0] = QT_OPEN(fname, O_RDONLY)) != -1)
+                return true;    // success
+
+            q->setErrorString(QProcess::tr("Could not open input redirection for reading"));
+        } else {
+            int mode = O_WRONLY | O_CREAT;
+            if (channel.append)
+                mode |= O_APPEND;
+            else
+                mode |= O_TRUNC;
+
+            channel.pipe[0] = -1;
+            if ( (channel.pipe[1] = QT_OPEN(fname, mode, 0666)) != -1)
+                return true; // success
+
+            q->setErrorString(QProcess::tr("Could not open output redirection for writing"));
+        }
+
+        // could not open file
+        processError = QProcess::FailedToStart;
+        emit q->error(processError);
+        cleanup();
+        return false;
+    } else {
+        Q_ASSERT_X(channel.process, "QProcess::start", "Internal error");
+
+        Channel *source;
+        Channel *sink;
+
+        if (channel.type == Channel::PipeSource) {
+            // we are the source
+            source = &channel;
+            sink = &channel.process->stdinChannel;
+
+            Q_ASSERT(source == &stdoutChannel);
+            Q_ASSERT(sink->process == this && sink->type == Channel::PipeSink);
+        } else {
+            // we are the sink;
+            source = &channel.process->stdoutChannel;
+            sink = &channel;
+
+            Q_ASSERT(sink == &stdinChannel);
+            Q_ASSERT(source->process == this && source->type == Channel::PipeSource);
+        }
+
+        if (source->pipe[1] != INVALID_Q_PIPE || sink->pipe[0] != INVALID_Q_PIPE) {
+            // already created, do nothing
+            return true;
+        } else {
+            Q_ASSERT(source->pipe[0] == INVALID_Q_PIPE && source->pipe[1] == INVALID_Q_PIPE);
+            Q_ASSERT(sink->pipe[0] == INVALID_Q_PIPE && sink->pipe[1] == INVALID_Q_PIPE);
+
+            Q_PIPE pipe[2] = { -1, -1 };
+            qt_create_pipe(pipe);
+            sink->pipe[0] = pipe[0];
+            source->pipe[1] = pipe[1];
+
+            return true;
+        }
+    }
+}
+
+static char **_q_dupEnvironment(const QHash<QString, QString> *environment, int *envc)
+{
+    *envc = 0;
+    if (!environment)
+        return 0;               // use the default environment
+
+    // if LD_LIBRARY_PATH exists in the current environment, but
+    // not in the environment list passed by the programmer, then
+    // copy it over.
+#if defined(Q_OS_MAC)
+    static const char libraryPath[] = "DYLD_LIBRARY_PATH";
+#else
+    static const char libraryPath[] = "LD_LIBRARY_PATH";
+#endif
+    const QByteArray envLibraryPath = qgetenv(libraryPath);
+    bool needToAddLibraryPath = !envLibraryPath.isEmpty() &&
+                                !environment->contains(QLatin1String(libraryPath));
+
+    char **envp = new char *[environment->count() + 2];
+    envp[environment->count()] = 0;
+    envp[environment->count() + 1] = 0;
+
+    QHash<QString, QString>::ConstIterator it = environment->constBegin();
+    const QHash<QString, QString>::ConstIterator end = environment->constEnd();
+    for ( ; it != end; ++it) {
+        QByteArray key = it.key().toLocal8Bit();
+        QByteArray value = it.value().toLocal8Bit();
+        key.reserve(key.length() + 1 + value.length());
+        key.append('=');
+        key.append(value);
+
+        envp[(*envc)++] = ::strdup(key.constData());
+    }
+
+    if (needToAddLibraryPath)
+        envp[(*envc)++] = ::strdup(QByteArray(libraryPath) + '=' +
+                                 envLibraryPath);
+    return envp;
+}
+
+// under QNX RTOS we have to use vfork() when multithreading
+inline pid_t qt_fork()
+{
+#if defined(Q_OS_QNX)
+    return vfork();
+#else
+    return fork();
+#endif
+}
+
+#ifdef Q_OS_MAC
+Q_GLOBAL_STATIC(QMutex, cfbundleMutex);
+#endif
+
+void QProcessPrivate::startProcess()
+{
+    Q_Q(QProcess);
+
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::startProcess()");
+#endif
+
+    processManager()->start();
+
+    // Initialize pipes
+    qt_create_pipe(childStartedPipe);
+    if (threadData->eventDispatcher) {
+        startupSocketNotifier = new QSocketNotifier(childStartedPipe[0],
+                                                    QSocketNotifier::Read, q);
+        QObject::connect(startupSocketNotifier, SIGNAL(activated(int)),
+                         q, SLOT(_q_startupNotification()));
+    }
+
+    qt_create_pipe(deathPipe);
+    ::fcntl(deathPipe[0], F_SETFD, FD_CLOEXEC);
+    ::fcntl(deathPipe[1], F_SETFD, FD_CLOEXEC);
+    if (threadData->eventDispatcher) {
+        deathNotifier = new QSocketNotifier(deathPipe[0],
+                                            QSocketNotifier::Read, q);
+        QObject::connect(deathNotifier, SIGNAL(activated(int)),
+                         q, SLOT(_q_processDied()));
+    }
+
+    if (!createChannel(stdinChannel) ||
+        !createChannel(stdoutChannel) ||
+        !createChannel(stderrChannel))
+        return;
+
+    // Start the process (platform dependent)
+    q->setProcessState(QProcess::Starting);
+
+    // Create argument list with right number of elements, and set the final
+    // one to 0.
+    char **argv = new char *[arguments.count() + 2];
+    argv[arguments.count() + 1] = 0;
+
+    // Encode the program name.
+    QByteArray encodedProgramName = QFile::encodeName(program);
+#ifdef Q_OS_MAC
+    // allow invoking of .app bundles on the Mac.
+    QFileInfo fileInfo(QString::fromUtf8(encodedProgramName.constData()));
+    if (encodedProgramName.endsWith(".app") && fileInfo.isDir()) {
+        QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0,
+                                                          QCFString(fileInfo.absoluteFilePath()),
+                                                          kCFURLPOSIXPathStyle, true);
+        {
+            // CFBundle is not reentrant, since CFBundleCreate might return a reference
+            // to a cached bundle object. Protect the bundle calls with a mutex lock.
+            QMutexLocker lock(cfbundleMutex());
+            QCFType<CFBundleRef> bundle = CFBundleCreate(0, url);
+            url = CFBundleCopyExecutableURL(bundle);
+        }
+        if (url) {
+            QCFString str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
+            encodedProgramName += "/Contents/MacOS/" + static_cast<QString>(str).toUtf8();
+        }
+    }
+#endif
+
+    // Add the program name to the argument list.
+    char *dupProgramName = ::strdup(encodedProgramName.constData());
+    argv[0] = dupProgramName;
+
+    // Add every argument to the list
+    for (int i = 0; i < arguments.count(); ++i) {
+        QString arg = arguments.at(i);
+#ifdef Q_OS_MAC
+        // Mac OS X uses UTF8 for exec, regardless of the system locale.
+        argv[i + 1] = ::strdup(arg.toUtf8().constData());
+#else
+        argv[i + 1] = ::strdup(arg.toLocal8Bit().constData());
+#endif
+    }
+
+    // Duplicate the environment.
+    int envc = 0;
+    char **envp = _q_dupEnvironment(environment, &envc);
+
+    // Encode the working directory if it's non-empty, otherwise just pass 0.
+    const char *workingDirPtr = 0;
+    QByteArray encodedWorkingDirectory;
+    if (!workingDirectory.isEmpty()) {
+        encodedWorkingDirectory = QFile::encodeName(workingDirectory);
+        workingDirPtr = encodedWorkingDirectory.constData();
+    }
+
+    // If the program does not specify a path, generate a list of possible
+    // locations for the binary using the PATH environment variable.
+    char **path = 0;
+    int pathc = 0;
+    if (!program.contains(QLatin1Char('/'))) {
+        const QString pathEnv = QString::fromLocal8Bit(::getenv("PATH"));
+        if (!pathEnv.isEmpty()) {
+            QStringList pathEntries = pathEnv.split(QLatin1Char(':'), QString::SkipEmptyParts);
+            if (!pathEntries.isEmpty()) {
+                pathc = pathEntries.size();
+                path = new char *[pathc + 1];
+                path[pathc] = 0;
+
+                for (int k = 0; k < pathEntries.size(); ++k) {
+                    QByteArray tmp = QFile::encodeName(pathEntries.at(k));
+                    if (!tmp.endsWith('/')) tmp += '/';
+                    tmp += encodedProgramName;
+                    path[k] = ::strdup(tmp.constData());
+                }
+            }
+        }
+    }
+
+    // Start the process manager, and fork off the child process.
+    processManager()->lock();
+    pid_t childPid = qt_fork();
+    int lastForkErrno = errno;
+    if (childPid != 0) {
+        // Clean up duplicated memory.
+        free(dupProgramName);
+        for (int i = 1; i <= arguments.count(); ++i)
+            free(argv[i]);
+        for (int i = 0; i < envc; ++i)
+            free(envp[i]);
+        for (int i = 0; i < pathc; ++i)
+            free(path[i]);
+        delete [] argv;
+        delete [] envp;
+        delete [] path;
+    }
+    if (childPid < 0) {
+        // Cleanup, report error and return
+#if defined (QPROCESS_DEBUG)
+        qDebug("qt_fork failed: %s", qt_error_string(lastForkErrno));
+#endif
+        processManager()->unlock();
+        q->setProcessState(QProcess::NotRunning);
+        processError = QProcess::FailedToStart;
+        q->setErrorString(QProcess::tr("Resource error (fork failure): %1").arg(qt_error_string(lastForkErrno)));
+        emit q->error(processError);
+        cleanup();
+        return;
+    }
+
+    // Start the child.
+    if (childPid == 0) {
+        execChild(workingDirPtr, path, argv, envp);
+        ::_exit(-1);
+    }
+
+    // Register the child. In the mean time, we can get a SIGCHLD, so we need
+    // to keep the lock held to avoid a race to catch the child.
+    processManager()->add(childPid, q);
+    pid = Q_PID(childPid);
+    processManager()->unlock();
+
+    // parent
+    // close the ends we don't use and make all pipes non-blocking
+    ::fcntl(deathPipe[0], F_SETFL, ::fcntl(deathPipe[0], F_GETFL) | O_NONBLOCK);
+    qt_native_close(childStartedPipe[1]);
+    childStartedPipe[1] = -1;
+
+    if (stdinChannel.pipe[0] != -1) {
+        qt_native_close(stdinChannel.pipe[0]);
+        stdinChannel.pipe[0] = -1;
+    }
+
+    if (stdinChannel.pipe[1] != -1)
+        ::fcntl(stdinChannel.pipe[1], F_SETFL, ::fcntl(stdinChannel.pipe[1], F_GETFL) | O_NONBLOCK);
+
+    if (stdoutChannel.pipe[1] != -1) {
+        qt_native_close(stdoutChannel.pipe[1]);
+        stdoutChannel.pipe[1] = -1;
+    }
+
+    if (stdoutChannel.pipe[0] != -1)
+        ::fcntl(stdoutChannel.pipe[0], F_SETFL, ::fcntl(stdoutChannel.pipe[0], F_GETFL) | O_NONBLOCK);
+
+    if (stderrChannel.pipe[1] != -1) {
+        qt_native_close(stderrChannel.pipe[1]);
+        stderrChannel.pipe[1] = -1;
+    }
+    if (stderrChannel.pipe[0] != -1)
+        ::fcntl(stderrChannel.pipe[0], F_SETFL, ::fcntl(stderrChannel.pipe[0], F_GETFL) | O_NONBLOCK);
+}
+
+void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv, char **envp)
+{
+    ::signal(SIGPIPE, SIG_DFL);         // reset the signal that we ignored
+
+    Q_Q(QProcess);
+
+    // copy the stdin socket
+    qt_native_dup2(stdinChannel.pipe[0], fileno(stdin));
+
+    // copy the stdout and stderr if asked to
+    if (processChannelMode != QProcess::ForwardedChannels) {
+        qt_native_dup2(stdoutChannel.pipe[1], fileno(stdout));
+
+        // merge stdout and stderr if asked to
+        if (processChannelMode == QProcess::MergedChannels) {
+            qt_native_dup2(fileno(stdout), fileno(stderr));
+        } else {
+            qt_native_dup2(stderrChannel.pipe[1], fileno(stderr));
+        }
+    }
+
+    // make sure this fd is closed if execvp() succeeds
+    qt_native_close(childStartedPipe[0]);
+    ::fcntl(childStartedPipe[1], F_SETFD, FD_CLOEXEC);
+
+    // enter the working directory
+    if (workingDir)
+        qt_native_chdir(workingDir);
+
+    // this is a virtual call, and it base behavior is to do nothing.
+    q->setupChildProcess();
+
+    // execute the process
+    if (!envp) {
+        qt_native_execvp(argv[0], argv);
+    } else {
+        if (path) {
+            char **arg = path;
+            while (*arg) {
+                argv[0] = *arg;
+#if defined (QPROCESS_DEBUG)
+                fprintf(stderr, "QProcessPrivate::execChild() searching / starting %s\n", argv[0]);
+#endif
+                qt_native_execve(argv[0], argv, envp);
+                ++arg;
+            }
+        } else {
+#if defined (QPROCESS_DEBUG)
+            fprintf(stderr, "QProcessPrivate::execChild() starting %s\n", argv[0]);
+#endif
+            qt_native_execve(argv[0], argv, envp);
+        }
+    }
+
+    // notify failure
+#if defined (QPROCESS_DEBUG)
+    fprintf(stderr, "QProcessPrivate::execChild() failed, notifying parent process\n");
+#endif
+    qt_native_write(childStartedPipe[1], "", 1);
+    qt_native_close(childStartedPipe[1]);
+    childStartedPipe[1] = -1;
+}
+
+bool QProcessPrivate::processStarted()
+{
+    char c;
+    int i = qt_native_read(childStartedPipe[0], &c, 1);
+    if (startupSocketNotifier) {
+        startupSocketNotifier->setEnabled(false);
+        startupSocketNotifier->deleteLater();
+        startupSocketNotifier = 0;
+    }
+    qt_native_close(childStartedPipe[0]);
+    childStartedPipe[0] = -1;
+
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::processStarted() == %s", i <= 0 ? "true" : "false");
+#endif
+    return i <= 0;
+}
+
+qint64 QProcessPrivate::bytesAvailableFromStdout() const
+{
+    size_t nbytes = 0;
+    qint64 available = 0;
+    if (::ioctl(stdoutChannel.pipe[0], FIONREAD, (char *) &nbytes) >= 0)
+        available = (qint64) *((int *) &nbytes);
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::bytesAvailableFromStdout() == %lld", available);
+#endif
+    return available;
+}
+
+qint64 QProcessPrivate::bytesAvailableFromStderr() const
+{
+    size_t nbytes = 0;
+    qint64 available = 0;
+    if (::ioctl(stderrChannel.pipe[0], FIONREAD, (char *) &nbytes) >= 0)
+        available = (qint64) *((int *) &nbytes);
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::bytesAvailableFromStderr() == %lld", available);
+#endif
+    return available;
+}
+
+qint64 QProcessPrivate::readFromStdout(char *data, qint64 maxlen)
+{
+    qint64 bytesRead = qt_native_read(stdoutChannel.pipe[0], data, maxlen);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::readFromStdout(%p \"%s\", %lld) == %lld",
+           data, qt_prettyDebug(data, bytesRead, 16).constData(), maxlen, bytesRead);
+#endif
+    return bytesRead;
+}
+
+qint64 QProcessPrivate::readFromStderr(char *data, qint64 maxlen)
+{
+    qint64 bytesRead = qt_native_read(stderrChannel.pipe[0], data, maxlen);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::readFromStderr(%p \"%s\", %lld) == %lld",
+           data, qt_prettyDebug(data, bytesRead, 16).constData(), maxlen, bytesRead);
+#endif
+    return bytesRead;
+}
+
+static void qt_ignore_sigpipe()
+{
+    // Set to ignore SIGPIPE once only.
+    static QBasicAtomicInt atom = Q_BASIC_ATOMIC_INITIALIZER(0);
+    if (atom.testAndSetRelaxed(0, 1)) {
+        struct sigaction noaction;
+        memset(&noaction, 0, sizeof(noaction));
+        noaction.sa_handler = SIG_IGN;
+        qt_native_sigaction(SIGPIPE, &noaction, 0);
+    }
+}
+
+qint64 QProcessPrivate::writeToStdin(const char *data, qint64 maxlen)
+{
+    qt_ignore_sigpipe();
+
+    qint64 written = qt_native_write(stdinChannel.pipe[1], data, maxlen);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::writeToStdin(%p \"%s\", %lld) == %lld",
+           data, qt_prettyDebug(data, maxlen, 16).constData(), maxlen, written);
+#endif
+    return written;
+}
+
+void QProcessPrivate::terminateProcess()
+{
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::killProcess()");
+#endif
+    if (pid)
+        ::kill(pid_t(pid), SIGTERM);
+}
+
+void QProcessPrivate::killProcess()
+{
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::killProcess()");
+#endif
+    if (pid)
+        ::kill(pid_t(pid), SIGKILL);
+}
+
+static int qt_native_select(fd_set *fdread, fd_set *fdwrite, int timeout)
+{
+    struct timeval tv;
+    tv.tv_sec = timeout / 1000;
+    tv.tv_usec = (timeout % 1000) * 1000;
+
+    int ret;
+    do {
+        ret = select(FD_SETSIZE, fdread, fdwrite, 0, timeout < 0 ? 0 : &tv);
+    } while (ret < 0 && (errno == EINTR));
+    return ret;
+}
+
+/*
+   Returns the difference between msecs and elapsed. If msecs is -1,
+   however, -1 is returned.
+*/
+static int qt_timeout_value(int msecs, int elapsed)
+{
+    if (msecs == -1)
+        return -1;
+
+    int timeout = msecs - elapsed;
+    return timeout < 0 ? 0 : timeout;
+}
+
+bool QProcessPrivate::waitForStarted(int msecs)
+{
+    Q_Q(QProcess);
+
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::waitForStarted(%d) waiting for child to start (fd = %d)", msecs,
+	   childStartedPipe[0]);
+#endif
+
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(childStartedPipe[0], &fds);
+    int ret;
+    do {
+        ret = qt_native_select(&fds, 0, msecs);
+    } while (ret < 0 && errno == EINTR);
+    if (ret == 0) {
+        processError = QProcess::Timedout;
+        q->setErrorString(QProcess::tr("Process operation timed out"));
+#if defined (QPROCESS_DEBUG)
+        qDebug("QProcessPrivate::waitForStarted(%d) == false (timed out)", msecs);
+#endif
+        return false;
+    }
+
+    bool startedEmitted = _q_startupNotification();
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::waitForStarted() == %s", startedEmitted ? "true" : "false");
+#endif
+    return startedEmitted;
+}
+
+bool QProcessPrivate::waitForReadyRead(int msecs)
+{
+    Q_Q(QProcess);
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::waitForReadyRead(%d)", msecs);
+#endif
+
+    QTime stopWatch;
+    stopWatch.start();
+
+    forever {
+        fd_set fdread;
+        fd_set fdwrite;
+
+        FD_ZERO(&fdread);
+        FD_ZERO(&fdwrite);
+
+        if (processState == QProcess::Starting)
+            FD_SET(childStartedPipe[0], &fdread);
+
+        if (stdoutChannel.pipe[0] != -1)
+            FD_SET(stdoutChannel.pipe[0], &fdread);
+        if (stderrChannel.pipe[0] != -1)
+            FD_SET(stderrChannel.pipe[0], &fdread);
+
+        FD_SET(deathPipe[0], &fdread);
+
+        if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
+            FD_SET(stdinChannel.pipe[1], &fdwrite);
+
+        int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
+        int ret = qt_native_select(&fdread, &fdwrite, timeout);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            break;
+        }
+        if (ret == 0) {
+            processError = QProcess::Timedout;
+            q->setErrorString(QProcess::tr("Process operation timed out"));
+	    return false;
+	}
+
+	if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
+            if (!_q_startupNotification())
+                return false;
+	}
+
+        bool readyReadEmitted = false;
+	if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread)) {
+	    bool canRead = _q_canReadStandardOutput();
+            if (processChannel == QProcess::StandardOutput && canRead)
+                readyReadEmitted = true;
+	}
+	if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread)) {
+	    bool canRead = _q_canReadStandardError();
+            if (processChannel == QProcess::StandardError && canRead)
+                readyReadEmitted = true;
+	}
+        if (readyReadEmitted)
+            return true;
+
+	if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
+	    _q_canWrite();
+
+	if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
+            if (_q_processDied())
+                return false;
+        }
+    }
+    return false;
+}
+
+bool QProcessPrivate::waitForBytesWritten(int msecs)
+{
+    Q_Q(QProcess);
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::waitForBytesWritten(%d)", msecs);
+#endif
+
+    QTime stopWatch;
+    stopWatch.start();
+
+    while (!writeBuffer.isEmpty()) {
+        fd_set fdread;
+        fd_set fdwrite;
+
+        FD_ZERO(&fdread);
+        FD_ZERO(&fdwrite);
+
+        if (processState == QProcess::Starting)
+            FD_SET(childStartedPipe[0], &fdread);
+
+        if (stdoutChannel.pipe[0] != -1)
+            FD_SET(stdoutChannel.pipe[0], &fdread);
+        if (stderrChannel.pipe[0] != -1)
+            FD_SET(stderrChannel.pipe[0], &fdread);
+
+        FD_SET(deathPipe[0], &fdread);
+
+        if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
+            FD_SET(stdinChannel.pipe[1], &fdwrite);
+
+	int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
+	int ret = qt_native_select(&fdread, &fdwrite, timeout);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            break;
+        }
+
+        if (ret == 0) {
+	    processError = QProcess::Timedout;
+	    q->setErrorString(QProcess::tr("Process operation timed out"));
+	    return false;
+	}
+
+	if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
+	    if (!_q_startupNotification())
+		return false;
+	}
+
+	if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
+	    return _q_canWrite();
+
+	if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
+	    _q_canReadStandardOutput();
+
+	if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
+	    _q_canReadStandardError();
+
+	if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
+            if (_q_processDied())
+                return false;
+        }
+    }
+
+    return false;
+}
+
+bool QProcessPrivate::waitForFinished(int msecs)
+{
+    Q_Q(QProcess);
+#if defined (QPROCESS_DEBUG)
+    qDebug("QProcessPrivate::waitForFinished(%d)", msecs);
+#endif
+
+    QTime stopWatch;
+    stopWatch.start();
+
+    forever {
+        fd_set fdread;
+        fd_set fdwrite;
+
+        FD_ZERO(&fdread);
+        FD_ZERO(&fdwrite);
+
+        if (processState == QProcess::Starting)
+            FD_SET(childStartedPipe[0], &fdread);
+
+        if (stdoutChannel.pipe[0] != -1)
+            FD_SET(stdoutChannel.pipe[0], &fdread);
+        if (stderrChannel.pipe[0] != -1)
+            FD_SET(stderrChannel.pipe[0], &fdread);
+
+        if (processState == QProcess::Running)
+            FD_SET(deathPipe[0], &fdread);
+
+        if (!writeBuffer.isEmpty() && stdinChannel.pipe[1] != -1)
+            FD_SET(stdinChannel.pipe[1], &fdwrite);
+
+	int timeout = qt_timeout_value(msecs, stopWatch.elapsed());
+	int ret = qt_native_select(&fdread, &fdwrite, timeout);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            break;
+        }
+	if (ret == 0) {
+	    processError = QProcess::Timedout;
+	    q->setErrorString(QProcess::tr("Process operation timed out"));
+	    return false;
+	}
+
+	if (childStartedPipe[0] != -1 && FD_ISSET(childStartedPipe[0], &fdread)) {
+	    if (!_q_startupNotification())
+		return false;
+	}
+	if (stdinChannel.pipe[1] != -1 && FD_ISSET(stdinChannel.pipe[1], &fdwrite))
+	    _q_canWrite();
+
+	if (stdoutChannel.pipe[0] != -1 && FD_ISSET(stdoutChannel.pipe[0], &fdread))
+	    _q_canReadStandardOutput();
+
+	if (stderrChannel.pipe[0] != -1 && FD_ISSET(stderrChannel.pipe[0], &fdread))
+	    _q_canReadStandardError();
+
+	if (deathPipe[0] == -1 || FD_ISSET(deathPipe[0], &fdread)) {
+            if (_q_processDied())
+                return true;
+	}
+    }
+    return false;
+}
+
+bool QProcessPrivate::waitForWrite(int msecs)
+{
+    fd_set fdwrite;
+    FD_ZERO(&fdwrite);
+    FD_SET(stdinChannel.pipe[1], &fdwrite);
+
+    int ret;
+    do {
+        ret = qt_native_select(0, &fdwrite, msecs < 0 ? 0 : msecs) == 1;
+    } while (ret < 0 && errno == EINTR);
+    return ret == 1;
+}
+
+void QProcessPrivate::findExitCode()
+{
+    Q_Q(QProcess);
+    processManager()->remove(q);
+}
+
+bool QProcessPrivate::waitForDeadChild()
+{
+    Q_Q(QProcess);
+
+    // read a byte from the death pipe
+    char c;
+    qt_native_read(deathPipe[0], &c, 1);
+
+    // check if our process is dead
+    int exitStatus;
+    pid_t waitResult = 0;
+    do {
+        waitResult = waitpid(pid_t(pid), &exitStatus, WNOHANG);
+    } while ((waitResult == -1 && errno == EINTR));
+    if (waitResult > 0) {
+        processManager()->remove(q);
+        crashed = !WIFEXITED(exitStatus);
+        exitCode = WEXITSTATUS(exitStatus);
+#if defined QPROCESS_DEBUG
+        qDebug() << "QProcessPrivate::waitForDeadChild() dead with exitCode"
+                 << exitCode << ", crashed?" << crashed;
+#endif
+        return true;
+    }
+#if defined QPROCESS_DEBUG
+    qDebug() << "QProcessPrivate::waitForDeadChild() not dead!";
+#endif
+    return false;
+}
+
+void QProcessPrivate::_q_notified()
+{
+}
+
+/*! \internal
+ */
+bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid)
+{
+    processManager()->start();
+
+    QByteArray encodedWorkingDirectory = QFile::encodeName(workingDirectory);
+
+    // To catch the startup of the child
+    int startedPipe[2];
+    ::pipe(startedPipe);
+    // To communicate the pid of the child
+    int pidPipe[2];
+    ::pipe(pidPipe);
+
+    pid_t childPid = qt_fork();
+    if (childPid == 0) {
+        struct sigaction noaction;
+        memset(&noaction, 0, sizeof(noaction));
+        noaction.sa_handler = SIG_IGN;
+        qt_native_sigaction(SIGPIPE, &noaction, 0);
+
+        ::setsid();
+
+        qt_native_close(startedPipe[0]);
+        qt_native_close(pidPipe[0]);
+
+        pid_t doubleForkPid = qt_fork();
+        if (doubleForkPid == 0) {
+            ::fcntl(startedPipe[1], F_SETFD, FD_CLOEXEC);
+            qt_native_close(pidPipe[1]);
+
+            if (!encodedWorkingDirectory.isEmpty())
+                qt_native_chdir(encodedWorkingDirectory.constData());
+
+            char **argv = new char *[arguments.size() + 2];
+            for (int i = 0; i < arguments.size(); ++i) {
+#ifdef Q_OS_MAC
+                argv[i + 1] = ::strdup(arguments.at(i).toUtf8().constData());
+#else
+                argv[i + 1] = ::strdup(arguments.at(i).toLocal8Bit().constData());
+#endif
+            }
+            argv[arguments.size() + 1] = 0;
+
+            if (!program.contains(QLatin1Char('/'))) {
+                const QString path = QString::fromLocal8Bit(::getenv("PATH"));
+                if (!path.isEmpty()) {
+                    QStringList pathEntries = path.split(QLatin1Char(':'));
+                    for (int k = 0; k < pathEntries.size(); ++k) {
+                        QByteArray tmp = QFile::encodeName(pathEntries.at(k));
+                        if (!tmp.endsWith('/')) tmp += '/';
+                        tmp += QFile::encodeName(program);
+                        argv[0] = tmp.data();
+                        qt_native_execv(argv[0], argv);
+                    }
+                }
+            } else {
+                QByteArray tmp = QFile::encodeName(program);
+                argv[0] = tmp.data();
+                qt_native_execv(argv[0], argv);
+            }
+
+            struct sigaction noaction;
+            memset(&noaction, 0, sizeof(noaction));
+            noaction.sa_handler = SIG_IGN;
+            qt_native_sigaction(SIGPIPE, &noaction, 0);
+
+            // '\1' means execv failed
+            char c = '\1';
+            qt_native_write(startedPipe[1], &c, 1);
+            qt_native_close(startedPipe[1]);
+            ::_exit(1);
+        } else if (doubleForkPid == -1) {
+            struct sigaction noaction;
+            memset(&noaction, 0, sizeof(noaction));
+            noaction.sa_handler = SIG_IGN;
+            qt_native_sigaction(SIGPIPE, &noaction, 0);
+
+            // '\2' means internal error
+            char c = '\2';
+            qt_native_write(startedPipe[1], &c, 1);
+        }
+
+        qt_native_close(startedPipe[1]);
+        qt_native_write(pidPipe[1], (const char *)&doubleForkPid, sizeof(pid_t));
+        qt_native_chdir("/");
+        ::_exit(1);
+    }
+
+    qt_native_close(startedPipe[1]);
+    qt_native_close(pidPipe[1]);
+
+    if (childPid == -1) {
+        qt_native_close(startedPipe[0]);
+        qt_native_close(pidPipe[0]);
+        return false;
+    }
+
+    char reply = '\0';
+    int startResult = qt_native_read(startedPipe[0], &reply, 1);
+    int result;
+    qt_native_close(startedPipe[0]);
+    while (::waitpid(childPid, &result, 0) == -1 && errno == EINTR)
+    { }
+    bool success = (startResult != -1 && reply == '\0');
+    if (success && pid) {
+        pid_t actualPid = 0;
+        if (qt_native_read(pidPipe[0], (char *)&actualPid, sizeof(pid_t)) == sizeof(pid_t)) {
+            *pid = actualPid;
+        } else {
+            *pid = 0;
+        }
+    }
+    qt_native_close(pidPipe[0]);
+    return success;
+}
+
+void QProcessPrivate::initializeProcessManager()
+{
+    (void) processManager();
+}
+
+QT_END_NAMESPACE
+
+#include "qprocess_unix.moc"
+
+#endif // QT_NO_PROCESS
diff --git a/src/corelib/io/qprocess_win.cpp b/src/corelib/io/qprocess_win.cpp
new file mode 100644
index 0000000..5d862e5
--- /dev/null
+++ b/src/corelib/io/qprocess_win.cpp
@@ -0,0 +1,934 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qprocess.h"
+#include "qprocess_p.h"
+#include "qwindowspipewriter_p.h"
+
+#include <qdatetime.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qtimer.h>
+#include <qthread.h>
+#include <qmutex.h>
+#include <qwaitcondition.h>
+#include <private/qwineventnotifier_p.h>
+#include <private/qthread_p.h>
+#include <qdebug.h>
+
+#include "private/qfsfileengine_p.h" // for longFileName and win95FileName
+
+
+#ifndef QT_NO_PROCESS
+
+QT_BEGIN_NAMESPACE
+
+//#define QPROCESS_DEBUG
+
+#define NOTIFYTIMEOUT 100
+
+static void qt_create_pipe(Q_PIPE *pipe, bool in)
+{
+    // Open the pipes.  Make non-inheritable copies of input write and output
+    // read handles to avoid non-closable handles (this is done by the
+    // DuplicateHandle() call).
+
+#if !defined(Q_OS_WINCE)
+    SECURITY_ATTRIBUTES secAtt = { sizeof( SECURITY_ATTRIBUTES ), NULL, TRUE };
+
+    HANDLE tmpHandle;
+    if (in) {                   // stdin
+        if (!CreatePipe(&pipe[0], &tmpHandle, &secAtt, 1024 * 1024))
+            return;
+        if (!DuplicateHandle(GetCurrentProcess(), tmpHandle, GetCurrentProcess(),
+                             &pipe[1], 0, FALSE, DUPLICATE_SAME_ACCESS))
+            return;
+    } else {                    // stdout or stderr
+        if (!CreatePipe(&tmpHandle, &pipe[1], &secAtt, 1024 * 1024))
+            return;
+        if (!DuplicateHandle(GetCurrentProcess(), tmpHandle, GetCurrentProcess(),
+                             &pipe[0], 0, FALSE, DUPLICATE_SAME_ACCESS))
+            return;
+    }
+
+    CloseHandle(tmpHandle);
+#else
+	Q_UNUSED(pipe);
+	Q_UNUSED(in);
+#endif
+}
+
+/*
+    Create the pipes to a QProcessPrivate::Channel.
+
+    This function must be called in order: stdin, stdout, stderr
+*/
+bool QProcessPrivate::createChannel(Channel &channel)
+{
+    Q_Q(QProcess);
+
+    if (&channel == &stderrChannel && processChannelMode == QProcess::MergedChannels) {
+        return DuplicateHandle(GetCurrentProcess(), stdoutChannel.pipe[1], GetCurrentProcess(),
+                               &stderrChannel.pipe[1], 0, TRUE, DUPLICATE_SAME_ACCESS);
+    }
+
+    if (channel.type == Channel::Normal) {
+        // we're piping this channel to our own process
+        qt_create_pipe(channel.pipe, &channel == &stdinChannel);
+
+        return true;
+    } else if (channel.type == Channel::Redirect) {
+        // we're redirecting the channel to/from a file
+        SECURITY_ATTRIBUTES secAtt = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
+
+        if (&channel == &stdinChannel) {
+            // try to open in read-only mode
+            channel.pipe[1] = INVALID_Q_PIPE;
+            QT_WA({
+                channel.pipe[0] =
+                    CreateFileW((TCHAR*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
+                                GENERIC_READ,
+                                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                &secAtt,
+                                OPEN_EXISTING,
+                                FILE_ATTRIBUTE_NORMAL,
+                                NULL);
+            }, {
+                channel.pipe[0] =
+                    CreateFileA(QFSFileEnginePrivate::win95Name(channel.file),
+                                GENERIC_READ,
+                                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                &secAtt,
+                                OPEN_EXISTING,
+                                FILE_ATTRIBUTE_NORMAL,
+                                NULL);
+            });
+            if (channel.pipe[0] != INVALID_Q_PIPE)
+                return true;
+
+            q->setErrorString(QProcess::tr("Could not open input redirection for reading"));
+        } else {
+            // open in write mode
+            channel.pipe[0] = INVALID_Q_PIPE;
+            DWORD creation;
+            if (channel.append)
+                creation = OPEN_ALWAYS;
+            else
+                creation = CREATE_ALWAYS;
+
+            QT_WA({
+                channel.pipe[1] =
+                    CreateFileW((TCHAR*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
+                                GENERIC_WRITE,
+                                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                &secAtt,
+                                creation,
+                                FILE_ATTRIBUTE_NORMAL,
+                                NULL);
+            }, {
+                channel.pipe[1] =
+                    CreateFileA(QFSFileEnginePrivate::win95Name(channel.file),
+                                GENERIC_WRITE,
+                                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                &secAtt,
+                                creation,
+                                FILE_ATTRIBUTE_NORMAL,
+                                NULL);
+            });
+            if (channel.pipe[1] != INVALID_Q_PIPE) {
+                if (channel.append) {
+                    SetFilePointer(channel.pipe[1], 0, NULL, FILE_END);
+                }
+                return true;
+            }
+
+            q->setErrorString(QProcess::tr("Could not open output redirection for writing"));
+        }
+
+        // could not open file
+        processError = QProcess::FailedToStart;
+        emit q->error(processError);
+        cleanup();
+        return false;
+    } else {
+        Q_ASSERT_X(channel.process, "QProcess::start", "Internal error");
+
+        Channel *source;
+        Channel *sink;
+
+        if (channel.type == Channel::PipeSource) {
+            // we are the source
+            source = &channel;
+            sink = &channel.process->stdinChannel;
+
+            if (source->pipe[1] != INVALID_Q_PIPE) {
+                // already constructed by the sink
+                // make it inheritable
+                HANDLE tmpHandle = source->pipe[1];
+                if (!DuplicateHandle(GetCurrentProcess(), tmpHandle,
+                                     GetCurrentProcess(), &source->pipe[1],
+                                     0, TRUE, DUPLICATE_SAME_ACCESS))
+                    return false;
+
+                CloseHandle(tmpHandle);
+                return true;
+            }
+
+            Q_ASSERT(source == &stdoutChannel);
+            Q_ASSERT(sink->process == this && sink->type == Channel::PipeSink);
+
+            qt_create_pipe(source->pipe, /* in = */ false); // source is stdout
+            sink->pipe[0] = source->pipe[0];
+            source->pipe[0] = INVALID_Q_PIPE;
+
+            return true;
+        } else {
+            // we are the sink;
+            source = &channel.process->stdoutChannel;
+            sink = &channel;
+
+            if (sink->pipe[0] != INVALID_Q_PIPE) {
+                // already constructed by the source
+                // make it inheritable
+                HANDLE tmpHandle = sink->pipe[0];
+                if (!DuplicateHandle(GetCurrentProcess(), tmpHandle,
+                                     GetCurrentProcess(), &sink->pipe[0],
+                                     0, TRUE, DUPLICATE_SAME_ACCESS))
+                    return false;
+
+                CloseHandle(tmpHandle);
+                return true;
+            }
+            Q_ASSERT(sink == &stdinChannel);
+            Q_ASSERT(source->process == this && source->type == Channel::PipeSource);
+
+            qt_create_pipe(sink->pipe, /* in = */ true); // sink is stdin
+            source->pipe[1] = sink->pipe[1];
+            sink->pipe[1] = INVALID_Q_PIPE;
+
+            return true;
+        }
+    }
+}
+
+void QProcessPrivate::destroyPipe(Q_PIPE pipe[2])
+{
+    if (pipe[0] == stdinChannel.pipe[0] && pipe[1] == stdinChannel.pipe[1] && pipeWriter) {
+        delete pipeWriter;
+        pipeWriter = 0;
+    }
+
+    if (pipe[0] != INVALID_Q_PIPE) {
+        CloseHandle(pipe[0]);
+        pipe[0] = INVALID_Q_PIPE;
+    }
+    if (pipe[1] != INVALID_Q_PIPE) {
+        CloseHandle(pipe[1]);
+        pipe[1] = INVALID_Q_PIPE;
+    }
+}
+
+
+static QString qt_create_commandline(const QString &program, const QStringList &arguments)
+{
+    QString args;
+    if (!program.isEmpty()) {
+        QString programName = program;
+        if (!programName.startsWith(QLatin1Char('\"')) && !programName.endsWith(QLatin1Char('\"')) && programName.contains(QLatin1String(" ")))
+            programName = QLatin1String("\"") + programName + QLatin1String("\"");
+        programName.replace(QLatin1String("/"), QLatin1String("\\"));
+
+        // add the prgram as the first arg ... it works better
+        args = programName + QLatin1String(" ");
+    }
+
+    for (int i=0; i<arguments.size(); ++i) {
+        QString tmp = arguments.at(i);
+        // in the case of \" already being in the string the \ must also be escaped
+        tmp.replace( QLatin1String("\\\""), QLatin1String("\\\\\"") );
+        // escape a single " because the arguments will be parsed
+        tmp.replace( QLatin1String("\""), QLatin1String("\\\"") );
+        if (tmp.isEmpty() || tmp.contains(QLatin1Char(' ')) || tmp.contains(QLatin1Char('\t'))) {
+            // The argument must not end with a \ since this would be interpreted
+            // as escaping the quote -- rather put the \ behind the quote: e.g.
+            // rather use "foo"\ than "foo\"
+            QString endQuote(QLatin1String("\""));
+            int i = tmp.length();
+            while (i>0 && tmp.at(i-1) == QLatin1Char('\\')) {
+                --i;
+                endQuote += QLatin1String("\\");
+            }
+            args += QLatin1String(" \"") + tmp.left(i) + endQuote;
+        } else {
+            args += QLatin1Char(' ') + tmp;
+        }
+    }
+    return args;
+}
+
+static QByteArray qt_create_environment(const QHash<QString, QString> *environment)
+{
+    QByteArray envlist;
+    if (environment) {
+        QHash<QString, QString> copy = *environment;
+
+        // add PATH if necessary (for DLL loading)
+        if (!copy.contains(QLatin1String("PATH"))) {
+            QByteArray path = qgetenv("PATH");
+            if (!path.isEmpty())
+            copy.insert(QLatin1String("PATH"), QString::fromLocal8Bit(path));
+        }
+
+        // add systemroot if needed
+        if (!copy.contains(QLatin1String("SYSTEMROOT"))) {
+            QByteArray systemRoot = qgetenv("SYSTEMROOT");
+            if (!systemRoot.isEmpty())
+                copy.insert(QLatin1String("SYSTEMROOT"), QString::fromLocal8Bit(systemRoot));
+        }
+
+        int pos = 0;
+        QHash<QString, QString>::ConstIterator it = copy.constBegin(),
+                                              end = copy.constEnd();
+#ifdef UNICODE
+        if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
+            static const TCHAR equal = L'=';
+            static const TCHAR nul = L'\0';
+
+            for ( ; it != end; ++it) {
+                uint tmpSize = sizeof(TCHAR) * (it.key().length() + it.value().length() + 2);
+                // ignore empty strings
+                if (tmpSize == sizeof(TCHAR)*2)
+                    continue;
+                envlist.resize(envlist.size() + tmpSize);
+
+                tmpSize = it.key().length() * sizeof(TCHAR);
+                memcpy(envlist.data()+pos, it.key().utf16(), tmpSize);
+                pos += tmpSize;
+
+                memcpy(envlist.data()+pos, &equal, sizeof(TCHAR));
+                pos += sizeof(TCHAR);
+
+                tmpSize = it.value().length() * sizeof(TCHAR);
+                memcpy(envlist.data()+pos, it.value().utf16(), tmpSize);
+                pos += tmpSize;
+
+                memcpy(envlist.data()+pos, &nul, sizeof(TCHAR));
+                pos += sizeof(TCHAR);
+            }
+            // add the 2 terminating 0 (actually 4, just to be on the safe side)
+            envlist.resize( envlist.size()+4 );
+            envlist[pos++] = 0;
+            envlist[pos++] = 0;
+            envlist[pos++] = 0;
+            envlist[pos++] = 0;
+        } else
+#endif // UNICODE
+        {
+            for ( ; it != end; it++) {
+                QByteArray tmp = it.key().toLocal8Bit();
+                tmp.append('=');
+                tmp.append(it.value().toLocal8Bit());
+
+                uint tmpSize = tmp.length() + 1;
+                envlist.resize(envlist.size() + tmpSize);
+                memcpy(envlist.data()+pos, tmp.data(), tmpSize);
+                pos += tmpSize;
+            }
+            // add the terminating 0 (actually 2, just to be on the safe side)
+            envlist.resize(envlist.size()+2);
+            envlist[pos++] = 0;
+            envlist[pos++] = 0;
+        }
+    }
+    return envlist;
+}
+
+void QProcessPrivate::startProcess()
+{
+    Q_Q(QProcess);
+
+    bool success = false;
+
+    if (pid) {
+        CloseHandle(pid->hThread);
+        CloseHandle(pid->hProcess);
+        delete pid;
+        pid = 0;
+    }
+    pid = new PROCESS_INFORMATION;
+    memset(pid, 0, sizeof(PROCESS_INFORMATION));
+
+    q->setProcessState(QProcess::Starting);
+
+    if (!createChannel(stdinChannel) ||
+        !createChannel(stdoutChannel) ||
+        !createChannel(stderrChannel))
+        return;
+
+#if defined(Q_OS_WINCE)
+    QString args = qt_create_commandline(QString(), arguments);
+#else
+    QString args = qt_create_commandline(program, arguments);
+    QByteArray envlist = qt_create_environment(environment);
+#endif
+
+#if defined QPROCESS_DEBUG
+    qDebug("Creating process");
+    qDebug("   program : [%s]", program.toLatin1().constData());
+    qDebug("   args : %s", args.toLatin1().constData());
+    qDebug("   pass environment : %s", environment.isEmpty() ? "no" : "yes");
+#endif
+
+    DWORD dwCreationFlags = 0;
+    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based))
+        dwCreationFlags |= CREATE_NO_WINDOW;
+
+#ifdef UNICODE
+    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
+#if defined(Q_OS_WINCE)
+        QString fullPathProgram = program;
+        if (!QDir::isAbsolutePath(fullPathProgram))
+            fullPathProgram = QFileInfo(fullPathProgram).absoluteFilePath();
+        fullPathProgram.replace(QLatin1String("/"), QLatin1String("\\"));
+        success = CreateProcessW((WCHAR*)fullPathProgram.utf16(),
+                                 (WCHAR*)args.utf16(),
+                                 0, 0, false, 0, 0, 0, 0, pid);
+#else
+        dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
+        STARTUPINFOW startupInfo = { sizeof( STARTUPINFO ), 0, 0, 0,
+	                                 (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                         0, 0, 0,
+                                         STARTF_USESTDHANDLES,
+                                         0, 0, 0,
+                                         stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
+        };
+        success = CreateProcessW(0, (WCHAR*)args.utf16(),
+                                 0, 0, TRUE, dwCreationFlags,
+                                 environment ? envlist.data() : 0,
+                                 workingDirectory.isEmpty() ? 0
+                                    : (WCHAR*)QDir::toNativeSeparators(workingDirectory).utf16(),
+                                 &startupInfo, pid);
+#endif
+    } else
+#endif // UNICODE
+    {
+#ifndef Q_OS_WINCE
+	    STARTUPINFOA startupInfo = { sizeof( STARTUPINFOA ), 0, 0, 0,
+                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                         0, 0, 0,
+                                         STARTF_USESTDHANDLES,
+                                         0, 0, 0,
+                                         stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
+	    };
+
+	    success = CreateProcessA(0, args.toLocal8Bit().data(),
+                                     0, 0, TRUE, dwCreationFlags, environment ? envlist.data() : 0,
+                                     workingDirectory.isEmpty() ? 0
+                                        : QDir::toNativeSeparators(workingDirectory).toLocal8Bit().data(),
+                                     &startupInfo, pid);
+#endif // Q_OS_WINCE
+    }
+#ifndef Q_OS_WINCE
+    if (stdinChannel.pipe[0] != INVALID_Q_PIPE) {
+        CloseHandle(stdinChannel.pipe[0]);
+        stdinChannel.pipe[0] = INVALID_Q_PIPE;
+    }
+    if (stdoutChannel.pipe[1] != INVALID_Q_PIPE) {
+        CloseHandle(stdoutChannel.pipe[1]);
+        stdoutChannel.pipe[1] = INVALID_Q_PIPE;
+    }
+    if (stderrChannel.pipe[1] != INVALID_Q_PIPE) {
+        CloseHandle(stderrChannel.pipe[1]);
+        stderrChannel.pipe[1] = INVALID_Q_PIPE;
+    }
+#endif // Q_OS_WINCE
+
+    if (!success) {
+        cleanup();
+        processError = QProcess::FailedToStart;
+        q->setErrorString(QProcess::tr("Process failed to start"));
+        emit q->error(processError);
+        q->setProcessState(QProcess::NotRunning);
+        return;
+    }
+
+    q->setProcessState(QProcess::Running);
+    // User can call kill()/terminate() from the stateChanged() slot
+    // so check before proceeding 
+    if (!pid) 
+        return;
+
+    if (threadData->eventDispatcher) {
+        processFinishedNotifier = new QWinEventNotifier(pid->hProcess, q);
+        QObject::connect(processFinishedNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_processDied()));
+        processFinishedNotifier->setEnabled(true);
+        notifier = new QTimer(q);
+        QObject::connect(notifier, SIGNAL(timeout()), q, SLOT(_q_notified()));
+        notifier->start(NOTIFYTIMEOUT);
+    }
+
+    // give the process a chance to start ...
+    Sleep(SLEEPMIN*2);
+    _q_startupNotification();
+}
+
+bool QProcessPrivate::processStarted()
+{
+    return processState == QProcess::Running;
+}
+
+qint64 QProcessPrivate::bytesAvailableFromStdout() const
+{
+    if (stdoutChannel.pipe[0] == INVALID_Q_PIPE)
+        return 0;
+
+    DWORD bytesAvail = 0;
+#if !defined(Q_OS_WINCE)
+	PeekNamedPipe(stdoutChannel.pipe[0], 0, 0, 0, &bytesAvail, 0);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::bytesAvailableFromStdout() == %d", bytesAvail);
+#endif
+    if (processChannelMode == QProcess::ForwardedChannels && bytesAvail > 0) {
+        QByteArray buf(bytesAvail, 0);
+        DWORD bytesRead = 0;
+        if (ReadFile(stdoutChannel.pipe[0], buf.data(), buf.size(), &bytesRead, 0) && bytesRead > 0) {
+            HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+            if (hStdout) {
+                DWORD bytesWritten = 0;
+                WriteFile(hStdout, buf.data(), bytesRead, &bytesWritten, 0);
+            }
+        }
+        bytesAvail = 0;
+    }
+#endif
+    return bytesAvail;
+}
+
+qint64 QProcessPrivate::bytesAvailableFromStderr() const
+{
+    if (stderrChannel.pipe[0] == INVALID_Q_PIPE)
+        return 0;
+
+    DWORD bytesAvail = 0;
+#if !defined(Q_OS_WINCE)
+	PeekNamedPipe(stderrChannel.pipe[0], 0, 0, 0, &bytesAvail, 0);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::bytesAvailableFromStderr() == %d", bytesAvail);
+#endif
+    if (processChannelMode == QProcess::ForwardedChannels && bytesAvail > 0) {
+        QByteArray buf(bytesAvail, 0);
+        DWORD bytesRead = 0;
+        if (ReadFile(stderrChannel.pipe[0], buf.data(), buf.size(), &bytesRead, 0) && bytesRead > 0) {
+            HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
+            if (hStderr) {
+                DWORD bytesWritten = 0;
+                WriteFile(hStderr, buf.data(), bytesRead, &bytesWritten, 0);
+            }
+        }
+        bytesAvail = 0;
+    }
+#endif
+    return bytesAvail;
+}
+
+qint64 QProcessPrivate::readFromStdout(char *data, qint64 maxlen)
+{
+    DWORD read = qMin(maxlen, bytesAvailableFromStdout());
+    DWORD bytesRead = 0;
+
+    if (read > 0 && !ReadFile(stdoutChannel.pipe[0], data, read, &bytesRead, 0))
+        return -1;
+    return bytesRead;
+}
+
+qint64 QProcessPrivate::readFromStderr(char *data, qint64 maxlen)
+{
+    DWORD read = qMin(maxlen, bytesAvailableFromStderr());
+    DWORD bytesRead = 0;
+
+    if (read > 0 && !ReadFile(stderrChannel.pipe[0], data, read, &bytesRead, 0))
+        return -1;
+    return bytesRead;
+}
+
+
+static BOOL CALLBACK qt_terminateApp(HWND hwnd, LPARAM procId)
+{
+    DWORD currentProcId = 0;
+    GetWindowThreadProcessId(hwnd, &currentProcId);
+    if (currentProcId == (DWORD)procId)
+	    PostMessage(hwnd, WM_CLOSE, 0, 0);
+
+    return TRUE;
+}
+
+void QProcessPrivate::terminateProcess()
+{
+    if (pid) {
+        EnumWindows(qt_terminateApp, (LPARAM)pid->dwProcessId);
+        PostThreadMessage(pid->dwThreadId, WM_CLOSE, 0, 0);
+    }
+}
+
+void QProcessPrivate::killProcess()
+{
+    if (pid)
+        TerminateProcess(pid->hProcess, 0xf291);
+}
+
+bool QProcessPrivate::waitForStarted(int)
+{
+    Q_Q(QProcess);
+
+    if (processStarted())
+        return true;
+
+    if (processError == QProcess::FailedToStart)
+        return false;
+
+    processError = QProcess::Timedout;
+    q->setErrorString(QProcess::tr("Process operation timed out"));
+    return false;
+}
+
+bool QProcessPrivate::waitForReadyRead(int msecs)
+{
+    Q_Q(QProcess);
+
+#if defined(Q_OS_WINCE)
+    processError = QProcess::ReadError;
+    q->setErrorString(QProcess::tr("Error reading from process"));
+    emit q->error(processError);
+    return false;
+#endif
+
+    QIncrementalSleepTimer timer(msecs);
+
+    forever {
+        if (!writeBuffer.isEmpty() && !_q_canWrite())
+            return false;
+        if (pipeWriter && pipeWriter->waitForWrite(0))
+            timer.resetIncrements();
+        bool readyReadEmitted = false;
+        if (bytesAvailableFromStdout() != 0) {
+            readyReadEmitted = _q_canReadStandardOutput() ? true : readyReadEmitted;
+            timer.resetIncrements();
+        }
+
+        if (bytesAvailableFromStderr() != 0) {
+            readyReadEmitted = _q_canReadStandardError() ? true : readyReadEmitted;
+            timer.resetIncrements();
+        }
+
+        if (readyReadEmitted)
+            return true;
+
+        if (!pid)
+            return false;
+        if (WaitForSingleObject(pid->hProcess, 0) == WAIT_OBJECT_0) {
+            // find the return value if there is noew data to read
+            _q_processDied();
+            return false;
+        }
+
+        Sleep(timer.nextSleepTime());
+        if (timer.hasTimedOut())
+            break;
+    }
+
+    processError = QProcess::Timedout;
+    q->setErrorString(QProcess::tr("Process operation timed out"));
+    return false;
+}
+
+bool QProcessPrivate::waitForBytesWritten(int msecs)
+{
+    Q_Q(QProcess);
+
+#if defined(Q_OS_WINCE)
+    processError = QProcess::ReadError;
+    q->setErrorString(QProcess::tr("Error reading from process"));
+    emit q->error(processError);
+    return false;
+#endif
+
+    QIncrementalSleepTimer timer(msecs);
+
+    forever {
+        // Check if we have any data pending: the pipe writer has
+        // bytes waiting to written, or it has written data since the
+        // last time we called pipeWriter->waitForWrite().
+        bool pendingDataInPipe = pipeWriter && (pipeWriter->bytesToWrite() || pipeWriter->hadWritten());
+
+        // If we don't have pending data, and our write buffer is
+        // empty, we fail.
+        if (!pendingDataInPipe && writeBuffer.isEmpty())
+            return false;
+
+        // If we don't have pending data and we do have data in our
+        // write buffer, try to flush that data over to the pipe
+        // writer.  Fail on error.
+        if (!pendingDataInPipe) {
+            if (!_q_canWrite())
+                return false;
+        }
+
+        // Wait for the pipe writer to acknowledge that it has
+        // written. This will succeed if either the pipe writer has
+        // already written the data, or if it manages to write data
+        // within the given timeout. If the write buffer was non-empty
+        // and the pipeWriter is now dead, that means _q_canWrite()
+        // destroyed the writer after it successfully wrote the last
+        // batch.
+        if (!pipeWriter || pipeWriter->waitForWrite(0))
+            return true;
+
+        // If we wouldn't write anything, check if we can read stdout.
+        if (bytesAvailableFromStdout() != 0) {
+            _q_canReadStandardOutput();
+            timer.resetIncrements();
+        }
+
+        // Check if we can read stderr.
+        if (bytesAvailableFromStderr() != 0) {
+            _q_canReadStandardError();
+            timer.resetIncrements();
+        }
+
+        // Check if the process died while reading.
+        if (!pid)
+            return false;
+
+        // Wait for the process to signal any change in its state,
+        // such as incoming data, or if the process died.
+        if (WaitForSingleObject(pid->hProcess, 0) == WAIT_OBJECT_0) {
+            _q_processDied();
+            return false;
+        }
+
+        // Only wait for as long as we've been asked.
+        if (timer.hasTimedOut())
+            break;
+    }
+
+    processError = QProcess::Timedout;
+    q->setErrorString(QProcess::tr("Process operation timed out"));
+    return false;
+}
+
+
+bool QProcessPrivate::waitForFinished(int msecs)
+{
+    Q_Q(QProcess);
+#if defined QPROCESS_DEBUG
+    qDebug("QProcessPrivate::waitForFinished(%d)", msecs);
+#endif
+
+    QIncrementalSleepTimer timer(msecs);
+
+    forever {
+        if (!writeBuffer.isEmpty() && !_q_canWrite())
+            return false;
+        if (pipeWriter && pipeWriter->waitForWrite(0))
+            timer.resetIncrements();
+
+        if (bytesAvailableFromStdout() != 0) {
+            _q_canReadStandardOutput();
+            timer.resetIncrements();
+        }
+
+        if (bytesAvailableFromStderr() != 0) {
+            _q_canReadStandardError();
+            timer.resetIncrements();
+        }
+
+        if (!pid)
+            return true;
+
+        if (WaitForSingleObject(pid->hProcess, timer.nextSleepTime()) == WAIT_OBJECT_0) {
+            _q_processDied();
+            return true;
+        }
+
+        if (timer.hasTimedOut())
+            break;
+    }
+    processError = QProcess::Timedout;
+    q->setErrorString(QProcess::tr("Process operation timed out"));
+    return false;
+}
+
+
+void QProcessPrivate::findExitCode()
+{
+    DWORD theExitCode;
+    if (GetExitCodeProcess(pid->hProcess, &theExitCode)) {
+        exitCode = theExitCode;
+        //### for now we assume a crash if exit code is less than -1 or the magic number
+        crashed = (exitCode == 0xf291 || (int)exitCode < 0);
+    }
+}
+
+void QProcessPrivate::flushPipeWriter()
+{
+    if (pipeWriter && pipeWriter->bytesToWrite() > 0) {
+        pipeWriter->waitForWrite(ULONG_MAX);
+    }
+}
+
+qint64 QProcessPrivate::pipeWriterBytesToWrite() const
+{
+    return pipeWriter ? pipeWriter->bytesToWrite() : qint64(0);
+}
+
+qint64 QProcessPrivate::writeToStdin(const char *data, qint64 maxlen)
+{
+    Q_Q(QProcess);
+
+#if defined(Q_OS_WINCE)
+    processError = QProcess::WriteError;
+    q->setErrorString(QProcess::tr("Error writing to process"));
+    emit q->error(processError);
+    return -1;
+#endif
+
+    if (!pipeWriter) {
+        pipeWriter = new QWindowsPipeWriter(stdinChannel.pipe[1], q);
+        pipeWriter->start();
+    }
+
+    return pipeWriter->write(data, maxlen);
+}
+
+bool QProcessPrivate::waitForWrite(int msecs)
+{
+    Q_Q(QProcess);
+
+    if (!pipeWriter || pipeWriter->waitForWrite(msecs))
+        return true;
+
+    processError = QProcess::Timedout;
+    q->setErrorString(QProcess::tr("Process operation timed out"));
+    return false;
+}
+
+void QProcessPrivate::_q_notified()
+{
+    notifier->stop();
+
+    if (!writeBuffer.isEmpty() && (!pipeWriter || pipeWriter->waitForWrite(0)))
+        _q_canWrite();
+
+    if (bytesAvailableFromStdout())
+        _q_canReadStandardOutput();
+
+    if (bytesAvailableFromStderr())
+        _q_canReadStandardError();
+
+    if (processState != QProcess::NotRunning)
+        notifier->start(NOTIFYTIMEOUT);
+}
+
+bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDir, qint64 *pid)
+{
+#if defined(Q_OS_WINCE)
+    Q_UNUSED(workingDir);
+    QString args = qt_create_commandline(QString(), arguments);
+#else
+    QString args = qt_create_commandline(program, arguments);
+#endif
+
+    bool success = false;
+
+    PROCESS_INFORMATION pinfo;
+
+#ifdef UNICODE
+    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
+#if defined(Q_OS_WINCE)
+        QString fullPathProgram = program;
+        if (!QDir::isAbsolutePath(fullPathProgram))
+            fullPathProgram.prepend(QDir::currentPath().append(QLatin1String("/")));
+        fullPathProgram.replace(QLatin1String("/"), QLatin1String("\\"));
+        success = CreateProcessW((WCHAR*)fullPathProgram.utf16(),
+                                 (WCHAR*)args.utf16(),
+                                 0, 0, false, CREATE_NEW_CONSOLE, 0, 0, 0, &pinfo);
+#else
+        STARTUPINFOW startupInfo = { sizeof( STARTUPINFO ), 0, 0, 0,
+                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+                                   };
+        success = CreateProcessW(0, (WCHAR*)args.utf16(),
+                                 0, 0, FALSE, CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE, 0, 
+                                 workingDir.isEmpty() ? (const WCHAR *)0 : (const WCHAR *)workingDir.utf16(),
+                                 &startupInfo, &pinfo);
+#endif
+    } else
+#endif // UNICODE
+    {
+#ifndef Q_OS_WINCE
+       STARTUPINFOA startupInfo = { sizeof( STARTUPINFOA ), 0, 0, 0,
+                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+                                  };
+       success = CreateProcessA(0, args.toLocal8Bit().data(),
+                                0, 0, FALSE, CREATE_NEW_CONSOLE, 0,
+                                workingDir.isEmpty() ? (LPCSTR)0 : workingDir.toLocal8Bit().constData(),
+                                &startupInfo, &pinfo);
+#endif // Q_OS_WINCE
+    }
+
+    if (success) {
+        CloseHandle(pinfo.hThread);
+        CloseHandle(pinfo.hProcess);
+        if (pid)
+            *pid = pinfo.dwProcessId;
+    }
+
+    return success;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PROCESS
diff --git a/src/corelib/io/qresource.cpp b/src/corelib/io/qresource.cpp
new file mode 100644
index 0000000..a1f921e
--- /dev/null
+++ b/src/corelib/io/qresource.cpp
@@ -0,0 +1,1460 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "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"
+
+//#define DEBUG_RESOURCE_MATCH
+
+QT_BEGIN_NAMESPACE
+
+//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;
+    }
+};
+
+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
+    \mainclass
+    \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();
+    for(int i = 0; i < list->size(); ++i) {
+        QResourceRoot *res = list->at(i);
+        const int node = res->findNode(file);
+        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);
+
+    bool found = false;
+    if(path.startsWith(QLatin1Char('/'))) {
+        found = 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)) {
+                found = true;
+                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;
+    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(path);
+            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()
+{
+    delete d_ptr;
+}
+
+/*!
+    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 heirarchy,
+    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 addSearchPath()
+*/
+
+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
+    for(int i = 0; i < name_length*2; i+=2)
+        ret += QChar(names[name_offset+i+1], names[name_offset+i]);
+    return ret;
+}
+int QResourceRoot::findNode(const QString &_path, const QLocale &locale) const
+{
+    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);
+
+    {
+        QString root = mappingRoot();
+        if(!root.isEmpty()) {
+            if(root == path) {
+                path = QLatin1String("/");
+            } else {
+                if(!root.endsWith(QLatin1String("/")))
+                    root += QLatin1String("/");
+                if(path.size() >= root.size() && path.startsWith(root))
+                    path = path.mid(root.length()-1);
+                if(path.isEmpty())
+                    path = QLatin1String("/");
+            }
+        }
+    }
+#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;
+    QStringList segments = path.split(QLatin1Char('/'), QString::SkipEmptyParts);
+#ifdef DEBUG_RESOURCE_MATCH
+    qDebug() << "****" << segments;
+#endif
+    for(int i = 0; child_count && i < segments.size(); ++i) {
+        const QString &segment = segments[i];
+#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(i == segments.size()-1) {
+                        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 (!resource.isValid()
+        || offset < 0
+        || size < 0
+        || offset + size > resource.size()
+        || (size == 0)) {
+        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
diff --git a/src/corelib/io/qresource.h b/src/corelib/io/qresource.h
new file mode 100644
index 0000000..1e9b2d5
--- /dev/null
+++ b/src/corelib/io/qresource.h
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QRESOURCE_H
+#define QRESOURCE_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qlocale.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QResourcePrivate;
+
+class Q_CORE_EXPORT QResource
+{
+public:
+    QResource(const QString &file=QString(), const QLocale &locale=QLocale());
+    ~QResource();
+
+    void setFileName(const QString &file);
+    QString fileName() const;
+    QString absoluteFilePath() const;
+
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+
+    bool isValid() const;
+
+    bool isCompressed() const;
+    qint64 size() const;
+    const uchar *data() const;
+
+    static void addSearchPath(const QString &path);
+    static QStringList searchPaths();
+
+    static bool registerResource(const QString &rccFilename, const QString &resourceRoot=QString());
+    static bool unregisterResource(const QString &rccFilename, const QString &resourceRoot=QString());
+
+    static bool registerResource(const uchar *rccData, const QString &resourceRoot=QString());
+    static bool unregisterResource(const uchar *rccData, const QString &resourceRoot=QString());
+
+protected:
+    friend class QResourceFileEngine;
+    friend class QResourceFileEngineIterator;
+    bool isDir() const;
+    inline bool isFile() const { return !isDir(); }
+    QStringList children() const;
+
+protected:
+    QResourcePrivate *d_ptr;
+
+private:
+    Q_DECLARE_PRIVATE(QResource)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QRESOURCE_H
diff --git a/src/corelib/io/qresource_iterator.cpp b/src/corelib/io/qresource_iterator.cpp
new file mode 100644
index 0000000..0e7c0dd
--- /dev/null
+++ b/src/corelib/io/qresource_iterator.cpp
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qresource.h"
+#include "qresource_iterator_p.h"
+
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_NAMESPACE
+
+QResourceFileEngineIterator::QResourceFileEngineIterator(QDir::Filters filters,
+                                                         const QStringList &filterNames)
+    : QAbstractFileEngineIterator(filters, filterNames), index(-1)
+{
+}
+
+QResourceFileEngineIterator::~QResourceFileEngineIterator()
+{
+}
+
+QString QResourceFileEngineIterator::next()
+{
+    if (!hasNext())
+        return QString();
+    ++index;
+    return currentFilePath();
+}
+
+bool QResourceFileEngineIterator::hasNext() const
+{
+    if (index == -1) {
+        // Lazy initialization of the iterator
+        QResource resource(path());
+        if (!resource.isValid())
+            return false;
+
+        // Initialize and move to the next entry.
+        QResourceFileEngineIterator *that = const_cast<QResourceFileEngineIterator *>(this);
+        that->entries = resource.children();
+        if (!that->entries.isEmpty())
+            that->index = 0;
+    }
+
+    return index <= entries.size();
+}
+
+QString QResourceFileEngineIterator::currentFileName() const
+{
+    if (index <= 0 || index > entries.size())
+        return QString();
+    return entries.at(index - 1);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qresource_iterator_p.h b/src/corelib/io/qresource_iterator_p.h
new file mode 100644
index 0000000..0cf8fe7
--- /dev/null
+++ b/src/corelib/io/qresource_iterator_p.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QRESOURCE_ITERATOR_P_H
+#define QRESOURCE_ITERATOR_P_H
+
+//
+//  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.
+//
+
+#include "qabstractfileengine.h"
+#include "qdir.h"
+
+QT_BEGIN_NAMESPACE
+
+class QResourceFileEngineIteratorPrivate;
+class QResourceFileEngineIterator : public QAbstractFileEngineIterator
+{
+public:
+    QResourceFileEngineIterator(QDir::Filters filters, const QStringList &filterNames);
+    ~QResourceFileEngineIterator();
+
+    QString next();
+    bool hasNext() const;
+
+    QString currentFileName() const;
+
+private:
+    QStringList entries;
+    int index;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/io/qresource_p.h b/src/corelib/io/qresource_p.h
new file mode 100644
index 0000000..9706e93
--- /dev/null
+++ b/src/corelib/io/qresource_p.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QRESOURCE_P_H
+#define QRESOURCE_P_H
+
+//
+//  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.
+//
+
+#include "QtCore/qabstractfileengine.h"
+
+QT_BEGIN_NAMESPACE
+
+class QResourceFileEnginePrivate;
+class QResourceFileEngine : public QAbstractFileEngine
+{
+private:
+    Q_DECLARE_PRIVATE(QResourceFileEngine)
+public:
+    explicit QResourceFileEngine(const QString &path);
+    ~QResourceFileEngine();
+
+    virtual void setFileName(const QString &file);
+
+    virtual bool open(QIODevice::OpenMode flags) ;
+    virtual bool close();
+    virtual bool flush();
+    virtual qint64 size() const;
+    virtual qint64 pos() const;
+    virtual bool atEnd() const;
+    virtual bool seek(qint64);
+    virtual qint64 read(char *data, qint64 maxlen);
+    virtual qint64 write(const char *data, qint64 len);
+
+    virtual bool remove();
+    virtual bool copy(const QString &newName);
+    virtual bool rename(const QString &newName);
+    virtual bool link(const QString &newName);
+
+    virtual bool isSequential() const;
+
+    virtual bool isRelativePath() const;
+
+    virtual bool mkdir(const QString &dirName, bool createParentDirectories) const;
+    virtual bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
+
+    virtual bool setSize(qint64 size);
+
+    virtual QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
+
+    virtual bool caseSensitive() const;
+
+    virtual FileFlags fileFlags(FileFlags type) const;
+
+    virtual bool setPermissions(uint perms);
+
+    virtual QString fileName(QAbstractFileEngine::FileName file) const;
+
+    virtual uint ownerId(FileOwner) const;
+    virtual QString owner(FileOwner) const;
+
+    virtual QDateTime fileTime(FileTime time) const;
+
+    virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
+    virtual Iterator *endEntryList();
+    
+    bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
+    bool supportsExtension(Extension extension) const;
+};
+
+QT_END_NAMESPACE
+
+#endif // QRESOURCE_P_H
diff --git a/src/corelib/io/qsettings.cpp b/src/corelib/io/qsettings.cpp
new file mode 100644
index 0000000..62b4ed5
--- /dev/null
+++ b/src/corelib/io/qsettings.cpp
@@ -0,0 +1,3822 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 <qdebug.h>
+#include "qplatformdefs.h"
+#include "qsettings.h"
+
+#ifndef QT_NO_SETTINGS
+
+#include "qsettings_p.h"
+#include "qcache.h"
+#include "qfile.h"
+#include "qdir.h"
+#include "qfileinfo.h"
+#include "qmutex.h"
+#include "qlibraryinfo.h"
+#include "qtemporaryfile.h"
+
+#ifndef QT_NO_TEXTCODEC
+#  include "qtextcodec.h"
+#endif
+
+#ifndef QT_NO_GEOM_VARIANT
+#include "qsize.h"
+#include "qpoint.h"
+#include "qrect.h"
+#endif // !QT_NO_GEOM_VARIANT
+
+#ifndef QT_NO_QOBJECT
+#include "qcoreapplication.h"
+
+#ifdef Q_OS_WIN // for homedirpath reading from registry
+#include "qt_windows.h"
+#include "qlibrary.h"
+
+#endif // Q_OS_WIN
+#endif // QT_NO_QOBJECT
+
+#include <stdlib.h>
+
+#ifndef CSIDL_COMMON_APPDATA
+#define CSIDL_COMMON_APPDATA	0x0023  // All Users\Application Data
+#endif
+
+#ifndef CSIDL_APPDATA
+#define CSIDL_APPDATA		0x001a	// <username>\Application Data
+#endif
+
+// ************************************************************************
+// QConfFile
+
+/*
+    QConfFile objects are explicitly shared within the application.
+    This ensures that modification to the settings done through one
+    QSettings object are immediately reflected in other setting
+    objects of the same application.
+*/
+
+QT_BEGIN_NAMESPACE
+
+struct QConfFileCustomFormat
+{
+    QString extension;
+    QSettings::ReadFunc readFunc;
+    QSettings::WriteFunc writeFunc;
+    Qt::CaseSensitivity caseSensitivity;
+};
+
+typedef QHash<QString, QConfFile *> ConfFileHash;
+typedef QCache<QString, QConfFile> ConfFileCache;
+typedef QHash<int, QString> PathHash;
+typedef QVector<QConfFileCustomFormat> CustomFormatVector;
+
+Q_GLOBAL_STATIC(ConfFileHash, usedHashFunc)
+Q_GLOBAL_STATIC(ConfFileCache, unusedCacheFunc)
+Q_GLOBAL_STATIC(PathHash, pathHashFunc)
+Q_GLOBAL_STATIC(CustomFormatVector, customFormatVectorFunc)
+Q_GLOBAL_STATIC(QMutex, globalMutex)
+static QSettings::Format globalDefaultFormat = QSettings::NativeFormat;
+
+#ifndef Q_OS_WIN
+inline bool qt_isEvilFsTypeName(const char *name)
+{
+    return (qstrncmp(name, "nfs", 3) == 0
+            || qstrncmp(name, "autofs", 6) == 0
+            || qstrncmp(name, "cachefs", 7) == 0);
+}
+
+#if defined(Q_OS_BSD4) && !defined(Q_OS_NETBSD)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include <sys/param.h>
+# include <sys/mount.h>
+QT_END_INCLUDE_NAMESPACE
+
+static bool isLikelyToBeNfs(int handle)
+{
+    struct statfs buf;
+    if (fstatfs(handle, &buf) != 0)
+        return false;
+    return qt_isEvilFsTypeName(buf.f_fstypename);
+}
+
+#elif defined(Q_OS_LINUX) || defined(Q_OS_HURD)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include <sys/vfs.h>
+# ifdef QT_LINUXBASE
+   // LSB 3.2 has fstatfs in sys/statfs.h, sys/vfs.h is just an empty dummy header
+#  include <sys/statfs.h>
+# endif
+QT_END_INCLUDE_NAMESPACE
+# ifndef NFS_SUPER_MAGIC
+#  define NFS_SUPER_MAGIC       0x00006969
+# endif
+# ifndef AUTOFS_SUPER_MAGIC
+#  define AUTOFS_SUPER_MAGIC    0x00000187
+# endif
+# ifndef AUTOFSNG_SUPER_MAGIC
+#  define AUTOFSNG_SUPER_MAGIC  0x7d92b1a0
+# endif
+
+static bool isLikelyToBeNfs(int handle)
+{
+    struct statfs buf;
+    if (fstatfs(handle, &buf) != 0)
+        return false;
+    return buf.f_type == NFS_SUPER_MAGIC
+           || buf.f_type == AUTOFS_SUPER_MAGIC
+           || buf.f_type == AUTOFSNG_SUPER_MAGIC;
+}
+
+#elif defined(Q_OS_SOLARIS) || defined(Q_OS_IRIX) || defined(Q_OS_AIX) || defined(Q_OS_HPUX) \
+      || defined(Q_OS_OSF) || defined(Q_OS_QNX) || defined(Q_OS_QNX6) || defined(Q_OS_SCO) \
+      || defined(Q_OS_UNIXWARE) || defined(Q_OS_RELIANT) || defined(Q_OS_NETBSD)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include <sys/statvfs.h>
+QT_END_INCLUDE_NAMESPACE
+
+static bool isLikelyToBeNfs(int handle)
+{
+    struct statvfs buf;
+    if (fstatvfs(handle, &buf) != 0)
+        return false;
+#if defined(Q_OS_NETBSD)
+    return qt_isEvilFsTypeName(buf.f_fstypename);
+#else
+    return qt_isEvilFsTypeName(buf.f_basetype);
+#endif
+}
+#else
+static inline bool isLikelyToBeNfs(int /* handle */)
+{
+    return true;
+}
+#endif
+
+static bool unixLock(int handle, int lockType)
+{
+    /*
+        NFS hangs on the fcntl() call below when statd or lockd isn't
+        running. There's no way to detect this. Our work-around for
+        now is to disable locking when we detect NFS (or AutoFS or
+        CacheFS, which are probably wrapping NFS).
+    */
+    if (isLikelyToBeNfs(handle))
+        return false;
+
+    struct flock fl;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
+    fl.l_type = lockType;
+    return fcntl(handle, F_SETLKW, &fl) == 0;
+}
+#endif
+
+QConfFile::QConfFile(const QString &fileName, bool _userPerms)
+    : name(fileName), size(0), ref(1), userPerms(_userPerms)
+{
+    usedHashFunc()->insert(name, this);
+}
+
+ParsedSettingsMap QConfFile::mergedKeyMap() const
+{
+    ParsedSettingsMap result = originalKeys;
+    ParsedSettingsMap::const_iterator i;
+
+    for (i = removedKeys.begin(); i != removedKeys.end(); ++i)
+        result.remove(i.key());
+    for (i = addedKeys.begin(); i != addedKeys.end(); ++i)
+        result.insert(i.key(), i.value());
+    return result;
+}
+
+bool QConfFile::isWritable() const
+{
+    QFileInfo fileInfo(name);
+
+#ifndef QT_NO_TEMPORARYFILE
+    if (fileInfo.exists()) {
+#endif
+        QFile file(name);
+        return file.open(QFile::ReadWrite);
+#ifndef QT_NO_TEMPORARYFILE
+    } else {
+        // Create the directories to the file.
+        QDir dir(fileInfo.absolutePath());
+        if (dir.exists() && dir.isReadable()) {
+            return true;
+        } else {
+            if (!dir.mkpath(dir.absolutePath()))
+                return false;
+        }
+
+        // we use a temporary file to avoid race conditions
+        QTemporaryFile file(name);
+        return file.open();
+    }
+#endif
+}
+
+QConfFile *QConfFile::fromName(const QString &fileName, bool _userPerms)
+{
+    QString absPath = QFileInfo(fileName).absoluteFilePath();
+
+    ConfFileHash *usedHash = usedHashFunc();
+    ConfFileCache *unusedCache = unusedCacheFunc();
+
+    QConfFile *confFile;
+    QMutexLocker locker(globalMutex());
+
+    if (!(confFile = usedHash->value(absPath))) {
+        if ((confFile = unusedCache->take(absPath)))
+            usedHash->insert(absPath, confFile);
+    }
+    if (confFile) {
+        confFile->ref.ref();
+        return confFile;
+    }
+    return new QConfFile(absPath, _userPerms);
+}
+
+void QConfFile::clearCache()
+{
+    QMutexLocker locker(globalMutex());
+    unusedCacheFunc()->clear();
+}
+
+// ************************************************************************
+// QSettingsPrivate
+
+QSettingsPrivate::QSettingsPrivate(QSettings::Format format)
+    : format(format), scope(QSettings::UserScope /* nothing better to put */), iniCodec(0), spec(0), fallbacks(true),
+      pendingChanges(false), status(QSettings::NoError)
+{
+}
+
+QSettingsPrivate::QSettingsPrivate(QSettings::Format format, QSettings::Scope scope,
+                                   const QString &organization, const QString &application)
+    : format(format), scope(scope), organizationName(organization), applicationName(application),
+      iniCodec(0), spec(0), fallbacks(true), pendingChanges(false), status(QSettings::NoError)
+{
+}
+
+QSettingsPrivate::~QSettingsPrivate()
+{
+}
+
+QString QSettingsPrivate::actualKey(const QString &key) const
+{
+    QString n = normalizedKey(key);
+    Q_ASSERT_X(!n.isEmpty(), "QSettings", "empty key");
+    n.prepend(groupPrefix);
+    return n;
+}
+
+/*
+    Returns a string that never starts nor ends with a slash (or an
+    empty string). Examples:
+
+            "foo"            becomes   "foo"
+            "/foo//bar///"   becomes   "foo/bar"
+            "///"            becomes   ""
+
+    This function is optimized to avoid a QString deep copy in the
+    common case where the key is already normalized.
+*/
+QString QSettingsPrivate::normalizedKey(const QString &key)
+{
+    QString result = key;
+
+    int i = 0;
+    while (i < result.size()) {
+        while (result.at(i) == QLatin1Char('/')) {
+            result.remove(i, 1);
+            if (i == result.size())
+                goto after_loop;
+        }
+        while (result.at(i) != QLatin1Char('/')) {
+            ++i;
+            if (i == result.size())
+                return result;
+        }
+        ++i; // leave the slash alone
+    }
+
+after_loop:
+    if (!result.isEmpty())
+        result.truncate(i - 1); // remove the trailing slash
+    return result;
+}
+
+// see also qsettings_win.cpp and qsettings_mac.cpp
+
+#if !defined(Q_OS_WIN) && !defined(Q_OS_MAC)
+QSettingsPrivate *QSettingsPrivate::create(QSettings::Format format, QSettings::Scope scope,
+                                           const QString &organization, const QString &application)
+{
+    return new QConfFileSettingsPrivate(format, scope, organization, application);
+}
+#endif
+
+#if !defined(Q_OS_WIN)
+QSettingsPrivate *QSettingsPrivate::create(const QString &fileName, QSettings::Format format)
+{
+    return new QConfFileSettingsPrivate(fileName, format);
+}
+#endif
+
+void QSettingsPrivate::processChild(QString key, ChildSpec spec, QMap<QString, QString> &result)
+{
+    if (spec != AllKeys) {
+        int slashPos = key.indexOf(QLatin1Char('/'));
+        if (slashPos == -1) {
+            if (spec != ChildKeys)
+                return;
+        } else {
+            if (spec != ChildGroups)
+                return;
+            key.truncate(slashPos);
+        }
+    }
+    result.insert(key, QString());
+}
+
+void QSettingsPrivate::beginGroupOrArray(const QSettingsGroup &group)
+{
+    groupStack.push(group);
+    if (!group.name().isEmpty()) {
+        groupPrefix += group.name();
+        groupPrefix += QLatin1Char('/');
+    }
+}
+
+/*
+    We only set an error if there isn't one set already. This way the user always gets the
+    first error that occurred. We always allow clearing errors.
+*/
+
+void QSettingsPrivate::setStatus(QSettings::Status status) const
+{
+    if (status == QSettings::NoError || this->status == QSettings::NoError)
+        this->status = status;
+}
+
+void QSettingsPrivate::update()
+{
+    flush();
+    pendingChanges = false;
+}
+
+void QSettingsPrivate::requestUpdate()
+{
+    if (!pendingChanges) {
+        pendingChanges = true;
+#ifndef QT_NO_QOBJECT
+        Q_Q(QSettings);
+        QCoreApplication::postEvent(q, new QEvent(QEvent::UpdateRequest));
+#else
+        update();
+#endif
+    }
+}
+
+QStringList QSettingsPrivate::variantListToStringList(const QVariantList &l)
+{
+    QStringList result;
+    QVariantList::const_iterator it = l.constBegin();
+    for (; it != l.constEnd(); ++it)
+        result.append(variantToString(*it));
+    return result;
+}
+
+QVariant QSettingsPrivate::stringListToVariantList(const QStringList &l)
+{
+    QStringList outStringList = l;
+    for (int i = 0; i < outStringList.count(); ++i) {
+        const QString &str = outStringList.at(i);
+
+        if (str.startsWith(QLatin1Char('@'))) {
+            if (str.length() >= 2 && str.at(1) == QLatin1Char('@')) {
+                outStringList[i].remove(0, 1);
+            } else {
+                QVariantList variantList;
+                for (int j = 0; j < l.count(); ++j)
+                    variantList.append(stringToVariant(l.at(j)));
+                return variantList;
+            }
+        }
+    }
+    return outStringList;
+}
+
+QString QSettingsPrivate::variantToString(const QVariant &v)
+{
+    QString result;
+
+    switch (v.type()) {
+        case QVariant::Invalid:
+            result = QLatin1String("@Invalid()");
+            break;
+
+        case QVariant::ByteArray: {
+            QByteArray a = v.toByteArray();
+            result = QLatin1String("@ByteArray(");
+            result += QString::fromLatin1(a.constData(), a.size());
+            result += QLatin1Char(')');
+            break;
+        }
+
+        case QVariant::String:
+        case QVariant::LongLong:
+        case QVariant::ULongLong:
+        case QVariant::Int:
+        case QVariant::UInt:
+        case QVariant::Bool:
+        case QVariant::Double:
+        case QVariant::KeySequence: {
+            result = v.toString();
+            if (result.startsWith(QLatin1Char('@')))
+                result.prepend(QLatin1Char('@'));
+            break;
+        }
+#ifndef QT_NO_GEOM_VARIANT
+        case QVariant::Rect: {
+            QRect r = qvariant_cast<QRect>(v);
+            result += QLatin1String("@Rect(");
+            result += QString::number(r.x());
+            result += QLatin1Char(' ');
+            result += QString::number(r.y());
+            result += QLatin1Char(' ');
+            result += QString::number(r.width());
+            result += QLatin1Char(' ');
+            result += QString::number(r.height());
+            result += QLatin1Char(')');
+            break;
+        }
+        case QVariant::Size: {
+            QSize s = qvariant_cast<QSize>(v);
+            result += QLatin1String("@Size(");
+            result += QString::number(s.width());
+            result += QLatin1Char(' ');
+            result += QString::number(s.height());
+            result += QLatin1Char(')');
+            break;
+        }
+        case QVariant::Point: {
+            QPoint p = qvariant_cast<QPoint>(v);
+            result += QLatin1String("@Point(");
+            result += QString::number(p.x());
+            result += QLatin1Char(' ');
+            result += QString::number(p.y());
+            result += QLatin1Char(')');
+            break;
+        }
+#endif // !QT_NO_GEOM_VARIANT
+
+        default: {
+#ifndef QT_NO_DATASTREAM
+            QByteArray a;
+            {
+                QDataStream s(&a, QIODevice::WriteOnly);
+                s.setVersion(QDataStream::Qt_4_0);
+                s << v;
+            }
+
+            result = QLatin1String("@Variant(");
+            result += QString::fromLatin1(a.constData(), a.size());
+            result += QLatin1Char(')');
+#else
+            Q_ASSERT(!"QSettings: Cannot save custom types without QDataStream support");
+#endif
+            break;
+        }
+    }
+
+    return result;
+}
+
+
+QVariant QSettingsPrivate::stringToVariant(const QString &s)
+{
+    if (s.startsWith(QLatin1Char('@'))) {
+        if (s.endsWith(QLatin1Char(')'))) {
+            if (s.startsWith(QLatin1String("@ByteArray("))) {
+                return QVariant(s.toLatin1().mid(11, s.size() - 12));
+            } else if (s.startsWith(QLatin1String("@Variant("))) {
+#ifndef QT_NO_DATASTREAM
+                QByteArray a(s.toLatin1().mid(9));
+                QDataStream stream(&a, QIODevice::ReadOnly);
+                stream.setVersion(QDataStream::Qt_4_0);
+                QVariant result;
+                stream >> result;
+                return result;
+#else
+                Q_ASSERT(!"QSettings: Cannot load custom types without QDataStream support");
+#endif
+#ifndef QT_NO_GEOM_VARIANT
+            } else if (s.startsWith(QLatin1String("@Rect("))) {
+                QStringList args = QSettingsPrivate::splitArgs(s, 5);
+                if (args.size() == 4)
+                    return QVariant(QRect(args[0].toInt(), args[1].toInt(), args[2].toInt(), args[3].toInt()));
+            } else if (s.startsWith(QLatin1String("@Size("))) {
+                QStringList args = QSettingsPrivate::splitArgs(s, 5);
+                if (args.size() == 2)
+                    return QVariant(QSize(args[0].toInt(), args[1].toInt()));
+            } else if (s.startsWith(QLatin1String("@Point("))) {
+                QStringList args = QSettingsPrivate::splitArgs(s, 6);
+                if (args.size() == 2)
+                    return QVariant(QPoint(args[0].toInt(), args[1].toInt()));
+#endif
+            } else if (s == QLatin1String("@Invalid()")) {
+                return QVariant();
+            }
+
+        }
+        if (s.startsWith(QLatin1String("@@")))
+            return QVariant(s.mid(1));
+    }
+
+    return QVariant(s);
+}
+
+static const char hexDigits[] = "0123456789ABCDEF";
+
+void QSettingsPrivate::iniEscapedKey(const QString &key, QByteArray &result)
+{
+    result.reserve(result.length() + key.length() * 3 / 2);
+    for (int i = 0; i < key.size(); ++i) {
+        uint ch = key.at(i).unicode();
+
+        if (ch == '/') {
+            result += '\\';
+        } else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')
+                || ch == '_' || ch == '-' || ch == '.') {
+            result += (char)ch;
+        } else if (ch <= 0xFF) {
+            result += '%';
+            result += hexDigits[ch / 16];
+            result += hexDigits[ch % 16];
+        } else {
+            result += "%U";
+            QByteArray hexCode;
+            for (int i = 0; i < 4; ++i) {
+                hexCode.prepend(hexDigits[ch % 16]);
+                ch >>= 4;
+            }
+            result += hexCode;
+        }
+    }
+}
+
+bool QSettingsPrivate::iniUnescapedKey(const QByteArray &key, int from, int to, QString &result)
+{
+    bool lowercaseOnly = true;
+    int i = from;
+    result.reserve(result.length() + (to - from));
+    while (i < to) {
+        int ch = (uchar)key.at(i);
+
+        if (ch == '\\') {
+            result += QLatin1Char('/');
+            ++i;
+            continue;
+        }
+
+        if (ch != '%' || i == to - 1) {
+            if (uint(ch - 'A') <= 'Z' - 'A') // only for ASCII
+                lowercaseOnly = false;
+            result += QLatin1Char(ch);
+            ++i;
+            continue;
+        }
+
+        int numDigits = 2;
+        int firstDigitPos = i + 1;
+
+        ch = key.at(i + 1);
+        if (ch == 'U') {
+            ++firstDigitPos;
+            numDigits = 4;
+        }
+
+        if (firstDigitPos + numDigits > to) {
+            result += QLatin1Char('%');
+            // ### missing U
+            ++i;
+            continue;
+        }
+
+        bool ok;
+        ch = key.mid(firstDigitPos, numDigits).toInt(&ok, 16);
+        if (!ok) {
+            result += QLatin1Char('%');
+            // ### missing U
+            ++i;
+            continue;
+        }
+
+        QChar qch(ch);
+        if (qch.isUpper())
+            lowercaseOnly = false;
+        result += qch;
+        i = firstDigitPos + numDigits;
+    }
+    return lowercaseOnly;
+}
+
+void QSettingsPrivate::iniEscapedString(const QString &str, QByteArray &result, QTextCodec *codec)
+{
+    bool needsQuotes = false;
+    bool escapeNextIfDigit = false;
+    int i;
+    int startPos = result.size();
+
+    result.reserve(startPos + str.size() * 3 / 2);
+    for (i = 0; i < str.size(); ++i) {
+        uint ch = str.at(i).unicode();
+        if (ch == ';' || ch == ',' || ch == '=')
+            needsQuotes = true;
+
+        if (escapeNextIfDigit
+                && ((ch >= '0' && ch <= '9')
+                    || (ch >= 'a' && ch <= 'f')
+                    || (ch >= 'A' && ch <= 'F'))) {
+            result += "\\x";
+            result += QByteArray::number(ch, 16);
+            continue;
+        }
+
+        escapeNextIfDigit = false;
+
+        switch (ch) {
+        case '\0':
+            result += "\\0";
+            escapeNextIfDigit = true;
+            break;
+        case '\a':
+            result += "\\a";
+            break;
+        case '\b':
+            result += "\\b";
+            break;
+        case '\f':
+            result += "\\f";
+            break;
+        case '\n':
+            result += "\\n";
+            break;
+        case '\r':
+            result += "\\r";
+            break;
+        case '\t':
+            result += "\\t";
+            break;
+        case '\v':
+            result += "\\v";
+            break;
+        case '"':
+        case '\\':
+            result += '\\';
+            result += (char)ch;
+            break;
+        default:
+            if (ch <= 0x1F || (ch >= 0x7F && !codec)) {
+                result += "\\x";
+                result += QByteArray::number(ch, 16);
+                escapeNextIfDigit = true;
+#ifndef QT_NO_TEXTCODEC
+            } else if (codec) {
+                // slow
+                result += codec->fromUnicode(str.at(i));
+#endif
+            } else {
+                result += (char)ch;
+            }
+        }
+    }
+
+    if (needsQuotes
+            || (startPos < result.size() && (result.at(startPos) == ' '
+                                                || result.at(result.size() - 1) == ' '))) {
+        result.insert(startPos, '"');
+        result += '"';
+    }
+}
+
+inline static void iniChopTrailingSpaces(QString &str)
+{
+    int n = str.size() - 1;
+    QChar ch;
+    while (n >= 0 && ((ch = str.at(n)) == QLatin1Char(' ') || ch == QLatin1Char('\t')))
+        str.truncate(n--);
+}
+
+void QSettingsPrivate::iniEscapedStringList(const QStringList &strs, QByteArray &result, QTextCodec *codec)
+{
+    if (strs.isEmpty()) {
+        /*
+            We need to distinguish between empty lists and one-item
+            lists that contain an empty string. Ideally, we'd have a
+            @EmptyList() symbol but that would break compatibility
+            with Qt 4.0. @Invalid() stands for QVariant(), and
+            QVariant().toStringList() returns an empty QStringList,
+            so we're in good shape.
+
+            ### Qt 5: Use a nicer syntax, e.g. @List, for variant lists
+        */
+        result += "@Invalid()";
+    } else {
+        for (int i = 0; i < strs.size(); ++i) {
+            if (i != 0)
+                result += ", ";
+            iniEscapedString(strs.at(i), result, codec);
+        }
+    }
+}
+
+bool QSettingsPrivate::iniUnescapedStringList(const QByteArray &str, int from, int to,
+                                              QString &stringResult, QStringList &stringListResult,
+                                              QTextCodec *codec)
+{
+    static const char escapeCodes[][2] =
+    {
+        { 'a', '\a' },
+        { 'b', '\b' },
+        { 'f', '\f' },
+        { 'n', '\n' },
+        { 'r', '\r' },
+        { 't', '\t' },
+        { 'v', '\v' },
+        { '"', '"' },
+        { '?', '?' },
+        { '\'', '\'' },
+        { '\\', '\\' }
+    };
+    static const int numEscapeCodes = sizeof(escapeCodes) / sizeof(escapeCodes[0]);
+
+    bool isStringList = false;
+    bool inQuotedString = false;
+    bool currentValueIsQuoted = false;
+    int escapeVal = 0;
+    int i = from;
+    char ch;
+
+StSkipSpaces:
+    while (i < to && ((ch = str.at(i)) == ' ' || ch == '\t'))
+        ++i;
+    // fallthrough
+
+StNormal:
+    while (i < to) {
+        switch (str.at(i)) {
+        case '\\':
+            ++i;
+            if (i >= to)
+                goto end;
+
+            ch = str.at(i++);
+            for (int j = 0; j < numEscapeCodes; ++j) {
+                if (ch == escapeCodes[j][0]) {
+                    stringResult += QLatin1Char(escapeCodes[j][1]);
+                    goto StNormal;
+                }
+            }
+
+            if (ch == 'x') {
+                escapeVal = 0;
+
+                if (i >= to)
+                    goto end;
+
+                ch = str.at(i);
+                if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f'))
+                    goto StHexEscape;
+            } else if (ch >= '0' && ch <= '7') {
+                escapeVal = ch - '0';
+                goto StOctEscape;
+            } else if (ch == '\n' || ch == '\r') {
+                if (i < to) {
+                    char ch2 = str.at(i);
+                    // \n, \r, \r\n, and \n\r are legitimate line terminators in INI files
+                    if ((ch2 == '\n' || ch2 == '\r') && ch2 != ch)
+                        ++i;
+                }
+            } else {
+                // the character is skipped
+            }
+            break;
+        case '"':
+            ++i;
+            currentValueIsQuoted = true;
+            inQuotedString = !inQuotedString;
+            if (!inQuotedString)
+                goto StSkipSpaces;
+            break;
+        case ',':
+            if (!inQuotedString) {
+                if (!currentValueIsQuoted)
+                    iniChopTrailingSpaces(stringResult);
+                if (!isStringList) {
+                    isStringList = true;
+                    stringListResult.clear();
+                    stringResult.squeeze();
+                }
+                stringListResult.append(stringResult);
+                stringResult.clear();
+                currentValueIsQuoted = false;
+                ++i;
+                goto StSkipSpaces;
+            }
+            // fallthrough
+        default: {
+            int j = i + 1;
+            while (j < to) {
+                ch = str.at(j);
+                if (ch == '\\' || ch == '"' || ch == ',')
+                    break;
+                ++j;
+            }
+
+#ifndef QT_NO_TEXTCODEC
+            if (codec) {
+                stringResult += codec->toUnicode(str.constData() + i, j - i);
+            } else
+#endif
+            {
+                int n = stringResult.size();
+                stringResult.resize(n + (j - i));
+                QChar *resultData = stringResult.data() + n;
+                for (int k = i; k < j; ++k)
+                    *resultData++ = QLatin1Char(str.at(k));
+            }
+            i = j;
+        }
+        }
+    }
+    goto end;
+
+StHexEscape:
+    if (i >= to) {
+        stringResult += QChar(escapeVal);
+        goto end;
+    }
+
+    ch = str.at(i);
+    if (ch >= 'a')
+        ch -= 'a' - 'A';
+    if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F')) {
+        escapeVal <<= 4;
+        escapeVal += strchr(hexDigits, ch) - hexDigits;
+        ++i;
+        goto StHexEscape;
+    } else {
+        stringResult += QChar(escapeVal);
+        goto StNormal;
+    }
+
+StOctEscape:
+    if (i >= to) {
+        stringResult += QChar(escapeVal);
+        goto end;
+    }
+
+    ch = str.at(i);
+    if (ch >= '0' && ch <= '7') {
+        escapeVal <<= 3;
+        escapeVal += ch - '0';
+        ++i;
+        goto StOctEscape;
+    } else {
+        stringResult += QChar(escapeVal);
+        goto StNormal;
+    }
+
+end:
+    if (!currentValueIsQuoted)
+        iniChopTrailingSpaces(stringResult);
+    if (isStringList)
+        stringListResult.append(stringResult);
+    return isStringList;
+}
+
+QStringList QSettingsPrivate::splitArgs(const QString &s, int idx)
+{
+    int l = s.length();
+    Q_ASSERT(l > 0);
+    Q_ASSERT(s.at(idx) == QLatin1Char('('));
+    Q_ASSERT(s.at(l - 1) == QLatin1Char(')'));
+
+    QStringList result;
+    QString item;
+
+    for (++idx; idx < l; ++idx) {
+        QChar c = s.at(idx);
+        if (c == QLatin1Char(')')) {
+            Q_ASSERT(idx == l - 1);
+            result.append(item);
+        } else if (c == QLatin1Char(' ')) {
+            result.append(item);
+            item.clear();
+        } else {
+            item.append(c);
+        }
+    }
+
+    return result;
+}
+
+// ************************************************************************
+// QConfFileSettingsPrivate
+
+/*
+    If we don't have the permission to read the file, returns false.
+    If the file doesn't exist, returns true.
+*/
+static bool checkAccess(const QString &name)
+{
+    QFileInfo fileInfo(name);
+
+    if (fileInfo.exists()) {
+        QFile file(name);
+        // if the file exists but we can't open it, report an error
+        return file.open(QFile::ReadOnly);
+    } else {
+        return true;
+    }
+}
+
+void QConfFileSettingsPrivate::initFormat()
+{
+    extension = (format == QSettings::NativeFormat) ? QLatin1String(".conf") : QLatin1String(".ini");
+    readFunc = 0;
+    writeFunc = 0;
+#if defined(Q_OS_MAC)
+    caseSensitivity = (format == QSettings::NativeFormat) ? Qt::CaseSensitive : Qt::CaseInsensitive;
+#else
+    caseSensitivity = IniCaseSensitivity;
+#endif
+
+    if (format > QSettings::IniFormat) {
+        QMutexLocker locker(globalMutex());
+        const CustomFormatVector *customFormatVector = customFormatVectorFunc();
+
+        int i = (int)format - (int)QSettings::CustomFormat1;
+        if (i >= 0 && i < customFormatVector->size()) {
+            QConfFileCustomFormat info = customFormatVector->at(i);
+            extension = info.extension;
+            readFunc = info.readFunc;
+            writeFunc = info.writeFunc;
+            caseSensitivity = info.caseSensitivity;
+        }
+    }
+}
+
+void QConfFileSettingsPrivate::initAccess()
+{
+    bool readAccess = false;
+    if (confFiles[spec]) {
+        readAccess = checkAccess(confFiles[spec]->name);
+        if (format > QSettings::IniFormat) {
+            if (!readFunc)
+                readAccess = false;
+        }
+    }
+
+    if (!readAccess)
+        setStatus(QSettings::AccessError);
+
+    sync();       // loads the files the first time
+}
+
+#ifdef Q_OS_WIN
+static QString windowsConfigPath(int type)
+{
+    QString result;
+
+#ifndef QT_NO_QOBJECT
+    // We can't use QLibrary if there is QT_NO_QOBJECT is defined
+    // This only happens when bootstrapping qmake.
+#ifndef Q_OS_WINCE
+    QLibrary library(QLatin1String("shell32"));
+    QT_WA( {
+        typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPTSTR, int, BOOL);
+        GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPathW");
+        if (SHGetSpecialFolderPath) {
+            TCHAR path[MAX_PATH];
+            SHGetSpecialFolderPath(0, path, type, FALSE);
+            result = QString::fromUtf16((ushort*)path);
+        }
+    } , {
+        typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, char*, int, BOOL);
+        GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPathA");
+        if (SHGetSpecialFolderPath) {
+            char path[MAX_PATH];
+            SHGetSpecialFolderPath(0, path, type, FALSE);
+            result = QString::fromLocal8Bit(path);
+        }
+    } );
+#else
+    QLibrary library(QLatin1String("coredll"));
+    typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPTSTR, int, BOOL);
+    GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPath");
+    if (SHGetSpecialFolderPath) {
+        wchar_t path[MAX_PATH];
+        SHGetSpecialFolderPath(0, path, type, FALSE);
+        result = QString::fromUtf16((ushort*)path);
+    }
+#endif // Q_OS_WINCE
+
+#endif // QT_NO_QOBJECT
+
+    if (result.isEmpty()) {
+        switch (type) {
+#ifndef Q_OS_WINCE
+        case CSIDL_COMMON_APPDATA:
+            result = QLatin1String("C:\\temp\\qt-common");
+            break;
+        case CSIDL_APPDATA:
+            result = QLatin1String("C:\\temp\\qt-user");
+            break;
+#else
+        case CSIDL_COMMON_APPDATA:
+            result = QLatin1String("\\Temp\\qt-common");
+            break;
+        case CSIDL_APPDATA:
+            result = QLatin1String("\\Temp\\qt-user");
+            break;
+#endif
+        default:
+            ;
+        }
+    }
+
+    return result;
+}
+#endif // Q_OS_WIN
+
+static inline int pathHashKey(QSettings::Format format, QSettings::Scope scope)
+{
+    return int((uint(format) << 1) | uint(scope == QSettings::SystemScope));
+}
+
+static QString getPath(QSettings::Format format, QSettings::Scope scope)
+{
+    Q_ASSERT((int)QSettings::NativeFormat == 0);
+    Q_ASSERT((int)QSettings::IniFormat == 1);
+
+    QString homePath = QDir::homePath();
+    QString systemPath;
+
+    globalMutex()->lock();
+    PathHash *pathHash = pathHashFunc();
+    bool loadSystemPath = pathHash->isEmpty();
+    globalMutex()->unlock();
+
+    if (loadSystemPath) {
+        /*
+           QLibraryInfo::location() uses QSettings, so in order to
+           avoid a dead-lock, we can't hold the global mutex while
+           calling it.
+       */
+        systemPath = QLibraryInfo::location(QLibraryInfo::SettingsPath);
+        systemPath += QLatin1Char('/');
+    }
+
+    QMutexLocker locker(globalMutex());
+    if (pathHash->isEmpty()) {
+        /*
+           Lazy initialization of pathHash. We initialize the
+           IniFormat paths and (on Unix) the NativeFormat paths.
+           (The NativeFormat paths are not configurable for the
+           Windows registry and the Mac CFPreferences.)
+       */
+#ifdef Q_OS_WIN
+        pathHash->insert(pathHashKey(QSettings::IniFormat, QSettings::UserScope),
+                         windowsConfigPath(CSIDL_APPDATA) + QDir::separator());
+        pathHash->insert(pathHashKey(QSettings::IniFormat, QSettings::SystemScope),
+                         windowsConfigPath(CSIDL_COMMON_APPDATA) + QDir::separator());
+#else
+        QString userPath;
+        char *env = getenv("XDG_CONFIG_HOME");
+        if (env == 0) {
+            userPath = homePath;
+            userPath += QLatin1Char('/');
+#ifdef Q_WS_QWS
+            userPath += QLatin1String("Settings");
+#else
+            userPath += QLatin1String(".config");
+#endif
+        } else if (*env == '/') {
+            userPath = QLatin1String(env);
+        } else {
+            userPath = homePath;
+            userPath += QLatin1Char('/');
+            userPath += QLatin1String(env);
+        }
+        userPath += QLatin1Char('/');
+
+        pathHash->insert(pathHashKey(QSettings::IniFormat, QSettings::UserScope), userPath);
+        pathHash->insert(pathHashKey(QSettings::IniFormat, QSettings::SystemScope), systemPath);
+#ifndef Q_OS_MAC
+        pathHash->insert(pathHashKey(QSettings::NativeFormat, QSettings::UserScope), userPath);
+        pathHash->insert(pathHashKey(QSettings::NativeFormat, QSettings::SystemScope), systemPath);
+#endif
+#endif
+    }
+
+    QString result = pathHash->value(pathHashKey(format, scope));
+    if (!result.isEmpty())
+        return result;
+
+    // fall back on INI path
+    return pathHash->value(pathHashKey(QSettings::IniFormat, scope));
+}
+
+QConfFileSettingsPrivate::QConfFileSettingsPrivate(QSettings::Format format,
+                                                   QSettings::Scope scope,
+                                                   const QString &organization,
+                                                   const QString &application)
+    : QSettingsPrivate(format, scope, organization, application),
+      nextPosition(0x40000000) // big positive number
+{
+    int i;
+    initFormat();
+
+    for (i = 0; i < NumConfFiles; ++i)
+        confFiles[i] = 0;
+
+    QString org = organization;
+    if (org.isEmpty()) {
+        setStatus(QSettings::AccessError);
+        org = QLatin1String("Unknown Organization");
+    }
+
+    QString appFile = org + QDir::separator() + application + extension;
+    QString orgFile = org + extension;
+
+    if (scope == QSettings::UserScope) {
+        QString userPath = getPath(format, QSettings::UserScope);
+        if (!application.isEmpty())
+            confFiles[F_User | F_Application] = QConfFile::fromName(userPath + appFile, true);
+        confFiles[F_User | F_Organization] = QConfFile::fromName(userPath + orgFile, true);
+    }
+
+    QString systemPath = getPath(format, QSettings::SystemScope);
+    if (!application.isEmpty())
+        confFiles[F_System | F_Application] = QConfFile::fromName(systemPath + appFile, false);
+    confFiles[F_System | F_Organization] = QConfFile::fromName(systemPath + orgFile, false);
+
+    for (i = 0; i < NumConfFiles; ++i) {
+        if (confFiles[i]) {
+            spec = i;
+            break;
+        }
+    }
+
+    initAccess();
+}
+
+QConfFileSettingsPrivate::QConfFileSettingsPrivate(const QString &fileName,
+                                                   QSettings::Format format)
+    : QSettingsPrivate(format),
+      nextPosition(0x40000000) // big positive number
+{
+    initFormat();
+
+    confFiles[0] = QConfFile::fromName(fileName, true);
+    for (int i = 1; i < NumConfFiles; ++i)
+        confFiles[i] = 0;
+
+    initAccess();
+}
+
+QConfFileSettingsPrivate::~QConfFileSettingsPrivate()
+{
+    QMutexLocker locker(globalMutex());
+    ConfFileHash *usedHash = usedHashFunc();
+    ConfFileCache *unusedCache = unusedCacheFunc();
+
+    for (int i = 0; i < NumConfFiles; ++i) {
+        if (confFiles[i] && !confFiles[i]->ref.deref()) {
+            if (usedHash)
+                usedHash->remove(confFiles[i]->name);
+
+            if (confFiles[i]->size == 0) {
+                delete confFiles[i];
+            } else if (unusedCache) {
+                // compute a better size?
+                unusedCache->insert(confFiles[i]->name, confFiles[i],
+                                    10 + (confFiles[i]->originalKeys.size() / 4));
+            }
+        }
+    }
+}
+
+void QConfFileSettingsPrivate::remove(const QString &key)
+{
+    QConfFile *confFile = confFiles[spec];
+    if (!confFile)
+        return;
+
+    QSettingsKey theKey(key, caseSensitivity);
+    QSettingsKey prefix(key + QLatin1Char('/'), caseSensitivity);
+    QMutexLocker locker(&confFile->mutex);
+
+    ensureSectionParsed(confFile, theKey);
+    ensureSectionParsed(confFile, prefix);
+
+    ParsedSettingsMap::iterator i = confFile->addedKeys.lowerBound(prefix);
+    while (i != confFile->addedKeys.end() && i.key().startsWith(prefix))
+        i = confFile->addedKeys.erase(i);
+    confFile->addedKeys.remove(theKey);
+
+    ParsedSettingsMap::const_iterator j = const_cast<const ParsedSettingsMap *>(&confFile->originalKeys)->lowerBound(prefix);
+    while (j != confFile->originalKeys.constEnd() && j.key().startsWith(prefix)) {
+        confFile->removedKeys.insert(j.key(), QVariant());
+        ++j;
+    }
+    if (confFile->originalKeys.contains(theKey))
+        confFile->removedKeys.insert(theKey, QVariant());
+}
+
+void QConfFileSettingsPrivate::set(const QString &key, const QVariant &value)
+{
+    QConfFile *confFile = confFiles[spec];
+    if (!confFile)
+        return;
+
+    QSettingsKey theKey(key, caseSensitivity, nextPosition++);
+    QMutexLocker locker(&confFile->mutex);
+    confFile->removedKeys.remove(theKey);
+    confFile->addedKeys.insert(theKey, value);
+}
+
+bool QConfFileSettingsPrivate::get(const QString &key, QVariant *value) const
+{
+    QSettingsKey theKey(key, caseSensitivity);
+    ParsedSettingsMap::const_iterator j;
+    bool found = false;
+
+    for (int i = 0; i < NumConfFiles; ++i) {
+        if (QConfFile *confFile = confFiles[i]) {
+            QMutexLocker locker(&confFile->mutex);
+
+            if (!confFile->addedKeys.isEmpty()) {
+                j = confFile->addedKeys.constFind(theKey);
+                found = (j != confFile->addedKeys.constEnd());
+            }
+            if (!found) {
+                ensureSectionParsed(confFile, theKey);
+                j = confFile->originalKeys.constFind(theKey);
+                found = (j != confFile->originalKeys.constEnd()
+                         && !confFile->removedKeys.contains(theKey));
+            }
+
+            if (found && value)
+                *value = *j;
+
+            if (found)
+                return true;
+            if (!fallbacks)
+                break;
+        }
+    }
+    return false;
+}
+
+QStringList QConfFileSettingsPrivate::children(const QString &prefix, ChildSpec spec) const
+{
+    QMap<QString, QString> result;
+    ParsedSettingsMap::const_iterator j;
+
+    QSettingsKey thePrefix(prefix, caseSensitivity);
+    int startPos = prefix.size();
+
+    for (int i = 0; i < NumConfFiles; ++i) {
+        if (QConfFile *confFile = confFiles[i]) {
+            QMutexLocker locker(&confFile->mutex);
+
+            if (thePrefix.isEmpty()) {
+                ensureAllSectionsParsed(confFile);
+            } else {
+                ensureSectionParsed(confFile, thePrefix);
+            }
+
+            j = const_cast<const ParsedSettingsMap *>(
+                    &confFile->originalKeys)->lowerBound( thePrefix);
+            while (j != confFile->originalKeys.constEnd() && j.key().startsWith(thePrefix)) {
+                if (!confFile->removedKeys.contains(j.key()))
+                    processChild(j.key().originalCaseKey().mid(startPos), spec, result);
+                ++j;
+            }
+
+            j = const_cast<const ParsedSettingsMap *>(
+                    &confFile->addedKeys)->lowerBound(thePrefix);
+            while (j != confFile->addedKeys.constEnd() && j.key().startsWith(thePrefix)) {
+                processChild(j.key().originalCaseKey().mid(startPos), spec, result);
+                ++j;
+            }
+
+            if (!fallbacks)
+                break;
+        }
+    }
+    return result.keys();
+}
+
+void QConfFileSettingsPrivate::clear()
+{
+    QConfFile *confFile = confFiles[spec];
+    if (!confFile)
+        return;
+
+    QMutexLocker locker(&confFile->mutex);
+    ensureAllSectionsParsed(confFile);
+    confFile->addedKeys.clear();
+    confFile->removedKeys = confFile->originalKeys;
+}
+
+void QConfFileSettingsPrivate::sync()
+{
+    // people probably won't be checking the status a whole lot, so in case of
+    // error we just try to go on and make the best of it
+
+    for (int i = 0; i < NumConfFiles; ++i) {
+        QConfFile *confFile = confFiles[i];
+        if (confFile) {
+            QMutexLocker locker(&confFile->mutex);
+            syncConfFile(i);
+        }
+    }
+}
+
+void QConfFileSettingsPrivate::flush()
+{
+    sync();
+}
+
+QString QConfFileSettingsPrivate::fileName() const
+{
+    QConfFile *confFile = confFiles[spec];
+    if (!confFile)
+        return QString();
+    return confFile->name;
+}
+
+bool QConfFileSettingsPrivate::isWritable() const
+{
+    if (format > QSettings::IniFormat && !writeFunc)
+        return false;
+
+    QConfFile *confFile = confFiles[spec];
+    if (!confFile)
+        return false;
+
+    return confFile->isWritable();
+}
+
+void QConfFileSettingsPrivate::syncConfFile(int confFileNo)
+{
+    QConfFile *confFile = confFiles[confFileNo];
+    bool readOnly = confFile->addedKeys.isEmpty() && confFile->removedKeys.isEmpty();
+    bool ok;
+
+    /*
+        We can often optimize the read-only case, if the file on disk
+        hasn't changed.
+    */
+    if (readOnly) {
+        QFileInfo fileInfo(confFile->name);
+        if (confFile->size == fileInfo.size() && confFile->timeStamp == fileInfo.lastModified())
+            return;
+    }
+
+    /*
+        Open the configuration file and try to use it using a named
+        semaphore on Windows and an advisory lock on Unix-based
+        systems. This protect us against other QSettings instances
+        trying to access the same file from other threads or
+        processes.
+
+        As it stands now, the locking mechanism doesn't work for
+        .plist files.
+    */
+    QFile file(confFile->name);
+    bool createFile = !file.exists();
+    if (!readOnly && confFile->isWritable())
+        file.open(QFile::ReadWrite);
+    if (!file.isOpen())
+        file.open(QFile::ReadOnly);
+
+#ifdef Q_OS_WIN
+    HANDLE readSemaphore = 0;
+    HANDLE writeSemaphore = 0;
+    static const int FileLockSemMax = 50;
+    int numReadLocks = readOnly ? 1 : FileLockSemMax;
+
+    if (file.isOpen()) {
+        // Acquire the write lock if we will be writing
+        if (!readOnly) {
+            QString writeSemName = QLatin1String("QSettingsWriteSem ");
+            writeSemName.append(file.fileName());
+
+            QT_WA( {
+                writeSemaphore = CreateSemaphoreW(0, 1, 1, reinterpret_cast<const wchar_t *>(writeSemName.utf16()));
+            } , {
+                writeSemaphore = CreateSemaphoreA(0, 1, 1, writeSemName.toLocal8Bit());
+            } );
+
+            if (writeSemaphore) {
+                WaitForSingleObject(writeSemaphore, INFINITE);
+            } else {
+                setStatus(QSettings::AccessError);
+                return;
+            }
+        }
+
+        // Acquire all the read locks if we will be writing, to make sure nobody
+        // reads while we're writing. If we are only reading, acquire a single
+        // read lock.
+        QString readSemName(QLatin1String("QSettingsReadSem "));
+        readSemName.append(file.fileName());
+
+        QT_WA( {
+            readSemaphore = CreateSemaphoreW(0, FileLockSemMax, FileLockSemMax, reinterpret_cast<const wchar_t *>(readSemName.utf16()));
+        } , {
+            readSemaphore = CreateSemaphoreA(0, FileLockSemMax, FileLockSemMax, readSemName.toLocal8Bit());
+        } );
+
+        if (readSemaphore) {
+            for (int i = 0; i < numReadLocks; ++i)
+                WaitForSingleObject(readSemaphore, INFINITE);
+        } else {
+            setStatus(QSettings::AccessError);
+            if (writeSemaphore != 0) {
+                ReleaseSemaphore(writeSemaphore, 1, 0);
+                CloseHandle(writeSemaphore);
+            }
+            return;
+        }
+    }
+#else
+    if (file.isOpen())
+        unixLock(file.handle(), readOnly ? F_RDLCK : F_WRLCK);
+#endif
+
+    // If we have created the file, apply the file perms
+    if (file.isOpen()) {
+        if (createFile) {
+            QFile::Permissions perms = file.permissions() | QFile::ReadOwner | QFile::WriteOwner;
+            if (!confFile->userPerms)
+                perms |= QFile::ReadGroup | QFile::ReadOther;
+            file.setPermissions(perms);
+        }
+    }
+
+    /*
+        We hold the lock. Let's reread the file if it has changed
+        since last time we read it.
+    */
+    QFileInfo fileInfo(confFile->name);
+    bool mustReadFile = true;
+
+    if (!readOnly)
+        mustReadFile = (confFile->size != fileInfo.size()
+                        || (confFile->size != 0 && confFile->timeStamp != fileInfo.lastModified()));
+
+    if (mustReadFile) {
+        confFile->unparsedIniSections.clear();
+        confFile->originalKeys.clear();
+
+        /*
+            Files that we can't read (because of permissions or
+            because they don't exist) are treated as empty files.
+        */
+        if (file.isReadable() && fileInfo.size() != 0) {
+#ifdef Q_OS_MAC
+            if (format == QSettings::NativeFormat) {
+                ok = readPlistFile(confFile->name, &confFile->originalKeys);
+            } else
+#endif
+            {
+                if (format <= QSettings::IniFormat) {
+                    QByteArray data = file.readAll();
+                    ok = readIniFile(data, &confFile->unparsedIniSections);
+                } else {
+                    if (readFunc) {
+                        QSettings::SettingsMap tempNewKeys;
+                        ok = readFunc(file, tempNewKeys);
+
+                        if (ok) {
+                            QSettings::SettingsMap::const_iterator i = tempNewKeys.constBegin();
+                            while (i != tempNewKeys.constEnd()) {
+                                confFile->originalKeys.insert(QSettingsKey(i.key(),
+                                                                           caseSensitivity),
+                                                              i.value());
+                                ++i;
+                            }
+                        }
+                    } else {
+                        ok = false;
+                    }
+                }
+            }
+
+            if (!ok)
+                setStatus(QSettings::FormatError);
+        }
+
+        confFile->size = fileInfo.size();
+        confFile->timeStamp = fileInfo.lastModified();
+    }
+
+    /*
+        We also need to save the file. We still hold the file lock,
+        so everything is under control.
+    */
+    if (!readOnly) {
+        ensureAllSectionsParsed(confFile);
+        ParsedSettingsMap mergedKeys = confFile->mergedKeyMap();
+
+        if (file.isWritable()) {
+#ifdef Q_OS_MAC
+            if (format == QSettings::NativeFormat) {
+                ok = writePlistFile(confFile->name, mergedKeys);
+            } else
+#endif
+            {
+                file.seek(0);
+                file.resize(0);
+
+                if (format <= QSettings::IniFormat) {
+                    ok = writeIniFile(file, mergedKeys);
+                    if (!ok) {
+                        // try to restore old data; might work if the disk was full and the new data
+                        // was larger than the old data
+                        file.seek(0);
+                        file.resize(0);
+                        writeIniFile(file, confFile->originalKeys);
+                    }
+                } else {
+                    if (writeFunc) {
+                        QSettings::SettingsMap tempOriginalKeys;
+
+                        ParsedSettingsMap::const_iterator i = mergedKeys.constBegin();
+                        while (i != mergedKeys.constEnd()) {
+                            tempOriginalKeys.insert(i.key(), i.value());
+                            ++i;
+                        }
+                        ok = writeFunc(file, tempOriginalKeys);
+                    } else {
+                        ok = false;
+                    }
+                }
+            }
+        } else {
+            ok = false;
+        }
+
+        if (ok) {
+            confFile->unparsedIniSections.clear();
+            confFile->originalKeys = mergedKeys;
+            confFile->addedKeys.clear();
+            confFile->removedKeys.clear();
+
+            QFileInfo fileInfo(confFile->name);
+            confFile->size = fileInfo.size();
+            confFile->timeStamp = fileInfo.lastModified();
+        } else {
+            setStatus(QSettings::AccessError);
+        }
+    }
+
+    /*
+        Release the file lock.
+    */
+#ifdef Q_OS_WIN
+    if (readSemaphore != 0) {
+        ReleaseSemaphore(readSemaphore, numReadLocks, 0);
+        CloseHandle(readSemaphore);
+    }
+    if (writeSemaphore != 0) {
+        ReleaseSemaphore(writeSemaphore, 1, 0);
+        CloseHandle(writeSemaphore);
+    }
+#endif
+}
+
+enum { Space = 0x1, Special = 0x2 };
+
+static const char charTraits[256] =
+{
+    // Space: '\t', '\n', '\r', ' '
+    // Special: '\n', '\r', '"', ';', '=', '\\'
+
+    0, 0, 0, 0, 0, 0, 0, 0, 0, Space, Space | Special, 0, 0, Space | Special, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    Space, 0, Special, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Special, 0, Special, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Special, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+bool QConfFileSettingsPrivate::readIniLine(const QByteArray &data, int &dataPos,
+                                           int &lineStart, int &lineLen, int &equalsPos)
+{
+    int dataLen = data.length();
+    bool inQuotes = false;
+
+    equalsPos = -1;
+
+    lineStart = dataPos;
+    while (lineStart < dataLen && (charTraits[uint(uchar(data.at(lineStart)))] & Space))
+        ++lineStart;
+
+    int i = lineStart;
+    while (i < dataLen) {
+        while (!(charTraits[uint(uchar(data.at(i)))] & Special)) {
+            if (++i == dataLen)
+                goto break_out_of_outer_loop;
+        }
+
+        char ch = data.at(i++);
+        if (ch == '=') {
+            if (!inQuotes && equalsPos == -1)
+                equalsPos = i - 1;
+        } else if (ch == '\n' || ch == '\r') {
+            if (i == lineStart + 1) {
+                ++lineStart;
+            } else if (!inQuotes) {
+                --i;
+                goto break_out_of_outer_loop;
+            }
+        } else if (ch == '\\') {
+            if (i < dataLen) {
+                char ch = data.at(i++);
+                if (i < dataLen) {
+                    char ch2 = data.at(i);
+                    // \n, \r, \r\n, and \n\r are legitimate line terminators in INI files
+                    if ((ch == '\n' && ch2 == '\r') || (ch == '\r' && ch2 == '\n'))
+                        ++i;
+                }
+            }
+        } else if (ch == '"') {
+            inQuotes = !inQuotes;
+        } else {
+            Q_ASSERT(ch == ';');
+
+            if (i == lineStart + 1) {
+                char ch;
+                while (i < dataLen && ((ch = data.at(i) != '\n') && ch != '\r'))
+                    ++i;
+                lineStart = i;
+            } else if (!inQuotes) {
+                --i;
+                goto break_out_of_outer_loop;
+            }
+        }
+    }
+
+break_out_of_outer_loop:
+    dataPos = i;
+    lineLen = i - lineStart;
+    return lineLen > 0;
+}
+
+/*
+    Returns false on parse error. However, as many keys are read as
+    possible, so if the user doesn't check the status he will get the
+    most out of the file anyway.
+*/
+bool QConfFileSettingsPrivate::readIniFile(const QByteArray &data,
+                                           UnparsedSettingsMap *unparsedIniSections)
+{
+#define FLUSH_CURRENT_SECTION() \
+    { \
+        QByteArray &sectionData = (*unparsedIniSections)[QSettingsKey(currentSection, \
+                                                                      IniCaseSensitivity, \
+                                                                      sectionPosition)]; \
+        if (!sectionData.isEmpty()) \
+            sectionData.append('\n'); \
+        sectionData += data.mid(currentSectionStart, lineStart - currentSectionStart); \
+        sectionPosition = ++position; \
+    }
+
+    QString currentSection;
+    int currentSectionStart = 0;
+    int dataPos = 0;
+    int lineStart;
+    int lineLen;
+    int equalsPos;
+    int position = 0;
+    int sectionPosition = 0;
+    bool ok = true;
+
+    while (readIniLine(data, dataPos, lineStart, lineLen, equalsPos)) {
+        char ch = data.at(lineStart);
+        if (ch == '[') {
+            FLUSH_CURRENT_SECTION();
+
+            // this is a section
+            QByteArray iniSection;
+            int idx = data.indexOf(']', lineStart);
+            if (idx == -1 || idx >= lineStart + lineLen) {
+                ok = false;
+                iniSection = data.mid(lineStart + 1, lineLen - 1);
+            } else {
+                iniSection = data.mid(lineStart + 1, idx - lineStart - 1);
+            }
+
+            iniSection = iniSection.trimmed();
+
+            if (qstricmp(iniSection, "general") == 0) {
+                currentSection.clear();
+            } else {
+                if (qstricmp(iniSection, "%general") == 0) {
+                    currentSection = QLatin1String(iniSection.constData() + 1);
+                } else {
+                    currentSection.clear();
+                    iniUnescapedKey(iniSection, 0, iniSection.size(), currentSection);
+                }
+                currentSection += QLatin1Char('/');
+            }
+            currentSectionStart = dataPos;
+        }
+        ++position;
+    }
+
+    Q_ASSERT(lineStart == data.length());
+    FLUSH_CURRENT_SECTION();
+
+    return ok;
+
+#undef FLUSH_CURRENT_SECTION
+}
+
+bool QConfFileSettingsPrivate::readIniSection(const QSettingsKey &section, const QByteArray &data,
+                                              ParsedSettingsMap *settingsMap, QTextCodec *codec)
+{
+    QStringList strListValue;
+    bool sectionIsLowercase = (section == section.originalCaseKey());
+    int equalsPos;
+
+    bool ok = true;
+    int dataPos = 0;
+    int lineStart;
+    int lineLen;
+    int position = section.originalKeyPosition();
+
+    while (readIniLine(data, dataPos, lineStart, lineLen, equalsPos)) {
+        char ch = data.at(lineStart);
+        Q_ASSERT(ch != '[');
+
+        if (equalsPos == -1) {
+            if (ch != ';')
+                ok = false;
+            continue;
+        }
+
+        int keyEnd = equalsPos;
+        while (keyEnd > lineStart && ((ch = data.at(keyEnd - 1)) == ' ' || ch == '\t'))
+            --keyEnd;
+        int valueStart = equalsPos + 1;
+
+        QString key = section.originalCaseKey();
+        bool keyIsLowercase = (iniUnescapedKey(data, lineStart, keyEnd, key) && sectionIsLowercase);
+
+        QString strValue;
+        strValue.reserve(lineLen - (valueStart - lineStart));
+        bool isStringList = iniUnescapedStringList(data, valueStart, lineStart + lineLen,
+                                                   strValue, strListValue, codec);
+        QVariant variant;
+        if (isStringList) {
+            variant = stringListToVariantList(strListValue);
+        } else {
+            variant = stringToVariant(strValue);
+        }
+
+        /*
+            We try to avoid the expensive toLower() call in
+            QSettingsKey by passing Qt::CaseSensitive when the
+            key is already in lowercase.
+        */
+        settingsMap->insert(QSettingsKey(key, keyIsLowercase ? Qt::CaseSensitive
+                                                             : IniCaseSensitivity,
+                                         position),
+                            variant);
+        ++position;
+    }
+
+    return ok;
+}
+
+class QSettingsIniKey : public QString
+{
+public:
+    inline QSettingsIniKey() : position(-1) {}
+    inline QSettingsIniKey(const QString &str, int pos = -1) : QString(str), position(pos) {}
+
+    int position;
+};
+
+static bool operator<(const QSettingsIniKey &k1, const QSettingsIniKey &k2)
+{
+    if (k1.position != k2.position)
+        return k1.position < k2.position;
+    return static_cast<const QString &>(k1) < static_cast<const QString &>(k2);
+}
+
+typedef QMap<QSettingsIniKey, QVariant> IniKeyMap;
+
+struct QSettingsIniSection
+{
+    int position;
+    IniKeyMap keyMap;
+
+    inline QSettingsIniSection() : position(-1) {}
+};
+
+typedef QMap<QString, QSettingsIniSection> IniMap;
+
+/*
+    This would be more straightforward if we didn't try to remember the original
+    key order in the .ini file, but we do.
+*/
+bool QConfFileSettingsPrivate::writeIniFile(QIODevice &device, const ParsedSettingsMap &map)
+{
+    IniMap iniMap;
+    IniMap::const_iterator i;
+
+#ifdef Q_OS_WIN
+    const char * const eol = "\r\n";
+#else
+    const char eol = '\n';
+#endif
+
+    for (ParsedSettingsMap::const_iterator j = map.constBegin(); j != map.constEnd(); ++j) {
+        QString section;
+        QSettingsIniKey key(j.key().originalCaseKey(), j.key().originalKeyPosition());
+        int slashPos;
+
+        if ((slashPos = key.indexOf(QLatin1Char('/'))) != -1) {
+            section = key.left(slashPos);
+            key.remove(0, slashPos + 1);
+        }
+
+        QSettingsIniSection &iniSection = iniMap[section];
+
+        // -1 means infinity
+        if (uint(key.position) < uint(iniSection.position))
+            iniSection.position = key.position;
+        iniSection.keyMap[key] = j.value();
+    }
+
+    const int sectionCount = iniMap.size();
+    QVector<QSettingsIniKey> sections;
+    sections.reserve(sectionCount);
+    for (i = iniMap.constBegin(); i != iniMap.constEnd(); ++i)
+        sections.append(QSettingsIniKey(i.key(), i.value().position));
+    qSort(sections);
+
+    bool writeError = false;
+    for (int j = 0; !writeError && j < sectionCount; ++j) {
+        i = iniMap.constFind(sections.at(j));
+        Q_ASSERT(i != iniMap.constEnd());
+
+        QByteArray realSection;
+
+        iniEscapedKey(i.key(), realSection);
+
+        if (realSection.isEmpty()) {
+            realSection = "[General]";
+        } else if (qstricmp(realSection, "general") == 0) {
+            realSection = "[%General]";
+        } else {
+            realSection.prepend('[');
+            realSection.append(']');
+        }
+
+        if (j != 0)
+            realSection.prepend(eol);
+        realSection += eol;
+
+        device.write(realSection);
+
+        const IniKeyMap &ents = i.value().keyMap;
+        for (IniKeyMap::const_iterator j = ents.constBegin(); j != ents.constEnd(); ++j) {
+            QByteArray block;
+            iniEscapedKey(j.key(), block);
+            block += '=';
+
+            const QVariant &value = j.value();
+
+            /*
+                The size() != 1 trick is necessary because
+                QVariant(QString("foo")).toList() returns an empty
+                list, not a list containing "foo".
+            */
+            if (value.type() == QVariant::StringList
+                    || (value.type() == QVariant::List && value.toList().size() != 1)) {
+                iniEscapedStringList(variantListToStringList(value.toList()), block, iniCodec);
+            } else {
+                iniEscapedString(variantToString(value), block, iniCodec);
+            }
+            block += eol;
+            if (device.write(block) == -1) {
+                writeError = true;
+                break;
+            }
+        }
+    }
+    return !writeError;
+}
+
+void QConfFileSettingsPrivate::ensureAllSectionsParsed(QConfFile *confFile) const
+{
+    UnparsedSettingsMap::const_iterator i = confFile->unparsedIniSections.constBegin();
+    const UnparsedSettingsMap::const_iterator end = confFile->unparsedIniSections.constEnd();
+
+    for (; i != end; ++i) {
+        if (!QConfFileSettingsPrivate::readIniSection(i.key(), i.value(), &confFile->originalKeys, iniCodec))
+            setStatus(QSettings::FormatError);
+    }
+    confFile->unparsedIniSections.clear();
+}
+
+void QConfFileSettingsPrivate::ensureSectionParsed(QConfFile *confFile,
+                                                   const QSettingsKey &key) const
+{
+    if (confFile->unparsedIniSections.isEmpty())
+        return;
+
+    UnparsedSettingsMap::iterator i;
+
+    int indexOfSlash = key.indexOf(QLatin1Char('/'));
+    if (indexOfSlash != -1) {
+        i = confFile->unparsedIniSections.upperBound(key);
+        if (i == confFile->unparsedIniSections.begin())
+            return;
+        --i;
+        if (i.key().isEmpty() || !key.startsWith(i.key()))
+            return;
+    } else {
+        i = confFile->unparsedIniSections.begin();
+        if (i == confFile->unparsedIniSections.end() || !i.key().isEmpty())
+            return;
+    }
+
+    if (!QConfFileSettingsPrivate::readIniSection(i.key(), i.value(), &confFile->originalKeys, iniCodec))
+        setStatus(QSettings::FormatError);
+    confFile->unparsedIniSections.erase(i);
+}
+
+/*!
+    \class QSettings
+    \brief The QSettings class provides persistent platform-independent application settings.
+
+    \ingroup io
+    \ingroup misc
+    \mainclass
+    \reentrant
+
+    Users normally expect an application to remember its settings
+    (window sizes and positions, options, etc.) across sessions. This
+    information is often stored in the system registry on Windows,
+    and in XML preferences files on Mac OS X. On Unix systems, in the
+    absence of a standard, many applications (including the KDE
+    applications) use INI text files.
+
+    QSettings is an abstraction around these technologies, enabling
+    you to save and restore application settings in a portable
+    manner. It also supports \l{registerFormat()}{custom storage
+    formats}.
+
+    QSettings's API is based on QVariant, allowing you to save
+    most value-based types, such as QString, QRect, and QImage,
+    with the minimum of effort.
+
+    If all you need is a non-persistent memory-based structure,
+    consider using QMap<QString, QVariant> instead.
+
+    \tableofcontents section1
+
+    \section1 Basic Usage
+
+    When creating a QSettings object, you must pass the name of your
+    company or organization as well as the name of your application.
+    For example, if your product is called Star Runner and your
+    company is called MySoft, you would construct the QSettings
+    object as follows:
+
+    \snippet doc/src/snippets/settings/settings.cpp 0
+
+    QSettings objects can be created either on the stack or on
+    the heap (i.e. using \c new). Constructing and destroying a
+    QSettings object is very fast.
+
+    If you use QSettings from many places in your application, you
+    might want to specify the organization name and the application
+    name using QCoreApplication::setOrganizationName() and
+    QCoreApplication::setApplicationName(), and then use the default
+    QSettings constructor:
+
+    \snippet doc/src/snippets/settings/settings.cpp 1
+    \snippet doc/src/snippets/settings/settings.cpp 2
+    \snippet doc/src/snippets/settings/settings.cpp 3
+    \dots
+    \snippet doc/src/snippets/settings/settings.cpp 4
+
+    (Here, we also specify the organization's Internet domain. When
+    the Internet domain is set, it is used on Mac OS X instead of the
+    organization name, since Mac OS X applications conventionally use
+    Internet domains to identify themselves. If no domain is set, a
+    fake domain is derived from the organization name. See the
+    \l{Platform-Specific Notes} below for details.)
+
+    QSettings stores settings. Each setting consists of a QString
+    that specifies the setting's name (the \e key) and a QVariant
+    that stores the data associated with the key. To write a setting,
+    use setValue(). For example:
+
+    \snippet doc/src/snippets/settings/settings.cpp 5
+
+    If there already exists a setting with the same key, the existing
+    value is overwritten by the new value. For efficiency, the
+    changes may not be saved to permanent storage immediately. (You
+    can always call sync() to commit your changes.)
+
+    You can get a setting's value back using value():
+
+    \snippet doc/src/snippets/settings/settings.cpp 6
+
+    If there is no setting with the specified name, QSettings
+    returns a null QVariant (which can be converted to the integer 0).
+    You can specify another default value by passing a second
+    argument to value():
+
+    \snippet doc/src/snippets/settings/settings.cpp 7
+
+    To test whether a given key exists, call contains(). To remove
+    the setting associated with a key, call remove(). To obtain the
+    list of all keys, call allKeys(). To remove all keys, call
+    clear().
+
+    \section1 QVariant and GUI Types
+
+    Because QVariant is part of the \l QtCore library, it cannot provide
+    conversion functions to data types such as QColor, QImage, and
+    QPixmap, which are part of \l QtGui. In other words, there is no
+    \c toColor(), \c toImage(), or \c toPixmap() functions in QVariant.
+
+    Instead, you can use the QVariant::value() or the qVariantValue()
+    template function. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 0
+
+    The inverse conversion (e.g., from QColor to QVariant) is
+    automatic for all data types supported by QVariant, including
+    GUI-related types:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 1
+
+    Custom types registered using qRegisterMetaType() and
+    qRegisterMetaTypeStreamOperators() can be stored using QSettings.
+
+    \section1 Key Syntax
+
+    Setting keys can contain any Unicode characters. The Windows
+    registry and INI files use case-insensitive keys, whereas the
+    Carbon Preferences API on Mac OS X uses case-sensitive keys. To
+    avoid portability problems, follow these two simple rules:
+
+    \list 1
+    \o Always refer to the same key using the same case. For example,
+       if you refer to a key as "text fonts" in one place in your
+       code, don't refer to it as "Text Fonts" somewhere else.
+
+    \o Avoid key names that are identical except for the case. For
+       example, if you have a key called "MainWindow", don't try to
+       save another key as "mainwindow".
+
+    \o Do not use slashes  ('/' and '\\') in key names; the
+       backslash character is used to separate sub keys (see below). On
+       windows '\\' are converted by QSettings to '/', which makes
+       them identical.
+    \endlist
+
+    You can form hierarchical keys using the '/' character as a
+    separator, similar to Unix file paths. For example:
+
+    \snippet doc/src/snippets/settings/settings.cpp 8
+    \snippet doc/src/snippets/settings/settings.cpp 9
+    \snippet doc/src/snippets/settings/settings.cpp 10
+
+    If you want to save or restore many settings with the same
+    prefix, you can specify the prefix using beginGroup() and call
+    endGroup() at the end. Here's the same example again, but this
+    time using the group mechanism:
+
+    \snippet doc/src/snippets/settings/settings.cpp 11
+    \codeline
+    \snippet doc/src/snippets/settings/settings.cpp 12
+
+    If a group is set using beginGroup(), the behavior of most
+    functions changes consequently. Groups can be set recursively.
+
+    In addition to groups, QSettings also supports an "array"
+    concept. See beginReadArray() and beginWriteArray() for details.
+
+    \section1 Fallback Mechanism
+
+    Let's assume that you have created a QSettings object with the
+    organization name MySoft and the application name Star Runner.
+    When you look up a value, up to four locations are searched in
+    that order:
+
+    \list 1
+    \o a user-specific location for the Star Runner application
+    \o a user-specific location for all applications by MySoft
+    \o a system-wide location for the Star Runner application
+    \o a system-wide location for all applications by MySoft
+    \endlist
+
+    (See \l{Platform-Specific Notes} below for information on what
+    these locations are on the different platforms supported by Qt.)
+
+    If a key cannot be found in the first location, the search goes
+    on in the second location, and so on. This enables you to store
+    system-wide or organization-wide settings and to override them on
+    a per-user or per-application basis. To turn off this mechanism,
+    call setFallbacksEnabled(false).
+
+    Although keys from all four locations are available for reading,
+    only the first file (the user-specific location for the
+    application at hand) is accessible for writing. To write to any
+    of the other files, omit the application name and/or specify
+    QSettings::SystemScope (as opposed to QSettings::UserScope, the
+    default).
+
+    Let's see with an example:
+
+    \snippet doc/src/snippets/settings/settings.cpp 13
+    \snippet doc/src/snippets/settings/settings.cpp 14
+
+    The table below summarizes which QSettings objects access
+    which location. "\bold{X}" means that the location is the main
+    location associated to the QSettings object and is used both
+    for reading and for writing; "o" means that the location is used
+    as a fallback when reading.
+
+    \table
+    \header \o Locations               \o \c{obj1} \o \c{obj2} \o \c{obj3} \o \c{obj4}
+    \row    \o 1. User, Application    \o \bold{X} \o          \o          \o
+    \row    \o 2. User, Organization   \o o        \o \bold{X} \o          \o
+    \row    \o 3. System, Application  \o o        \o          \o \bold{X} \o
+    \row    \o 4. System, Organization \o o        \o o        \o o        \o \bold{X}
+    \endtable
+
+    The beauty of this mechanism is that it works on all platforms
+    supported by Qt and that it still gives you a lot of flexibility,
+    without requiring you to specify any file names or registry
+    paths.
+
+    If you want to use INI files on all platforms instead of the
+    native API, you can pass QSettings::IniFormat as the first
+    argument to the QSettings constructor, followed by the scope, the
+    organization name, and the application name:
+
+    \snippet doc/src/snippets/settings/settings.cpp 15
+
+    The \l{tools/settingseditor}{Settings Editor} example lets you
+    experiment with different settings location and with fallbacks
+    turned on or off.
+
+    \section1 Restoring the State of a GUI Application
+
+    QSettings is often used to store the state of a GUI
+    application. The following example illustrates how to use QSettings
+    to save and restore the geometry of an application's main window.
+
+    \snippet doc/src/snippets/settings/settings.cpp 16
+    \codeline
+    \snippet doc/src/snippets/settings/settings.cpp 17
+
+    See \l{Window Geometry} for a discussion on why it is better to
+    call QWidget::resize() and QWidget::move() rather than QWidget::setGeometry()
+    to restore a window's geometry.
+
+    The \c readSettings() and \c writeSettings() functions must be
+    called from the main window's constructor and close event handler
+    as follows:
+
+    \snippet doc/src/snippets/settings/settings.cpp 18
+    \dots
+    \snippet doc/src/snippets/settings/settings.cpp 19
+    \snippet doc/src/snippets/settings/settings.cpp 20
+    \codeline
+    \snippet doc/src/snippets/settings/settings.cpp 21
+
+    See the \l{mainwindows/application}{Application} example for a
+    self-contained example that uses QSettings.
+
+    \section1 Accessing Settings from Multiple Threads or Processes Simultaneously
+
+    QSettings is \l{reentrant}. This means that you can use
+    distinct QSettings object in different threads
+    simultaneously. This guarantee stands even when the QSettings
+    objects refer to the same files on disk (or to the same entries
+    in the system registry). If a setting is modified through one
+    QSettings object, the change will immediately be visible in
+    any other QSettings objects that operate on the same location
+    and that live in the same process.
+
+    QSettings can safely be used from different processes (which can
+    be different instances of your application running at the same
+    time or different applications altogether) to read and write to
+    the same system locations. It uses advisory file locking and a
+    smart merging algorithm to ensure data integrity. Changes
+    performed by another process aren't visible in the current
+    process until sync() is called.
+
+    \section1 Platform-Specific Notes
+
+    \section2 Locations Where Application Settings Are Stored
+
+    As mentioned in the \l{Fallback Mechanism} section, QSettings
+    stores settings for an application in up to four locations,
+    depending on whether the settings are user-specific or
+    system-wide and whether the the settings are application-specific
+    or organization-wide. For simplicity, we're assuming the
+    organization is called MySoft and the application is called Star
+    Runner.
+
+    On Unix systems, if the file format is NativeFormat, the
+    following files are used by default:
+
+    \list 1
+    \o \c{$HOME/.config/MySoft/Star Runner.conf} (Qt for Embedded Linux: \c{$HOME/Settings/MySoft/Star Runner.conf})
+    \o \c{$HOME/.config/MySoft.conf} (Qt for Embedded Linux: \c{$HOME/Settings/MySoft.conf})
+    \o \c{/etc/xdg/MySoft/Star Runner.conf}
+    \o \c{/etc/xdg/MySoft.conf}
+    \endlist
+
+    On Mac OS X versions 10.2 and 10.3, these files are used by
+    default:
+
+    \list 1
+    \o \c{$HOME/Library/Preferences/com.MySoft.Star Runner.plist}
+    \o \c{$HOME/Library/Preferences/com.MySoft.plist}
+    \o \c{/Library/Preferences/com.MySoft.Star Runner.plist}
+    \o \c{/Library/Preferences/com.MySoft.plist}
+    \endlist
+
+    On Windows, NativeFormat settings are stored in the following
+    registry paths:
+
+    \list 1
+    \o \c{HKEY_CURRENT_USER\Software\MySoft\Star Runner}
+    \o \c{HKEY_CURRENT_USER\Software\MySoft}
+    \o \c{HKEY_LOCAL_MACHINE\Software\MySoft\Star Runner}
+    \o \c{HKEY_LOCAL_MACHINE\Software\MySoft}
+    \endlist
+
+    If the file format is IniFormat, the following files are
+    used on Unix and Mac OS X:
+
+    \list 1
+    \o \c{$HOME/.config/MySoft/Star Runner.ini} (Qt for Embedded Linux: \c{$HOME/Settings/MySoft/Star Runner.ini})
+    \o \c{$HOME/.config/MySoft.ini} (Qt for Embedded Linux: \c{$HOME/Settings/MySoft.ini})
+    \o \c{/etc/xdg/MySoft/Star Runner.ini}
+    \o \c{/etc/xdg/MySoft.ini}
+    \endlist
+
+    On Windows, the following files are used:
+
+    \list 1
+    \o \c{%APPDATA%\MySoft\Star Runner.ini}
+    \o \c{%APPDATA%\MySoft.ini}
+    \o \c{%COMMON_APPDATA%\MySoft\Star Runner.ini}
+    \o \c{%COMMON_APPDATA%\MySoft.ini}
+    \endlist
+
+    The \c %APPDATA% path is usually \tt{C:\\Documents and
+    Settings\\\e{User Name}\\Application Data}; the \c
+    %COMMON_APPDATA% path is usually \tt{C:\\Documents and
+    Settings\\All Users\\Application Data}.
+
+    The paths for the \c .ini and \c .conf files can be changed using
+    setPath(). On Unix and Mac OS X, the user can override them by by
+    setting the \c XDG_CONFIG_HOME environment variable; see
+    setPath() for details.
+
+    \section2 Accessing INI and .plist Files Directly
+
+    Sometimes you do want to access settings stored in a specific
+    file or registry path. On all platforms, if you want to read an
+    INI file directly, you can use the QSettings constructor that
+    takes a file name as first argument and pass QSettings::IniFormat
+    as second argument. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 2
+
+    You can then use the QSettings object to read and write settings
+    in the file.
+
+    On Mac OS X, you can access XML-based \c .plist files by passing
+    QSettings::NativeFormat as second argument. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 3
+
+    \section2 Accessing the Windows Registry Directly
+
+    On Windows, QSettings lets you access settings that have been
+    written with QSettings (or settings in a supported format, e.g., string
+    data) in the system registry. This is done by constructing a QSettings
+    object with a path in the registry and QSettings::NativeFormat.
+
+    For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 4
+
+    All the registry entries that appear under the specified path can
+    be read or written through the QSettings object as usual (using
+    forward slashes instead of backslashes). For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 5
+
+    Note that the backslash character is, as mentioned, used by
+    QSettings to separate subkeys. As a result, you cannot read or
+    write windows registry entries that contain slashes or
+    backslashes; you should use a native windows API if you need to do
+    so.
+
+    \section2 Accessing Common Registry Settings on Windows
+
+    On Windows, it is possible for a key to have both a value and subkeys.
+    Its default value is accessed by using "Default" or "." in
+    place of a subkey:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 6
+
+    On other platforms than Windows, "Default" and "." would be
+    treated as regular subkeys.
+
+    \section2 Platform Limitations
+
+    While QSettings attempts to smooth over the differences between
+    the different supported platforms, there are still a few
+    differences that you should be aware of when porting your
+    application:
+
+    \list
+    \o  The Windows system registry has the following limitations: A
+        subkey may not exceed 255 characters, an entry's value may
+        not exceed 16,383 characters, and all the values of a key may
+        not exceed 65,535 characters. One way to work around these
+        limitations is to store the settings using the IniFormat
+        instead of the NativeFormat.
+
+    \o  On Mac OS X, allKeys() will return some extra keys for global
+        settings that apply to all applications. These keys can be
+        read using value() but cannot be changed, only shadowed.
+        Calling setFallbacksEnabled(false) will hide these global
+        settings.
+
+    \o  On Mac OS X, the CFPreferences API used by QSettings expects
+        Internet domain names rather than organization names. To
+        provide a uniform API, QSettings derives a fake domain name
+        from the organization name (unless the organization name
+        already is a domain name, e.g. OpenOffice.org). The algorithm
+        appends ".com" to the company name and replaces spaces and
+        other illegal characters with hyphens. If you want to specify
+        a different domain name, call
+        QCoreApplication::setOrganizationDomain(),
+        QCoreApplication::setOrganizationName(), and
+        QCoreApplication::setApplicationName() in your \c main()
+        function and then use the default QSettings constructor.
+        Another solution is to use preprocessor directives, for
+        example:
+
+        \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 7
+
+    \o On Unix and Mac OS X systems, the advisory file locking is disabled
+       if NFS (or AutoFS or CacheFS) is detected to work around a bug in the
+       NFS fcntl() implementation, which hangs forever if statd or lockd aren't
+       running. Also, the locking isn't performed when accessing \c .plist
+       files.
+
+    \endlist
+
+    \sa QVariant, QSessionManager, {Settings Editor Example}, {Application Example}
+*/
+
+/*! \enum QSettings::Status
+
+    The following status values are possible:
+
+    \value NoError  No error occurred.
+    \value AccessError  An access error occurred (e.g. trying to write to a read-only file).
+    \value FormatError  A format error occurred (e.g. loading a malformed INI file).
+
+    \sa status()
+*/
+
+/*! \enum QSettings::Format
+
+    This enum type specifies the storage format used by QSettings.
+
+    \value NativeFormat  Store the settings using the most
+                         appropriate storage format for the platform.
+                         On Windows, this means the system registry;
+                         on Mac OS X, this means the CFPreferences
+                         API; on Unix, this means textual
+                         configuration files in INI format.
+    \value IniFormat  Store the settings in INI files.
+    \value InvalidFormat Special value returned by registerFormat().
+    \omitvalue CustomFormat1
+    \omitvalue CustomFormat2
+    \omitvalue CustomFormat3
+    \omitvalue CustomFormat4
+    \omitvalue CustomFormat5
+    \omitvalue CustomFormat6
+    \omitvalue CustomFormat7
+    \omitvalue CustomFormat8
+    \omitvalue CustomFormat9
+    \omitvalue CustomFormat10
+    \omitvalue CustomFormat11
+    \omitvalue CustomFormat12
+    \omitvalue CustomFormat13
+    \omitvalue CustomFormat14
+    \omitvalue CustomFormat15
+    \omitvalue CustomFormat16
+
+    On Unix, NativeFormat and IniFormat mean the same thing, except
+    that the file extension is different (\c .conf for NativeFormat,
+    \c .ini for IniFormat).
+
+    The INI file format is a Windows file format that Qt supports on
+    all platforms. In the absence of an INI standard, we try to
+    follow what Microsoft does, with the following exceptions:
+
+    \list
+    \o  If you store types that QVariant can't convert to QString
+        (e.g., QPoint, QRect, and QSize), Qt uses an \c{@}-based
+        syntax to encode the type. For example:
+
+        \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 8
+
+        To minimize compatibility issues, any \c @ that doesn't
+        appear at the first position in the value or that isn't
+        followed by a Qt type (\c Point, \c Rect, \c Size, etc.) is
+        treated as a normal character.
+
+    \o  Although backslash is a special character in INI files, most
+        Windows applications don't escape backslashes (\c{\}) in file
+        paths:
+
+        \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 9
+
+        QSettings always treats backslash as a special character and
+        provides no API for reading or writing such entries.
+
+    \o  The INI file format has severe restrictions on the syntax of
+        a key. Qt works around this by using \c % as an escape
+        character in keys. In addition, if you save a top-level
+        setting (a key with no slashes in it, e.g., "someKey"), it
+        will appear in the INI file's "General" section. To avoid
+        overwriting other keys, if you save something using the a key
+        such as "General/someKey", the key will be located in the
+        "%General" section, \e not in the "General" section.
+
+    \o  Following the philosophy that we should be liberal in what
+        we accept and conservative in what we generate, QSettings
+        will accept Latin-1 encoded INI files, but generate pure
+        ASCII files, where non-ASCII values are encoded using standard
+        INI escape sequences. To make the INI files more readable (but
+        potentially less compatible), call setIniCodec().
+    \endlist
+
+    \sa registerFormat(), setPath()
+*/
+
+/*! \enum QSettings::Scope
+
+    This enum specifies whether settings are user-specific or shared
+    by all users of the same system.
+
+    \value UserScope  Store settings in a location specific to the
+                      current user (e.g., in the user's home
+                      directory).
+    \value SystemScope  Store settings in a global location, so that
+                        all users on the same machine access the same
+                        set of settings.
+    \omitvalue User
+    \omitvalue Global
+
+    \sa setPath()
+*/
+
+#ifndef QT_NO_QOBJECT
+/*!
+    Constructs a QSettings object for accessing settings of the
+    application called \a application from the organization called \a
+    organization, and with parent \a parent.
+
+    Example:
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 10
+
+    The scope is QSettings::UserScope and the format is
+    QSettings::NativeFormat.
+
+    \sa setDefaultFormat(), {Fallback Mechanism}
+*/
+QSettings::QSettings(const QString &organization, const QString &application, QObject *parent)
+    : QObject(*QSettingsPrivate::create(NativeFormat, UserScope, organization, application),
+              parent)
+{
+}
+
+/*!
+    Constructs a QSettings object for accessing settings of the
+    application called \a application from the organization called \a
+    organization, and with parent \a parent.
+
+    If \a scope is QSettings::UserScope, the QSettings object searches
+    user-specific settings first, before it searches system-wide
+    settings as a fallback. If \a scope is
+    QSettings::SystemScope, the QSettings object ignores user-specific
+    settings and provides access to system-wide settings.
+
+    The storage format is QSettings::NativeFormat.
+
+    If no application name is given, the QSettings object will
+    only access the organization-wide \l{Fallback Mechanism}{locations}.
+
+    \sa setDefaultFormat()
+*/
+QSettings::QSettings(Scope scope, const QString &organization, const QString &application,
+                     QObject *parent)
+    : QObject(*QSettingsPrivate::create(NativeFormat, scope, organization, application), parent)
+{
+}
+
+/*!
+    Constructs a QSettings object for accessing settings of the
+    application called \a application from the organization called
+    \a organization, and with parent \a parent.
+
+    If \a scope is QSettings::UserScope, the QSettings object searches
+    user-specific settings first, before it searches system-wide
+    settings as a fallback. If \a scope is
+    QSettings::SystemScope, the QSettings object ignores user-specific
+    settings and provides access to system-wide settings.
+
+    If \a format is QSettings::NativeFormat, the native API is used for
+    storing settings. If \a format is QSettings::IniFormat, the INI format
+    is used.
+
+    If no application name is given, the QSettings object will
+    only access the organization-wide \l{Fallback Mechanism}{locations}.
+*/
+QSettings::QSettings(Format format, Scope scope, const QString &organization,
+                     const QString &application, QObject *parent)
+    : QObject(*QSettingsPrivate::create(format, scope, organization, application), parent)
+{
+}
+
+/*!
+    Constructs a QSettings object for accessing the settings
+    stored in the file called \a fileName, with parent \a parent. If
+    the file doesn't already exist, it is created.
+
+    If \a format is QSettings::NativeFormat, the meaning of \a
+    fileName depends on the platform. On Unix, \a fileName is the
+    name of an INI file. On Mac OS X, \a fileName is the name of a
+    \c .plist file. On Windows, \a fileName is a path in the system
+    registry.
+
+    If \a format is QSettings::IniFormat, \a fileName is the name of an INI
+    file.
+
+    \warning This function is provided for convenience. It works well for
+    accessing INI or \c .plist files generated by Qt, but might fail on some
+    syntaxes found in such files originated by other programs. In particular,
+    be aware of the following limitations:
+
+    \list
+    \o QSettings provides no way of reading INI "path" entries, i.e., entries
+       with unescaped slash characters. (This is because these entries are
+       ambiguous and cannot be resolved automatically.)
+    \o In INI files, QSettings uses the \c @ character as a metacharacter in some
+       contexts, to encode Qt-specific data types (e.g., \c @Rect), and might
+       therefore misinterpret it when it occurs in pure INI files.
+    \endlist
+
+    \sa fileName()
+*/
+QSettings::QSettings(const QString &fileName, Format format, QObject *parent)
+    : QObject(*QSettingsPrivate::create(fileName, format), parent)
+{
+}
+
+/*!
+    Constructs a QSettings object for accessing settings of the
+    application and organization set previously with a call to
+    QCoreApplication::setOrganizationName(),
+    QCoreApplication::setOrganizationDomain(), and
+    QCoreApplication::setApplicationName().
+
+    The scope is QSettings::UserScope and the format is
+    defaultFormat() (QSettings::NativeFormat by default).
+
+    The code
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 11
+
+    is equivalent to
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 12
+
+    If QCoreApplication::setOrganizationName() and
+    QCoreApplication::setApplicationName() has not been previously
+    called, the QSettings object will not be able to read or write
+    any settings, and status() will return AccessError.
+
+    On Mac OS X, if both a name and an Internet domain are specified
+    for the organization, the domain is preferred over the name. On
+    other platforms, the name is preferred over the domain.
+
+    \sa QCoreApplication::setOrganizationName(),
+        QCoreApplication::setOrganizationDomain(),
+        QCoreApplication::setApplicationName(),
+        setDefaultFormat()
+*/
+QSettings::QSettings(QObject *parent)
+    : QObject(*QSettingsPrivate::create(globalDefaultFormat, UserScope,
+#ifdef Q_OS_MAC
+                                        QCoreApplication::organizationDomain().isEmpty()
+                                            ? QCoreApplication::organizationName()
+                                            : QCoreApplication::organizationDomain()
+#else
+                                        QCoreApplication::organizationName().isEmpty()
+                                            ? QCoreApplication::organizationDomain()
+                                            : QCoreApplication::organizationName()
+#endif
+                                        , QCoreApplication::applicationName()),
+              parent)
+{
+}
+
+#else
+QSettings::QSettings(const QString &organization, const QString &application)
+    : d_ptr(QSettingsPrivate::create(globalDefaultFormat, QSettings::UserScope, organization, application))
+{
+    d_ptr->q_ptr = this;
+}
+
+QSettings::QSettings(Scope scope, const QString &organization, const QString &application)
+    : d_ptr(QSettingsPrivate::create(globalDefaultFormat, scope, organization, application))
+{
+    d_ptr->q_ptr = this;
+}
+
+QSettings::QSettings(Format format, Scope scope, const QString &organization,
+                     const QString &application)
+    : d_ptr(QSettingsPrivate::create(format, scope, organization, application))
+{
+    d_ptr->q_ptr = this;
+}
+
+QSettings::QSettings(const QString &fileName, Format format)
+    : d_ptr(QSettingsPrivate::create(fileName, format))
+{
+    d_ptr->q_ptr = this;
+}
+#endif
+
+/*!
+    Destroys the QSettings object.
+
+    Any unsaved changes will eventually be written to permanent
+    storage.
+
+    \sa sync()
+*/
+QSettings::~QSettings()
+{
+    Q_D(QSettings);
+    if (d->pendingChanges)
+        d->flush();
+#ifdef QT_NO_QOBJECT
+    delete d;
+#endif
+}
+
+/*!
+    Removes all entries in the primary location associated to this
+    QSettings object.
+
+    Entries in fallback locations are not removed.
+
+    If you only want to remove the entries in the current group(),
+    use remove("") instead.
+
+    \sa remove(), setFallbacksEnabled()
+*/
+void QSettings::clear()
+{
+    Q_D(QSettings);
+    d->clear();
+    d->requestUpdate();
+}
+
+/*!
+    Writes any unsaved changes to permanent storage, and reloads any
+    settings that have been changed in the meantime by another
+    application.
+
+    This function is called automatically from QSettings's destructor and
+    by the event loop at regular intervals, so you normally don't need to
+    call it yourself.
+
+    \sa status()
+*/
+void QSettings::sync()
+{
+    Q_D(QSettings);
+    d->sync();
+}
+
+/*!
+    Returns the path where settings written using this QSettings
+    object are stored.
+
+    On Windows, if the format is QSettings::NativeFormat, the return value
+    is a system registry path, not a file path.
+
+    \sa isWritable(), format()
+*/
+QString QSettings::fileName() const
+{
+    Q_D(const QSettings);
+    return d->fileName();
+}
+
+/*!
+    \since 4.4
+
+    Returns the format used for storing the settings.
+
+    \sa defaultFormat(), fileName(), scope(), organizationName(), applicationName()
+*/
+QSettings::Format QSettings::format() const
+{
+    Q_D(const QSettings);
+    return d->format;
+}
+
+/*!
+    \since 4.4
+
+    Returns the scope used for storing the settings.
+
+    \sa format(), organizationName(), applicationName()
+*/
+QSettings::Scope QSettings::scope() const
+{
+    Q_D(const QSettings);
+    return d->scope;
+}
+
+/*!
+    \since 4.4
+
+    Returns the organization name used for storing the settings.
+
+    \sa QCoreApplication::organizationName(), format(), scope(), applicationName()
+*/
+QString QSettings::organizationName() const
+{
+    Q_D(const QSettings);
+    return d->organizationName;
+}
+
+/*!
+    \since 4.4
+
+    Returns the application name used for storing the settings.
+
+    \sa QCoreApplication::applicationName(), format(), scope(), organizationName()
+*/
+QString QSettings::applicationName() const
+{
+    Q_D(const QSettings);
+    return d->applicationName;
+}
+
+#ifndef QT_NO_TEXTCODEC
+
+/*!
+    \since 4.5
+
+    Sets the codec for accessing INI files (including \c .conf files on Unix)
+    to \a codec. The codec is used for decoding any data that is read from
+    the INI file, and for encoding any data that is written to the file. By
+    default, no codec is used, and non-ASCII characters are encoded using
+    standard INI escape sequences.
+
+    \warning The codec must be set immediately after creating the QSettings
+    object, before accessing any data.
+
+    \sa iniCodec()
+*/
+void QSettings::setIniCodec(QTextCodec *codec)
+{
+    Q_D(QSettings);
+    d->iniCodec = codec;
+}
+
+/*!
+    \since 4.5
+    \overload
+
+    Sets the codec for accessing INI files (including \c .conf files on Unix)
+    to the QTextCodec for the encoding specified by \a codecName. Common
+    values for \c codecName include "ISO 8859-1", "UTF-8", and "UTF-16".
+    If the encoding isn't recognized, nothing happens.
+
+    \sa QTextCodec::codecForName()
+*/
+void QSettings::setIniCodec(const char *codecName)
+{
+    Q_D(QSettings);
+    if (QTextCodec *codec = QTextCodec::codecForName(codecName))
+        d->iniCodec = codec;
+}
+
+/*!
+    \since 4.5
+
+    Returns the codec that is used for accessing INI files. By default,
+    no codec is used, so a null pointer is returned.
+*/
+
+QTextCodec *QSettings::iniCodec() const
+{
+    Q_D(const QSettings);
+    return d->iniCodec;
+}
+
+#endif // QT_NO_TEXTCODEC
+
+/*!
+    Returns a status code indicating the first error that was met by
+    QSettings, or QSettings::NoError if no error occurred.
+
+    Be aware that QSettings delays performing some operations. For this
+    reason, you might want to call sync() to ensure that the data stored
+    in QSettings is written to disk before calling status().
+
+    \sa sync()
+*/
+QSettings::Status QSettings::status() const
+{
+    Q_D(const QSettings);
+    return d->status;
+}
+
+/*!
+    Appends \a prefix to the current group.
+
+    The current group is automatically prepended to all keys
+    specified to QSettings. In addition, query functions such as
+    childGroups(), childKeys(), and allKeys() are based on the group.
+    By default, no group is set.
+
+    Groups are useful to avoid typing in the same setting paths over
+    and over. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 13
+
+    This will set the value of three settings:
+
+    \list
+    \o \c mainwindow/size
+    \o \c mainwindow/fullScreen
+    \o \c outputpanel/visible
+    \endlist
+
+    Call endGroup() to reset the current group to what it was before
+    the corresponding beginGroup() call. Groups can be nested.
+
+    \sa endGroup(), group()
+*/
+void QSettings::beginGroup(const QString &prefix)
+{
+    Q_D(QSettings);
+    d->beginGroupOrArray(QSettingsGroup(d->normalizedKey(prefix)));
+}
+
+/*!
+    Resets the group to what it was before the corresponding
+    beginGroup() call.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 14
+
+    \sa beginGroup(), group()
+*/
+void QSettings::endGroup()
+{
+    Q_D(QSettings);
+    if (d->groupStack.isEmpty()) {
+        qWarning("QSettings::endGroup: No matching beginGroup()");
+        return;
+    }
+
+    QSettingsGroup group = d->groupStack.pop();
+    int len = group.toString().size();
+    if (len > 0)
+        d->groupPrefix.truncate(d->groupPrefix.size() - (len + 1));
+
+    if (group.isArray())
+        qWarning("QSettings::endGroup: Expected endArray() instead");
+}
+
+/*!
+    Returns the current group.
+
+    \sa beginGroup(), endGroup()
+*/
+QString QSettings::group() const
+{
+    Q_D(const QSettings);
+    return d->groupPrefix.left(d->groupPrefix.size() - 1);
+}
+
+/*!
+    Adds \a prefix to the current group and starts reading from an
+    array. Returns the size of the array.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 15
+
+    Use beginWriteArray() to write the array in the first place.
+
+    \sa beginWriteArray(), endArray(), setArrayIndex()
+*/
+int QSettings::beginReadArray(const QString &prefix)
+{
+    Q_D(QSettings);
+    d->beginGroupOrArray(QSettingsGroup(d->normalizedKey(prefix), false));
+    return value(QLatin1String("size")).toInt();
+}
+
+/*!
+    Adds \a prefix to the current group and starts writing an array
+    of size \a size. If \a size is -1 (the default), it is automatically
+    determined based on the indexes of the entries written.
+
+    If you have many occurrences of a certain set of keys, you can
+    use arrays to make your life easier. For example, let's suppose
+    that you want to save a variable-length list of user names and
+    passwords. You could then write:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 16
+
+    The generated keys will have the form
+
+    \list
+    \o \c logins/size
+    \o \c logins/1/userName
+    \o \c logins/1/password
+    \o \c logins/2/userName
+    \o \c logins/2/password
+    \o \c logins/3/userName
+    \o \c logins/3/password
+    \o ...
+    \endlist
+
+    To read back an array, use beginReadArray().
+
+    \sa beginReadArray(), endArray(), setArrayIndex()
+*/
+void QSettings::beginWriteArray(const QString &prefix, int size)
+{
+    Q_D(QSettings);
+    d->beginGroupOrArray(QSettingsGroup(d->normalizedKey(prefix), size < 0));
+
+    if (size < 0)
+        remove(QLatin1String("size"));
+    else
+        setValue(QLatin1String("size"), size);
+}
+
+/*!
+    Closes the array that was started using beginReadArray() or
+    beginWriteArray().
+
+    \sa beginReadArray(), beginWriteArray()
+*/
+void QSettings::endArray()
+{
+    Q_D(QSettings);
+    if (d->groupStack.isEmpty()) {
+        qWarning("QSettings::endArray: No matching beginArray()");
+        return;
+    }
+
+    QSettingsGroup group = d->groupStack.top();
+    int len = group.toString().size();
+    d->groupStack.pop();
+    if (len > 0)
+        d->groupPrefix.truncate(d->groupPrefix.size() - (len + 1));
+
+    if (group.arraySizeGuess() != -1)
+        setValue(group.name() + QLatin1String("/size"), group.arraySizeGuess());
+
+    if (!group.isArray())
+        qWarning("QSettings::endArray: Expected endGroup() instead");
+}
+
+/*!
+    Sets the current array index to \a i. Calls to functions such as
+    setValue(), value(), remove(), and contains() will operate on the
+    array entry at that index.
+
+    You must call beginReadArray() or beginWriteArray() before you
+    can call this function.
+*/
+void QSettings::setArrayIndex(int i)
+{
+    Q_D(QSettings);
+    if (d->groupStack.isEmpty() || !d->groupStack.top().isArray()) {
+        qWarning("QSettings::setArrayIndex: Missing beginArray()");
+        return;
+    }
+
+    QSettingsGroup &top = d->groupStack.top();
+    int len = top.toString().size();
+    top.setArrayIndex(qMax(i, 0));
+    d->groupPrefix.replace(d->groupPrefix.size() - len - 1, len, top.toString());
+}
+
+/*!
+    Returns a list of all keys, including subkeys, that can be read
+    using the QSettings object.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 17
+
+    If a group is set using beginGroup(), only the keys in the group
+    are returned, without the group prefix:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 18
+
+    \sa childGroups(), childKeys()
+*/
+QStringList QSettings::allKeys() const
+{
+    Q_D(const QSettings);
+    return d->children(d->groupPrefix, QSettingsPrivate::AllKeys);
+}
+
+/*!
+    Returns a list of all top-level keys that can be read using the
+    QSettings object.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 19
+
+    If a group is set using beginGroup(), the top-level keys in that
+    group are returned, without the group prefix:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 20
+
+    You can navigate through the entire setting hierarchy using
+    childKeys() and childGroups() recursively.
+
+    \sa childGroups(), allKeys()
+*/
+QStringList QSettings::childKeys() const
+{
+    Q_D(const QSettings);
+    return d->children(d->groupPrefix, QSettingsPrivate::ChildKeys);
+}
+
+/*!
+    Returns a list of all key top-level groups that contain keys that
+    can be read using the QSettings object.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 21
+
+    If a group is set using beginGroup(), the first-level keys in
+    that group are returned, without the group prefix.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 22
+
+    You can navigate through the entire setting hierarchy using
+    childKeys() and childGroups() recursively.
+
+    \sa childKeys(), allKeys()
+*/
+QStringList QSettings::childGroups() const
+{
+    Q_D(const QSettings);
+    return d->children(d->groupPrefix, QSettingsPrivate::ChildGroups);
+}
+
+/*!
+    Returns true if settings can be written using this QSettings
+    object; returns false otherwise.
+
+    One reason why isWritable() might return false is if
+    QSettings operates on a read-only file.
+
+    \warning This function is not perfectly reliable, because the
+    file permissions can change at any time.
+
+    \sa fileName(), status(), sync()
+*/
+bool QSettings::isWritable() const
+{
+    Q_D(const QSettings);
+    return d->isWritable();
+}
+
+/*!
+  
+  Sets the value of setting \a key to \a value. If the \a key already
+  exists, the previous value is overwritten.
+
+  Note that the Windows registry and INI files use case-insensitive
+  keys, whereas the Carbon Preferences API on Mac OS X uses
+  case-sensitive keys. To avoid portability problems, see the \l{Key
+  Syntax} rules.
+
+  Example:
+
+  \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 23
+
+  \sa value(), remove(), contains()
+*/
+void QSettings::setValue(const QString &key, const QVariant &value)
+{
+    Q_D(QSettings);
+    QString k = d->actualKey(key);
+    d->set(k, value);
+    d->requestUpdate();
+}
+
+/*!
+    Removes the setting \a key and any sub-settings of \a key.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 24
+
+    Be aware that if one of the fallback locations contains a setting
+    with the same key, that setting will be visible after calling
+    remove().
+
+    If \a key is an empty string, all keys in the current group() are
+    removed. For example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 25
+
+    Note that the Windows registry and INI files use case-insensitive
+    keys, whereas the Carbon Preferences API on Mac OS X uses
+    case-sensitive keys. To avoid portability problems, see the \l{Key
+    Syntax} rules.
+
+    \sa setValue(), value(), contains()
+*/
+void QSettings::remove(const QString &key)
+{
+    Q_D(QSettings);
+    /*
+        We cannot use actualKey(), because remove() supports empty
+        keys. The code is also tricky because of slash handling.
+    */
+    QString theKey = d->normalizedKey(key);
+    if (theKey.isEmpty())
+        theKey = group();
+    else
+        theKey.prepend(d->groupPrefix);
+
+    if (theKey.isEmpty()) {
+        d->clear();
+    } else {
+        d->remove(theKey);
+    }
+    d->requestUpdate();
+}
+
+/*!
+    Returns true if there exists a setting called \a key; returns
+    false otherwise.
+
+    If a group is set using beginGroup(), \a key is taken to be
+    relative to that group.
+
+    Note that the Windows registry and INI files use case-insensitive
+    keys, whereas the Carbon Preferences API on Mac OS X uses
+    case-sensitive keys. To avoid portability problems, see the \l{Key
+    Syntax} rules.
+
+    \sa value(), setValue()
+*/
+bool QSettings::contains(const QString &key) const
+{
+    Q_D(const QSettings);
+    QString k = d->actualKey(key);
+    return d->get(k, 0);
+}
+
+/*!
+    Sets whether fallbacks are enabled to \a b.
+
+    By default, fallbacks are enabled.
+
+    \sa fallbacksEnabled()
+*/
+void QSettings::setFallbacksEnabled(bool b)
+{
+    Q_D(QSettings);
+    d->fallbacks = !!b;
+}
+
+/*!
+    Returns true if fallbacks are enabled; returns false otherwise.
+
+    By default, fallbacks are enabled.
+
+    \sa setFallbacksEnabled()
+*/
+bool QSettings::fallbacksEnabled() const
+{
+    Q_D(const QSettings);
+    return d->fallbacks;
+}
+
+#ifndef QT_NO_QOBJECT
+/*!
+    \reimp
+*/
+bool QSettings::event(QEvent *event)
+{
+    Q_D(QSettings);
+    if (event->type() == QEvent::UpdateRequest) {
+        d->update();
+        return true;
+    }
+    return QObject::event(event);
+}
+#endif
+
+/*!
+    Returns the value for setting \a key. If the setting doesn't
+    exist, returns \a defaultValue.
+
+    If no default value is specified, a default QVariant is
+    returned.
+
+    Note that the Windows registry and INI files use case-insensitive
+    keys, whereas the Carbon Preferences API on Mac OS X uses
+    case-sensitive keys. To avoid portability problems, see the \l{Key
+    Syntax} rules.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 26
+
+    \sa setValue(), contains(), remove()
+*/
+QVariant QSettings::value(const QString &key, const QVariant &defaultValue) const
+{
+    Q_D(const QSettings);
+    QVariant result = defaultValue;
+    QString k = d->actualKey(key);
+    d->get(k, &result);
+    return result;
+}
+
+/*!
+    \since 4.4
+
+    Sets the default file format to the given \a format, used for storing
+    settings for the QSettings(QObject *) constructor.
+
+    If no default format is set, QSettings::NativeFormat is used.
+
+    \sa format()
+*/
+void QSettings::setDefaultFormat(Format format)
+{
+    globalDefaultFormat = format;
+}
+
+/*!
+    \since 4.4
+
+    Returns default file format used for storing settings for the QSettings(QObject *) constructor.
+    If no default format is set, QSettings::NativeFormat is used.
+
+    \sa format()
+*/
+QSettings::Format QSettings::defaultFormat()
+{
+    return globalDefaultFormat;
+}
+
+/*!
+    \obsolete
+
+    Use setPath() instead.
+
+    \oldcode
+        setSystemIniPath(path);
+    \newcode
+        setPath(QSettings::NativeFormat, QSettings::SystemScope, path);
+        setPath(QSettings::IniFormat, QSettings::SystemScope, path);
+    \endcode
+*/
+void QSettings::setSystemIniPath(const QString &dir)
+{
+    setPath(IniFormat, SystemScope, dir);
+#if !defined(Q_OS_WIN) && !defined(Q_OS_MAC)
+    setPath(NativeFormat, SystemScope, dir);
+#endif
+}
+
+/*!
+    \obsolete
+
+    Use setPath() instead.
+*/
+
+void QSettings::setUserIniPath(const QString &dir)
+{
+    setPath(IniFormat, UserScope, dir);
+#if !defined(Q_OS_WIN) && !defined(Q_OS_MAC)
+    setPath(NativeFormat, UserScope, dir);
+#endif
+}
+
+/*!
+    \since 4.1
+
+    Sets the path used for storing settings for the given \a format
+    and \a scope, to \a path. The \a format can be a custom format.
+
+    The table below summarizes the default values:
+
+    \table
+    \header \o Platform         \o Format                       \o Scope       \o Path
+    \row    \o{1,2} Windows     \o{1,2} IniFormat               \o UserScope   \o \c %APPDATA%
+    \row                                                        \o SystemScope \o \c %COMMON_APPDATA%
+    \row    \o{1,2} Unix        \o{1,2} NativeFormat, IniFormat \o UserScope   \o \c $HOME/.config
+    \row                                                        \o SystemScope \o \c /etc/xdg
+    \row    \o{1,2} Qt for Embedded Linux \o{1,2} NativeFormat, IniFormat \o UserScope   \o \c $HOME/Settings
+    \row                                                        \o SystemScope \o \c /etc/xdg
+    \row    \o{1,2} Mac OS X    \o{1,2} IniFormat               \o UserScope   \o \c $HOME/.config
+    \row                                                        \o SystemScope \o \c /etc/xdg
+    \endtable
+
+    The default UserScope paths on Unix and Mac OS X (\c
+    $HOME/.config or $HOME/Settings) can be overridden by the user by setting the
+    \c XDG_CONFIG_HOME environment variable. The default SystemScope
+    paths on Unix and Mac OS X (\c /etc/xdg) can be overridden when
+    building the Qt library using the \c configure script's \c
+    --sysconfdir flag (see QLibraryInfo for details).
+
+    Setting the NativeFormat paths on Windows and Mac OS X has no
+    effect.
+
+    \warning This function doesn't affect existing QSettings objects.
+
+    \sa registerFormat()
+*/
+void QSettings::setPath(Format format, Scope scope, const QString &path)
+{
+    QMutexLocker locker(globalMutex());
+    PathHash *pathHash = pathHashFunc();
+    pathHash->insert(pathHashKey(format, scope), path + QDir::separator());
+}
+
+/*!
+    \typedef QSettings::SettingsMap
+
+    Typedef for QMap<QString, QVariant>.
+
+    \sa registerFormat()
+*/
+
+/*!
+    \typedef QSettings::ReadFunc
+
+    Typedef for a pointer to a function with the following signature:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 27
+
+    \sa WriteFunc, registerFormat()
+*/
+
+/*!
+    \typedef QSettings::WriteFunc
+
+    Typedef for a pointer to a function with the following signature:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 28
+
+    \sa ReadFunc, registerFormat()
+*/
+
+/*!
+    \since 4.1
+    \threadsafe
+
+    Registers a custom storage format. On success, returns a special
+    Format value that can then be passed to the QSettings constuctor.
+    On failure, returns InvalidFormat.
+
+    The \a extension is the file
+    extension associated to the format (without the '.').
+
+    The \a readFunc and \a writeFunc parameters are pointers to
+    functions that read and write a set of (key, value) pairs. The
+    QIODevice parameter to the read and write functions is always
+    opened in binary mode (i.e., without the QIODevice::Text flag).
+
+    The \a caseSensitivity parameter specifies whether keys are case
+    sensitive or not. This makes a difference when looking up values
+    using QSettings. The default is case sensitive.
+
+    By default, if you use one of the constructors that work in terms
+    of an organization name and an application name, the file system
+    locations used are the same as for IniFormat. Use setPath() to
+    specify other locations.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qsettings.cpp 29
+
+    \sa setPath()
+*/
+QSettings::Format QSettings::registerFormat(const QString &extension, ReadFunc readFunc,
+                                            WriteFunc writeFunc,
+                                            Qt::CaseSensitivity caseSensitivity)
+{
+#ifdef QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER
+    Q_ASSERT(caseSensitivity == Qt::CaseSensitive);
+#endif
+
+    QMutexLocker locker(globalMutex());
+    CustomFormatVector *customFormatVector = customFormatVectorFunc();
+    int index = customFormatVector->size();
+    if (index == 16) // the QSettings::Format enum has room for 16 custom formats
+        return QSettings::InvalidFormat;
+
+    QConfFileCustomFormat info;
+    info.extension = QLatin1Char('.');
+    info.extension += extension;
+    info.readFunc = readFunc;
+    info.writeFunc = writeFunc;
+    info.caseSensitivity = caseSensitivity;
+    customFormatVector->append(info);
+
+    return QSettings::Format((int)QSettings::CustomFormat1 + index);
+}
+
+#ifdef QT3_SUPPORT
+void QSettings::setPath_helper(Scope scope, const QString &organization, const QString &application)
+{
+    Q_D(QSettings);
+    if (d->pendingChanges)
+        d->flush();
+    QSettingsPrivate *oldPriv = d;
+    QSettingsPrivate *newPriv = QSettingsPrivate::create(oldPriv->format, scope, organization, application);
+    static_cast<QObjectPrivate &>(*newPriv) = static_cast<QObjectPrivate &>(*oldPriv);  // copy the QObject stuff over (hack)
+    delete oldPriv;
+    d_ptr = newPriv;
+}
+
+/*! \fn bool QSettings::writeEntry(const QString &key, bool value)
+
+    Sets the value of setting \a key to \a value.
+
+    Use setValue() instead.
+*/
+
+/*! \fn bool QSettings::writeEntry(const QString &key, double value)
+
+    \overload
+*/
+
+/*! \fn bool QSettings::writeEntry(const QString &key, int value)
+
+    \overload
+*/
+
+/*! \fn bool QSettings::writeEntry(const QString &key, const char *value)
+
+    \overload
+*/
+
+/*! \fn bool QSettings::writeEntry(const QString &key, const QString &value)
+
+    \overload
+*/
+
+/*! \fn bool QSettings::writeEntry(const QString &key, const QStringList &value)
+
+    \overload
+*/
+
+/*! \fn bool QSettings::writeEntry(const QString &key, const QStringList &value, QChar separator)
+
+    \overload
+
+    Use setValue(\a key, \a value) instead. You don't need \a separator.
+*/
+
+/*! \fn QStringList QSettings::readListEntry(const QString &key, bool *ok = 0)
+
+    Returns the value of setting \a key converted to a QStringList.
+
+    If \a ok is not 0, *\a{ok} is set to true if the key exists,
+    otherwise *\a{ok} is set to false.
+
+    Use value() instead.
+
+    \oldcode
+        bool ok;
+        QStringList list = settings.readListEntry("recentFiles", &ok);
+    \newcode
+        bool ok = settings.contains("recentFiles");
+        QStringList list = settings.value("recentFiles").toStringList();
+    \endcode
+*/
+
+/*! \fn QStringList QSettings::readListEntry(const QString &key, QChar separator, bool *ok)
+
+    Returns the value of setting \a key converted to a QStringList.
+    \a separator is ignored.
+
+    If \a ok is not 0, *\a{ok} is set to true if the key exists,
+    otherwise *\a{ok} is set to false.
+
+    Use value() instead.
+
+    \oldcode
+        bool ok;
+        QStringList list = settings.readListEntry("recentFiles", ":", &ok);
+    \newcode
+        bool ok = settings.contains("recentFiles");
+        QStringList list = settings.value("recentFiles").toStringList();
+    \endcode
+*/
+
+/*! \fn QString QSettings::readEntry(const QString &key, const QString &defaultValue, bool *ok)
+
+    Returns the value for setting \a key converted to a QString. If
+    the setting doesn't exist, returns \a defaultValue.
+
+    If \a ok is not 0, *\a{ok} is set to true if the key exists,
+    otherwise *\a{ok} is set to false.
+
+    Use value() instead.
+
+    \oldcode
+        bool ok;
+        QString str = settings.readEntry("userName", "administrator", &ok);
+    \newcode
+        bool ok = settings.contains("userName");
+        QString str = settings.value("userName", "administrator").toString();
+    \endcode
+*/
+
+/*! \fn int QSettings::readNumEntry(const QString &key, int defaultValue, bool *ok)
+
+    Returns the value for setting \a key converted to an \c int. If
+    the setting doesn't exist, returns \a defaultValue.
+
+    If \a ok is not 0, *\a{ok} is set to true if the key exists,
+    otherwise *\a{ok} is set to false.
+
+    Use value() instead.
+
+    \oldcode
+        bool ok;
+        int max = settings.readNumEntry("maxConnections", 30, &ok);
+    \newcode
+        bool ok = settings.contains("maxConnections");
+        int max = settings.value("maxConnections", 30).toInt();
+    \endcode
+*/
+
+/*! \fn double QSettings::readDoubleEntry(const QString &key, double defaultValue, bool *ok)
+
+    Returns the value for setting \a key converted to a \c double. If
+    the setting doesn't exist, returns \a defaultValue.
+
+    If \a ok is not 0, *\a{ok} is set to true if the key exists,
+    otherwise *\a{ok} is set to false.
+
+    Use value() instead.
+
+    \oldcode
+        bool ok;
+        double pi = settings.readDoubleEntry("pi", 3.141592, &ok);
+    \newcode
+        bool ok = settings.contains("pi");
+        double pi = settings.value("pi", 3.141592).toDouble();
+    \endcode
+*/
+
+/*! \fn bool QSettings::readBoolEntry(const QString &key, bool defaultValue, bool *ok)
+
+    Returns the value for setting \a key converted to a \c bool. If
+    the setting doesn't exist, returns \a defaultValue.
+
+    If \a ok is not 0, *\a{ok} is set to true if the key exists,
+    otherwise *\a{ok} is set to false.
+
+    Use value() instead.
+
+    \oldcode
+        bool ok;
+        bool grid = settings.readBoolEntry("showGrid", true, &ok);
+    \newcode
+        bool ok = settings.contains("showGrid");
+        bool grid = settings.value("showGrid", true).toBool();
+    \endcode
+*/
+
+/*! \fn bool QSettings::removeEntry(const QString &key)
+
+    Use remove() instead.
+*/
+
+/*! \enum QSettings::System
+    \compat
+
+    \value Unix Unix systems (X11 and Embedded Linux)
+    \value Windows Microsoft Windows systems
+    \value Mac Mac OS X systems
+
+    \sa insertSearchPath(), removeSearchPath()
+*/
+
+/*! \fn void QSettings::insertSearchPath(System system, const QString &path)
+
+    This function is implemented as a no-op. It is provided for
+    source compatibility with Qt 3. The new QSettings class has no
+    concept of "search path".
+*/
+
+/*! \fn void QSettings::removeSearchPath(System system, const QString &path)
+
+    This function is implemented as a no-op. It is provided for
+    source compatibility with Qt 3. The new QSettings class has no
+    concept of "search path".
+*/
+
+/*! \fn void QSettings::setPath(const QString &organization, const QString &application, \
+                                Scope scope)
+
+    Specifies the \a organization, \a application, and \a scope to
+    use by the QSettings object.
+
+    Use the appropriate constructor instead, with QSettings::UserScope
+    instead of QSettings::User and QSettings::SystemScope instead of
+    QSettings::Global.
+
+    \oldcode
+        QSettings settings;
+        settings.setPath("twikimaster.com", "Kanooth", QSettings::Global);
+    \newcode
+        QSettings settings(QSettings::SystemScope, "twikimaster.com", "Kanooth");
+    \endcode
+*/
+
+/*! \fn void QSettings::resetGroup()
+
+    Sets the current group to be the empty string.
+
+    Use endGroup() instead (possibly multiple times).
+
+    \oldcode
+        QSettings settings;
+        settings.beginGroup("mainWindow");
+        settings.beginGroup("leftPanel");
+        ...
+        settings.resetGroup();
+    \newcode
+        QSettings settings;
+        settings.beginGroup("mainWindow");
+        settings.beginGroup("leftPanel");
+        ...
+        settings.endGroup();
+        settings.endGroup();
+    \endcode
+*/
+
+/*! \fn QStringList QSettings::entryList(const QString &key) const
+
+    Returns a list of all sub-keys of \a key.
+
+    Use childKeys() instead.
+
+    \oldcode
+        QSettings settings;
+        QStringList keys = settings.entryList("cities");
+        ...
+    \newcode
+        QSettings settings;
+        settings.beginGroup("cities");
+        QStringList keys = settings.childKeys();
+        ...
+        settings.endGroup();
+    \endcode
+*/
+
+/*! \fn QStringList QSettings::subkeyList(const QString &key) const
+
+    Returns a list of all sub-keys of \a key.
+
+    Use childGroups() instead.
+
+    \oldcode
+        QSettings settings;
+        QStringList groups = settings.entryList("cities");
+        ...
+    \newcode
+        QSettings settings;
+        settings.beginGroup("cities");
+        QStringList groups = settings.childKeys();
+        ...
+        settings.endGroup();
+    \endcode
+*/
+#endif
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SETTINGS
diff --git a/src/corelib/io/qsettings.h b/src/corelib/io/qsettings.h
new file mode 100644
index 0000000..cbb24ba
--- /dev/null
+++ b/src/corelib/io/qsettings.h
@@ -0,0 +1,313 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSETTINGS_H
+#define QSETTINGS_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qvariant.h>
+#include <QtCore/qstring.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+QT_MODULE(Core)
+QT_END_NAMESPACE
+
+#ifndef QT_NO_SETTINGS
+
+#ifdef QT3_SUPPORT
+#include <QtCore/qstringlist.h>
+#endif
+
+#include <ctype.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Status // we seem to pick up a macro Status --> int somewhere
+#undef Status
+#endif
+
+class QIODevice;
+class QSettingsPrivate;
+
+#ifndef QT_NO_QOBJECT
+class Q_CORE_EXPORT QSettings : public QObject
+#else
+class Q_CORE_EXPORT QSettings
+#endif
+{
+#ifndef QT_NO_QOBJECT
+    Q_OBJECT
+#else
+    QSettingsPrivate *d_ptr;
+#endif
+    Q_DECLARE_PRIVATE(QSettings)
+
+public:
+    enum Status {
+        NoError = 0,
+        AccessError,
+        FormatError
+    };
+
+    enum Format {
+        NativeFormat,
+        IniFormat,
+
+        InvalidFormat = 16,
+        CustomFormat1,
+        CustomFormat2,
+        CustomFormat3,
+        CustomFormat4,
+        CustomFormat5,
+        CustomFormat6,
+        CustomFormat7,
+        CustomFormat8,
+        CustomFormat9,
+        CustomFormat10,
+        CustomFormat11,
+        CustomFormat12,
+        CustomFormat13,
+        CustomFormat14,
+        CustomFormat15,
+        CustomFormat16
+    };
+
+    enum Scope {
+        UserScope,
+        SystemScope
+#ifdef QT3_SUPPORT
+        ,
+        User = UserScope,
+        Global = SystemScope
+#endif
+    };
+
+#ifndef QT_NO_QOBJECT
+    explicit QSettings(const QString &organization,
+                       const QString &application = QString(), QObject *parent = 0);
+    QSettings(Scope scope, const QString &organization,
+              const QString &application = QString(), QObject *parent = 0);
+    QSettings(Format format, Scope scope, const QString &organization,
+	      const QString &application = QString(), QObject *parent = 0);
+    QSettings(const QString &fileName, Format format, QObject *parent = 0);
+    explicit QSettings(QObject *parent = 0);
+#else
+    explicit QSettings(const QString &organization,
+                       const QString &application = QString());
+    QSettings(Scope scope, const QString &organization,
+              const QString &application = QString());
+    QSettings(Format format, Scope scope, const QString &organization,
+              const QString &application = QString());
+    QSettings(const QString &fileName, Format format);
+#endif
+    ~QSettings();
+
+    void clear();
+    void sync();
+    Status status() const;
+
+    void beginGroup(const QString &prefix);
+    void endGroup();
+    QString group() const;
+
+    int beginReadArray(const QString &prefix);
+    void beginWriteArray(const QString &prefix, int size = -1);
+    void endArray();
+    void setArrayIndex(int i);
+
+    QStringList allKeys() const;
+    QStringList childKeys() const;
+    QStringList childGroups() const;
+    bool isWritable() const;
+
+    void setValue(const QString &key, const QVariant &value);
+    QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;
+
+    void remove(const QString &key);
+    bool contains(const QString &key) const;
+
+    void setFallbacksEnabled(bool b);
+    bool fallbacksEnabled() const;
+
+    QString fileName() const;
+    Format format() const;
+    Scope scope() const;
+    QString organizationName() const;
+    QString applicationName() const;
+
+#ifndef QT_NO_TEXTCODEC
+    void setIniCodec(QTextCodec *codec);
+    void setIniCodec(const char *codecName);
+    QTextCodec *iniCodec() const;
+#endif
+
+    static void setDefaultFormat(Format format);
+    static Format defaultFormat();
+    static void setSystemIniPath(const QString &dir); // ### remove in 5.0 (use setPath() instead)
+    static void setUserIniPath(const QString &dir);   // ### remove in 5.0 (use setPath() instead)
+    static void setPath(Format format, Scope scope, const QString &path);
+
+    typedef QMap<QString, QVariant> SettingsMap;
+    typedef bool (*ReadFunc)(QIODevice &device, SettingsMap &map);
+    typedef bool (*WriteFunc)(QIODevice &device, const SettingsMap &map);
+
+    static Format registerFormat(const QString &extension, ReadFunc readFunc, WriteFunc writeFunc,
+                                 Qt::CaseSensitivity caseSensitivity = Qt::CaseSensitive);
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT bool writeEntry(const QString &key, bool value)
+    { setValue(key, value); return isWritable(); }
+    inline QT3_SUPPORT bool writeEntry(const QString &key, double value)
+    { setValue(key, value); return isWritable(); }
+    inline QT3_SUPPORT bool writeEntry(const QString &key, int value)
+    { setValue(key, value); return isWritable(); }
+    inline QT3_SUPPORT bool writeEntry(const QString &key, const char *value)
+    { setValue(key, QString::fromAscii(value)); return isWritable(); }
+    inline QT3_SUPPORT bool writeEntry(const QString &key, const QString &value)
+    { setValue(key, value); return isWritable(); }
+    inline QT3_SUPPORT bool writeEntry(const QString &key, const QStringList &value)
+    { setValue(key, value); return isWritable(); }
+    inline QT3_SUPPORT bool writeEntry(const QString &key, const QStringList &value, QChar separator)
+    { setValue(key, value.join(QString(separator))); return isWritable(); }
+    inline QT3_SUPPORT QStringList readListEntry(const QString &key, bool *ok = 0)
+    {
+        if (ok)
+            *ok = contains(key);
+        return value(key).toStringList();
+    }
+    inline QT3_SUPPORT QStringList readListEntry(const QString &key, QChar separator, bool *ok = 0)
+    {
+        if (ok)
+            *ok = contains(key);
+        QString str = value(key).toString();
+        if (str.isEmpty())
+            return QStringList();
+        return str.split(separator);
+    }
+    inline QT3_SUPPORT QString readEntry(const QString &key, const QString &defaultValue = QString(),
+                                         bool *ok = 0)
+    {
+        if (ok)
+            *ok = contains(key);
+        return value(key, defaultValue).toString();
+    }
+    inline QT3_SUPPORT int readNumEntry(const QString &key, int defaultValue = 0, bool *ok = 0)
+    {
+        if (ok)
+            *ok = contains(key);
+        return value(key, defaultValue).toInt();
+    }
+    inline QT3_SUPPORT double readDoubleEntry(const QString &key, double defaultValue = 0,
+                                              bool *ok = 0)
+    {
+        if (ok)
+            *ok = contains(key);
+        return value(key, defaultValue).toDouble();
+    }
+    inline QT3_SUPPORT bool readBoolEntry(const QString &key, bool defaultValue = false,
+                                          bool *ok = 0)
+    {
+        if (ok)
+            *ok = contains(key);
+        return value(key, defaultValue).toBool();
+    }
+    inline QT3_SUPPORT bool removeEntry(const QString &key)
+    { remove(key); return true; }
+
+    enum System { Unix, Windows, Mac };
+    inline QT3_SUPPORT void insertSearchPath(System, const QString &) {}
+    inline QT3_SUPPORT void removeSearchPath(System, const QString &) {}
+
+    inline QT3_SUPPORT void setPath(const QString &organization, const QString &application,
+                                    Scope scope = Global)
+    {
+        setPath_helper(scope == Global ? QSettings::SystemScope : QSettings::UserScope,
+                       organization, application);
+    }
+    inline QT3_SUPPORT void resetGroup()
+    {
+        while (!group().isEmpty())
+            endGroup();
+    }
+    inline QT3_SUPPORT QStringList entryList(const QString &key) const
+    {
+        QSettings *that = const_cast<QSettings *>(this);
+        QStringList result;
+
+        that->beginGroup(key);
+        result = that->childKeys();
+        that->endGroup();
+        return result;
+    }
+    inline QT3_SUPPORT QStringList subkeyList(const QString &key) const
+    {
+        QSettings *that = const_cast<QSettings *>(this);
+        QStringList result;
+
+        that->beginGroup(key);
+        result = that->childGroups();
+        that->endGroup();
+        return result;
+    }
+#endif
+
+protected:
+#ifndef QT_NO_QOBJECT
+    bool event(QEvent *event);
+#endif
+
+private:
+#ifdef QT3_SUPPORT
+    void setPath_helper(Scope scope, const QString &organization, const QString &application);
+#endif
+
+    Q_DISABLE_COPY(QSettings)
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SETTINGS
+
+QT_END_HEADER
+
+#endif // QSETTINGS_H
diff --git a/src/corelib/io/qsettings_mac.cpp b/src/corelib/io/qsettings_mac.cpp
new file mode 100644
index 0000000..9a9e2d7
--- /dev/null
+++ b/src/corelib/io/qsettings_mac.cpp
@@ -0,0 +1,654 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qsettings.h"
+#include "qsettings_p.h"
+#include "qdatetime.h"
+#include "qdir.h"
+#include "qvarlengtharray.h"
+#include "private/qcore_mac_p.h"
+
+QT_BEGIN_NAMESPACE
+
+static const CFStringRef hostNames[2] = { kCFPreferencesCurrentHost, kCFPreferencesAnyHost };
+static const int numHostNames = 2;
+
+/*
+    On the Mac, it is more natural to use '.' as the key separator
+    than '/'. Therefore, it makes sense to replace '/' with '.' in
+    keys. Then we replace '.' with middle dots (which we can't show
+    here) and middle dots with '/'. A key like "4.0/BrowserCommand"
+    becomes "4<middot>0.BrowserCommand".
+*/
+
+enum RotateShift { Macify = 1, Qtify = 2 };
+
+static QString rotateSlashesDotsAndMiddots(const QString &key, int shift)
+{
+    static const int NumKnights = 3;
+    static const char knightsOfTheRoundTable[NumKnights] = { '/', '.', '\xb7' };
+    QString result = key;
+
+    for (int i = 0; i < result.size(); ++i) {
+        for (int j = 0; j < NumKnights; ++j) {
+            if (result.at(i) == QLatin1Char(knightsOfTheRoundTable[j])) {
+                result[i] = QLatin1Char(knightsOfTheRoundTable[(j + shift) % NumKnights]).unicode();
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+static QCFType<CFStringRef> macKey(const QString &key)
+{
+    return QCFString::toCFStringRef(rotateSlashesDotsAndMiddots(key, Macify));
+}
+
+static QString qtKey(CFStringRef cfkey)
+{
+    return rotateSlashesDotsAndMiddots(QCFString::toQString(cfkey), Qtify);
+}
+
+static QCFType<CFPropertyListRef> macValue(const QVariant &value);
+
+static CFArrayRef macList(const QList<QVariant> &list)
+{
+    int n = list.size();
+    QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(n);
+    for (int i = 0; i < n; ++i)
+        cfvalues[i] = macValue(list.at(i));
+    return CFArrayCreate(kCFAllocatorDefault, reinterpret_cast<const void **>(cfvalues.data()),
+                         CFIndex(n), &kCFTypeArrayCallBacks);
+}
+
+static QCFType<CFPropertyListRef> macValue(const QVariant &value)
+{
+    CFPropertyListRef result = 0;
+
+    switch (value.type()) {
+    case QVariant::ByteArray:
+        {
+            QByteArray ba = value.toByteArray();
+            result = CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(ba.data()),
+                                  CFIndex(ba.size()));
+        }
+        break;
+    // should be same as below (look for LIST)
+    case QVariant::List:
+    case QVariant::StringList:
+    case QVariant::Polygon:
+        result = macList(value.toList());
+        break;
+    case QVariant::Map:
+        {
+            /*
+                QMap<QString, QVariant> is potentially a multimap,
+                whereas CFDictionary is a single-valued map. To allow
+                for multiple values with the same key, we store
+                multiple values in a CFArray. To avoid ambiguities,
+                we also wrap lists in a CFArray singleton.
+            */
+            QMap<QString, QVariant> map = value.toMap();
+            QMap<QString, QVariant>::const_iterator i = map.constBegin();
+
+            int maxUniqueKeys = map.size();
+            int numUniqueKeys = 0;
+            QVarLengthArray<QCFType<CFPropertyListRef> > cfkeys(maxUniqueKeys);
+            QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(maxUniqueKeys);
+
+            while (i != map.constEnd()) {
+                const QString &key = i.key();
+                QList<QVariant> values;
+
+                do {
+                    values << i.value();
+                    ++i;
+                } while (i != map.constEnd() && i.key() == key);
+
+                bool singleton = (values.count() == 1);
+                if (singleton) {
+                    switch (values.first().type()) {
+                    // should be same as above (look for LIST)
+                    case QVariant::List:
+                    case QVariant::StringList:
+                    case QVariant::Polygon:
+                        singleton = false;
+                    default:
+                        ;
+                    }
+                }
+
+                cfkeys[numUniqueKeys] = QCFString::toCFStringRef(key);
+                cfvalues[numUniqueKeys] = singleton ? macValue(values.first()) : macList(values);
+                ++numUniqueKeys;
+            }
+
+            result = CFDictionaryCreate(kCFAllocatorDefault,
+                                        reinterpret_cast<const void **>(cfkeys.data()),
+                                        reinterpret_cast<const void **>(cfvalues.data()),
+                                        CFIndex(numUniqueKeys),
+                                        &kCFTypeDictionaryKeyCallBacks,
+                                        &kCFTypeDictionaryValueCallBacks);
+        }
+        break;
+    case QVariant::DateTime:
+        {
+            /*
+                CFDate, unlike QDateTime, doesn't store timezone information.
+            */
+            QDateTime dt = value.toDateTime();
+            if (dt.timeSpec() == Qt::LocalTime) {
+                QDateTime reference;
+                reference.setTime_t((uint)kCFAbsoluteTimeIntervalSince1970);
+                result = CFDateCreate(kCFAllocatorDefault, CFAbsoluteTime(reference.secsTo(dt)));
+            } else {
+                goto string_case;
+            }
+        }
+        break;
+    case QVariant::Bool:
+        result = value.toBool() ? kCFBooleanTrue : kCFBooleanFalse;
+        break;
+    case QVariant::Int:
+    case QVariant::UInt:
+        {
+            int n = value.toInt();
+            result = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &n);
+        }
+        break;
+    case QVariant::Double:
+        {
+            double n = value.toDouble();
+            result = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &n);
+        }
+        break;
+    case QVariant::LongLong:
+    case QVariant::ULongLong:
+        {
+            qint64 n = value.toLongLong();
+            result = CFNumberCreate(0, kCFNumberLongLongType, &n);
+        }
+        break;
+    case QVariant::String:
+    string_case:
+    default:
+        result = QCFString::toCFStringRef(QSettingsPrivate::variantToString(value));
+    }
+    return result;
+}
+
+static QVariant qtValue(CFPropertyListRef cfvalue)
+{
+    if (!cfvalue)
+        return QVariant();
+
+    CFTypeID typeId = CFGetTypeID(cfvalue);
+
+    /*
+        Sorted grossly from most to least frequent type.
+    */
+    if (typeId == CFStringGetTypeID()) {
+        return QSettingsPrivate::stringToVariant(QCFString::toQString(static_cast<CFStringRef>(cfvalue)));
+    } else if (typeId == CFNumberGetTypeID()) {
+        CFNumberRef cfnumber = static_cast<CFNumberRef>(cfvalue);
+        if (CFNumberIsFloatType(cfnumber)) {
+            double d;
+            CFNumberGetValue(cfnumber, kCFNumberDoubleType, &d);
+            return d;
+        } else {
+            int i;
+            qint64 ll;
+
+            if (CFNumberGetValue(cfnumber, kCFNumberIntType, &i))
+                return i;
+            CFNumberGetValue(cfnumber, kCFNumberLongLongType, &ll);
+            return ll;
+        }
+    } else if (typeId == CFArrayGetTypeID()) {
+        CFArrayRef cfarray = static_cast<CFArrayRef>(cfvalue);
+        QList<QVariant> list;
+        CFIndex size = CFArrayGetCount(cfarray);
+        bool metNonString = false;
+        for (CFIndex i = 0; i < size; ++i) {
+            QVariant value = qtValue(CFArrayGetValueAtIndex(cfarray, i));
+            if (value.type() != QVariant::String)
+                metNonString = true;
+            list << value;
+        }
+        if (metNonString)
+            return list;
+        else
+            return QVariant(list).toStringList();
+    } else if (typeId == CFBooleanGetTypeID()) {
+        return (bool)CFBooleanGetValue(static_cast<CFBooleanRef>(cfvalue));
+    } else if (typeId == CFDataGetTypeID()) {
+        CFDataRef cfdata = static_cast<CFDataRef>(cfvalue);
+        return QByteArray(reinterpret_cast<const char *>(CFDataGetBytePtr(cfdata)),
+                          CFDataGetLength(cfdata));
+    } else if (typeId == CFDictionaryGetTypeID()) {
+        CFDictionaryRef cfdict = static_cast<CFDictionaryRef>(cfvalue);
+        CFTypeID arrayTypeId = CFArrayGetTypeID();
+        int size = (int)CFDictionaryGetCount(cfdict);
+        QVarLengthArray<CFPropertyListRef> keys(size);
+        QVarLengthArray<CFPropertyListRef> values(size);
+        CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data());
+
+        QMultiMap<QString, QVariant> map;
+        for (int i = 0; i < size; ++i) {
+            QString key = QCFString::toQString(static_cast<CFStringRef>(keys[i]));
+
+            if (CFGetTypeID(values[i]) == arrayTypeId) {
+                CFArrayRef cfarray = static_cast<CFArrayRef>(values[i]);
+                CFIndex arraySize = CFArrayGetCount(cfarray);
+                for (CFIndex j = arraySize - 1; j >= 0; --j)
+                    map.insert(key, qtValue(CFArrayGetValueAtIndex(cfarray, j)));
+            } else {
+                map.insert(key, qtValue(values[i]));
+            }
+        }
+        return map;
+    } else if (typeId == CFDateGetTypeID()) {
+        QDateTime dt;
+        dt.setTime_t((uint)kCFAbsoluteTimeIntervalSince1970);
+        return dt.addSecs((int)CFDateGetAbsoluteTime(static_cast<CFDateRef>(cfvalue)));
+    }
+    return QVariant();
+}
+
+static QString comify(const QString &organization)
+{
+    for (int i = organization.size() - 1; i >= 0; --i) {
+        QChar ch = organization.at(i);
+        if (ch == QLatin1Char('.') || ch == QChar(0x3002) || ch == QChar(0xff0e)
+                || ch == QChar(0xff61)) {
+            QString suffix = organization.mid(i + 1).toLower();
+            if (suffix.size() == 2 || suffix == QLatin1String("com")
+                    || suffix == QLatin1String("org") || suffix == QLatin1String("net")
+                    || suffix == QLatin1String("edu") || suffix == QLatin1String("gov")
+                    || suffix == QLatin1String("mil") || suffix == QLatin1String("biz")
+                    || suffix == QLatin1String("info") || suffix == QLatin1String("name")
+                    || suffix == QLatin1String("pro") || suffix == QLatin1String("aero")
+                    || suffix == QLatin1String("coop") || suffix == QLatin1String("museum")) {
+                QString result = organization;
+                result.replace(QLatin1Char('/'), QLatin1Char(' '));
+                return result;
+            }
+            break;
+        }
+        int uc = ch.unicode();
+        if ((uc < 'a' || uc > 'z') && (uc < 'A' || uc > 'Z'))
+            break;
+    }
+
+    QString domain;
+    for (int i = 0; i < organization.size(); ++i) {
+        QChar ch = organization.at(i);
+        int uc = ch.unicode();
+        if ((uc >= 'a' && uc <= 'z') || (uc >= '0' && uc <= '9')) {
+            domain += ch;
+        } else if (uc >= 'A' && uc <= 'Z') {
+            domain += ch.toLower();
+        } else {
+           domain += QLatin1Char(' ');
+        }
+    }
+    domain = domain.simplified();
+    domain.replace(QLatin1Char(' '), QLatin1Char('-'));
+    if (!domain.isEmpty())
+        domain.append(QLatin1String(".com"));
+    return domain;
+}
+
+class QMacSettingsPrivate : public QSettingsPrivate
+{
+public:
+    QMacSettingsPrivate(QSettings::Scope scope, const QString &organization,
+                        const QString &application);
+    ~QMacSettingsPrivate();
+
+    void remove(const QString &key);
+    void set(const QString &key, const QVariant &value);
+    bool get(const QString &key, QVariant *value) const;
+    QStringList children(const QString &prefix, ChildSpec spec) const;
+    void clear();
+    void sync();
+    void flush();
+    bool isWritable() const;
+    QString fileName() const;
+
+private:
+    struct SearchDomain
+    {
+        CFStringRef userName;
+        CFStringRef applicationOrSuiteId;
+    };
+
+    QCFString applicationId;
+    QCFString suiteId;
+    QCFString hostName;
+    SearchDomain domains[6];
+    int numDomains;
+};
+
+QMacSettingsPrivate::QMacSettingsPrivate(QSettings::Scope scope, const QString &organization,
+                                         const QString &application)
+    : QSettingsPrivate(QSettings::NativeFormat, scope, organization, application)
+{
+    QString javaPackageName;
+    int curPos = 0;
+    int nextDot;
+
+    QString domainName = comify(organization);
+    if (domainName.isEmpty()) {
+        setStatus(QSettings::AccessError);
+        domainName = QLatin1String("unknown-organization.trolltech.com");
+    }
+
+    while ((nextDot = domainName.indexOf(QLatin1Char('.'), curPos)) != -1) {
+        javaPackageName.prepend(domainName.mid(curPos, nextDot - curPos));
+        javaPackageName.prepend(QLatin1Char('.'));
+        curPos = nextDot + 1;
+    }
+    javaPackageName.prepend(domainName.mid(curPos));
+    javaPackageName = javaPackageName.toLower();
+    if (curPos == 0)
+        javaPackageName.prepend(QLatin1String("com."));
+    suiteId = javaPackageName;
+
+    if (scope == QSettings::SystemScope)
+        spec |= F_System;
+
+    if (application.isEmpty()) {
+        spec |= F_Organization;
+    } else {
+        javaPackageName += QLatin1Char('.');
+        javaPackageName += application;
+        applicationId = javaPackageName;
+    }
+
+    numDomains = 0;
+    for (int i = (spec & F_System) ? 1 : 0; i < 2; ++i) {
+        for (int j = (spec & F_Organization) ? 1 : 0; j < 3; ++j) {
+            SearchDomain &domain = domains[numDomains++];
+            domain.userName = (i == 0) ? kCFPreferencesCurrentUser : kCFPreferencesAnyUser;
+            if (j == 0)
+                domain.applicationOrSuiteId = applicationId;
+            else if (j == 1)
+                domain.applicationOrSuiteId = suiteId;
+            else
+                domain.applicationOrSuiteId = kCFPreferencesAnyApplication;
+        }
+    }
+
+    hostName = (scope == QSettings::SystemScope) ? kCFPreferencesCurrentHost : kCFPreferencesAnyHost;
+    sync();
+}
+
+QMacSettingsPrivate::~QMacSettingsPrivate()
+{
+}
+
+void QMacSettingsPrivate::remove(const QString &key)
+{
+    QStringList keys = children(key + QLatin1Char('/'), AllKeys);
+
+    // If i == -1, then delete "key" itself.
+    for (int i = -1; i < keys.size(); ++i) {
+        QString subKey = key;
+        if (i >= 0) {
+            subKey += QLatin1Char('/');
+            subKey += keys.at(i);
+        }
+        CFPreferencesSetValue(macKey(subKey), 0, domains[0].applicationOrSuiteId,
+                              domains[0].userName, hostName);
+    }
+}
+
+void QMacSettingsPrivate::set(const QString &key, const QVariant &value)
+{
+    CFPreferencesSetValue(macKey(key), macValue(value), domains[0].applicationOrSuiteId,
+                          domains[0].userName, hostName);
+}
+
+bool QMacSettingsPrivate::get(const QString &key, QVariant *value) const
+{
+    QCFString k = macKey(key);
+    for (int i = 0; i < numDomains; ++i) {
+        for (int j = 0; j < numHostNames; ++j) {
+            QCFType<CFPropertyListRef> ret =
+                    CFPreferencesCopyValue(k, domains[i].applicationOrSuiteId, domains[i].userName,
+                                           hostNames[j]);
+            if (ret) {
+                if (value)
+                    *value = qtValue(ret);
+                return true;
+            }
+        }
+
+        if (!fallbacks)
+            break;
+    }
+    return false;
+}
+
+QStringList QMacSettingsPrivate::children(const QString &prefix, ChildSpec spec) const
+{
+    QMap<QString, QString> result;
+    int startPos = prefix.size();
+
+    for (int i = 0; i < numDomains; ++i) {
+        for (int j = 0; j < numHostNames; ++j) {
+            QCFType<CFArrayRef> cfarray = CFPreferencesCopyKeyList(domains[i].applicationOrSuiteId,
+                                                                   domains[i].userName,
+                                                                   hostNames[j]);
+            if (cfarray) {
+                CFIndex size = CFArrayGetCount(cfarray);
+                for (CFIndex k = 0; k < size; ++k) {
+                    QString currentKey =
+                            qtKey(static_cast<CFStringRef>(CFArrayGetValueAtIndex(cfarray, k)));
+                    if (currentKey.startsWith(prefix))
+                        processChild(currentKey.mid(startPos), spec, result);
+                }
+            }
+        }
+
+        if (!fallbacks)
+            break;
+    }
+    return result.keys();
+}
+
+void QMacSettingsPrivate::clear()
+{
+    QCFType<CFArrayRef> cfarray = CFPreferencesCopyKeyList(domains[0].applicationOrSuiteId,
+                                                           domains[0].userName, hostName);
+    CFPreferencesSetMultiple(0, cfarray, domains[0].applicationOrSuiteId, domains[0].userName,
+                             hostName);
+}
+
+void QMacSettingsPrivate::sync()
+{
+    for (int i = 0; i < numDomains; ++i) {
+        for (int j = 0; j < numHostNames; ++j) {
+            Boolean ok = CFPreferencesSynchronize(domains[i].applicationOrSuiteId,
+                                                  domains[i].userName, hostNames[j]);
+            // only report failures for the primary file (the one we write to)
+            if (!ok && i == 0 && hostNames[j] == hostName && status == QSettings::NoError) {
+#if 1
+                // work around what seems to be a bug in CFPreferences:
+                // don't report an error if there are no preferences for the application
+                QCFType<CFArrayRef> appIds = CFPreferencesCopyApplicationList(domains[i].userName,
+                                                                              hostNames[j]);
+
+                // iterate through all the applications and see if we're there
+                CFIndex size = CFArrayGetCount(appIds);
+                for (CFIndex k = 0; k < size; ++k) {
+                    const void *cfvalue = CFArrayGetValueAtIndex(appIds, k);
+                    if (CFGetTypeID(cfvalue) == CFStringGetTypeID()) {
+                        if (CFStringCompare(static_cast<CFStringRef>(cfvalue),
+                                            domains[i].applicationOrSuiteId,
+                                            kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
+                            setStatus(QSettings::AccessError);
+                            break;
+                        }
+                    }
+                }
+#else
+                setStatus(QSettings::AccessError);
+#endif
+            }
+        }
+    }
+}
+
+void QMacSettingsPrivate::flush()
+{
+    sync();
+}
+
+bool QMacSettingsPrivate::isWritable() const
+{
+    QMacSettingsPrivate *that = const_cast<QMacSettingsPrivate *>(this);
+    QString impossibleKey(QLatin1String("qt_internal/"));
+
+    QSettings::Status oldStatus = that->status;
+    that->status = QSettings::NoError;
+
+    that->set(impossibleKey, QVariant());
+    that->sync();
+    bool writable = (status == QSettings::NoError) && that->get(impossibleKey, 0);
+    that->remove(impossibleKey);
+    that->sync();
+
+    that->status = oldStatus;
+    return writable;
+}
+
+QString QMacSettingsPrivate::fileName() const
+{
+    QString result;
+    if ((spec & F_System) == 0)
+        result = QDir::homePath();
+    result += QLatin1String("/Library/Preferences/");
+    result += QCFString::toQString(domains[0].applicationOrSuiteId);
+    result += QLatin1String(".plist");
+    return result;
+}
+
+QSettingsPrivate *QSettingsPrivate::create(QSettings::Format format,
+                                           QSettings::Scope scope,
+                                           const QString &organization,
+                                           const QString &application)
+{
+    if (format == QSettings::NativeFormat) {
+        return new QMacSettingsPrivate(scope, organization, application);
+    } else {
+        return new QConfFileSettingsPrivate(format, scope, organization, application);
+    }
+}
+
+static QCFType<CFURLRef> urlFromFileName(const QString &fileName)
+{
+    return CFURLCreateWithFileSystemPath(kCFAllocatorDefault, QCFString(fileName),
+                                         kCFURLPOSIXPathStyle, false);
+}
+
+bool QConfFileSettingsPrivate::readPlistFile(const QString &fileName, ParsedSettingsMap *map) const
+{
+    QCFType<CFDataRef> resource;
+    SInt32 code;
+    if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, urlFromFileName(fileName),
+                                                  &resource, 0, 0, &code))
+        return false;
+
+    QCFString errorStr;
+    QCFType<CFPropertyListRef> propertyList =
+            CFPropertyListCreateFromXMLData(kCFAllocatorDefault, resource, kCFPropertyListImmutable,
+                                            &errorStr);
+
+    if (!propertyList)
+        return true;
+    if (CFGetTypeID(propertyList) != CFDictionaryGetTypeID())
+        return false;
+
+    CFDictionaryRef cfdict =
+            static_cast<CFDictionaryRef>(static_cast<CFPropertyListRef>(propertyList));
+    int size = (int)CFDictionaryGetCount(cfdict);
+    QVarLengthArray<CFPropertyListRef> keys(size);
+    QVarLengthArray<CFPropertyListRef> values(size);
+    CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data());
+
+    for (int i = 0; i < size; ++i) {
+        QString key = qtKey(static_cast<CFStringRef>(keys[i]));
+        map->insert(QSettingsKey(key, Qt::CaseSensitive), qtValue(values[i]));
+    }
+    return true;
+}
+
+bool QConfFileSettingsPrivate::writePlistFile(const QString &fileName,
+                                              const ParsedSettingsMap &map) const
+{
+    QVarLengthArray<QCFType<CFStringRef> > cfkeys(map.size());
+    QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(map.size());
+    int i = 0;
+    ParsedSettingsMap::const_iterator j;
+    for (j = map.constBegin(); j != map.constEnd(); ++j) {
+        cfkeys[i] = macKey(j.key());
+        cfvalues[i] = macValue(j.value());
+        ++i;
+    }
+
+    QCFType<CFDictionaryRef> propertyList =
+            CFDictionaryCreate(kCFAllocatorDefault,
+                               reinterpret_cast<const void **>(cfkeys.data()),
+                               reinterpret_cast<const void **>(cfvalues.data()),
+                               CFIndex(map.size()),
+                               &kCFTypeDictionaryKeyCallBacks,
+                               &kCFTypeDictionaryValueCallBacks);
+
+    QCFType<CFDataRef> xmlData = CFPropertyListCreateXMLData(kCFAllocatorDefault, propertyList);
+
+    SInt32 code;
+    return CFURLWriteDataAndPropertiesToResource(urlFromFileName(fileName), xmlData, 0, &code);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qsettings_p.h b/src/corelib/io/qsettings_p.h
new file mode 100644
index 0000000..dd72fd9
--- /dev/null
+++ b/src/corelib/io/qsettings_p.h
@@ -0,0 +1,313 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSETTINGS_P_H
+#define QSETTINGS_P_H
+
+//
+//  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.
+//
+
+#include "QtCore/qdatetime.h"
+#include "QtCore/qmap.h"
+#include "QtCore/qmutex.h"
+#include "QtCore/qiodevice.h"
+#include "QtCore/qstack.h"
+#include "QtCore/qstringlist.h"
+#ifndef QT_NO_QOBJECT
+#include "private/qobject_p.h"
+#endif
+
+#ifdef Q_OS_WIN
+#include "QtCore/qt_windows.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#if defined(Q_WS_QWS)
+#define QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER
+#endif
+
+// used in testing framework
+#define QSETTINGS_P_H_VERSION 3
+
+#ifdef QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER
+static const Qt::CaseSensitivity IniCaseSensitivity = Qt::CaseSensitive;
+
+class QSettingsKey : public QString
+{
+public:
+    inline QSettingsKey(const QString &key, Qt::CaseSensitivity cs, int /* position */ = -1)
+        : QString(key) { Q_ASSERT(cs == Qt::CaseSensitive); Q_UNUSED(cs); }
+
+    inline QString originalCaseKey() const { return *this; }
+    inline int originalKeyPosition() const { return -1; }
+};
+#else
+static const Qt::CaseSensitivity IniCaseSensitivity = Qt::CaseInsensitive;
+
+class QSettingsKey : public QString
+{
+public:
+    inline QSettingsKey(const QString &key, Qt::CaseSensitivity cs, int position = -1)
+         : QString(key), theOriginalKey(key), theOriginalKeyPosition(position)
+    {
+        if (cs == Qt::CaseInsensitive)
+            QString::operator=(toLower());
+    }
+
+    inline QString originalCaseKey() const { return theOriginalKey; }
+    inline int originalKeyPosition() const { return theOriginalKeyPosition; }
+
+private:
+    QString theOriginalKey;
+    int theOriginalKeyPosition;
+};
+#endif
+
+typedef QMap<QSettingsKey, QByteArray> UnparsedSettingsMap;
+typedef QMap<QSettingsKey, QVariant> ParsedSettingsMap;
+
+class QSettingsGroup
+{
+public:
+    inline QSettingsGroup()
+        : num(-1), maxNum(-1) {}
+    inline QSettingsGroup(const QString &s)
+        : str(s), num(-1), maxNum(-1) {}
+    inline QSettingsGroup(const QString &s, bool guessArraySize)
+        : str(s), num(0), maxNum(guessArraySize ? 0 : -1) {}
+
+    inline QString name() const { return str; }
+    inline QString toString() const;
+    inline bool isArray() const { return num != -1; }
+    inline int arraySizeGuess() const { return maxNum; }
+    inline void setArrayIndex(int i)
+    { num = i + 1; if (maxNum != -1 && num > maxNum) maxNum = num; }
+
+    QString str;
+    int num;
+    int maxNum;
+};
+
+inline QString QSettingsGroup::toString() const
+{
+    QString result;
+    result = str;
+    if (num > 0) {
+        result += QLatin1Char('/');
+        result += QString::number(num);
+    }
+    return result;
+}
+
+class Q_CORE_EXPORT QConfFile
+{
+public:
+    ParsedSettingsMap mergedKeyMap() const;
+    bool isWritable() const;
+
+    static QConfFile *fromName(const QString &name, bool _userPerms);
+    static void clearCache();
+
+    QString name;
+    QDateTime timeStamp;
+    qint64 size;
+    UnparsedSettingsMap unparsedIniSections;
+    ParsedSettingsMap originalKeys;
+    ParsedSettingsMap addedKeys;
+    ParsedSettingsMap removedKeys;
+    QAtomicInt ref;
+    QMutex mutex;
+    bool userPerms;
+
+private:
+#ifdef Q_DISABLE_COPY
+    QConfFile(const QConfFile &);
+    QConfFile &operator=(const QConfFile &);
+#endif
+    QConfFile(const QString &name, bool _userPerms);
+
+    friend class QConfFile_createsItself; // silences compiler warning
+};
+
+class Q_AUTOTEST_EXPORT QSettingsPrivate
+#ifndef QT_NO_QOBJECT
+    : public QObjectPrivate
+#endif
+{
+#ifdef QT_NO_QOBJECT
+    QSettings *q_ptr;
+#endif
+    Q_DECLARE_PUBLIC(QSettings)
+
+public:
+    QSettingsPrivate(QSettings::Format format);
+    QSettingsPrivate(QSettings::Format format, QSettings::Scope scope,
+                     const QString &organization, const QString &application);
+    virtual ~QSettingsPrivate();
+
+    virtual void remove(const QString &key) = 0;
+    virtual void set(const QString &key, const QVariant &value) = 0;
+    virtual bool get(const QString &key, QVariant *value) const = 0;
+
+    enum ChildSpec { AllKeys, ChildKeys, ChildGroups };
+    virtual QStringList children(const QString &prefix, ChildSpec spec) const = 0;
+
+    virtual void clear() = 0;
+    virtual void sync() = 0;
+    virtual void flush() = 0;
+    virtual bool isWritable() const = 0;
+    virtual QString fileName() const = 0;
+
+    QString actualKey(const QString &key) const;
+    void beginGroupOrArray(const QSettingsGroup &group);
+    void setStatus(QSettings::Status status) const;
+    void requestUpdate();
+    void update();
+
+    static QString normalizedKey(const QString &key);
+    static QSettingsPrivate *create(QSettings::Format format, QSettings::Scope scope,
+                                        const QString &organization, const QString &application);
+    static QSettingsPrivate *create(const QString &fileName, QSettings::Format format);
+
+    static void processChild(QString key, ChildSpec spec, QMap<QString, QString> &result);
+
+    // Variant streaming functions
+    static QStringList variantListToStringList(const QVariantList &l);
+    static QVariant stringListToVariantList(const QStringList &l);
+
+    // parser functions
+    static QString variantToString(const QVariant &v);
+    static QVariant stringToVariant(const QString &s);
+    static void iniEscapedKey(const QString &key, QByteArray &result);
+    static bool iniUnescapedKey(const QByteArray &key, int from, int to, QString &result);
+    static void iniEscapedString(const QString &str, QByteArray &result, QTextCodec *codec);
+    static void iniEscapedStringList(const QStringList &strs, QByteArray &result, QTextCodec *codec);
+    static bool iniUnescapedStringList(const QByteArray &str, int from, int to,
+                                       QString &stringResult, QStringList &stringListResult,
+                                       QTextCodec *codec);
+    static QStringList splitArgs(const QString &s, int idx);
+
+    /*
+    The numeric values of these enums define their search order. For example,
+    F_User | F_Organization is searched before F_System | F_Application,
+    because their values are respectively 1 and 2.
+    */
+    enum {
+       F_Application = 0x0,
+       F_Organization = 0x1,
+       F_User = 0x0,
+       F_System = 0x2,
+       NumConfFiles = 4
+    };
+
+    QSettings::Format format;
+    QSettings::Scope scope;
+    QString organizationName;
+    QString applicationName;
+    QTextCodec *iniCodec;
+
+protected:
+    QStack<QSettingsGroup> groupStack;
+    QString groupPrefix;
+    int spec;
+    bool fallbacks;
+    bool pendingChanges;
+    mutable QSettings::Status status;
+};
+
+class QConfFileSettingsPrivate : public QSettingsPrivate
+{
+public:
+    QConfFileSettingsPrivate(QSettings::Format format, QSettings::Scope scope,
+                             const QString &organization, const QString &application);
+    QConfFileSettingsPrivate(const QString &fileName, QSettings::Format format);
+    ~QConfFileSettingsPrivate();
+
+    void remove(const QString &key);
+    void set(const QString &key, const QVariant &value);
+    bool get(const QString &key, QVariant *value) const;
+
+    QStringList children(const QString &prefix, ChildSpec spec) const;
+
+    void clear();
+    void sync();
+    void flush();
+    bool isWritable() const;
+    QString fileName() const;
+
+    static bool readIniFile(const QByteArray &data, UnparsedSettingsMap *unparsedIniSections);
+    static bool readIniSection(const QSettingsKey &section, const QByteArray &data,
+                               ParsedSettingsMap *settingsMap, QTextCodec *codec);
+    static bool readIniLine(const QByteArray &data, int &dataPos, int &lineStart, int &lineLen,
+                            int &equalsPos);
+
+private:
+    void initFormat();
+    void initAccess();
+    void syncConfFile(int confFileNo);
+    bool writeIniFile(QIODevice &device, const ParsedSettingsMap &map);
+#ifdef Q_OS_MAC
+    bool readPlistFile(const QString &fileName, ParsedSettingsMap *map) const;
+    bool writePlistFile(const QString &fileName, const ParsedSettingsMap &map) const;
+#endif
+    void ensureAllSectionsParsed(QConfFile *confFile) const;
+    void ensureSectionParsed(QConfFile *confFile, const QSettingsKey &key) const;
+
+    QConfFile *confFiles[NumConfFiles];
+    QSettings::ReadFunc readFunc;
+    QSettings::WriteFunc writeFunc;
+    QString extension;
+    Qt::CaseSensitivity caseSensitivity;
+    int nextPosition;
+};
+
+QT_END_NAMESPACE
+
+#endif // QSETTINGS_P_H
diff --git a/src/corelib/io/qsettings_win.cpp b/src/corelib/io/qsettings_win.cpp
new file mode 100644
index 0000000..a08c969
--- /dev/null
+++ b/src/corelib/io/qsettings_win.cpp
@@ -0,0 +1,962 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qsettings.h"
+
+#ifndef QT_NO_SETTINGS
+
+#include "qsettings_p.h"
+#include "qvector.h"
+#include "qmap.h"
+#include "qt_windows.h"
+#include "qdebug.h"
+
+QT_BEGIN_NAMESPACE
+
+/*  Keys are stored in QStrings. If the variable name starts with 'u', this is a "user"
+    key, ie. "foo/bar/alpha/beta". If the variable name starts with 'r', this is a "registry"
+    key, ie. "\foo\bar\alpha\beta". */
+
+/*******************************************************************************
+** Some convenience functions
+*/
+
+/*
+  We don't use KEY_ALL_ACCESS because it gives more rights than what we
+  need. See task 199061.
+ */
+static const REGSAM registryPermissions = KEY_READ | KEY_WRITE;
+
+static QString keyPath(const QString &rKey)
+{
+    int idx = rKey.lastIndexOf(QLatin1Char('\\'));
+    if (idx == -1)
+        return QString();
+    return rKey.left(idx + 1);
+}
+
+static QString keyName(const QString &rKey)
+{
+    int idx = rKey.lastIndexOf(QLatin1Char('\\'));
+
+    QString res;
+    if (idx == -1)
+        res = rKey;
+    else
+        res = rKey.mid(idx + 1);
+
+    if (res == QLatin1String("Default") || res == QLatin1String("."))
+        res = QLatin1String("");
+
+    return res;
+}
+
+static QString escapedKey(QString uKey)
+{
+    QChar *data = uKey.data();
+    int l = uKey.length();
+    for (int i = 0; i < l; ++i) {
+        ushort &ucs = data[i].unicode();
+        if (ucs == '\\')
+            ucs = '/';
+        else if (ucs == '/')
+            ucs = '\\';
+    }
+    return uKey;
+}
+
+static QString unescapedKey(QString rKey)
+{
+    return escapedKey(rKey);
+}
+
+typedef QMap<QString, QString> NameSet;
+
+static void mergeKeySets(NameSet *dest, const NameSet &src)
+{
+    NameSet::const_iterator it = src.constBegin();
+    for (; it != src.constEnd(); ++it)
+        dest->insert(unescapedKey(it.key()), QString());
+}
+
+static void mergeKeySets(NameSet *dest, const QStringList &src)
+{
+    QStringList::const_iterator it = src.constBegin();
+    for (; it != src.constEnd(); ++it)
+        dest->insert(unescapedKey(*it), QString());
+}
+
+/*******************************************************************************
+** Wrappers for the insane windows registry API
+*/
+
+static QString errorCodeToString(DWORD errorCode)
+{
+    QString result;
+	QT_WA({
+		wchar_t *data = 0;
+		FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+			0, errorCode, 0,
+			data, 0, 0);
+		result = QString::fromUtf16(reinterpret_cast<const ushort *> (data));
+		if (data != 0)
+			LocalFree(data);
+	},	{
+		char *data = 0;
+		FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+			0, errorCode, 0,
+			(char *)&data, 0, 0);
+		result = QString::fromLocal8Bit(data);
+		if (data != 0)
+			LocalFree(data);
+	})
+    if (result.endsWith(QLatin1String("\n")))
+        result.truncate(result.length() - 1);
+
+    return result;
+}
+
+// Open a key with the specified perms
+static HKEY openKey(HKEY parentHandle, REGSAM perms, const QString &rSubKey)
+{
+    HKEY resultHandle = 0;
+
+    LONG res;
+    QT_WA( {
+        res = RegOpenKeyExW(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()),
+                            0, perms, &resultHandle);
+    } , {
+        res = RegOpenKeyExA(parentHandle, rSubKey.toLocal8Bit(),
+                            0, perms, &resultHandle);
+    } );
+
+    if (res == ERROR_SUCCESS)
+        return resultHandle;
+
+    return 0;
+}
+
+// Open a key with the specified perms, create it if it does not exist
+static HKEY createOrOpenKey(HKEY parentHandle, REGSAM perms, const QString &rSubKey)
+{
+    // try to open it
+    HKEY resultHandle = openKey(parentHandle, perms, rSubKey);
+    if (resultHandle != 0)
+        return resultHandle;
+
+    // try to create it
+    LONG res;
+    QT_WA( {
+        res = RegCreateKeyExW(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()), 0, 0,
+                              REG_OPTION_NON_VOLATILE, perms, 0, &resultHandle, 0);
+    } , {
+        res = RegCreateKeyExA(parentHandle, rSubKey.toLocal8Bit(), 0, 0,
+                              REG_OPTION_NON_VOLATILE, perms, 0, &resultHandle, 0);
+    } );
+
+    if (res == ERROR_SUCCESS)
+        return resultHandle;
+
+    //qWarning("QSettings: Failed to create subkey \"%s\": %s",
+    //        rSubKey.toLatin1().data(), errorCodeToString(res).toLatin1().data());
+
+    return 0;
+}
+
+// Open or create a key in read-write mode if possible, otherwise read-only
+static HKEY createOrOpenKey(HKEY parentHandle, const QString &rSubKey, bool *readOnly)
+{
+    // try to open or create it read/write
+    HKEY resultHandle = createOrOpenKey(parentHandle, registryPermissions, rSubKey);
+    if (resultHandle != 0) {
+        if (readOnly != 0)
+            *readOnly = false;
+        return resultHandle;
+    }
+
+    // try to open or create it read/only
+    resultHandle = createOrOpenKey(parentHandle, KEY_READ, rSubKey);
+    if (resultHandle != 0) {
+        if (readOnly != 0)
+            *readOnly = true;
+        return resultHandle;
+    }
+    return 0;
+}
+
+static QStringList childKeysOrGroups(HKEY parentHandle, QSettingsPrivate::ChildSpec spec)
+{
+    QStringList result;
+    LONG res;
+    DWORD numKeys;
+    DWORD maxKeySize;
+    DWORD numSubgroups;
+    DWORD maxSubgroupSize;
+
+    // Find the number of keys and subgroups, as well as the max of their lengths.
+    QT_WA( {
+        res = RegQueryInfoKeyW(parentHandle, 0, 0, 0, &numSubgroups, &maxSubgroupSize, 0,
+                               &numKeys, &maxKeySize, 0, 0, 0);
+    }, {
+        res = RegQueryInfoKeyA(parentHandle, 0, 0, 0, &numSubgroups, &maxSubgroupSize, 0,
+                               &numKeys, &maxKeySize, 0, 0, 0);
+    } );
+
+    if (res != ERROR_SUCCESS) {
+        qWarning("QSettings: RegQueryInfoKey() failed: %s", errorCodeToString(res).toLatin1().data());
+        return result;
+    }
+
+    ++maxSubgroupSize;
+    ++maxKeySize;
+
+    int n;
+    int m;
+    if (spec == QSettingsPrivate::ChildKeys) {
+        n = numKeys;
+        m = maxKeySize;
+    } else {
+        n = numSubgroups;
+        m = maxSubgroupSize;
+    }
+
+    /* Windows NT/2000/XP: The size does not include the terminating null character.
+       Windows Me/98/95: The size includes the terminating null character. */
+    ++m;
+
+    // Get the list
+    QByteArray buff(m*sizeof(ushort), 0);
+    for (int i = 0; i < n; ++i) {
+        QString item;
+        QT_WA( {
+            DWORD l = buff.size() / sizeof(ushort);
+            if (spec == QSettingsPrivate::ChildKeys) {
+                res = RegEnumValueW(parentHandle, i,
+                                    reinterpret_cast<wchar_t *>(buff.data()),
+                                    &l, 0, 0, 0, 0);
+            } else {
+                res = RegEnumKeyExW(parentHandle, i,
+                                    reinterpret_cast<wchar_t *>(buff.data()),
+                                    &l, 0, 0, 0, 0);
+            }
+            if (res == ERROR_SUCCESS)
+                item = QString::fromUtf16(reinterpret_cast<ushort*>(buff.data()), l);
+        }, {
+            DWORD l = buff.size();
+            if (spec == QSettingsPrivate::ChildKeys)
+                res = RegEnumValueA(parentHandle, i, buff.data(), &l, 0, 0, 0, 0);
+            else
+                res = RegEnumKeyExA(parentHandle, i, buff.data(), &l, 0, 0, 0, 0);
+            if (res == ERROR_SUCCESS)
+                item = QString::fromLocal8Bit(buff.data(), l);
+        } );
+
+        if (res != ERROR_SUCCESS) {
+            qWarning("QSettings: RegEnumValue failed: %s", errorCodeToString(res).toLatin1().data());
+            continue;
+        }
+        if (item.isEmpty())
+            item = QLatin1String(".");
+        result.append(item);
+    }
+    return result;
+}
+
+static void allKeys(HKEY parentHandle, const QString &rSubKey, NameSet *result)
+{
+    HKEY handle = openKey(parentHandle, KEY_READ, rSubKey);
+    if (handle == 0)
+        return;
+
+    QStringList childKeys = childKeysOrGroups(handle, QSettingsPrivate::ChildKeys);
+    QStringList childGroups = childKeysOrGroups(handle, QSettingsPrivate::ChildGroups);
+    RegCloseKey(handle);
+
+    for (int i = 0; i < childKeys.size(); ++i) {
+        QString s = rSubKey;
+        if (!s.isEmpty())
+            s += QLatin1Char('\\');
+        s += childKeys.at(i);
+        result->insert(s, QString());
+    }
+
+    for (int i = 0; i < childGroups.size(); ++i) {
+        QString s = rSubKey;
+        if (!s.isEmpty())
+            s += QLatin1Char('\\');
+        s += childGroups.at(i);
+        allKeys(parentHandle, s, result);
+    }
+}
+
+static void deleteChildGroups(HKEY parentHandle)
+{
+    QStringList childGroups = childKeysOrGroups(parentHandle, QSettingsPrivate::ChildGroups);
+
+    for (int i = 0; i < childGroups.size(); ++i) {
+        QString group = childGroups.at(i);
+
+        // delete subgroups in group
+        HKEY childGroupHandle = openKey(parentHandle, registryPermissions, group);
+        if (childGroupHandle == 0)
+            continue;
+        deleteChildGroups(childGroupHandle);
+        RegCloseKey(childGroupHandle);
+
+        // delete group itself
+        LONG res;
+        QT_WA( {
+            res = RegDeleteKeyW(parentHandle, reinterpret_cast<const wchar_t *>(group.utf16()));
+        }, {
+            res = RegDeleteKeyA(parentHandle, group.toLocal8Bit());
+        } );
+        if (res != ERROR_SUCCESS) {
+            qWarning("QSettings: RegDeleteKey failed on subkey \"%s\": %s",
+                      group.toLatin1().data(), errorCodeToString(res).toLatin1().data());
+            return;
+        }
+    }
+}
+
+/*******************************************************************************
+** class RegistryKey
+*/
+
+class RegistryKey
+{
+public:
+    RegistryKey(HKEY parent_handle = 0, const QString &key = QString(), bool read_only = true);
+    QString key() const;
+    HKEY handle() const;
+    HKEY parentHandle() const;
+    bool readOnly() const;
+    void close();
+private:
+    HKEY m_parent_handle;
+    mutable HKEY m_handle;
+    QString m_key;
+    mutable bool m_read_only;
+};
+
+RegistryKey::RegistryKey(HKEY parent_handle, const QString &key, bool read_only)
+{
+    m_parent_handle = parent_handle;
+    m_handle = 0;
+    m_read_only = read_only;
+    m_key = key;
+}
+
+QString RegistryKey::key() const
+{
+    return m_key;
+}
+
+HKEY RegistryKey::handle() const
+{
+    if (m_handle != 0)
+        return m_handle;
+
+    if (m_read_only)
+        m_handle = openKey(m_parent_handle, KEY_READ, m_key);
+    else
+        m_handle = createOrOpenKey(m_parent_handle, m_key, &m_read_only);
+
+    return m_handle;
+}
+
+HKEY RegistryKey::parentHandle() const
+{
+    return m_parent_handle;
+}
+
+bool RegistryKey::readOnly() const
+{
+    return m_read_only;
+}
+
+void RegistryKey::close()
+{
+    if (m_handle != 0)
+        RegCloseKey(m_handle);
+    m_handle = 0;
+}
+
+typedef QVector<RegistryKey> RegistryKeyList;
+
+/*******************************************************************************
+** class QWinSettingsPrivate
+*/
+
+class QWinSettingsPrivate : public QSettingsPrivate
+{
+public:
+    QWinSettingsPrivate(QSettings::Scope scope, const QString &organization,
+                        const QString &application);
+    QWinSettingsPrivate(QString rKey);
+    ~QWinSettingsPrivate();
+
+    void remove(const QString &uKey);
+    void set(const QString &uKey, const QVariant &value);
+    bool get(const QString &uKey, QVariant *value) const;
+    QStringList children(const QString &uKey, ChildSpec spec) const;
+    void clear();
+    void sync();
+    void flush();
+    bool isWritable() const;
+    HKEY writeHandle() const;
+    bool readKey(HKEY parentHandle, const QString &rSubKey, QVariant *value) const;
+    QString fileName() const;
+
+private:
+    RegistryKeyList regList; // list of registry locations to search for keys
+    bool deleteWriteHandleOnExit;
+};
+
+QWinSettingsPrivate::QWinSettingsPrivate(QSettings::Scope scope, const QString &organization,
+                                         const QString &application)
+    : QSettingsPrivate(QSettings::NativeFormat, scope, organization, application)
+{
+    deleteWriteHandleOnExit = false;
+
+    if (!organization.isEmpty()) {
+        QString prefix = QLatin1String("Software\\") + organization;
+        QString orgPrefix = prefix + QLatin1String("\\OrganizationDefaults");
+        QString appPrefix = prefix + QLatin1Char('\\') + application;
+
+        if (scope == QSettings::UserScope) {
+            if (!application.isEmpty())
+                regList.append(RegistryKey(HKEY_CURRENT_USER, appPrefix, !regList.isEmpty()));
+
+            regList.append(RegistryKey(HKEY_CURRENT_USER, orgPrefix, !regList.isEmpty()));
+        }
+
+        if (!application.isEmpty())
+            regList.append(RegistryKey(HKEY_LOCAL_MACHINE, appPrefix, !regList.isEmpty()));
+
+        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, orgPrefix, !regList.isEmpty()));
+    }
+
+    if (regList.isEmpty())
+        setStatus(QSettings::AccessError);
+}
+
+QWinSettingsPrivate::QWinSettingsPrivate(QString rPath)
+    : QSettingsPrivate(QSettings::NativeFormat)
+{
+    deleteWriteHandleOnExit = false;
+
+    if (rPath.startsWith(QLatin1String("\\")))
+        rPath = rPath.mid(1);
+
+    if (rPath.startsWith(QLatin1String("HKEY_CURRENT_USER\\")))
+        regList.append(RegistryKey(HKEY_CURRENT_USER, rPath.mid(18), false));
+    else if (rPath == QLatin1String("HKEY_CURRENT_USER"))
+        regList.append(RegistryKey(HKEY_CURRENT_USER, QString(), false));
+    else if (rPath.startsWith(QLatin1String("HKEY_LOCAL_MACHINE\\")))
+        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, rPath.mid(19), false));
+    else if (rPath == QLatin1String("HKEY_LOCAL_MACHINE"))
+        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, QString(), false));
+    else if (rPath.startsWith(QLatin1String("HKEY_CLASSES_ROOT\\")))
+        regList.append(RegistryKey(HKEY_CLASSES_ROOT, rPath.mid(18), false));
+    else if (rPath == QLatin1String("HKEY_CLASSES_ROOT"))
+        regList.append(RegistryKey(HKEY_CLASSES_ROOT, QString(), false));
+    else if (rPath.startsWith(QLatin1String("HKEY_USERS\\")))
+        regList.append(RegistryKey(HKEY_USERS, rPath.mid(11), false));
+    else if (rPath == QLatin1String(QLatin1String("HKEY_USERS")))
+        regList.append(RegistryKey(HKEY_USERS, QString(), false));
+    else
+        regList.append(RegistryKey(HKEY_LOCAL_MACHINE, rPath, false));
+}
+
+bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVariant *value) const
+{
+    QString rSubkeyName = keyName(rSubKey);
+    QString rSubkeyPath = keyPath(rSubKey);
+
+    // open a handle on the subkey
+    HKEY handle = openKey(parentHandle, KEY_READ, rSubkeyPath);
+    if (handle == 0)
+        return false;
+
+    // get the size and type of the value
+    DWORD dataType;
+    DWORD dataSize;
+    LONG res;
+    QT_WA( {
+        res = RegQueryValueExW(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, &dataType, 0, &dataSize);
+    }, {
+        res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, &dataType, 0, &dataSize);
+    } );
+    if (res != ERROR_SUCCESS) {
+        RegCloseKey(handle);
+        return false;
+    }
+
+    // get the value
+    QByteArray data(dataSize, 0);
+    QT_WA( {
+        res = RegQueryValueExW(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, 0,
+                               reinterpret_cast<unsigned char*>(data.data()), &dataSize);
+    }, {
+        res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, 0,
+                               reinterpret_cast<unsigned char*>(data.data()), &dataSize);
+    } );
+    if (res != ERROR_SUCCESS) {
+        RegCloseKey(handle);
+        return false;
+    }
+
+    switch (dataType) {
+        case REG_EXPAND_SZ:
+        case REG_SZ: {
+            QString s;
+            if (dataSize) {
+                QT_WA( {
+                    s = QString::fromUtf16(((const ushort*)data.constData()));
+                }, {
+                    s = QString::fromLocal8Bit(data.constData());
+                } );
+            }
+            if (value != 0)
+                *value = stringToVariant(s);
+            break;
+        }
+
+        case REG_MULTI_SZ: {
+            QStringList l;
+            if (dataSize) {
+                int i = 0;
+                for (;;) {
+                    QString s;
+                    QT_WA( {
+                        s = QString::fromUtf16((const ushort*)data.constData() + i);
+                    }, {
+                        s = QString::fromLocal8Bit(data.constData() + i);
+                    } );
+                    i += s.length() + 1;
+
+                    if (s.isEmpty())
+                        break;
+                    l.append(s);
+                }
+            }
+            if (value != 0)
+                *value = stringListToVariantList(l);
+            break;
+        }
+
+        case REG_NONE:
+        case REG_BINARY: {
+            QString s;
+            if (dataSize) {
+                QT_WA( {
+                    s = QString::fromUtf16((const ushort*)data.constData(), data.size()/2);
+                }, {
+                    s = QString::fromLocal8Bit(data.constData(), data.size());
+                } );
+            }
+            if (value != 0)
+                *value = stringToVariant(s);
+            break;
+        }
+
+        case REG_DWORD_BIG_ENDIAN:
+        case REG_DWORD: {
+            Q_ASSERT(data.size() == sizeof(int));
+            int i;
+            memcpy((char*)&i, data.constData(), sizeof(int));
+            if (value != 0)
+                *value = i;
+            break;
+        }
+
+        default:
+            qWarning("QSettings: Unknown data %d type in Windows registry", static_cast<int>(dataType));
+            if (value != 0)
+                *value = QVariant();
+            break;
+    }
+
+    RegCloseKey(handle);
+    return true;
+}
+
+HKEY QWinSettingsPrivate::writeHandle() const
+{
+    if (regList.isEmpty())
+        return 0;
+    const RegistryKey &key = regList.at(0);
+    if (key.handle() == 0 || key.readOnly())
+        return 0;
+    return key.handle();
+}
+
+QWinSettingsPrivate::~QWinSettingsPrivate()
+{
+    if (deleteWriteHandleOnExit && writeHandle() != 0) {
+#if defined(Q_OS_WINCE)
+        remove(regList.at(0).key()); 
+#else
+        DWORD res;
+        QString emptyKey;
+        QT_WA( {
+            res = RegDeleteKeyW(writeHandle(), reinterpret_cast<const wchar_t *>(emptyKey.utf16()));
+        }, {
+            res = RegDeleteKeyA(writeHandle(), emptyKey.toLocal8Bit());
+        } );
+        if (res != ERROR_SUCCESS) {
+            qWarning("QSettings: Failed to delete key \"%s\": %s",
+                    regList.at(0).key().toLatin1().data(), errorCodeToString(res).toLatin1().data());
+        }
+#endif
+    }
+
+    for (int i = 0; i < regList.size(); ++i)
+        regList[i].close();
+}
+
+void QWinSettingsPrivate::remove(const QString &uKey)
+{
+    if (writeHandle() == 0) {
+        setStatus(QSettings::AccessError);
+        return;
+    }
+
+    QString rKey = escapedKey(uKey);
+
+    // try to delete value bar in key foo
+    LONG res;
+    HKEY handle = openKey(writeHandle(), registryPermissions, keyPath(rKey));
+    if (handle != 0) {
+        QT_WA( {
+            res = RegDeleteValueW(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()));
+        }, {
+            res = RegDeleteValueA(handle, keyName(rKey).toLocal8Bit());
+        } );
+        RegCloseKey(handle);
+    }
+
+    // try to delete key foo/bar and all subkeys
+    handle = openKey(writeHandle(), registryPermissions, rKey);
+    if (handle != 0) {
+        deleteChildGroups(handle);
+
+        if (rKey.isEmpty()) {
+            QStringList childKeys = childKeysOrGroups(handle, QSettingsPrivate::ChildKeys);
+
+            for (int i = 0; i < childKeys.size(); ++i) {
+                QString group = childKeys.at(i);
+
+                LONG res;
+                QT_WA( {
+                    res = RegDeleteValueW(handle, reinterpret_cast<const wchar_t *>(group.utf16()));
+                }, {
+                    res = RegDeleteValueA(handle, group.toLocal8Bit());
+                } );
+                if (res != ERROR_SUCCESS) {
+                    qWarning("QSettings: RegDeleteValue failed on subkey \"%s\": %s",
+                              group.toLatin1().data(), errorCodeToString(res).toLatin1().data());
+                }
+            }
+        } else {
+#if defined(Q_OS_WINCE)
+            // For WinCE always Close the handle first.
+            RegCloseKey(handle);
+#endif
+            QT_WA( {
+                res = RegDeleteKeyW(writeHandle(), reinterpret_cast<const wchar_t *>(rKey.utf16()));
+            }, {
+                res = RegDeleteKeyA(writeHandle(), rKey.toLocal8Bit());
+            } );
+
+            if (res != ERROR_SUCCESS) {
+                qWarning("QSettings: RegDeleteKey failed on key \"%s\": %s",
+                            rKey.toLatin1().data(), errorCodeToString(res).toLatin1().data());
+            }
+        }
+        RegCloseKey(handle);
+    }
+}
+
+static bool stringContainsNullChar(const QString &s)
+{
+    for (int i = 0; i < s.length(); ++i) {
+        if (s.at(i).unicode() == 0)
+            return true;
+    }
+    return false;
+}
+
+void QWinSettingsPrivate::set(const QString &uKey, const QVariant &value)
+{
+    if (writeHandle() == 0) {
+        setStatus(QSettings::AccessError);
+        return;
+    }
+
+    QString rKey = escapedKey(uKey);
+
+    HKEY handle = createOrOpenKey(writeHandle(), registryPermissions, keyPath(rKey));
+    if (handle == 0) {
+        setStatus(QSettings::AccessError);
+        return;
+    }
+
+    DWORD type;
+    QByteArray regValueBuff;
+
+    // Determine the type
+    switch (value.type()) {
+        case QVariant::List:
+        case QVariant::StringList: {
+            // If none of the elements contains '\0', we can use REG_MULTI_SZ, the
+            // native registry string list type. Otherwise we use REG_BINARY.
+            type = REG_MULTI_SZ;
+            QStringList l = variantListToStringList(value.toList());
+            QStringList::const_iterator it = l.constBegin();
+            for (; it != l.constEnd(); ++it) {
+                if ((*it).length() == 0 || stringContainsNullChar(*it)) {
+                    type = REG_BINARY;
+                    break;
+                }
+            }
+
+            if (type == REG_BINARY) {
+                QString s = variantToString(value);
+                QT_WA( {
+                    regValueBuff = QByteArray((const char*)s.utf16(), s.length()*2);
+                }, {
+                    regValueBuff = QByteArray((const char*)s.toLocal8Bit(), s.length());
+                } );
+            } else {
+                QStringList::const_iterator it = l.constBegin();
+                for (; it != l.constEnd(); ++it) {
+                    const QString &s = *it;
+                    QT_WA( {
+                        regValueBuff += QByteArray((const char*)s.utf16(), (s.length() + 1)*2);
+                    }, {
+                        regValueBuff += QByteArray((const char*)s.toLocal8Bit(), s.length() + 1);
+                    } );
+                }
+                QT_WA( {
+                    regValueBuff.append((char)0);
+                    regValueBuff.append((char)0);
+                }, {
+                    regValueBuff.append((char)0);
+                } );
+            }
+            break;
+        }
+
+        case QVariant::Int: {
+            type = REG_DWORD;
+            int i = value.toInt();
+            regValueBuff = QByteArray((const char*)&i, sizeof(int));
+            break;
+        }
+
+        case QVariant::ByteArray:
+            // On Win95/98/Me QString::toLocal8Bit() fails to handle chars > 0x7F. So we don't go through variantToString() at all.
+            if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
+                QByteArray ba = value.toByteArray();
+                regValueBuff = "@ByteArray(";
+                regValueBuff += ba;
+                regValueBuff += ')';
+                if (ba.contains('\0')) {
+                    type = REG_BINARY;
+                } else {
+                    type = REG_SZ;
+                    regValueBuff += '\0';
+                }
+                    
+                break;
+            }
+            // fallthrough intended
+
+        default: {
+            // If the string does not contain '\0', we can use REG_SZ, the native registry
+            // string type. Otherwise we use REG_BINARY.
+            QString s = variantToString(value);
+            type = stringContainsNullChar(s) ? REG_BINARY : REG_SZ;
+            if (type == REG_BINARY) {
+                QT_WA( {
+                    regValueBuff = QByteArray((const char*)s.utf16(), s.length()*2);
+                }, {
+                    regValueBuff = QByteArray((const char*)s.toLocal8Bit(), s.length());
+                } );
+            } else {
+                QT_WA( {
+                    regValueBuff = QByteArray((const char*)s.utf16(), (s.length() + 1)*2);
+                }, {
+                    regValueBuff = QByteArray((const char*)s.toLocal8Bit(), s.length() + 1);
+                } );
+            }
+            break;
+        }
+    }
+
+    // set the value
+    LONG res;
+    QT_WA( {
+        res = RegSetValueExW(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()), 0, type,
+                             reinterpret_cast<const unsigned char*>(regValueBuff.constData()),
+                             regValueBuff.size());
+    }, {
+        res = RegSetValueExA(handle, keyName(rKey).toLocal8Bit(), 0, type,
+                             reinterpret_cast<const unsigned char*>(regValueBuff.constData()),
+                             regValueBuff.size());
+    } );
+
+    if (res == ERROR_SUCCESS) {
+        deleteWriteHandleOnExit = false;
+    } else {
+        qWarning("QSettings: failed to set subkey \"%s\": %s",
+                rKey.toLatin1().data(), errorCodeToString(res).toLatin1().data());
+        setStatus(QSettings::AccessError);
+    }
+
+    RegCloseKey(handle);
+}
+
+bool QWinSettingsPrivate::get(const QString &uKey, QVariant *value) const
+{
+    QString rKey = escapedKey(uKey);
+
+    for (int i = 0; i < regList.size(); ++i) {
+        HKEY handle = regList.at(i).handle();
+        if (handle != 0 && readKey(handle, rKey, value))
+            return true;
+
+        if (!fallbacks)
+            return false;
+    }
+
+    return false;
+}
+
+QStringList QWinSettingsPrivate::children(const QString &uKey, ChildSpec spec) const
+{
+    NameSet result;
+    QString rKey = escapedKey(uKey);
+
+    for (int i = 0; i < regList.size(); ++i) {
+        HKEY parent_handle = regList.at(i).handle();
+        if (parent_handle == 0)
+            continue;
+        HKEY handle = openKey(parent_handle, KEY_READ, rKey);
+        if (handle == 0)
+            continue;
+
+        if (spec == AllKeys) {
+            NameSet keys;
+            allKeys(handle, QLatin1String(""), &keys);
+            mergeKeySets(&result, keys);
+        } else { // ChildGroups or ChildKeys
+            QStringList names = childKeysOrGroups(handle, spec);
+            mergeKeySets(&result, names);
+        }
+
+        RegCloseKey(handle);
+
+        if (!fallbacks)
+            return result.keys();
+    }
+
+    return result.keys();
+}
+
+void QWinSettingsPrivate::clear()
+{
+    remove(QString());
+    deleteWriteHandleOnExit = true;
+}
+
+void QWinSettingsPrivate::sync()
+{
+    RegFlushKey(writeHandle());
+}
+
+void QWinSettingsPrivate::flush()
+{
+    // Windows does this for us.
+}
+
+QString QWinSettingsPrivate::fileName() const
+{
+    if (regList.isEmpty())
+        return QString();
+
+    const RegistryKey &key = regList.at(0);
+    QString result;
+    if (key.parentHandle() == HKEY_CURRENT_USER)
+        result = QLatin1String("\\HKEY_CURRENT_USER\\");
+    else
+        result = QLatin1String("\\HKEY_LOCAL_MACHINE\\");
+
+    return result + regList.at(0).key();
+}
+
+bool QWinSettingsPrivate::isWritable() const
+{
+    return writeHandle() != 0;
+}
+
+QSettingsPrivate *QSettingsPrivate::create(QSettings::Format format, QSettings::Scope scope,
+                                           const QString &organization, const QString &application)
+{
+    if (format == QSettings::NativeFormat) {
+        return new QWinSettingsPrivate(scope, organization, application);
+    } else {
+        return new QConfFileSettingsPrivate(format, scope, organization, application);
+    }
+}
+
+QSettingsPrivate *QSettingsPrivate::create(const QString &fileName, QSettings::Format format)
+{
+    if (format == QSettings::NativeFormat) {
+        return new QWinSettingsPrivate(fileName);
+    } else {
+        return new QConfFileSettingsPrivate(fileName, format);
+    }
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_SETTINGS
diff --git a/src/corelib/io/qtemporaryfile.cpp b/src/corelib/io/qtemporaryfile.cpp
new file mode 100644
index 0000000..3cfce83
--- /dev/null
+++ b/src/corelib/io/qtemporaryfile.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 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 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 "qtemporaryfile.h"
+
+#ifndef QT_NO_TEMPORARYFILE
+
+#include "qplatformdefs.h"
+#include "qabstractfileengine.h"
+#include "private/qfile_p.h"
+#include "private/qabstractfileengine_p.h"
+#include "private/qfsfileengine_p.h"
+
+#include <stdlib.h>
+#if !defined(Q_OS_WINCE)
+#  include <errno.h>
+#  include <sys/stat.h>
+#  include <sys/types.h>
+#endif
+
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+# include <process.h>
+# if defined(_MSC_VER) && _MSC_VER >= 1400
+#  include <share.h>
+# endif
+#endif
+
+#if defined(Q_OS_WINCE)
+#  include <types.h>
+#  include "qfunctions_wince.h"
+#endif
+
+
+QT_BEGIN_NAMESPACE
+
+/*
+ * Copyright (c) 1987, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+static int _gettemp(char *path, int *doopen, int domkdir, int slen)
+{
+	char *start, *trv, *suffp;
+	QT_STATBUF sbuf;
+	int rval;
+#if defined(Q_OS_WIN)
+    int pid;
+#else
+	pid_t pid;
+#endif
+
+	if (doopen && domkdir) {
+		errno = EINVAL;
+		return(0);
+	}
+
+	for (trv = path; *trv; ++trv)
+		;
+	trv -= slen;
+	suffp = trv;
+	--trv;
+	if (trv < path) {
+		errno = EINVAL;
+		return (0);
+	}
+#if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400
+        pid = _getpid();
+#else
+        pid = getpid();
+#endif
+	while (trv >= path && *trv == 'X' && pid != 0) {
+		*trv-- = (pid % 10) + '0';
+		pid /= 10;
+        }
+
+#ifndef S_ISDIR
+#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#endif
+
+        while (trv >= path && *trv == 'X') {
+            char c;
+
+            // CHANGE arc4random() -> random()
+            pid = (qrand() & 0xffff) % (26+26);
+		if (pid < 26)
+			c = pid + 'A';
+		else
+			c = (pid - 26) + 'a';
+		*trv-- = c;
+	}
+	start = trv + 1;
+
+	/*
+	 * check the target directory; if you have six X's and it
+	 * doesn't exist this runs for a *very* long time.
+	 */
+	if (doopen || domkdir) {
+		for (;; --trv) {
+			if (trv <= path)
+				break;
+			if (*trv == '/') {
+				*trv = '\0';
+#if defined (Q_OS_WIN) && !defined(Q_OS_WINCE)
+                                if (trv - path == 2 && path[1] == ':') {
+                                    // Special case for Windows drives
+                                    // (e.g., "C:" => "C:\").
+                                    // ### Better to use a Windows
+                                    // call for this.
+									char drive[] = "c:\\";
+                                    drive[0] = path[0];
+                                    rval = QT_STAT(drive, &sbuf);
+                                } else
+#endif
+				rval = QT_STAT(path, &sbuf);
+				*trv = '/';
+				if (rval != 0)
+					return(0);
+				if (!S_ISDIR(sbuf.st_mode)) {
+					errno = ENOTDIR;
+					return(0);
+				}
+				break;
+			}
+		}
+	}
+
+	for (;;) {
+		if (doopen) {
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
+                        if (_sopen_s(doopen, path, QT_OPEN_CREAT|O_EXCL|QT_OPEN_RDWR|QT_OPEN_BINARY
+#ifdef QT_LARGEFILE_SUPPORT
+                                     |QT_OPEN_LARGEFILE
+#endif
+                                     , _SH_DENYNO, _S_IREAD | _S_IWRITE)== 0)
+#else
+#if defined(Q_OS_WINCE)
+            QString targetPath;
+            if (QDir::isAbsolutePath(QString::fromLatin1(path)))
+                targetPath = QLatin1String(path);
+            else
+                targetPath = QDir::currentPath().append(QLatin1String("/")) + QLatin1String(path);
+
+            if ((*doopen =
+                QT_OPEN(targetPath.toLocal8Bit(), O_CREAT|O_EXCL|O_RDWR
+#else
+                        if ((*doopen =
+                            open(path, QT_OPEN_CREAT|O_EXCL|QT_OPEN_RDWR
+#endif
+#ifdef QT_LARGEFILE_SUPPORT
+                                 |QT_OPEN_LARGEFILE
+#endif
+#  if defined(Q_OS_WINCE)
+                                                             |_O_BINARY
+#  elif defined(Q_OS_WIN)
+                                 |O_BINARY
+#  endif
+                                 , 0600)) >= 0)
+#endif
+
+                                return(1);
+                        if (errno != EEXIST)
+                                return(0);
+                } else if (domkdir) {
+#ifdef Q_OS_WIN
+                    if (QT_MKDIR(path) == 0)
+#else
+                    if (mkdir(path, 0700) == 0)
+#endif
+                                return(1);
+                        if (errno != EEXIST)
+                                return(0);
+            }
+#ifndef Q_OS_WIN
+            else if (QT_LSTAT(path, &sbuf))
+			return(errno == ENOENT ? 1 : 0);
+#else
+            if (!QFileInfo(QLatin1String(path)).exists())
+                return 1;
+#endif
+
+                /* tricky little algorwwithm for backward compatibility */
+                for (trv = start;;) {
+                        if (!*trv)
+                                return (0);
+                        if (*trv == 'Z') {
+                                if (trv == suffp)
+                                        return (0);
+                                *trv++ = 'a';
+                        } else {
+                                if (isdigit(*trv))
+                                        *trv = 'a';
+                                else if (*trv == 'z')	/* inc from z to A */
+                                        *trv = 'A';
+                                else {
+                                        if (trv == suffp)
+                                                return (0);
+                                        ++*trv;
+                                }
+                                break;
+                        }
+                }
+        }
+        /*NOTREACHED*/
+}
+
+static int qt_mkstemps(char *path, int slen)
+{
+        int fd = 0;
+        return (_gettemp(path, &fd, 0, slen) ? fd : -1);
+}
+
+//************* QTemporaryFileEngine
+class QTemporaryFileEngine : public QFSFileEngine
+{
+    Q_DECLARE_PRIVATE(QFSFileEngine)
+public:
+    QTemporaryFileEngine(const QString &file) : QFSFileEngine(file) { }
+    ~QTemporaryFileEngine();
+
+    bool open(QIODevice::OpenMode flags);
+    bool remove();
+    bool close();
+};
+
+QTemporaryFileEngine::~QTemporaryFileEngine()
+{
+    QFSFileEngine::close();
+}
+
+bool QTemporaryFileEngine::open(QIODevice::OpenMode openMode)
+{
+    Q_D(QFSFileEngine);
+
+    QString qfilename = d->filePath;
+    if(!qfilename.contains(QLatin1String("XXXXXX")))
+        qfilename += QLatin1String(".XXXXXX");
+
+    int suffixLength = qfilename.length() - (qfilename.lastIndexOf(QLatin1String("XXXXXX"), -1, Qt::CaseSensitive) + 6);
+    d->closeFileHandle = true;
+    char *filename = qstrdup(qfilename.toLocal8Bit());
+
+#ifndef Q_WS_WIN
+    int fd = qt_mkstemps(filename, suffixLength);
+    if (fd != -1) {
+        // First open the fd as an external file descriptor to
+        // initialize the engine properly.
+        QFSFileEngine::open(openMode, fd);
+
+        // Allow the engine to close the handle even if it's "external".
+        d->closeFileHandle = true;
+
+        // Restore the file names (open() resets them).
+        d->filePath = QString::fromLocal8Bit(filename); //changed now!
+        d->nativeInitFileName();
+        delete [] filename;
+        return true;
+    }
+    delete [] filename;
+    setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError, qt_error_string(errno));
+    return false;
+#else
+    if (!_gettemp(filename, 0, 0, suffixLength)) {
+        delete [] filename;
+        return false;
+    }
+
+    d->filePath = QString::fromLocal8Bit(filename);
+    d->nativeInitFileName();
+    d->closeFileHandle = true;
+    delete [] filename;
+    return QFSFileEngine::open(openMode);
+#endif
+}
+
+bool QTemporaryFileEngine::remove()
+{
+    Q_D(QFSFileEngine);
+    // Since the QTemporaryFileEngine::close() does not really close the file,
+    // we must explicitly call QFSFileEngine::close() before we remove it.
+    QFSFileEngine::close();
+    bool removed = QFSFileEngine::remove();
+    d->filePath.clear();
+    return removed;
+}
+
+bool QTemporaryFileEngine::close()
+{
+    // Don't close the file, just seek to the front.
+    seek(0);
+    setError(QFile::UnspecifiedError, QString());
+    return true;
+}
+
+//************* QTemporaryFilePrivate
+class QTemporaryFilePrivate : public QFilePrivate
+{
+    Q_DECLARE_PUBLIC(QTemporaryFile)
+
+protected:
+    QTemporaryFilePrivate();
+    ~QTemporaryFilePrivate();
+
+    bool autoRemove;
+    QString templateName;
+    mutable QTemporaryFileEngine *fileEngine;
+};
+
+QTemporaryFilePrivate::QTemporaryFilePrivate() : autoRemove(true), fileEngine(0)
+{
+}
+
+QTemporaryFilePrivate::~QTemporaryFilePrivate()
+{
+    delete fileEngine;
+    fileEngine = 0;
+}
+
+//************* QTemporaryFile
+
+/*!
+    \class QTemporaryFile
+    \reentrant
+    \brief The QTemporaryFile class is an I/O device that operates on temporary files.
+
+    \ingroup io
+    \mainclass
+
+    QTemporaryFile is used to create unique temporary files safely.
+    The file itself is created by calling open(). The name of the
+    temporary file is guaranteed to be unique (i.e., you are
+    guaranteed to not overwrite an existing file), and the file will
+    subsequently be removed upon destruction of the QTemporaryFile
+    object. This is an important technique that avoids data
+    corruption for applications that store data in temporary files.
+    The file name is either auto-generated, or created based on a
+    template, which is passed to QTemporaryFile's constructor.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtemporaryfile.cpp 0
+
+    Reopening a QTemporaryFile after calling close() is safe. For as long as
+    the QTemporaryFile object itself is not destroyed, the unique temporary
+    file will exist and be kept open internally by QTemporaryFile.
+
+    The file name of the temporary file can be found by calling fileName().
+    Note that this is only defined while the file is open; the function returns
+    an empty string before the file is opened and after it is closed.
+
+    A temporary file will have some static part of the name and some
+    part that is calculated to be unique. The default filename \c
+    qt_temp will be placed into the temporary path as returned by
+    QDir::tempPath(). If you specify your own filename, a relative
+    file path will not be placed in the temporary directory by
+    default, but be relative to the current working directory.
+
+    Specified filenames can contain the following template \c XXXXXX
+    (six upper case "X" characters), which will be replaced by the
+    auto-generated portion of the filename. Note that the template is
+    case sensitive. If the template is not present in the filename,
+    QTemporaryFile appends the generated part to the filename given.
+
+    \sa QDir::tempPath(), QFile
+*/
+
+#ifdef QT_NO_QOBJECT
+QTemporaryFile::QTemporaryFile()
+    : QFile(*new QTemporaryFilePrivate)
+{
+    Q_D(QTemporaryFile);
+    d->templateName = QDir::tempPath() + QLatin1String("/qt_temp.XXXXXX");
+}
+
+QTemporaryFile::QTemporaryFile(const QString &templateName)
+    : QFile(*new QTemporaryFilePrivate)
+{
+    Q_D(QTemporaryFile);
+    d->templateName = templateName;
+}
+
+#else
+/*!
+    Constructs a QTemporaryFile in QDir::tempPath(), using the file template
+    "qt_temp.XXXXXX". The file is stored in the system's temporary directory.
+
+    \sa setFileTemplate(), QDir::tempPath()
+*/
+QTemporaryFile::QTemporaryFile()
+    : QFile(*new QTemporaryFilePrivate, 0)
+{
+    Q_D(QTemporaryFile);
+    d->templateName = QDir::tempPath() + QLatin1String("/qt_temp.XXXXXX");
+}
+
+/*!
+    Constructs a QTemporaryFile with a template filename of \a
+    templateName. Upon opening the temporary file this will be used to create
+    a unique filename.
+
+    If the \a templateName does not contain XXXXXX it will automatically be
+    appended and used as the dynamic portion of the filename.
+
+    If \a templateName is a relative path, the path will be relative to the
+    current working directory. You can use QDir::tempPath() to construct \a
+    templateName if you want use the system's temporary directory.
+
+    \sa open(), fileTemplate()
+*/
+QTemporaryFile::QTemporaryFile(const QString &templateName)
+    : QFile(*new QTemporaryFilePrivate, 0)
+{
+    setFileTemplate(templateName);
+}
+
+/*!
+    Constructs a QTemporaryFile (with the given \a parent) in
+    QDir::tempPath(), using the file template "qt_temp.XXXXXX".
+
+    \sa setFileTemplate()
+*/
+QTemporaryFile::QTemporaryFile(QObject *parent)
+    : QFile(*new QTemporaryFilePrivate, parent)
+{
+    Q_D(QTemporaryFile);
+    d->templateName = QDir::tempPath() + QLatin1String("/qt_temp.XXXXXX");
+}
+
+/*!
+    Constructs a QTemporaryFile with a template filename of \a
+    templateName and the specified \a parent.
+    Upon opening the temporary file this will be used to
+    create a unique filename.
+
+    If the \a templateName does not contain XXXXXX it will automatically be
+    appended and used as the dynamic portion of the filename.
+
+    If \a templateName is a relative path, the path will be relative to the
+    current working directory. You can use QDir::tempPath() to construct \a
+    templateName if you want use the system's temporary directory.
+
+    \sa open(), fileTemplate()
+*/
+QTemporaryFile::QTemporaryFile(const QString &templateName, QObject *parent)
+    : QFile(*new QTemporaryFilePrivate, parent)
+{
+    setFileTemplate(templateName);
+}
+#endif
+
+/*!
+    Destroys the temporary file object, the file is automatically
+    closed if necessary and if in auto remove mode it will
+    automatically delete the file.
+
+    \sa autoRemove()
+*/
+QTemporaryFile::~QTemporaryFile()
+{
+    Q_D(QTemporaryFile);
+    close();
+    if (!d->fileName.isEmpty() && d->autoRemove)
+        remove();
+}
+
+/*!
+  \fn bool QTemporaryFile::open()
+
+  A QTemporaryFile will always be opened in QIODevice::ReadWrite mode,
+  this allows easy access to the data in the file. This function will
+  return true upon success and will set the fileName() to the unique
+  filename used.
+
+  \sa fileName()
+*/
+
+/*!
+   Returns true if the QTemporaryFile is in auto remove
+   mode. Auto-remove mode will automatically delete the filename from
+   disk upon destruction. This makes it very easy to create your
+   QTemporaryFile object on the stack, fill it with data, read from
+   it, and finally on function return it will automatically clean up
+   after itself.
+
+   Auto-remove is on by default.
+
+   \sa setAutoRemove(), remove()
+*/
+bool QTemporaryFile::autoRemove() const
+{
+    Q_D(const QTemporaryFile);
+    return d->autoRemove;
+}
+
+/*!
+    Sets the QTemporaryFile into auto-remove mode if \a b is true.
+
+    Auto-remove is on by default.
+
+    \sa autoRemove(), remove()
+*/
+void QTemporaryFile::setAutoRemove(bool b)
+{
+    Q_D(QTemporaryFile);
+    d->autoRemove = b;
+}
+
+/*!
+   Returns the complete unique filename backing the QTemporaryFile
+   object. This string is null before the QTemporaryFile is opened,
+   afterwards it will contain the fileTemplate() plus
+   additional characters to make it unique.
+
+   \sa fileTemplate()
+*/
+
+QString QTemporaryFile::fileName() const
+{
+    if(!isOpen())
+        return QString();
+    return fileEngine()->fileName(QAbstractFileEngine::DefaultName);
+}
+
+/*!
+  Returns the set file template. The default file template will be
+  called qt_temp and be placed in QDir::tempPath().
+
+  \sa setFileTemplate()
+*/
+QString QTemporaryFile::fileTemplate() const
+{
+    Q_D(const QTemporaryFile);
+    return d->templateName;
+}
+
+/*!
+   Sets the static portion of the file name to \a name. If the file
+   template ends in XXXXXX that will automatically be replaced with
+   the unique part of the filename, otherwise a filename will be
+   determined automatically based on the static portion specified.
+
+    If \a name contains a relative file path, the path will be relative to the
+    current working directory. You can use QDir::tempPath() to construct \a
+    name if you want use the system's temporary directory.
+
+   \sa fileTemplate()
+*/
+void QTemporaryFile::setFileTemplate(const QString &name)
+{
+    Q_ASSERT(!isOpen());
+    Q_D(QTemporaryFile);
+    fileEngine()->setFileName(name);
+    d->templateName = name;
+}
+
+/*!
+  \fn QTemporaryFile *QTemporaryFile::createLocalFile(const QString &fileName)
+  \overload
+
+  Works on the given \a fileName rather than an existing QFile
+  object.
+*/
+
+
+/*!
+  If \a file is not on a local disk, a temporary file is created
+  on a local disk, \a file is copied into the temporary local file,
+  and a pointer to the temporary local file is returned. If \a file
+  is already on a local disk, a copy is not created and 0 is returned.
+*/
+QTemporaryFile *QTemporaryFile::createLocalFile(QFile &file)
+{
+    if (QAbstractFileEngine *engine = file.fileEngine()) {
+        if(engine->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::LocalDiskFlag)
+            return 0; //local already
+        //cache
+        bool wasOpen = file.isOpen();
+        qint64 old_off = 0;
+        if(wasOpen)
+            old_off = file.pos();
+        else
+            file.open(QIODevice::ReadOnly);
+        //dump data
+        QTemporaryFile *ret = new QTemporaryFile;
+        ret->open();
+        file.seek(0);
+        char buffer[1024];
+        while(true) {
+            qint64 len = file.read(buffer, 1024);
+            if(len < 1)
+                break;
+            ret->write(buffer, len);
+        }
+        ret->seek(0);
+        //restore
+        if(wasOpen)
+            file.seek(old_off);
+        else
+            file.close();
+        //done
+        return ret;
+    }
+    return 0;
+}
+
+/*!
+   \internal
+*/
+
+QAbstractFileEngine *QTemporaryFile::fileEngine() const
+{
+    Q_D(const QTemporaryFile);
+    if(!d->fileEngine)
+        d->fileEngine = new QTemporaryFileEngine(d->templateName);
+    return d->fileEngine;
+}
+
+/*!
+   \reimp
+
+    Creates a unique file name for the temporary file, and opens it.  You can
+    get the unique name later by calling fileName(). The file is guaranteed to
+    have been created by this function (i.e., it has never existed before).
+*/
+bool QTemporaryFile::open(OpenMode flags)
+{
+    Q_D(QTemporaryFile);
+    if (!d->fileName.isEmpty()) {
+        setOpenMode(flags);
+        return true;
+    }
+
+    if (QFile::open(flags)) {
+        d->fileName = d->fileEngine->fileName(QAbstractFileEngine::DefaultName);
+        return true;
+    }
+    return false;
+}
+
+#endif // QT_NO_TEMPORARYFILE
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qtemporaryfile.h b/src/corelib/io/qtemporaryfile.h
new file mode 100644
index 0000000..4c3eb9a
--- /dev/null
+++ b/src/corelib/io/qtemporaryfile.h
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTEMPORARYFILE_H
+#define QTEMPORARYFILE_H
+
+#include <QtCore/qiodevice.h>
+#include <QtCore/qfile.h>
+
+#ifdef open
+#error qtemporaryfile.h must be included before any header file that defines open
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_TEMPORARYFILE
+
+class QTemporaryFilePrivate;
+
+class Q_CORE_EXPORT QTemporaryFile : public QFile
+{
+#ifndef QT_NO_QOBJECT
+    Q_OBJECT
+#endif
+    Q_DECLARE_PRIVATE(QTemporaryFile)
+
+public:
+    QTemporaryFile();
+    explicit QTemporaryFile(const QString &templateName);
+#ifndef QT_NO_QOBJECT
+    explicit QTemporaryFile(QObject *parent);
+    QTemporaryFile(const QString &templateName, QObject *parent);
+#endif
+    ~QTemporaryFile();
+
+    bool autoRemove() const;
+    void setAutoRemove(bool b);
+
+    // ### Hides open(flags)
+    bool open() { return open(QIODevice::ReadWrite); }
+
+    QString fileName() const;
+    QString fileTemplate() const;
+    void setFileTemplate(const QString &name);
+
+    inline static QTemporaryFile *createLocalFile(const QString &fileName)
+        { QFile file(fileName); return createLocalFile(file); }
+    static QTemporaryFile *createLocalFile(QFile &file);
+
+    virtual QAbstractFileEngine *fileEngine() const;
+
+protected:
+    bool open(OpenMode flags);
+
+private:
+    friend class QFile;
+    Q_DISABLE_COPY(QTemporaryFile)
+};
+
+#endif // QT_NO_TEMPORARYFILE
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QTEMPORARYFILE_H
diff --git a/src/corelib/io/qtextstream.cpp b/src/corelib/io/qtextstream.cpp
new file mode 100644
index 0000000..512332e
--- /dev/null
+++ b/src/corelib/io/qtextstream.cpp
@@ -0,0 +1,3387 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+//#define QTEXTSTREAM_DEBUG
+static const int QTEXTSTREAM_BUFFERSIZE = 16384;
+
+/*!
+    \class QTextStream
+
+    \brief The QTextStream class provides a convenient interface for
+    reading and writing text.
+
+    \ingroup io
+    \ingroup text
+    \reentrant
+
+    QTextStream can operate on a QIODevice, a QByteArray or a
+    QString. Using QTextStream's streaming operators, you can
+    conveniently read and write words, lines and numbers. For
+    generating text, QTextStream supports formatting options for field
+    padding and alignment, and formatting of numbers. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 0
+
+    It's also common to use QTextStream to read console input and write
+    console output. QTextStream is locale aware, and will automatically decode
+    standard input using the correct codec. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 1
+
+    Note that you cannot use QTextStream::atEnd(), which returns true when you
+    have reached the end of the data stream, with stdin.
+
+    Besides using QTextStream's constructors, you can also set the
+    device or string QTextStream operates on by calling setDevice() or
+    setString(). You can seek to a position by calling seek(), and
+    atEnd() will return true when there is no data left to be read. If
+    you call flush(), QTextStream will empty all data from its write
+    buffer into the device and call flush() on the device.
+
+    Internally, QTextStream uses a Unicode based buffer, and
+    QTextCodec is used by QTextStream to automatically support
+    different character sets. By default, QTextCodec::codecForLocale()
+    is used for reading and writing, but you can also set the codec by
+    calling setCodec(). Automatic Unicode detection is also
+    supported. When this feature is enabled (the default behavior),
+    QTextStream will detect the UTF-16 or the UTF-32 BOM (Byte Order Mark) and
+    switch to the appropriate UTF codec when reading. QTextStream
+    does not write a BOM by default, but you can enable this by calling
+    setGenerateByteOrderMark(true). When QTextStream operates on a QString
+    directly, the codec is disabled.
+
+    There are three general ways to use QTextStream when reading text
+    files:
+
+    \list
+
+    \o Chunk by chunk, by calling readLine() or readAll().
+
+    \o Word by word. QTextStream supports streaming into QStrings,
+    QByteArrays and char* buffers. Words are delimited by space, and
+    leading white space is automatically skipped.
+
+    \o Character by character, by streaming into QChar or char types.
+    This method is often used for convenient input handling when
+    parsing files, independent of character encoding and end-of-line
+    semantics. To skip white space, call skipWhiteSpace().
+
+    \endlist
+
+    Since the text stream uses a buffer, you should not read from
+    the stream using the implementation of a superclass. For instance,
+    if you have a QFile and read from it directly using
+    QFile::readLine() instead of using the stream, the text stream's
+    internal position will be out of sync with the file's position.
+
+    By default, when reading numbers from a stream of text,
+    QTextStream will automatically detect the number's base
+    representation. For example, if the number starts with "0x", it is
+    assumed to be in hexadecimal form. If it starts with the digits
+    1-9, it is assumed to be in decimal form, and so on. You can set
+    the integer base, thereby disabling the automatic detection, by
+    calling setIntegerBase(). Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 2
+
+    QTextStream supports many formatting options for generating text.
+    You can set the field width and pad character by calling
+    setFieldWidth() and setPadChar(). Use setFieldAlignment() to set
+    the alignment within each field. For real numbers, call
+    setRealNumberNotation() and setRealNumberPrecision() to set the
+    notation (SmartNotation, ScientificNotation, FixedNotation) and precision in
+    digits of the generated number. Some extra number formatting
+    options are also available through setNumberFlags().
+
+    \keyword QTextStream manipulators
+
+    Like \c <iostream> in the standard C++ library, QTextStream also
+    defines several global manipulator functions:
+
+    \table
+    \header \o Manipulator        \o Description
+    \row    \o \c bin             \o Same as setIntegerBase(2).
+    \row    \o \c oct             \o Same as setIntegerBase(8).
+    \row    \o \c dec             \o Same as setIntegerBase(10).
+    \row    \o \c hex             \o Same as setIntegerBase(16).
+    \row    \o \c showbase        \o Same as setNumberFlags(numberFlags() | ShowBase).
+    \row    \o \c forcesign       \o Same as setNumberFlags(numberFlags() | ForceSign).
+    \row    \o \c forcepoint      \o Same as setNumberFlags(numberFlags() | ForcePoint).
+    \row    \o \c noshowbase      \o Same as setNumberFlags(numberFlags() & ~ShowBase).
+    \row    \o \c noforcesign     \o Same as setNumberFlags(numberFlags() & ~ForceSign).
+    \row    \o \c noforcepoint    \o Same as setNumberFlags(numberFlags() & ~ForcePoint).
+    \row    \o \c uppercasebase   \o Same as setNumberFlags(numberFlags() | UppercaseBase).
+    \row    \o \c uppercasedigits \o Same as setNumberFlags(numberFlags() | UppercaseDigits).
+    \row    \o \c lowercasebase   \o Same as setNumberFlags(numberFlags() & ~UppercaseBase).
+    \row    \o \c lowercasedigits \o Same as setNumberFlags(numberFlags() & ~UppercaseDigits).
+    \row    \o \c fixed           \o Same as setRealNumberNotation(FixedNotation).
+    \row    \o \c scientific      \o Same as setRealNumberNotation(ScientificNotation).
+    \row    \o \c left            \o Same as setFieldAlignment(AlignLeft).
+    \row    \o \c right           \o Same as setFieldAlignment(AlignRight).
+    \row    \o \c center          \o Same as setFieldAlignment(AlignCenter).
+    \row    \o \c endl            \o Same as operator<<('\n') and flush().
+    \row    \o \c flush           \o Same as flush().
+    \row    \o \c reset           \o Same as reset().
+    \row    \o \c ws              \o Same as skipWhiteSpace().
+    \row    \o \c bom             \o Same as setGenerateByteOrderMark(true).
+    \endtable
+
+    In addition, Qt provides three global manipulators that take a
+    parameter: qSetFieldWidth(), qSetPadChar(), and
+    qSetRealNumberPrecision().
+
+    \sa QDataStream, QIODevice, QFile, QBuffer, QTcpSocket, {Codecs Example}
+*/
+
+/*! \enum QTextStream::RealNumberNotation
+
+    This enum specifies which notations to use for expressing \c
+    float and \c double as strings.
+
+    \value ScientificNotation Scientific notation (\c{printf()}'s \c %e flag).
+    \value FixedNotation Fixed-point notation (\c{printf()}'s \c %f flag).
+    \value SmartNotation Scientific or fixed-point notation, depending on which makes most sense (\c{printf()}'s \c %g flag).
+
+    \sa setRealNumberNotation()
+*/
+
+/*! \enum QTextStream::FieldAlignment
+
+    This enum specifies how to align text in fields when the field is
+    wider than the text that occupies it.
+
+    \value AlignLeft  Pad on the right side of fields.
+    \value AlignRight  Pad on the left side of fields.
+    \value AlignCenter  Pad on both sides of field.
+    \value AlignAccountingStyle  Same as AlignRight, except that the
+                                 sign of a number is flush left.
+
+    \sa setFieldAlignment()
+*/
+
+/*! \enum QTextStream::NumberFlag
+
+    This enum specifies various flags that can be set to affect the
+    output of integers, \c{float}s, and \c{double}s.
+
+    \value ShowBase  Show the base as a prefix if the base
+                     is 16 ("0x"), 8 ("0"), or 2 ("0b").
+    \value ForcePoint  Always put the decimal separator in numbers, even if
+                       there are no decimals.
+    \value ForceSign  Always put the sign in numbers, even for positive numbers.
+    \value UppercaseBase  Use uppercase versions of base prefixes ("0X", "0B").
+    \value UppercaseDigits  Use uppercase letters for expressing
+                            digits 10 to 35 instead of lowercase.
+
+    \sa setNumberFlags()
+*/
+
+/*! \enum QTextStream::Status
+
+    This enum describes the current status of the text stream.
+
+    \value Ok               The text stream is operating normally.
+    \value ReadPastEnd      The text stream has read past the end of the
+                            data in the underlying device.
+    \value ReadCorruptData  The text stream has read corrupt data.
+
+    \sa status()
+*/
+
+#include "qtextstream.h"
+#include "qbuffer.h"
+#include "qfile.h"
+#include "qnumeric.h"
+#ifndef QT_NO_TEXTCODEC
+#include "qtextcodec.h"
+#endif
+#ifndef Q_OS_WINCE
+#include <locale.h>
+#endif
+#include "private/qlocale_p.h"
+
+#include <stdlib.h>
+#include <new>
+
+#if defined QTEXTSTREAM_DEBUG
+#include <ctype.h>
+
+QT_BEGIN_NAMESPACE
+
+// Returns a human readable representation of the first \a len
+// characters in \a data.
+static QByteArray qt_prettyDebug(const char *data, int len, int maxSize)
+{
+    if (!data) return "(null)";
+    QByteArray out;
+    for (int i = 0; i < len; ++i) {
+        char c = data[i];
+        if (isprint(int(uchar(c)))) {
+            out += c;
+        } else switch (c) {
+        case '\n': out += "\\n"; break;
+        case '\r': out += "\\r"; break;
+        case '\t': out += "\\t"; break;
+        default:
+            QString tmp;
+            tmp.sprintf("\\x%x", (unsigned int)(unsigned char)c);
+            out += tmp.toLatin1();
+        }
+    }
+
+    if (len < maxSize)
+        out += "...";
+
+    return out;
+}
+QT_END_NAMESPACE
+
+#endif
+
+// A precondition macro
+#define Q_VOID
+#define CHECK_VALID_STREAM(x) do { \
+    if (!d->string && !d->device) { \
+        qWarning("QTextStream: No device"); \
+        return x; \
+    } } while (0)
+
+// Base implementations of operator>> for ints and reals
+#define IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(type) do { \
+    Q_D(QTextStream); \
+    CHECK_VALID_STREAM(*this); \
+    qulonglong tmp; \
+    switch (d->getNumber(&tmp)) { \
+    case QTextStreamPrivate::npsOk: \
+        i = (type)tmp; \
+        break; \
+    case QTextStreamPrivate::npsMissingDigit: \
+    case QTextStreamPrivate::npsInvalidPrefix: \
+        i = (type)0; \
+        setStatus(atEnd() ? QTextStream::ReadPastEnd : QTextStream::ReadCorruptData); \
+        break; \
+    } \
+    return *this; } while (0)
+
+#define IMPLEMENT_STREAM_RIGHT_REAL_OPERATOR(type) do { \
+    Q_D(QTextStream); \
+    CHECK_VALID_STREAM(*this); \
+    double tmp; \
+    if (d->getReal(&tmp)) { \
+        f = (type)tmp; \
+    } else { \
+        f = (type)0; \
+        setStatus(atEnd() ? QTextStream::ReadPastEnd : QTextStream::ReadCorruptData); \
+    } \
+    return *this; } while (0)
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_QOBJECT
+class QDeviceClosedNotifier : public QObject
+{
+    Q_OBJECT
+public:
+    inline QDeviceClosedNotifier()
+    { }
+
+    inline void setupDevice(QTextStream *stream, QIODevice *device)
+    {
+        disconnect();
+        if (device)
+            connect(device, SIGNAL(aboutToClose()), this, SLOT(flushStream()));
+        this->stream = stream;
+    }
+
+public slots:
+    inline void flushStream() { stream->flush(); }
+
+private:
+    QTextStream *stream;
+};
+#endif
+
+//-------------------------------------------------------------------
+class QTextStreamPrivate
+{
+    Q_DECLARE_PUBLIC(QTextStream)
+public:
+    QTextStreamPrivate(QTextStream *q_ptr);
+    ~QTextStreamPrivate();
+    void reset();
+
+    // device
+    QIODevice *device;
+#ifndef QT_NO_QOBJECT
+    QDeviceClosedNotifier deviceClosedNotifier;
+#endif
+    bool deleteDevice;
+
+    // string
+    QString *string;
+    int stringOffset;
+    QIODevice::OpenMode stringOpenMode;
+
+#ifndef QT_NO_TEXTCODEC
+    // codec
+    QTextCodec *codec;
+    QTextCodec::ConverterState readConverterState;
+    QTextCodec::ConverterState writeConverterState;
+    QTextCodec::ConverterState *readConverterSavedState;
+    bool autoDetectUnicode;
+#endif
+
+    // i/o
+    enum TokenDelimiter {
+        Space,
+        NotSpace,
+        EndOfLine,
+        EndOfFile
+    };
+
+    bool scan(const QChar **ptr, int *tokenLength,
+              int maxlen, TokenDelimiter delimiter);
+    inline const QChar *readPtr() const;
+    inline void consumeLastToken();
+    inline void consume(int nchars);
+    void saveConverterState(qint64 newPos);
+    void restoreToSavedConverterState();
+    int lastTokenSize;
+
+    // Return value type for getNumber()
+    enum NumberParsingStatus {
+        npsOk,
+        npsMissingDigit,
+        npsInvalidPrefix
+    };
+
+    inline bool write(const QString &data);
+    inline bool getChar(QChar *ch);
+    inline void ungetChar(const QChar &ch);
+    NumberParsingStatus getNumber(qulonglong *l);
+    bool getReal(double *f);
+
+    bool putNumber(qulonglong number, bool negative);
+    inline bool putString(const QString &ch, bool number = false);
+
+    // buffers
+    bool fillReadBuffer(qint64 maxBytes = -1);
+    void resetReadBuffer();
+    bool flushWriteBuffer();
+    QString writeBuffer;
+    QString readBuffer;
+    int readBufferOffset;
+    qint64 readBufferStartDevicePos;
+
+    // streaming parameters
+    int realNumberPrecision;
+    int integerBase;
+    int fieldWidth;
+    QChar padChar;
+    QTextStream::FieldAlignment fieldAlignment;
+    QTextStream::RealNumberNotation realNumberNotation;
+    QTextStream::NumberFlags numberFlags;
+
+    // status
+    QTextStream::Status status;
+
+    QLocale locale;
+
+    QTextStream *q_ptr;
+};
+
+/*! \internal
+*/
+QTextStreamPrivate::QTextStreamPrivate(QTextStream *q_ptr)
+    :
+#ifndef QT_NO_TEXTCODEC
+    readConverterSavedState(0),
+#endif
+    locale(QLocale::C)
+{
+    this->q_ptr = q_ptr;
+    reset();
+}
+
+/*! \internal
+*/
+QTextStreamPrivate::~QTextStreamPrivate()
+{
+    if (deleteDevice) {
+#ifndef QT_NO_QOBJECT
+        device->blockSignals(true);
+#endif
+        delete device;
+    }
+#ifndef QT_NO_TEXTCODEC
+    delete readConverterSavedState;
+#endif
+}
+
+#ifndef QT_NO_TEXTCODEC
+static void resetCodecConverterStateHelper(QTextCodec::ConverterState *state)
+{
+    state->~ConverterState();
+    new (state) QTextCodec::ConverterState;
+}
+
+static void copyConverterStateHelper(QTextCodec::ConverterState *dest,
+    const QTextCodec::ConverterState *src)
+{
+    // ### QTextCodec::ConverterState's copy constructors and assignments are
+    // private. This function copies the structure manually.
+    Q_ASSERT(!src->d);
+    dest->flags = src->flags;
+    dest->invalidChars = src->invalidChars;
+    dest->state_data[0] = src->state_data[0];
+    dest->state_data[1] = src->state_data[1];
+    dest->state_data[2] = src->state_data[2];
+}
+#endif
+
+/*! \internal
+*/
+void QTextStreamPrivate::reset()
+{
+    realNumberPrecision = 6;
+    integerBase = 0;
+    fieldWidth = 0;
+    padChar = QLatin1Char(' ');
+    fieldAlignment = QTextStream::AlignRight;
+    realNumberNotation = QTextStream::SmartNotation;
+    numberFlags = 0;
+
+    device = 0;
+    deleteDevice = false;
+    string = 0;
+    stringOffset = 0;
+    stringOpenMode = QIODevice::NotOpen;
+
+    readBufferOffset = 0;
+    readBufferStartDevicePos = 0;
+    lastTokenSize = 0;
+
+#ifndef QT_NO_TEXTCODEC
+    codec = QTextCodec::codecForLocale();
+    resetCodecConverterStateHelper(&readConverterState);
+    resetCodecConverterStateHelper(&writeConverterState);
+    delete readConverterSavedState;
+    readConverterSavedState = 0;
+    writeConverterState.flags |= QTextCodec::IgnoreHeader;
+    autoDetectUnicode = true;
+#endif
+}
+
+/*! \internal
+*/
+bool QTextStreamPrivate::fillReadBuffer(qint64 maxBytes)
+{
+    // no buffer next to the QString itself; this function should only
+    // be called internally, for devices.
+    Q_ASSERT(!string);
+    Q_ASSERT(device);
+
+    // handle text translation and bypass the Text flag in the device.
+    bool textModeEnabled = device->isTextModeEnabled();
+    if (textModeEnabled)
+        device->setTextModeEnabled(false);
+
+    // read raw data into a temporary buffer
+    char buf[QTEXTSTREAM_BUFFERSIZE];
+    qint64 bytesRead = 0;
+#if defined(Q_OS_WIN)
+    // On Windows, there is no non-blocking stdin - so we fall back to reading
+    // lines instead. If there is no QOBJECT, we read lines for all sequential
+    // devices; otherwise, we read lines only for stdin.
+    QFile *file = 0;
+    Q_UNUSED(file);
+    if (device->isSequential()
+#if !defined(QT_NO_QOBJECT)
+        && (file = qobject_cast<QFile *>(device)) && file->handle() == 0
+#endif
+        ) {
+        if (maxBytes != -1)
+            bytesRead = device->readLine(buf, qMin<qint64>(sizeof(buf), maxBytes));
+        else
+            bytesRead = device->readLine(buf, sizeof(buf));
+    } else
+#endif
+    {
+        if (maxBytes != -1)
+            bytesRead = device->read(buf, qMin<qint64>(sizeof(buf), maxBytes));
+        else
+            bytesRead = device->read(buf, sizeof(buf));
+    }
+
+#ifndef QT_NO_TEXTCODEC
+    // codec auto detection, explicitly defaults to locale encoding if the
+    // codec has been set to 0.
+    if (!codec || autoDetectUnicode) {
+        autoDetectUnicode = false;
+
+        if (bytesRead >= 4 && ((uchar(buf[0]) == 0xff && uchar(buf[1]) == 0xfe && uchar(buf[2]) == 0 && uchar(buf[3]) == 0)
+                               || (uchar(buf[0]) == 0 && uchar(buf[1]) == 0 && uchar(buf[2]) == 0xfe && uchar(buf[3]) == 0xff))) {
+            codec = QTextCodec::codecForName("UTF-32");
+        } else if (bytesRead >= 2 && ((uchar(buf[0]) == 0xff && uchar(buf[1]) == 0xfe)
+                                      || (uchar(buf[0]) == 0xfe && uchar(buf[1]) == 0xff))) {
+            codec = QTextCodec::codecForName("UTF-16");
+        } else if (!codec) {
+            codec = QTextCodec::codecForLocale();
+            writeConverterState.flags |= QTextCodec::IgnoreHeader;
+        }
+    }
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::fillReadBuffer(), using %s codec",
+           codec->name().constData());
+#endif
+#endif
+
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::fillReadBuffer(), device->read(\"%s\", %d) == %d",
+           qt_prettyDebug(buf, qMin(32,int(bytesRead)) , int(bytesRead)).constData(), sizeof(buf), int(bytesRead));
+#endif
+
+    if (bytesRead <= 0)
+        return false;
+
+    int oldReadBufferSize = readBuffer.size();
+#ifndef QT_NO_TEXTCODEC
+    // convert to unicode
+    readBuffer += codec->toUnicode(buf, bytesRead, &readConverterState);
+#else
+    readBuffer += QString::fromLatin1(QByteArray(buf, bytesRead).constData());
+#endif
+
+    // reset the Text flag.
+    if (textModeEnabled)
+        device->setTextModeEnabled(true);
+
+    // remove all '\r\n' in the string.
+    if (readBuffer.size() > oldReadBufferSize && textModeEnabled) {
+        QChar CR = QLatin1Char('\r');
+        QChar *writePtr = readBuffer.data() + oldReadBufferSize;
+        QChar *readPtr = readBuffer.data() + oldReadBufferSize;
+        QChar *endPtr = readBuffer.data() + readBuffer.size();
+
+        int n = oldReadBufferSize;
+        if (readPtr < endPtr) {
+            // Cut-off to avoid unnecessary self-copying.
+            while (*readPtr++ != CR) {
+                ++n;
+                if (++writePtr == endPtr)
+                    break;
+            }
+        }
+        while (readPtr < endPtr) {
+            QChar ch = *readPtr++;
+            if (ch != CR) {
+                *writePtr++ = ch;
+            } else {
+                if (n < readBufferOffset)
+                    --readBufferOffset;
+                --bytesRead;
+            }
+            ++n;
+        }
+        readBuffer.resize(writePtr - readBuffer.data());
+    }
+
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::fillReadBuffer() read %d bytes from device. readBuffer = [%s]", int(bytesRead),
+           qt_prettyDebug(readBuffer.toLatin1(), readBuffer.size(), readBuffer.size()).data());
+#endif
+    return true;
+}
+
+/*! \internal
+*/
+void QTextStreamPrivate::resetReadBuffer()
+{
+    readBuffer.clear();
+    readBufferOffset = 0;
+    readBufferStartDevicePos = (device ? device->pos() : 0);
+}
+
+/*! \internal
+*/
+bool QTextStreamPrivate::flushWriteBuffer()
+{
+    // no buffer next to the QString itself; this function should only
+    // be called internally, for devices.
+    if (string || !device)
+        return false;
+    if (writeBuffer.isEmpty())
+        return true;
+
+#if defined (Q_OS_WIN)
+    // handle text translation and bypass the Text flag in the device.
+    bool textModeEnabled = device->isTextModeEnabled();
+    if (textModeEnabled) {
+        device->setTextModeEnabled(false);
+        writeBuffer.replace(QLatin1Char('\n'), QLatin1String("\r\n"));
+    }
+#endif
+
+#ifndef QT_NO_TEXTCODEC
+    if (!codec)
+        codec = QTextCodec::codecForLocale();
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::flushWriteBuffer(), using %s codec (%s generating BOM)",
+           codec->name().constData(), writeConverterState.flags & QTextCodec::IgnoreHeader ? "not" : "");
+#endif
+
+    // convert from unicode to raw data
+    QByteArray data = codec->fromUnicode(writeBuffer.data(), writeBuffer.size(), &writeConverterState);
+#else
+    QByteArray data = writeBuffer.toLocal8Bit();
+#endif
+    writeBuffer.clear();
+
+    // write raw data to the device
+    qint64 bytesWritten = device->write(data);
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::flushWriteBuffer(), device->write(\"%s\") == %d",
+           qt_prettyDebug(data.constData(), qMin(data.size(),32), data.size()).constData(), int(bytesWritten));
+#endif
+    if (bytesWritten <= 0)
+        return false;
+
+#if defined (Q_OS_WIN)
+    // replace the text flag
+    if (textModeEnabled)
+        device->setTextModeEnabled(true);
+#endif
+
+    // flush the file
+#ifndef QT_NO_QOBJECT
+    QFile *file = qobject_cast<QFile *>(device);
+    bool flushed = file && file->flush();
+#else
+    bool flushed = true;
+#endif
+
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::flushWriteBuffer() wrote %d bytes",
+           int(bytesWritten));
+#endif
+    return flushed && bytesWritten == qint64(data.size());
+}
+
+/*! \internal
+
+    Scans no more than \a maxlen QChars in the current buffer for the
+    first \a delimiter. Stores a pointer to the start offset of the
+    token in \a ptr, and the length in QChars in \a length.
+*/
+bool QTextStreamPrivate::scan(const QChar **ptr, int *length, int maxlen, TokenDelimiter delimiter)
+{
+    int totalSize = 0;
+    int delimSize = 0;
+    bool consumeDelimiter = false;
+    bool foundToken = false;
+    int startOffset = device ? readBufferOffset : stringOffset;
+    QChar lastChar;
+
+    bool canStillReadFromDevice = true;
+    do {
+        int endOffset;
+        const QChar *chPtr;
+        if (device) {
+            chPtr = readBuffer.constData();
+            endOffset = readBuffer.size();
+        } else {
+            chPtr = string->constData();
+            endOffset = string->size();
+        }
+        chPtr += startOffset;
+
+        for (; !foundToken && startOffset < endOffset && (!maxlen || totalSize < maxlen); ++startOffset) {
+            const QChar ch = *chPtr++;
+            ++totalSize;
+
+            if (delimiter == Space && ch.isSpace()) {
+                foundToken = true;
+                delimSize = 1;
+            } else if (delimiter == NotSpace && !ch.isSpace()) {
+                foundToken = true;
+                delimSize = 1;
+            } else if (delimiter == EndOfLine && ch == QLatin1Char('\n')) {
+                foundToken = true;
+                delimSize = (lastChar == QLatin1Char('\r')) ? 2 : 1;
+                consumeDelimiter = true;
+            }
+
+            lastChar = ch;
+        }
+    } while (!foundToken
+             && (!maxlen || totalSize < maxlen)
+             && (device && (canStillReadFromDevice = fillReadBuffer())));
+
+    // if the token was not found, but we reached the end of input,
+    // then we accept what we got. if we are not at the end of input,
+    // we return false.
+    if (!foundToken && (!maxlen || totalSize < maxlen)
+        && (totalSize == 0
+            || (string && stringOffset + totalSize < string->size())
+            || (device && !device->atEnd() && canStillReadFromDevice))) {
+#if defined (QTEXTSTREAM_DEBUG)
+        qDebug("QTextStreamPrivate::scan() did not find the token.");
+#endif
+        return false;
+    }
+
+    // if we find a '\r' at the end of the data when reading lines,
+    // don't make it part of the line.
+    if (totalSize > 0 && !foundToken && delimiter == EndOfLine) {
+        if (((string && stringOffset + totalSize == string->size()) || (device && device->atEnd()))
+            && lastChar == QLatin1Char('\r')) {
+            consumeDelimiter = true;
+            ++delimSize;
+        }
+    }
+
+    // set the read offset and length of the token
+    if (length)
+        *length = totalSize - delimSize;
+    if (ptr)
+        *ptr = readPtr();
+
+    // update last token size. the callee will call consumeLastToken() when
+    // done.
+    lastTokenSize = totalSize;
+    if (!consumeDelimiter)
+        lastTokenSize -= delimSize;
+
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::scan(%p, %p, %d, %x) token length = %d, delimiter = %d",
+           ptr, length, maxlen, (int)delimiter, totalSize - delimSize, delimSize);
+#endif
+    return true;
+}
+
+/*! \internal
+*/
+inline const QChar *QTextStreamPrivate::readPtr() const
+{
+    Q_ASSERT(readBufferOffset <= readBuffer.size());
+    if (string)
+        return string->constData() + stringOffset;
+    return readBuffer.constData() + readBufferOffset;
+}
+
+/*! \internal
+*/
+inline void QTextStreamPrivate::consumeLastToken()
+{
+    if (lastTokenSize)
+        consume(lastTokenSize);
+    lastTokenSize = 0;
+}
+
+/*! \internal
+*/
+inline void QTextStreamPrivate::consume(int size)
+{
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStreamPrivate::consume(%d)", size);
+#endif
+    if (string) {
+        stringOffset += size;
+        if (stringOffset > string->size())
+            stringOffset = string->size();
+    } else {
+        readBufferOffset += size;
+        if (readBufferOffset >= readBuffer.size()) {
+            readBufferOffset = 0;
+            readBuffer.clear();
+            saveConverterState(device->pos());
+        }
+    }
+}
+
+/*! \internal
+*/
+inline void QTextStreamPrivate::saveConverterState(qint64 newPos)
+{
+#ifndef QT_NO_TEXTCODEC
+    if (readConverterState.d) {
+        // converter cannot be copied, so don't save anything
+        // don't update readBufferStartDevicePos either
+        return;
+    }
+
+    if (!readConverterSavedState)
+        readConverterSavedState = new QTextCodec::ConverterState;
+    copyConverterStateHelper(readConverterSavedState, &readConverterState);
+#endif
+
+    readBufferStartDevicePos = newPos;
+}
+
+/*! \internal
+*/
+inline void QTextStreamPrivate::restoreToSavedConverterState()
+{
+#ifndef QT_NO_TEXTCODEC
+    if (readConverterSavedState) {
+        // we have a saved state
+        // that means the converter can be copied
+        copyConverterStateHelper(&readConverterState, readConverterSavedState);
+    } else {
+        // the only state we could save was the initial
+        // so reset to that
+        resetCodecConverterStateHelper(&readConverterState);
+    }
+#endif
+}
+
+/*! \internal
+*/
+inline bool QTextStreamPrivate::write(const QString &data)
+{
+    if (string) {
+        // ### What about seek()??
+        string->append(data);
+    } else {
+        writeBuffer += data;
+        if (writeBuffer.size() > QTEXTSTREAM_BUFFERSIZE)
+            return flushWriteBuffer();
+    }
+    return true;
+}
+
+/*! \internal
+*/
+inline bool QTextStreamPrivate::getChar(QChar *ch)
+{
+    if ((string && stringOffset == string->size())
+        || (device && readBuffer.isEmpty() && !fillReadBuffer())) {
+        if (ch)
+            *ch = 0;
+        return false;
+    }
+    if (ch)
+        *ch = *readPtr();
+    consume(1);
+    return true;
+}
+
+/*! \internal
+*/
+inline void QTextStreamPrivate::ungetChar(const QChar &ch)
+{
+    if (string) {
+        if (stringOffset == 0)
+            string->prepend(ch);
+        else
+            (*string)[--stringOffset] = ch;
+        return;
+    }
+
+    if (readBufferOffset == 0) {
+        readBuffer.prepend(ch);
+        return;
+    }
+
+    readBuffer[--readBufferOffset] = ch;
+}
+
+/*! \internal
+*/
+inline bool QTextStreamPrivate::putString(const QString &s, bool number)
+{
+    QString tmp = s;
+
+    // handle padding
+    int padSize = fieldWidth - s.size();
+    if (padSize > 0) {
+        QString pad(padSize > 0 ? padSize : 0, padChar);
+        if (fieldAlignment == QTextStream::AlignLeft) {
+            tmp.append(QString(padSize, padChar));
+        } else if (fieldAlignment == QTextStream::AlignRight
+                   || fieldAlignment == QTextStream::AlignAccountingStyle) {
+            tmp.prepend(QString(padSize, padChar));
+            if (fieldAlignment == QTextStream::AlignAccountingStyle && number) {
+                const QChar sign = s.size() > 0 ? s.at(0) : QChar();
+                if (sign == locale.negativeSign() || sign == locale.positiveSign()) {
+                    QChar *data = tmp.data();
+                    data[padSize] = tmp.at(0);
+                    data[0] = sign;
+                }
+           }
+        } else if (fieldAlignment == QTextStream::AlignCenter) {
+            tmp.prepend(QString(padSize/2, padChar));
+            tmp.append(QString(padSize - padSize/2, padChar));
+        }
+    }
+
+#if defined (QTEXTSTREAM_DEBUG)
+    QByteArray a = s.toUtf8();
+    QByteArray b = tmp.toUtf8();
+    qDebug("QTextStreamPrivate::putString(\"%s\") calls write(\"%s\")",
+           qt_prettyDebug(a.constData(), a.size(), qMax(16, a.size())).constData(),
+           qt_prettyDebug(b.constData(), b.size(), qMax(16, b.size())).constData());
+#endif
+    return write(tmp);
+}
+
+/*!
+    Constructs a QTextStream. Before you can use it for reading or
+    writing, you must assign a device or a string.
+
+    \sa setDevice(), setString()
+*/
+QTextStream::QTextStream()
+    : d_ptr(new QTextStreamPrivate(this))
+{
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStream::QTextStream()");
+#endif
+    Q_D(QTextStream);
+    d->status = Ok;
+}
+
+/*!
+    Constructs a QTextStream that operates on \a device.
+*/
+QTextStream::QTextStream(QIODevice *device)
+    : d_ptr(new QTextStreamPrivate(this))
+{
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStream::QTextStream(QIODevice *device == *%p)",
+           device);
+#endif
+    Q_D(QTextStream);
+    d->device = device;
+#ifndef QT_NO_QOBJECT
+    d->deviceClosedNotifier.setupDevice(this, d->device);
+#endif
+    d->status = Ok;
+}
+
+/*!
+    Constructs a QTextStream that operates on \a string, using \a
+    openMode to define the open mode.
+*/
+QTextStream::QTextStream(QString *string, QIODevice::OpenMode openMode)
+    : d_ptr(new QTextStreamPrivate(this))
+{
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStream::QTextStream(QString *string == *%p, openMode = %d)",
+           string, int(openMode));
+#endif
+    Q_D(QTextStream);
+    d->string = string;
+    d->stringOpenMode = openMode;
+    d->status = Ok;
+}
+
+/*!
+    Constructs a QTextStream that operates on \a array, using \a
+    openMode to define the open mode. Internally, the array is wrapped
+    by a QBuffer.
+*/
+QTextStream::QTextStream(QByteArray *array, QIODevice::OpenMode openMode)
+    : d_ptr(new QTextStreamPrivate(this))
+{
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStream::QTextStream(QByteArray *array == *%p, openMode = %d)",
+           array, int(openMode));
+#endif
+    Q_D(QTextStream);
+    d->device = new QBuffer(array);
+    d->device->open(openMode);
+    d->deleteDevice = true;
+#ifndef QT_NO_QOBJECT
+    d->deviceClosedNotifier.setupDevice(this, d->device);
+#endif
+    d->status = Ok;
+}
+
+/*!
+    Constructs a QTextStream that operates on \a array, using \a
+    openMode to define the open mode. The array is accessed as
+    read-only, regardless of the values in \a openMode.
+
+    This constructor is convenient for working on constant
+    strings. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 3
+*/
+QTextStream::QTextStream(const QByteArray &array, QIODevice::OpenMode openMode)
+    : d_ptr(new QTextStreamPrivate(this))
+{
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStream::QTextStream(const QByteArray &array == *(%p), openMode = %d)",
+           &array, int(openMode));
+#endif
+    QBuffer *buffer = new QBuffer;
+    buffer->setData(array);
+    buffer->open(openMode);
+
+    Q_D(QTextStream);
+    d->device = buffer;
+    d->deleteDevice = true;
+#ifndef QT_NO_QOBJECT
+    d->deviceClosedNotifier.setupDevice(this, d->device);
+#endif
+    d->status = Ok;
+}
+
+/*!
+    Constructs a QTextStream that operates on \a fileHandle, using \a
+    openMode to define the open mode. Internally, a QFile is created
+    to handle the FILE pointer.
+
+    This constructor is useful for working directly with the common
+    FILE based input and output streams: stdin, stdout and stderr. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 4
+*/
+
+QTextStream::QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode)
+    : d_ptr(new QTextStreamPrivate(this))
+{
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStream::QTextStream(FILE *fileHandle = %p, openMode = %d)",
+           fileHandle, int(openMode));
+#endif
+    QFile *file = new QFile;
+    file->open(fileHandle, openMode);
+
+    Q_D(QTextStream);
+    d->device = file;
+    d->deleteDevice = true;
+#ifndef QT_NO_QOBJECT
+    d->deviceClosedNotifier.setupDevice(this, d->device);
+#endif
+    d->status = Ok;
+}
+
+/*!
+    Destroys the QTextStream.
+
+    If the stream operates on a device, flush() will be called
+    implicitly. Otherwise, the device is unaffected.
+*/
+QTextStream::~QTextStream()
+{
+    Q_D(QTextStream);
+#if defined (QTEXTSTREAM_DEBUG)
+    qDebug("QTextStream::~QTextStream()");
+#endif
+    if (!d->writeBuffer.isEmpty())
+        d->flushWriteBuffer();
+
+    delete d;
+    d_ptr = 0;
+}
+
+/*!
+    Resets QTextStream's formatting options, bringing it back to its
+    original constructed state. The device, string and any buffered
+    data is left untouched.
+*/
+void QTextStream::reset()
+{
+    Q_D(QTextStream);
+
+    d->realNumberPrecision = 6;
+    d->integerBase = 0;
+    d->fieldWidth = 0;
+    d->padChar = QLatin1Char(' ');
+    d->fieldAlignment = QTextStream::AlignRight;
+    d->realNumberNotation = QTextStream::SmartNotation;
+    d->numberFlags = 0;
+}
+
+/*!
+    Flushes any buffered data waiting to be written to the device.
+
+    If QTextStream operates on a string, this function does nothing.
+*/
+void QTextStream::flush()
+{
+    Q_D(QTextStream);
+    d->flushWriteBuffer();
+}
+
+/*!
+    Seeks to the position \a pos in the device. Returns true on
+    success; otherwise returns false.
+*/
+bool QTextStream::seek(qint64 pos)
+{
+    Q_D(QTextStream);
+    d->lastTokenSize = 0;
+
+    if (d->device) {
+        // Empty the write buffer
+        d->flushWriteBuffer();
+        if (!d->device->seek(pos))
+            return false;
+        d->resetReadBuffer();
+
+#ifndef QT_NO_TEXTCODEC
+        // Reset the codec converter states.
+        resetCodecConverterStateHelper(&d->readConverterState);
+        resetCodecConverterStateHelper(&d->writeConverterState);
+        delete d->readConverterSavedState;
+        d->readConverterSavedState = 0;
+#endif
+        return true;
+    }
+
+    // string
+    if (d->string && pos <= d->string->size()) {
+        d->stringOffset = int(pos);
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \since 4.2
+
+    Returns the device position corresponding to the current position of the
+    stream, or -1 if an error occurs (e.g., if there is no device or string,
+    or if there's a device error).
+
+    Because QTextStream is buffered, this function may have to
+    seek the device to reconstruct a valid device position. This
+    operation can be expensive, so you may want to avoid calling this
+    function in a tight loop.
+
+    \sa seek()
+*/
+qint64 QTextStream::pos() const
+{
+    Q_D(const QTextStream);
+    if (d->device) {
+        // Cutoff
+        if (d->readBuffer.isEmpty())
+            return d->device->pos();
+        if (d->device->isSequential())
+            return 0;
+
+        // Seek the device
+        if (!d->device->seek(d->readBufferStartDevicePos))
+            return qint64(-1);
+
+        // Reset the read buffer
+        QTextStreamPrivate *thatd = const_cast<QTextStreamPrivate *>(d);
+        thatd->readBuffer.clear();
+
+#ifndef QT_NO_TEXTCODEC
+        thatd->restoreToSavedConverterState();
+        if (d->readBufferStartDevicePos == 0)
+            thatd->autoDetectUnicode = true;
+#endif
+
+        // Rewind the device to get to the current position Ensure that
+        // readBufferOffset is unaffected by fillReadBuffer()
+        int oldReadBufferOffset = d->readBufferOffset;
+        while (d->readBuffer.size() < oldReadBufferOffset) {
+            if (!thatd->fillReadBuffer(1))
+                return qint64(-1);
+        }
+        thatd->readBufferOffset = oldReadBufferOffset;
+
+        // Return the device position.
+        return d->device->pos();
+    }
+
+    if (d->string)
+        return d->stringOffset;
+
+    qWarning("QTextStream::pos: no device");
+    return qint64(-1);
+}
+
+/*!
+    Reads and discards whitespace from the stream until either a
+    non-space character is detected, or until atEnd() returns
+    true. This function is useful when reading a stream character by
+    character.
+
+    Whitespace characters are all characters for which
+    QChar::isSpace() returns true.
+
+    \sa operator>>()
+*/
+void QTextStream::skipWhiteSpace()
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(Q_VOID);
+    d->scan(0, 0, 0, QTextStreamPrivate::NotSpace);
+    d->consumeLastToken();
+}
+
+/*!
+    Sets the current device to \a device. If a device has already been
+    assigned, QTextStream will call flush() before the old device is
+    replaced.
+
+    \note This function resets locale to the default locale ('C')
+    and codec to the default codec, QTextCodec::codecForLocale().
+
+    \sa device(), setString()
+*/
+void QTextStream::setDevice(QIODevice *device)
+{
+    Q_D(QTextStream);
+    flush();
+    if (d->deleteDevice) {
+#ifndef QT_NO_QOBJECT
+        d->deviceClosedNotifier.disconnect();
+#endif
+        delete d->device;
+        d->deleteDevice = false;
+    }
+
+    d->reset();
+    d->status = Ok;
+    d->device = device;
+    d->resetReadBuffer();
+#ifndef QT_NO_QOBJECT
+    d->deviceClosedNotifier.setupDevice(this, d->device);
+#endif
+}
+
+/*!
+    Returns the current device associated with the QTextStream,
+    or 0 if no device has been assigned.
+
+    \sa setDevice(), string()
+*/
+QIODevice *QTextStream::device() const
+{
+    Q_D(const QTextStream);
+    return d->device;
+}
+
+/*!
+    Sets the current string to \a string, using the given \a
+    openMode. If a device has already been assigned, QTextStream will
+    call flush() before replacing it.
+
+    \sa string(), setDevice()
+*/
+void QTextStream::setString(QString *string, QIODevice::OpenMode openMode)
+{
+    Q_D(QTextStream);
+    flush();
+    if (d->deleteDevice) {
+#ifndef QT_NO_QOBJECT
+        d->deviceClosedNotifier.disconnect();
+        d->device->blockSignals(true);
+#endif
+        delete d->device;
+        d->deleteDevice = false;
+    }
+
+    d->reset();
+    d->status = Ok;
+    d->string = string;
+    d->stringOpenMode = openMode;
+}
+
+/*!
+    Returns the current string assigned to the QTextStream, or 0 if no
+    string has been assigned.
+
+    \sa setString(), device()
+*/
+QString *QTextStream::string() const
+{
+    Q_D(const QTextStream);
+    return d->string;
+}
+
+/*!
+    Sets the field alignment to \a mode. When used together with
+    setFieldWidth(), this function allows you to generate formatted
+    output with text aligned to the left, to the right or center
+    aligned.
+
+    \sa fieldAlignment(), setFieldWidth()
+*/
+void QTextStream::setFieldAlignment(FieldAlignment mode)
+{
+    Q_D(QTextStream);
+    d->fieldAlignment = mode;
+}
+
+/*!
+    Returns the current field alignment.
+
+    \sa setFieldAlignment(), fieldWidth()
+*/
+QTextStream::FieldAlignment QTextStream::fieldAlignment() const
+{
+    Q_D(const QTextStream);
+    return d->fieldAlignment;
+}
+
+/*!
+    Sets the pad character to \a ch. The default value is the ASCII
+    space character (' '), or QChar(0x20). This character is used to
+    fill in the space in fields when generating text.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 5
+
+    The string \a s contains:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 6
+
+    \sa padChar(), setFieldWidth()
+*/
+void QTextStream::setPadChar(QChar ch)
+{
+    Q_D(QTextStream);
+    d->padChar = ch;
+}
+
+/*!
+    Returns the current pad character.
+
+    \sa setPadChar(), setFieldWidth()
+*/
+QChar QTextStream::padChar() const
+{
+    Q_D(const QTextStream);
+    return d->padChar;
+}
+
+/*!
+    Sets the current field width to \a width. If \a width is 0 (the
+    default), the field width is equal to the length of the generated
+    text.
+
+    \note The field width applies to every element appended to this
+    stream after this function has been called (e.g., it also pads
+    endl). This behavior is different from similar classes in the STL,
+    where the field width only applies to the next element.
+
+    \sa fieldWidth(), setPadChar()
+*/
+void QTextStream::setFieldWidth(int width)
+{
+    Q_D(QTextStream);
+    d->fieldWidth = width;
+}
+
+/*!
+    Returns the current field width.
+
+    \sa setFieldWidth()
+*/
+int QTextStream::fieldWidth() const
+{
+    Q_D(const QTextStream);
+    return d->fieldWidth;
+}
+
+/*!
+    Sets the current number flags to \a flags. \a flags is a set of
+    flags from the NumberFlag enum, and describes options for
+    formatting generated code (e.g., whether or not to always write
+    the base or sign of a number).
+
+    \sa numberFlags(), setIntegerBase(), setRealNumberNotation()
+*/
+void QTextStream::setNumberFlags(NumberFlags flags)
+{
+    Q_D(QTextStream);
+    d->numberFlags = flags;
+}
+
+/*!
+    Returns the current number flags.
+
+    \sa setNumberFlags(), integerBase(), realNumberNotation()
+*/
+QTextStream::NumberFlags QTextStream::numberFlags() const
+{
+    Q_D(const QTextStream);
+    return d->numberFlags;
+}
+
+/*!
+    Sets the base of integers to \a base, both for reading and for
+    generating numbers. \a base can be either 2 (binary), 8 (octal),
+    10 (decimal) or 16 (hexadecimal). If \a base is 0, QTextStream
+    will attempt to detect the base by inspecting the data on the
+    stream. When generating numbers, QTextStream assumes base is 10
+    unless the base has been set explicitly.
+
+    \sa integerBase(), QString::number(), setNumberFlags()
+*/
+void QTextStream::setIntegerBase(int base)
+{
+    Q_D(QTextStream);
+    d->integerBase = base;
+}
+
+/*!
+    Returns the current base of integers. 0 means that the base is
+    detected when reading, or 10 (decimal) when generating numbers.
+
+    \sa setIntegerBase(), QString::number(), numberFlags()
+*/
+int QTextStream::integerBase() const
+{
+    Q_D(const QTextStream);
+    return d->integerBase;
+}
+
+/*!
+    Sets the real number notation to \a notation (SmartNotation,
+    FixedNotation, ScientificNotation). When reading and generating
+    numbers, QTextStream uses this value to detect the formatting of
+    real numbers.
+
+    \sa realNumberNotation(), setRealNumberPrecision(), setNumberFlags(), setIntegerBase()
+*/
+void QTextStream::setRealNumberNotation(RealNumberNotation notation)
+{
+    Q_D(QTextStream);
+    d->realNumberNotation = notation;
+}
+
+/*!
+    Returns the current real number notation.
+
+    \sa setRealNumberNotation(), realNumberPrecision(), numberFlags(), integerBase()
+*/
+QTextStream::RealNumberNotation QTextStream::realNumberNotation() const
+{
+    Q_D(const QTextStream);
+    return d->realNumberNotation;
+}
+
+/*!
+    Sets the precision of real numbers to \a precision. This value
+    describes the number of fraction digits QTextStream should
+    write when generating real numbers.
+
+    The precision cannot be a negative value. The default value is 6.
+
+    \sa realNumberPrecision(), setRealNumberNotation()
+*/
+void QTextStream::setRealNumberPrecision(int precision)
+{
+    Q_D(QTextStream);
+    if (precision < 0) {
+        qWarning("QTextStream::setRealNumberPrecision: Invalid precision (%d)", precision);
+        d->realNumberPrecision = 6;
+        return;
+    }
+    d->realNumberPrecision = precision;
+}
+
+/*!
+    Returns the current real number precision, or the number of fraction
+    digits QTextStream will write when generating real numbers.
+
+    \sa setRealNumberNotation(), realNumberNotation(), numberFlags(), integerBase()
+*/
+int QTextStream::realNumberPrecision() const
+{
+    Q_D(const QTextStream);
+    return d->realNumberPrecision;
+}
+
+/*!
+    Returns the status of the text stream.
+
+    \sa QTextStream::Status, setStatus(), resetStatus()
+*/
+
+QTextStream::Status QTextStream::status() const
+{
+    Q_D(const QTextStream);
+    return d->status;
+}
+
+/*!
+    \since 4.1
+
+    Resets the status of the text stream.
+
+    \sa QTextStream::Status, status(), setStatus()
+*/
+void QTextStream::resetStatus()
+{
+    Q_D(QTextStream);
+    d->status = Ok;
+}
+
+/*!
+    \since 4.1
+
+    Sets the status of the text stream to the \a status given.
+
+    \sa Status status() resetStatus()
+*/
+void QTextStream::setStatus(Status status)
+{
+    Q_D(QTextStream);
+    if (d->status == Ok)
+        d->status = status;
+}
+
+/*!
+    Returns true if there is no more data to be read from the
+    QTextStream; otherwise returns false. This is similar to, but not
+    the same as calling QIODevice::atEnd(), as QTextStream also takes
+    into account its internal Unicode buffer.
+*/
+bool QTextStream::atEnd() const
+{
+    Q_D(const QTextStream);
+    CHECK_VALID_STREAM(true);
+
+    if (d->string)
+        return d->string->size() == d->stringOffset;
+    return d->readBuffer.isEmpty() && d->device->atEnd();
+}
+
+/*!
+    Reads the entire content of the stream, and returns it as a
+    QString. Avoid this function when working on large files, as it
+    will consume a significant amount of memory.
+
+    Calling readLine() is better if you do not know how much data is
+    available.
+
+    \sa readLine()
+*/
+QString QTextStream::readAll()
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(QString());
+
+    const QChar *readPtr;
+    int length;
+    if (!d->scan(&readPtr, &length, /* maxlen = */ 0, QTextStreamPrivate::EndOfFile))
+        return QString();
+
+    QString tmp = QString(readPtr, length);
+    d->consumeLastToken();
+    return tmp;
+}
+
+/*!
+    Reads one line of text from the stream, and returns it as a
+    QString. The maximum allowed line length is set to \a maxlen. If
+    the stream contains lines longer than this, then the lines will be
+    split after \a maxlen characters and returned in parts.
+
+    If \a maxlen is 0, the lines can be of any length. A common value
+    for \a maxlen is 75.
+
+    The returned line has no trailing end-of-line characters ("\\n"
+    or "\\r\\n"), so calling QString::trimmed() is unnecessary.
+
+    If the stream has read to the end of the file, readLine() will return a
+    null QString. For strings, or for devices that support it, you can
+    explicitly test for the end of the stream using atEnd().
+
+    \sa readAll(), QIODevice::readLine()
+*/
+QString QTextStream::readLine(qint64 maxlen)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(QString());
+
+    const QChar *readPtr;
+    int length;
+    if (!d->scan(&readPtr, &length, int(maxlen), QTextStreamPrivate::EndOfLine))
+        return QString();
+
+    QString tmp = QString(readPtr, length);
+    d->consumeLastToken();
+    return tmp;
+}
+
+/*!
+    \since 4.1
+
+    Reads at most \a maxlen characters from the stream, and returns the data
+    read as a QString.
+
+    \sa readAll(), readLine(), QIODevice::read()
+*/
+QString QTextStream::read(qint64 maxlen)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(QString());
+
+    if (maxlen <= 0)
+        return QString::fromLatin1("");     // empty, not null
+
+    const QChar *readPtr;
+    int length;
+    if (!d->scan(&readPtr, &length, int(maxlen), QTextStreamPrivate::EndOfFile))
+        return QString();
+
+    QString tmp = QString(readPtr, length);
+    d->consumeLastToken();
+    return tmp;
+}
+
+/*! \internal
+*/
+QTextStreamPrivate::NumberParsingStatus QTextStreamPrivate::getNumber(qulonglong *ret)
+{
+    scan(0, 0, 0, NotSpace);
+    consumeLastToken();
+
+    // detect int encoding
+    int base = integerBase;
+    if (base == 0) {
+        QChar ch;
+        if (!getChar(&ch))
+            return npsInvalidPrefix;
+        if (ch == QLatin1Char('0')) {
+            QChar ch2;
+            if (!getChar(&ch2)) {
+                // Result is the number 0
+                *ret = 0;
+                return npsOk;
+            }
+            ch2 = ch2.toLower();
+
+            if (ch2 == QLatin1Char('x')) {
+                base = 16;
+            } else if (ch2 == QLatin1Char('b')) {
+                base = 2;
+            } else if (ch2.isDigit() && ch2.digitValue() >= 0 && ch2.digitValue() <= 7) {
+                base = 8;
+            } else {
+                base = 10;
+            }
+            ungetChar(ch2);
+        } else if (ch == locale.negativeSign() || ch == locale.positiveSign() || ch.isDigit()) {
+            base = 10;
+        } else {
+            ungetChar(ch);
+            return npsInvalidPrefix;
+        }
+        ungetChar(ch);
+        // State of the stream is now the same as on entry
+        // (cursor is at prefix),
+        // and local variable 'base' has been set appropriately.
+    }
+
+    qulonglong val=0;
+    switch (base) {
+    case 2: {
+        QChar pf1, pf2, dig;
+        // Parse prefix '0b'
+        if (!getChar(&pf1) || pf1 != QLatin1Char('0'))
+            return npsInvalidPrefix;
+        if (!getChar(&pf2) || pf2.toLower() != QLatin1Char('b'))
+            return npsInvalidPrefix;
+        // Parse digits
+        int ndigits = 0;
+        while (getChar(&dig)) {
+            int n = dig.toLower().unicode();
+            if (n == '0' || n == '1') {
+                val <<= 1;
+                val += n - '0';
+            } else {
+                ungetChar(dig);
+                break;
+            }
+            ndigits++;
+        }
+        if (ndigits == 0) {
+            // Unwind the prefix and abort
+            ungetChar(pf2);
+            ungetChar(pf1);
+            return npsMissingDigit;
+        }
+        break;
+    }
+    case 8: {
+        QChar pf, dig;
+        // Parse prefix '0'
+        if (!getChar(&pf) || pf != QLatin1Char('0'))
+            return npsInvalidPrefix;
+        // Parse digits
+        int ndigits = 0;
+        while (getChar(&dig)) {
+            int n = dig.toLower().unicode();
+            if (n >= '0' && n <= '7') {
+                val *= 8;
+                val += n - '0';
+            } else {
+                ungetChar(dig);
+                break;
+            }
+            ndigits++;
+        }
+        if (ndigits == 0) {
+            // Unwind the prefix and abort
+            ungetChar(pf);
+            return npsMissingDigit;
+        }
+        break;
+    }
+    case 10: {
+        // Parse sign (or first digit)
+        QChar sign;
+        int ndigits = 0;
+        if (!getChar(&sign))
+            return npsMissingDigit;
+        if (sign != locale.negativeSign() && sign != locale.positiveSign()) {
+            if (!sign.isDigit()) {
+                ungetChar(sign);
+                return npsMissingDigit;
+            }
+            val += sign.digitValue();
+            ndigits++;
+        }
+        // Parse digits
+        QChar ch;
+        while (getChar(&ch)) {
+            if (ch.isDigit()) {
+                val *= 10;
+                val += ch.digitValue();
+            } else if (locale.language() != QLocale::C
+                       && ch == locale.groupSeparator()) {
+                continue;
+            } else {
+                ungetChar(ch);
+                break;
+            }
+            ndigits++;
+        }
+        if (ndigits == 0)
+            return npsMissingDigit;
+        if (sign == locale.negativeSign()) {
+            qlonglong ival = qlonglong(val);
+            if (ival > 0)
+                ival = -ival;
+            val = qulonglong(ival);
+        }
+        break;
+    }
+    case 16: {
+        QChar pf1, pf2, dig;
+        // Parse prefix ' 0x'
+        if (!getChar(&pf1) || pf1 != QLatin1Char('0'))
+            return npsInvalidPrefix;
+        if (!getChar(&pf2) || pf2.toLower() != QLatin1Char('x'))
+            return npsInvalidPrefix;
+        // Parse digits
+        int ndigits = 0;
+        while (getChar(&dig)) {
+            int n = dig.toLower().unicode();
+            if (n >= '0' && n <= '9') {
+                val <<= 4;
+                val += n - '0';
+            } else if (n >= 'a' && n <= 'f') {
+                val <<= 4;
+                val += 10 + (n - 'a');
+            } else {
+                ungetChar(dig);
+                break;
+            }
+            ndigits++;
+        }
+        if (ndigits == 0) {
+            return npsMissingDigit;
+        }
+        break;
+    }
+    default:
+        // Unsupported integerBase
+        return npsInvalidPrefix;
+    }
+
+    if (ret)
+        *ret = val;
+    return npsOk;
+}
+
+/*! \internal
+    (hihi)
+*/
+bool QTextStreamPrivate::getReal(double *f)
+{
+    // We use a table-driven FSM to parse floating point numbers
+    // strtod() cannot be used directly since we may be reading from a
+    // QIODevice.
+    enum ParserState {
+        Init = 0,
+        Sign = 1,
+        Mantissa = 2,
+        Dot = 3,
+        Abscissa = 4,
+        ExpMark = 5,
+        ExpSign = 6,
+        Exponent = 7,
+        Nan1 = 8,
+        Nan2 = 9,
+        Inf1 = 10,
+        Inf2 = 11,
+        NanInf = 12,
+        Done = 13
+    };
+    enum InputToken {
+        None = 0,
+        InputSign = 1,
+        InputDigit = 2,
+        InputDot = 3,
+        InputExp = 4,
+        InputI = 5,
+        InputN = 6,
+        InputF = 7,
+        InputA = 8,
+        InputT = 9
+    };
+
+    static const uchar table[13][10] = {
+        // None InputSign InputDigit InputDot InputExp InputI    InputN    InputF    InputA    InputT
+        { 0,    Sign,     Mantissa,  Dot,     0,       Inf1,     Nan1,     0,        0,        0      }, // 0  Init
+        { 0,    0,        Mantissa,  Dot,     0,       Inf1,     Nan1,     0,        0,        0      }, // 1  Sign
+        { Done, Done,     Mantissa,  Dot,     ExpMark, 0,        0,        0,        0,        0      }, // 2  Mantissa
+        { 0,    0,        Abscissa,  0,       0,       0,        0,        0,        0,        0      }, // 3  Dot
+        { Done, Done,     Abscissa,  Done,    ExpMark, 0,        0,        0,        0,        0      }, // 4  Abscissa
+        { 0,    ExpSign,  Exponent,  0,       0,       0,        0,        0,        0,        0      }, // 5  ExpMark
+        { 0,    0,        Exponent,  0,       0,       0,        0,        0,        0,        0      }, // 6  ExpSign
+        { Done, Done,     Exponent,  Done,    Done,    0,        0,        0,        0,        0      }, // 7  Exponent
+        { 0,    0,        0,         0,       0,       0,        0,        0,        Nan2,     0      }, // 8  Nan1
+        { 0,    0,        0,         0,       0,       0,        NanInf,   0,        0,        0      }, // 9  Nan2
+        { 0,    0,        0,         0,       0,       0,        Inf2,     0,        0,        0      }, // 10 Inf1
+        { 0,    0,        0,         0,       0,       0,        0,        NanInf,   0,        0      }, // 11 Inf2
+        { Done, 0,        0,         0,       0,       0,        0,        0,        0,        0      }, // 11 NanInf
+    };
+
+    ParserState state = Init;
+    InputToken input = None;
+
+    scan(0, 0, 0, NotSpace);
+    consumeLastToken();
+
+    const int BufferSize = 128;
+    char buf[BufferSize];
+    int i = 0;
+
+    QChar c;
+    while (getChar(&c)) {
+        switch (c.unicode()) {
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+            input = InputDigit;
+            break;
+        case 'i': case 'I':
+            input = InputI;
+            break;
+        case 'n': case 'N':
+            input = InputN;
+            break;
+        case 'f': case 'F':
+            input = InputF;
+            break;
+        case 'a': case 'A':
+            input = InputA;
+            break;
+        case 't': case 'T':
+            input = InputT;
+            break;
+        default: {
+            QChar lc = c.toLower();
+            if (lc == locale.decimalPoint().toLower())
+                input = InputDot;
+            else if (lc == locale.exponential().toLower())
+                input = InputExp;
+            else if (lc == locale.negativeSign().toLower()
+                     || lc == locale.positiveSign().toLower())
+                input = InputSign;
+            else if (locale.language() != QLocale::C // backward-compatibility
+                     && lc == locale.groupSeparator().toLower())
+                input = InputDigit; // well, it isn't a digit, but no one cares.
+            else
+                input = None;
+        }
+            break;
+        }
+
+        state = ParserState(table[state][input]);
+
+        if  (state == Init || state == Done || i > (BufferSize - 5)) {
+            ungetChar(c);
+            if (i > (BufferSize - 5)) { // ignore rest of digits
+                while (getChar(&c)) {
+                    if (!c.isDigit()) {
+                        ungetChar(c);
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+
+        buf[i++] = c.toLatin1();
+    }
+
+    if (i == 0)
+        return false;
+    if (!f)
+        return true;
+    buf[i] = '\0';
+
+    // backward-compatibility. Old implmentation supported +nan/-nan
+    // for some reason. QLocale only checks for lower-case
+    // nan/+inf/-inf, so here we also check for uppercase and mixed
+    // case versions.
+    if (!qstricmp(buf, "nan") || !qstricmp(buf, "+nan") || !qstricmp(buf, "-nan")) {
+        *f = qSNaN();
+        return true;
+    } else if (!qstricmp(buf, "+inf") || !qstricmp(buf, "inf")) {
+        *f = qInf();
+        return true;
+    } else if (!qstricmp(buf, "-inf")) {
+        *f = -qInf();
+        return true;
+    }
+    bool ok;
+    *f = locale.toDouble(QString::fromLatin1(buf), &ok);
+    return ok;
+}
+
+/*!
+    Reads a character from the stream and stores it in \a c. Returns a
+    reference to the QTextStream, so several operators can be
+    nested. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 7
+
+    Whitespace is \e not skipped.
+*/
+
+QTextStream &QTextStream::operator>>(QChar &c)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->scan(0, 0, 0, QTextStreamPrivate::NotSpace);
+    if (!d->getChar(&c))
+        setStatus(ReadPastEnd);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Reads a character from the stream and stores it in \a c. The
+    character from the stream is converted to ISO-5589-1 before it is
+    stored.
+
+    \sa QChar::toLatin1()
+*/
+QTextStream &QTextStream::operator>>(char &c)
+{
+    QChar ch;
+    *this >> ch;
+    c = ch.toLatin1();
+    return *this;
+}
+
+/*!
+    Reads an integer from the stream and stores it in \a i, then
+    returns a reference to the QTextStream. The number is cast to
+    the correct type before it is stored. If no number was detected on
+    the stream, \a i is set to 0.
+
+    By default, QTextStream will attempt to detect the base of the
+    number using the following rules:
+
+    \table
+    \header \o Prefix                \o Base
+    \row    \o "0b" or "0B"          \o 2 (binary)
+    \row    \o "0" followed by "0-7" \o 8 (octal)
+    \row    \o "0" otherwise         \o 10 (decimal)
+    \row    \o "0x" or "0X"          \o 16 (hexadecimal)
+    \row    \o "1" to "9"            \o 10 (decimal)
+    \endtable
+
+    By calling setIntegerBase(), you can specify the integer base
+    explicitly. This will disable the auto-detection, and speed up
+    QTextStream slightly.
+
+    Leading whitespace is skipped.
+*/
+QTextStream &QTextStream::operator>>(signed short &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(signed short);
+}
+
+/*!
+    \overload
+
+    Stores the integer in the unsigned short \a i.
+*/
+QTextStream &QTextStream::operator>>(unsigned short &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(unsigned short);
+}
+
+/*!
+    \overload
+
+    Stores the integer in the signed int \a i.
+*/
+QTextStream &QTextStream::operator>>(signed int &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(signed int);
+}
+
+/*!
+    \overload
+
+    Stores the integer in the unsigned int \a i.
+*/
+QTextStream &QTextStream::operator>>(unsigned int &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(unsigned int);
+}
+
+/*!
+    \overload
+
+    Stores the integer in the signed long \a i.
+*/
+QTextStream &QTextStream::operator>>(signed long &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(signed long);
+}
+
+/*!
+    \overload
+
+    Stores the integer in the unsigned long \a i.
+*/
+QTextStream &QTextStream::operator>>(unsigned long &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(unsigned long);
+}
+
+/*!
+    \overload
+
+    Stores the integer in the qlonglong \a i.
+*/
+QTextStream &QTextStream::operator>>(qlonglong &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(qlonglong);
+}
+
+/*!
+    \overload
+
+    Stores the integer in the qulonglong \a i.
+*/
+QTextStream &QTextStream::operator>>(qulonglong &i)
+{
+    IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(qulonglong);
+}
+
+/*!
+    Reads a real number from the stream and stores it in \a f, then
+    returns a reference to the QTextStream. The number is cast to
+    the correct type. If no real number is detect on the stream, \a f
+    is set to 0.0.
+
+    As a special exception, QTextStream allows the strings "nan" and "inf" to
+    represent NAN and INF floats or doubles.
+
+    Leading whitespace is skipped.
+*/
+QTextStream &QTextStream::operator>>(float &f)
+{
+    IMPLEMENT_STREAM_RIGHT_REAL_OPERATOR(float);
+}
+
+/*!
+    \overload
+
+    Stores the real number in the double \a f.
+*/
+QTextStream &QTextStream::operator>>(double &f)
+{
+    IMPLEMENT_STREAM_RIGHT_REAL_OPERATOR(double);
+}
+
+/*!
+    Reads a word from the stream and stores it in \a str, then returns
+    a reference to the stream. Words are separated by whitespace
+    (i.e., all characters for which QChar::isSpace() returns true).
+
+    Leading whitespace is skipped.
+*/
+QTextStream &QTextStream::operator>>(QString &str)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+
+    str.clear();
+    d->scan(0, 0, 0, QTextStreamPrivate::NotSpace);
+    d->consumeLastToken();
+
+    const QChar *ptr;
+    int length;
+    if (!d->scan(&ptr, &length, 0, QTextStreamPrivate::Space)) {
+        setStatus(ReadPastEnd);
+        return *this;
+    }
+
+    str = QString(ptr, length);
+    d->consumeLastToken();
+    return *this;
+}
+
+/*!
+    \overload
+
+    Converts the word to ISO-8859-1, then stores it in \a array.
+
+    \sa QString::toLatin1()
+*/
+QTextStream &QTextStream::operator>>(QByteArray &array)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+
+    array.clear();
+    d->scan(0, 0, 0, QTextStreamPrivate::NotSpace);
+    d->consumeLastToken();
+
+    const QChar *ptr;
+    int length;
+    if (!d->scan(&ptr, &length, 0, QTextStreamPrivate::Space)) {
+        setStatus(ReadPastEnd);
+        return *this;
+    }
+
+    for (int i = 0; i < length; ++i)
+        array += ptr[i].toLatin1();
+
+    d->consumeLastToken();
+    return *this;
+}
+
+/*!
+    \overload
+
+    Stores the word in \a c, terminated by a '\0' character. If no word is
+    available, only the '\0' character is stored.
+
+    Warning: Although convenient, this operator is dangerous and must
+    be used with care. QTextStream assumes that \a c points to a
+    buffer with enough space to hold the word. If the buffer is too
+    small, your application may crash.
+
+    If possible, use the QByteArray operator instead.
+*/
+QTextStream &QTextStream::operator>>(char *c)
+{
+    Q_D(QTextStream);
+    *c = 0;
+    CHECK_VALID_STREAM(*this);
+    d->scan(0, 0, 0, QTextStreamPrivate::NotSpace);
+    d->consumeLastToken();
+
+    const QChar *ptr;
+    int length;
+    if (!d->scan(&ptr, &length, 0, QTextStreamPrivate::Space)) {
+        setStatus(ReadPastEnd);
+        return *this;
+    }
+
+    for (int i = 0; i < length; ++i)
+        *c++ = ptr[i].toLatin1();
+    *c = '\0';
+    d->consumeLastToken();
+    return *this;
+}
+
+/*! \internal
+ */
+bool QTextStreamPrivate::putNumber(qulonglong number, bool negative)
+{
+    QString result;
+
+    unsigned flags = 0;
+    if (numberFlags & QTextStream::ShowBase)
+        flags |= QLocalePrivate::ShowBase;
+    if (numberFlags & QTextStream::ForceSign)
+        flags |= QLocalePrivate::AlwaysShowSign;
+    if (numberFlags & QTextStream::UppercaseBase)
+        flags |= QLocalePrivate::UppercaseBase;
+    if (numberFlags & QTextStream::UppercaseDigits)
+        flags |= QLocalePrivate::CapitalEorX;
+
+    // add thousands group separators. For backward compatibility we
+    // don't add a group separator for C locale.
+    if (locale.language() != QLocale::C)
+        flags |= QLocalePrivate::ThousandsGroup;
+
+    const QLocalePrivate *dd = locale.d();
+    int base = integerBase ? integerBase : 10;
+    if (negative && base == 10) {
+        result = dd->longLongToString(-static_cast<qlonglong>(number), -1,
+                                      base, -1, flags);
+    } else if (negative) {
+        // Workaround for backward compatibility for writing negative
+        // numbers in octal and hex:
+        // QTextStream(result) << showbase << hex << -1 << oct << -1
+        // should output: -0x1 -0b1
+        result = dd->unsLongLongToString(number, -1, base, -1, flags);
+        result.prepend(locale.negativeSign());
+    } else {
+        result = dd->unsLongLongToString(number, -1, base, -1, flags);
+        // workaround for backward compatibility - in octal form with
+        // ShowBase flag set zero should be written as '00'
+        if (number == 0 && base == 8 && numberFlags & QTextStream::ShowBase
+            && result == QLatin1String("0")) {
+            result.prepend(QLatin1String("0"));
+        }
+    }
+    return putString(result, true);
+}
+
+/*!
+    \internal
+    \overload
+*/
+QTextStream &QTextStream::operator<<(QBool b)
+{
+    return *this << bool(b);
+}
+
+/*!
+    Writes the character \a c to the stream, then returns a reference
+    to the QTextStream.
+
+    \sa setFieldWidth()
+*/
+QTextStream &QTextStream::operator<<(QChar c)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putString(QString(c));
+    return *this;
+}
+
+/*!
+    \overload
+
+    Converts \a c from ASCII to a QChar, then writes it to the stream.
+*/
+QTextStream &QTextStream::operator<<(char c)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putString(QString(QChar::fromAscii(c)));
+    return *this;
+}
+
+/*!
+    Writes the integer number \a i to the stream, then returns a
+    reference to the QTextStream. By default, the number is stored in
+    decimal form, but you can also set the base by calling
+    setIntegerBase().
+
+    \sa setFieldWidth(), setNumberFlags()
+*/
+QTextStream &QTextStream::operator<<(signed short i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber((qulonglong)qAbs(qlonglong(i)), i < 0);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the unsigned short \a i to the stream.
+*/
+QTextStream &QTextStream::operator<<(unsigned short i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber((qulonglong)i, false);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the signed int \a i to the stream.
+*/
+QTextStream &QTextStream::operator<<(signed int i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber((qulonglong)qAbs(qlonglong(i)), i < 0);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the unsigned int \a i to the stream.
+*/
+QTextStream &QTextStream::operator<<(unsigned int i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber((qulonglong)i, false);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the signed long \a i to the stream.
+*/
+QTextStream &QTextStream::operator<<(signed long i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber((qulonglong)qAbs(qlonglong(i)), i < 0);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the unsigned long \a i to the stream.
+*/
+QTextStream &QTextStream::operator<<(unsigned long i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber((qulonglong)i, false);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the qlonglong \a i to the stream.
+*/
+QTextStream &QTextStream::operator<<(qlonglong i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber((qulonglong)qAbs(i), i < 0);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the qulonglong \a i to the stream.
+*/
+QTextStream &QTextStream::operator<<(qulonglong i)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putNumber(i, false);
+    return *this;
+}
+
+/*!
+    Writes the real number \a f to the stream, then returns a
+    reference to the QTextStream. By default, QTextStream stores it
+    using SmartNotation, with up to 6 digits of precision. You can
+    change the textual representation QTextStream will use for real
+    numbers by calling setRealNumberNotation(),
+    setRealNumberPrecision() and setNumberFlags().
+
+    \sa setFieldWidth(), setRealNumberNotation(),
+    setRealNumberPrecision(), setNumberFlags()
+*/
+QTextStream &QTextStream::operator<<(float f)
+{
+    return *this << double(f);
+}
+
+/*!
+    \overload
+
+    Writes the double \a f to the stream.
+*/
+QTextStream &QTextStream::operator<<(double f)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+
+    QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
+    switch (realNumberNotation()) {
+    case FixedNotation:
+        form = QLocalePrivate::DFDecimal;
+        break;
+    case ScientificNotation:
+        form = QLocalePrivate::DFExponent;
+        break;
+    case SmartNotation:
+        form = QLocalePrivate::DFSignificantDigits;
+        break;
+    }
+
+    uint flags = 0;
+    if (numberFlags() & ShowBase)
+        flags |= QLocalePrivate::ShowBase;
+    if (numberFlags() & ForceSign)
+        flags |= QLocalePrivate::AlwaysShowSign;
+    if (numberFlags() & UppercaseBase)
+        flags |= QLocalePrivate::UppercaseBase;
+    if (numberFlags() & UppercaseDigits)
+        flags |= QLocalePrivate::CapitalEorX;
+    if (numberFlags() & ForcePoint)
+        flags |= QLocalePrivate::Alternate;
+
+    const QLocalePrivate *dd = d->locale.d();
+    QString num = dd->doubleToString(f, d->realNumberPrecision, form, -1, flags);
+    d->putString(num, true);
+    return *this;
+}
+
+/*!
+    Writes the string \a string to the stream, and returns a reference
+    to the QTextStream. The string is first encoded using the assigned
+    codec (the default codec is QTextCodec::codecForLocale()) before
+    it is written to the stream.
+
+    \sa setFieldWidth(), setCodec()
+*/
+QTextStream &QTextStream::operator<<(const QString &string)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putString(string);
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes \a array to the stream. The contents of \a array are
+    converted with QString::fromAscii().
+*/
+QTextStream &QTextStream::operator<<(const QByteArray &array)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putString(QString::fromAscii(array.constData(), array.length()));
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes the constant string pointed to by \a string to the stream. \a
+    string is assumed to be in ISO-8859-1 encoding. This operator
+    is convenient when working with constant string data. Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 8
+
+    Warning: QTextStream assumes that \a string points to a string of
+    text, terminated by a '\0' character. If there is no terminating
+    '\0' character, your application may crash.
+*/
+QTextStream &QTextStream::operator<<(const char *string)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    d->putString(QLatin1String(string));
+    return *this;
+}
+
+/*!
+    \overload
+
+    Writes \a ptr to the stream as a hexadecimal number with a base.
+*/
+
+QTextStream &QTextStream::operator<<(const void *ptr)
+{
+    Q_D(QTextStream);
+    CHECK_VALID_STREAM(*this);
+    int oldBase = d->integerBase;
+    NumberFlags oldFlags = d->numberFlags;
+    d->integerBase = 16;
+    d->numberFlags |= ShowBase;
+    d->putNumber(reinterpret_cast<quintptr>(ptr), false);
+    d->integerBase = oldBase;
+    d->numberFlags = oldFlags;
+    return *this;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setIntegerBase(2) on \a stream and returns \a
+    stream.
+
+    \sa oct(), dec(), hex(), {QTextStream manipulators}
+*/
+QTextStream &bin(QTextStream &stream)
+{
+    stream.setIntegerBase(2);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setIntegerBase(8) on \a stream and returns \a
+    stream.
+
+    \sa bin(), dec(), hex(), {QTextStream manipulators}
+*/
+QTextStream &oct(QTextStream &stream)
+{
+    stream.setIntegerBase(8);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setIntegerBase(10) on \a stream and returns \a
+    stream.
+
+    \sa bin(), oct(), hex(), {QTextStream manipulators}
+*/
+QTextStream &dec(QTextStream &stream)
+{
+    stream.setIntegerBase(10);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setIntegerBase(16) on \a stream and returns \a
+    stream.
+
+    \note The hex modifier can only be used for writing to streams.
+    \sa bin(), oct(), dec(), {QTextStream manipulators}
+*/
+QTextStream &hex(QTextStream &stream)
+{
+    stream.setIntegerBase(16);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() |
+    QTextStream::ShowBase) on \a stream and returns \a stream.
+
+    \sa noshowbase(), forcesign(), forcepoint(), {QTextStream manipulators}
+*/
+QTextStream &showbase(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() | QTextStream::ShowBase);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() |
+    QTextStream::ForceSign) on \a stream and returns \a stream.
+
+    \sa noforcesign(), forcepoint(), showbase(), {QTextStream manipulators}
+*/
+QTextStream &forcesign(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() | QTextStream::ForceSign);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() |
+    QTextStream::ForcePoint) on \a stream and returns \a stream.
+
+    \sa noforcepoint(), forcesign(), showbase(), {QTextStream manipulators}
+*/
+QTextStream &forcepoint(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() | QTextStream::ForcePoint);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() &
+    ~QTextStream::ShowBase) on \a stream and returns \a stream.
+
+    \sa showbase(), noforcesign(), noforcepoint(), {QTextStream manipulators}
+*/
+QTextStream &noshowbase(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() &= ~QTextStream::ShowBase);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() &
+    ~QTextStream::ForceSign) on \a stream and returns \a stream.
+
+    \sa forcesign(), noforcepoint(), noshowbase(), {QTextStream manipulators}
+*/
+QTextStream &noforcesign(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() &= ~QTextStream::ForceSign);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() &
+    ~QTextStream::ForcePoint) on \a stream and returns \a stream.
+
+    \sa forcepoint(), noforcesign(), noshowbase(), {QTextStream manipulators}
+*/
+QTextStream &noforcepoint(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() &= ~QTextStream::ForcePoint);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() |
+    QTextStream::UppercaseBase) on \a stream and returns \a stream.
+
+    \sa lowercasebase(), uppercasedigits(), {QTextStream manipulators}
+*/
+QTextStream &uppercasebase(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() | QTextStream::UppercaseBase);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() |
+    QTextStream::UppercaseDigits) on \a stream and returns \a stream.
+
+    \sa lowercasedigits(), uppercasebase(), {QTextStream manipulators}
+*/
+QTextStream &uppercasedigits(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() | QTextStream::UppercaseDigits);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() &
+    ~QTextStream::UppercaseBase) on \a stream and returns \a stream.
+
+    \sa uppercasebase(), lowercasedigits(), {QTextStream manipulators}
+*/
+QTextStream &lowercasebase(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() & ~QTextStream::UppercaseBase);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setNumberFlags(QTextStream::numberFlags() &
+    ~QTextStream::UppercaseDigits) on \a stream and returns \a stream.
+
+    \sa uppercasedigits(), lowercasebase(), {QTextStream manipulators}
+*/
+QTextStream &lowercasedigits(QTextStream &stream)
+{
+    stream.setNumberFlags(stream.numberFlags() & ~QTextStream::UppercaseDigits);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setRealNumberNotation(QTextStream::FixedNotation)
+    on \a stream and returns \a stream.
+
+    \sa scientific(), {QTextStream manipulators}
+*/
+QTextStream &fixed(QTextStream &stream)
+{
+    stream.setRealNumberNotation(QTextStream::FixedNotation);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setRealNumberNotation(QTextStream::ScientificNotation)
+    on \a stream and returns \a stream.
+
+    \sa fixed(), {QTextStream manipulators}
+*/
+QTextStream &scientific(QTextStream &stream)
+{
+    stream.setRealNumberNotation(QTextStream::ScientificNotation);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setFieldAlignment(QTextStream::AlignLeft)
+    on \a stream and returns \a stream.
+
+    \sa right(), center(), {QTextStream manipulators}
+*/
+QTextStream &left(QTextStream &stream)
+{
+    stream.setFieldAlignment(QTextStream::AlignLeft);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setFieldAlignment(QTextStream::AlignRight)
+    on \a stream and returns \a stream.
+
+    \sa left(), center(), {QTextStream manipulators}
+*/
+QTextStream &right(QTextStream &stream)
+{
+    stream.setFieldAlignment(QTextStream::AlignRight);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::setFieldAlignment(QTextStream::AlignCenter)
+    on \a stream and returns \a stream.
+
+    \sa left(), right(), {QTextStream manipulators}
+*/
+QTextStream &center(QTextStream &stream)
+{
+    stream.setFieldAlignment(QTextStream::AlignCenter);
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Writes '\n' to the \a stream and flushes the stream.
+
+    Equivalent to
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 9
+
+    Note: On Windows, all '\n' characters are written as '\r\n' if
+    QTextStream's device or string is opened using the QIODevice::Text flag.
+
+    \sa flush(), reset(), {QTextStream manipulators}
+*/
+QTextStream &endl(QTextStream &stream)
+{
+    return stream << QLatin1Char('\n') << flush;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::flush() on \a stream and returns \a stream.
+
+    \sa endl(), reset(), {QTextStream manipulators}
+*/
+QTextStream &flush(QTextStream &stream)
+{
+    stream.flush();
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls QTextStream::reset() on \a stream and returns \a stream.
+
+    \sa flush(), {QTextStream manipulators}
+*/
+QTextStream &reset(QTextStream &stream)
+{
+    stream.reset();
+    return stream;
+}
+
+/*!
+    \relates QTextStream
+
+    Calls skipWhiteSpace() on \a stream and returns \a stream.
+
+    \sa {QTextStream manipulators}
+*/
+QTextStream &ws(QTextStream &stream)
+{
+    stream.skipWhiteSpace();
+    return stream;
+}
+
+/*!
+    \fn QTextStreamManipulator qSetFieldWidth(int width)
+    \relates QTextStream
+
+    Equivalent to QTextStream::setFieldWidth(\a width).
+*/
+
+/*!
+    \fn QTextStreamManipulator qSetPadChar(QChar ch)
+    \relates QTextStream
+
+    Equivalent to QTextStream::setPadChar(\a ch).
+*/
+
+/*!
+    \fn QTextStreamManipulator qSetRealNumberPrecision(int precision)
+    \relates QTextStream
+
+    Equivalent to QTextStream::setRealNumberPrecision(\a precision).
+*/
+
+#ifndef QT_NO_TEXTCODEC
+/*!
+    \relates QTextStream
+
+    Toggles insertion of the Byte Order Mark on \a stream when QTextStream is
+    used with a UTF codec.
+
+    \sa QTextStream::setGenerateByteOrderMark(), {QTextStream manipulators}
+*/
+QTextStream &bom(QTextStream &stream)
+{
+    stream.setGenerateByteOrderMark(true);
+    return stream;
+}
+
+/*!
+    Sets the codec for this stream to \a codec. The codec is used for
+    decoding any data that is read from the assigned device, and for
+    encoding any data that is written. By default,
+    QTextCodec::codecForLocale() is used, and automatic unicode
+    detection is enabled.
+
+    If QTextStream operates on a string, this function does nothing.
+
+    \warning If you call this function while the text stream is reading
+    from an open sequential socket, the internal buffer may still contain
+    text decoded using the old codec.
+
+    \sa codec(), setAutoDetectUnicode(), setLocale()
+*/
+void QTextStream::setCodec(QTextCodec *codec)
+{
+    Q_D(QTextStream);
+    qint64 seekPos = -1;
+    if (!d->readBuffer.isEmpty()) {
+        if (!d->device->isSequential()) {
+            seekPos = pos();
+        }
+    }
+    d->codec = codec;
+    if (seekPos >=0 && !d->readBuffer.isEmpty())
+        seek(seekPos);
+}
+
+/*!
+    Sets the codec for this stream to the QTextCodec for the encoding
+    specified by \a codecName. Common values for \c codecName include
+    "ISO 8859-1", "UTF-8", and "UTF-16". If the encoding isn't
+    recognized, nothing happens.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 10
+
+    \sa QTextCodec::codecForName(), setLocale()
+*/
+void QTextStream::setCodec(const char *codecName)
+{
+    QTextCodec *codec = QTextCodec::codecForName(codecName);
+    if (codec)
+        setCodec(codec);
+}
+
+/*!
+    Returns the codec that is current assigned to the stream.
+
+    \sa setCodec(), setAutoDetectUnicode(), locale()
+*/
+QTextCodec *QTextStream::codec() const
+{
+    Q_D(const QTextStream);
+    return d->codec;
+}
+
+/*!
+    If \a enabled is true, QTextStream will attempt to detect Unicode
+    encoding by peeking into the stream data to see if it can find the
+    UTF-16 or UTF-32 BOM (Byte Order Mark). If this mark is found, QTextStream
+    will replace the current codec with the UTF codec.
+
+    This function can be used together with setCodec(). It is common
+    to set the codec to UTF-8, and then enable UTF-16 detection.
+
+    \sa autoDetectUnicode(), setCodec()
+*/
+void QTextStream::setAutoDetectUnicode(bool enabled)
+{
+    Q_D(QTextStream);
+    d->autoDetectUnicode = enabled;
+}
+
+/*!
+    Returns true if automatic Unicode detection is enabled; otherwise
+    returns false.
+
+    \sa setAutoDetectUnicode(), setCodec()
+*/
+bool QTextStream::autoDetectUnicode() const
+{
+    Q_D(const QTextStream);
+    return d->autoDetectUnicode;
+}
+
+/*!
+    If \a generate is true and a UTF codec is used, QTextStream will insert
+    the BOM (Byte Order Mark) before any data has been written to the
+    device. If \a generate is false, no BOM will be inserted. This function
+    must be called before any data is written. Otherwise, it does nothing.
+
+    \sa generateByteOrderMark(), bom()
+*/
+void QTextStream::setGenerateByteOrderMark(bool generate)
+{
+    Q_D(QTextStream);
+    if (d->writeBuffer.isEmpty()) {
+        if (generate)
+            d->writeConverterState.flags &= ~QTextCodec::IgnoreHeader;
+        else
+            d->writeConverterState.flags |= QTextCodec::IgnoreHeader;
+    }
+}
+
+/*!
+    Returns true if QTextStream is set to generate the UTF BOM (Byte Order
+    Mark) when using a UTF codec; otherwise returns false.
+
+    \sa setGenerateByteOrderMark()
+*/
+bool QTextStream::generateByteOrderMark() const
+{
+    Q_D(const QTextStream);
+    return (d->writeConverterState.flags & QTextCodec::IgnoreHeader) == 0;
+}
+
+#endif
+
+/*!
+    \since 4.5
+
+    Sets the locale for this stream to \a locale. The specified locale is
+    used for conversions between numbers and their string representations.
+
+    The default locale is C and it is a special case - the thousands
+    group separator is not used for backward compatibility reasons.
+
+    \sa locale()
+*/
+void QTextStream::setLocale(const QLocale &locale)
+{
+    Q_D(QTextStream);
+    d->locale = locale;
+}
+
+/*!
+    \since 4.5
+
+    Returns the locale for this stream. The default locale is C.
+
+    \sa setLocale()
+*/
+QLocale QTextStream::locale() const
+{
+    Q_D(const QTextStream);
+    return d->locale;
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    \class QTextIStream
+    \brief The QTextIStream class is a convenience class for input streams.
+
+    \compat
+    \reentrant
+    \ingroup io
+    \ingroup text
+
+    Use QTextStream instead.
+*/
+
+/*!
+    \fn QTextIStream::QTextIStream(const QString *string)
+
+    Use QTextStream(&\a{string}, QIODevice::ReadOnly) instead.
+*/
+/*!
+    \fn QTextIStream::QTextIStream(QByteArray *byteArray)
+
+    Use QTextStream(&\a{byteArray}, QIODevice::ReadOnly) instead.
+*/
+/*!
+    \fn QTextIStream::QTextIStream(FILE *file)
+
+    Use QTextStream(\a{file}, QIODevice::ReadOnly) instead.
+*/
+
+/*!
+    \class QTextOStream
+    \brief The QTextOStream class is a convenience class for output streams.
+
+    \compat
+    \reentrant
+    \ingroup io
+    \ingroup text
+
+    Use QTextStream instead.
+*/
+
+/*!
+    \fn QTextOStream::QTextOStream(QString *string)
+
+    Use QTextStream(&\a{string}, QIODevice::WriteOnly) instead.
+*/
+/*!
+    \fn QTextOStream::QTextOStream(QByteArray *byteArray)
+
+    Use QTextStream(&\a{byteArray}, QIODevice::WriteOnly) instead.
+*/
+/*!
+    \fn QTextOStream::QTextOStream(FILE *file)
+
+    Use QTextStream(\a{file}, QIODevice::WriteOnly) instead.
+*/
+
+/*! \internal
+*/
+int QTextStream::flagsInternal() const
+{
+    Q_D(const QTextStream);
+
+    int f = 0;
+    switch (d->fieldAlignment) {
+    case AlignLeft: f |= left; break;
+    case AlignRight: f |= right; break;
+    case AlignCenter: f |= internal; break;
+    default:
+        break;
+    }
+    switch (d->integerBase) {
+    case 2: f |= bin; break;
+    case 8: f |= oct; break;
+    case 10: f |= dec; break;
+    case 16: f |= hex; break;
+    default:
+        break;
+    }
+    switch (d->realNumberNotation) {
+    case FixedNotation: f |= fixed; break;
+    case ScientificNotation: f |= scientific; break;
+    default:
+        break;
+    }
+    if (d->numberFlags & ShowBase)
+        f |= showbase;
+    if (d->numberFlags & ForcePoint)
+        f |= showpoint;
+    if (d->numberFlags & ForceSign)
+        f |= showpos;
+    if (d->numberFlags & UppercaseBase)
+        f |= uppercase;
+    return f;
+}
+
+/*! \internal
+*/
+int QTextStream::flagsInternal(int newFlags)
+{
+    int oldFlags = flagsInternal();
+
+    if (newFlags & left)
+        setFieldAlignment(AlignLeft);
+    else if (newFlags & right)
+        setFieldAlignment(AlignRight);
+    else if (newFlags & internal)
+        setFieldAlignment(AlignCenter);
+
+    if (newFlags & bin)
+        setIntegerBase(2);
+    else if (newFlags & oct)
+        setIntegerBase(8);
+    else if (newFlags & dec)
+        setIntegerBase(10);
+    else if (newFlags & hex)
+        setIntegerBase(16);
+
+    if (newFlags & showbase)
+        setNumberFlags(numberFlags() | ShowBase);
+    if (newFlags & showpos)
+        setNumberFlags(numberFlags() | ForceSign);
+    if (newFlags & showpoint)
+        setNumberFlags(numberFlags() | ForcePoint);
+    if (newFlags & uppercase)
+        setNumberFlags(numberFlags() | UppercaseBase);
+
+    if (newFlags & fixed)
+        setRealNumberNotation(FixedNotation);
+    else if (newFlags & scientific)
+        setRealNumberNotation(ScientificNotation);
+
+    return oldFlags;
+}
+
+#ifndef QT_NO_TEXTCODEC
+/*!
+    Use setCodec() and setAutoDetectUnicode() instead.
+*/
+void QTextStream::setEncoding(Encoding encoding)
+{
+    Q_D(QTextStream);
+    resetCodecConverterStateHelper(&d->readConverterState);
+    resetCodecConverterStateHelper(&d->writeConverterState);
+
+    switch (encoding) {
+    case Locale:
+        d->writeConverterState.flags |= QTextCodec::IgnoreHeader;
+        setCodec(QTextCodec::codecForLocale());
+        d->autoDetectUnicode = true;
+        break;
+    case Latin1:
+        d->readConverterState.flags |= QTextCodec::IgnoreHeader;
+        d->writeConverterState.flags |= QTextCodec::IgnoreHeader;
+        setCodec(QTextCodec::codecForName("ISO-8859-1"));
+        d->autoDetectUnicode = false;
+        break;
+    case Unicode:
+        setCodec(QTextCodec::codecForName("UTF-16"));
+        d->autoDetectUnicode = false;
+        break;
+    case RawUnicode:
+        d->readConverterState.flags |= QTextCodec::IgnoreHeader;
+        d->writeConverterState.flags |= QTextCodec::IgnoreHeader;
+        setCodec(QTextCodec::codecForName("UTF-16"));
+        d->autoDetectUnicode = false;
+        break;
+    case UnicodeNetworkOrder:
+        d->readConverterState.flags |= QTextCodec::IgnoreHeader;
+        d->writeConverterState.flags |= QTextCodec::IgnoreHeader;
+        setCodec(QTextCodec::codecForName("UTF-16BE"));
+        d->autoDetectUnicode = false;
+        break;
+    case UnicodeReverse:
+        d->readConverterState.flags |= QTextCodec::IgnoreHeader;
+        d->writeConverterState.flags |= QTextCodec::IgnoreHeader;
+        setCodec(QTextCodec::codecForName("UTF-16LE"));
+        d->autoDetectUnicode = false;
+        break;
+    case UnicodeUTF8:
+        d->writeConverterState.flags |= QTextCodec::IgnoreHeader;
+        setCodec(QTextCodec::codecForName("UTF-8"));
+        d->autoDetectUnicode = true;
+        break;
+    }
+}
+#endif
+
+/*!
+    \enum QTextStream::Encoding
+    \compat
+
+    \value Latin1  Use setCodec(QTextCodec::codecForName("ISO-8859-1")) instead.
+    \value Locale  Use setCodec(QTextCodec::codecForLocale()) instead.
+    \value RawUnicode  Use setCodec(QTextCodec::codecForName("UTF-16")) instead.
+    \value Unicode  Use setCodec(QTextCodec::codecForName("UTF-16")) instead.
+    \value UnicodeNetworkOrder  Use setCodec(QTextCodec::codecForName("UTF-16BE")) instead.
+    \value UnicodeReverse  Use setCodec(QTextCodec::codecForName("UTF-16LE")) instead.
+    \value UnicodeUTF8  Use setCodec(QTextCodec::codecForName("UTF-8")) instead.
+
+    Also, for all encodings except QTextStream::Latin1 and
+    QTextStream::UTF8, you need to call setAutoDetectUnicode(false)
+    to obtain the Qt 3 behavior in addition to the setCodec() call.
+
+    \sa setCodec(), setAutoDetectUnicode()
+*/
+
+/*!
+    \fn int QTextStream::flags() const
+
+    Use fieldAlignment(), padChar(), fieldWidth(), numberFlags(),
+    integerBase(), realNumberNotation(), and realNumberNotation
+    instead.
+*/
+
+/*!
+    \fn int QTextStream::flags(int)
+
+    Use setFieldAlignment(), setPadChar(), setFieldWidth(),
+    setNumberFlags(), setIntegerBase(), setRealNumberNotation(), and
+    setRealNumberNotation instead.
+*/
+
+/*!
+    \fn int QTextStream::setf(int)
+
+    Use setFieldAlignment(), setPadChar(), setFieldWidth(),
+    setNumberFlags(), setIntegerBase(), setRealNumberNotation(), and
+    setRealNumberNotation instead.
+*/
+
+/*!
+    \fn int QTextStream::setf(int, int)
+
+    Use setFieldAlignment(), setPadChar(), setFieldWidth(),
+    setNumberFlags(), setIntegerBase(), setRealNumberNotation(), and
+    setRealNumberNotation instead.
+*/
+
+/*!
+    \fn int QTextStream::unsetf(int)
+
+    Use setFieldAlignment(), setPadChar(), setFieldWidth(),
+    setNumberFlags(), setIntegerBase(), setRealNumberNotation(), and
+    setRealNumberNotation instead.
+*/
+
+/*!
+    \fn int QTextStream::width(int)
+
+    Use setFieldWidth() instead.
+*/
+
+/*!
+    \fn int QTextStream::fill(int)
+
+    Use setPadChar() instead.
+*/
+
+/*!
+    \fn int QTextStream::precision(int)
+
+    Use setRealNumberPrecision() instead.
+*/
+
+/*!
+    \fn int QTextStream::read()
+
+    Use readAll() or readLine() instead.
+*/
+
+/*!
+    \fn int QTextStream::unsetDevice()
+
+    Use setDevice(0) instead.
+*/
+
+/*!
+    \variable QTextStream::skipws
+    \variable QTextStream::left
+    \variable QTextStream::right
+    \variable QTextStream::internal
+    \variable QTextStream::bin
+    \variable QTextStream::oct
+    \variable QTextStream::dec
+    \variable QTextStream::hex
+    \variable QTextStream::showbase
+    \variable QTextStream::showpoint
+    \variable QTextStream::uppercase
+    \variable QTextStream::showpos
+    \variable QTextStream::scientific
+    \variable QTextStream::fixed
+    \variable QTextStream::basefield
+    \variable QTextStream::adjustfield
+    \variable QTextStream::floatfield
+    \compat
+
+    Use the new \l{QTextStream manipulators} instead.
+*/
+
+#endif
+
+QT_END_NAMESPACE
+
+#ifndef QT_NO_QOBJECT
+#include "qtextstream.moc"
+#endif
+
diff --git a/src/corelib/io/qtextstream.h b/src/corelib/io/qtextstream.h
new file mode 100644
index 0000000..6302d34
--- /dev/null
+++ b/src/corelib/io/qtextstream.h
@@ -0,0 +1,375 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTEXTSTREAM_H
+#define QTEXTSTREAM_H
+
+#include <QtCore/qiodevice.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qchar.h>
+#include <QtCore/qlocale.h>
+
+#ifndef QT_NO_TEXTCODEC
+#  ifdef QT3_SUPPORT
+#    include <QtCore/qtextcodec.h>
+#  endif
+#endif
+
+#include <stdio.h>
+
+#ifdef Status
+#error qtextstream.h must be included before any header file that defines Status
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QTextCodec;
+class QTextDecoder;
+
+class QTextStreamPrivate;
+class Q_CORE_EXPORT QTextStream                                // text stream class
+{
+    Q_DECLARE_PRIVATE(QTextStream)
+
+public:
+    enum RealNumberNotation {
+        SmartNotation,
+        FixedNotation,
+        ScientificNotation
+    };
+    enum FieldAlignment {
+        AlignLeft,
+        AlignRight,
+        AlignCenter,
+        AlignAccountingStyle
+    };
+    enum Status {
+        Ok,
+        ReadPastEnd,
+        ReadCorruptData
+    };
+    enum NumberFlag {
+        ShowBase = 0x1,
+        ForcePoint = 0x2,
+        ForceSign = 0x4,
+        UppercaseBase = 0x8,
+        UppercaseDigits = 0x10
+    };
+    Q_DECLARE_FLAGS(NumberFlags, NumberFlag)
+
+    QTextStream();
+    explicit QTextStream(QIODevice *device);
+    explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);
+    virtual ~QTextStream();
+
+#ifndef QT_NO_TEXTCODEC
+    void setCodec(QTextCodec *codec);
+    void setCodec(const char *codecName);
+    QTextCodec *codec() const;
+    void setAutoDetectUnicode(bool enabled);
+    bool autoDetectUnicode() const;
+    void setGenerateByteOrderMark(bool generate);
+    bool generateByteOrderMark() const;
+#endif
+
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+
+    void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    QString *string() const;
+
+    Status status() const;
+    void setStatus(Status status);
+    void resetStatus();
+
+    bool atEnd() const;
+    void reset();
+    void flush();
+    bool seek(qint64 pos);
+    qint64 pos() const;
+
+    void skipWhiteSpace();
+
+    QString readLine(qint64 maxlen = 0);
+    QString readAll();
+    QString read(qint64 maxlen);
+
+    void setFieldAlignment(FieldAlignment alignment);
+    FieldAlignment fieldAlignment() const;
+
+    void setPadChar(QChar ch);
+    QChar padChar() const;
+
+    void setFieldWidth(int width);
+    int fieldWidth() const;
+
+    void setNumberFlags(NumberFlags flags);
+    NumberFlags numberFlags() const;
+
+    void setIntegerBase(int base);
+    int integerBase() const;
+
+    void setRealNumberNotation(RealNumberNotation notation);
+    RealNumberNotation realNumberNotation() const;
+
+    void setRealNumberPrecision(int precision);
+    int realNumberPrecision() const;
+
+    QTextStream &operator>>(QChar &ch);
+    QTextStream &operator>>(char &ch);
+    QTextStream &operator>>(signed short &i);
+    QTextStream &operator>>(unsigned short &i);
+    QTextStream &operator>>(signed int &i);
+    QTextStream &operator>>(unsigned int &i);
+    QTextStream &operator>>(signed long &i);
+    QTextStream &operator>>(unsigned long &i);
+    QTextStream &operator>>(qlonglong &i);
+    QTextStream &operator>>(qulonglong &i);
+    QTextStream &operator>>(float &f);
+    QTextStream &operator>>(double &f);
+    QTextStream &operator>>(QString &s);
+    QTextStream &operator>>(QByteArray &array);
+    QTextStream &operator>>(char *c);
+
+    QTextStream &operator<<(QBool b);
+    QTextStream &operator<<(QChar ch);
+    QTextStream &operator<<(char ch);
+    QTextStream &operator<<(signed short i);
+    QTextStream &operator<<(unsigned short i);
+    QTextStream &operator<<(signed int i);
+    QTextStream &operator<<(unsigned int i);
+    QTextStream &operator<<(signed long i);
+    QTextStream &operator<<(unsigned long i);
+    QTextStream &operator<<(qlonglong i);
+    QTextStream &operator<<(qulonglong i);
+    QTextStream &operator<<(float f);
+    QTextStream &operator<<(double f);
+    QTextStream &operator<<(const QString &s);
+    QTextStream &operator<<(const QByteArray &array);
+    QTextStream &operator<<(const char *c);
+    QTextStream &operator<<(const void *ptr);
+
+#ifdef QT3_SUPPORT
+    // not marked as QT3_SUPPORT to avoid double compiler warnings, as
+    // they are used in the QT3_SUPPORT functions below.
+    inline QT3_SUPPORT int flags() const { return flagsInternal(); }
+    inline QT3_SUPPORT int flags(int f) { return flagsInternal(f); }
+
+    inline QT3_SUPPORT int setf(int bits)
+    { int old = flagsInternal(); flagsInternal(flagsInternal() | bits); return old; }
+    inline QT3_SUPPORT int setf(int bits, int mask)
+    { int old = flagsInternal(); flagsInternal(flagsInternal() | (bits & mask)); return old; }
+    inline QT3_SUPPORT int unsetf(int bits)
+    { int old = flagsInternal(); flagsInternal(flagsInternal() & ~bits); return old; }
+
+    inline QT3_SUPPORT int width(int w)
+    { int old = fieldWidth(); setFieldWidth(w); return old; }
+    inline QT3_SUPPORT int fill(int f)
+    { QChar ch = padChar(); setPadChar(QChar(f)); return ch.unicode(); }
+    inline QT3_SUPPORT int precision(int p)
+    { int old = realNumberPrecision(); setRealNumberPrecision(p); return old; }
+
+    enum {
+        skipws       = 0x0001,                        // skip whitespace on input
+        left         = 0x0002,                        // left-adjust output
+        right        = 0x0004,                        // right-adjust output
+        internal     = 0x0008,                        // pad after sign
+        bin          = 0x0010,                        // binary format integer
+        oct          = 0x0020,                        // octal format integer
+        dec          = 0x0040,                        // decimal format integer
+        hex          = 0x0080,                        // hex format integer
+        showbase     = 0x0100,                        // show base indicator
+        showpoint    = 0x0200,                        // force decimal point (float)
+        uppercase    = 0x0400,                        // upper-case hex output
+        showpos      = 0x0800,                        // add '+' to positive integers
+        scientific   = 0x1000,                        // scientific float output
+        fixed        = 0x2000                         // fixed float output
+    };
+    enum {
+        basefield = bin | oct | dec | hex,
+        adjustfield = left | right | internal,
+        floatfield = scientific | fixed
+    };
+
+#ifndef QT_NO_TEXTCODEC
+    enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder,
+                    UnicodeReverse, RawUnicode, UnicodeUTF8 };
+    QT3_SUPPORT void setEncoding(Encoding encoding);
+#endif
+    inline QT3_SUPPORT QString read() { return readAll(); }
+    inline QT3_SUPPORT void unsetDevice() { setDevice(0); }
+#endif
+
+private:
+#ifdef QT3_SUPPORT
+    int flagsInternal() const;
+    int flagsInternal(int flags);
+#endif
+
+    Q_DISABLE_COPY(QTextStream)
+
+    QTextStreamPrivate *d_ptr;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QTextStream::NumberFlags)
+
+/*****************************************************************************
+  QTextStream manipulators
+ *****************************************************************************/
+
+typedef QTextStream & (*QTextStreamFunction)(QTextStream &);// manipulator function
+typedef void (QTextStream::*QTSMFI)(int); // manipulator w/int argument
+typedef void (QTextStream::*QTSMFC)(QChar); // manipulator w/QChar argument
+
+class Q_CORE_EXPORT QTextStreamManipulator
+{
+public:
+    QTextStreamManipulator(QTSMFI m, int a) { mf = m; mc = 0; arg = a; }
+    QTextStreamManipulator(QTSMFC m, QChar c) { mf = 0; mc = m; ch = c; }
+    void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } }
+
+private:
+    QTSMFI mf;                                        // QTextStream member function
+    QTSMFC mc;                                        // QTextStream member function
+    int arg;                                          // member function argument
+    QChar ch;
+};
+
+inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+
+inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+
+inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m)
+{ m.exec(s); return s; }
+
+Q_CORE_EXPORT QTextStream &bin(QTextStream &s);
+Q_CORE_EXPORT QTextStream &oct(QTextStream &s);
+Q_CORE_EXPORT QTextStream &dec(QTextStream &s);
+Q_CORE_EXPORT QTextStream &hex(QTextStream &s);
+
+Q_CORE_EXPORT QTextStream &showbase(QTextStream &s);
+Q_CORE_EXPORT QTextStream &forcesign(QTextStream &s);
+Q_CORE_EXPORT QTextStream &forcepoint(QTextStream &s);
+Q_CORE_EXPORT QTextStream &noshowbase(QTextStream &s);
+Q_CORE_EXPORT QTextStream &noforcesign(QTextStream &s);
+Q_CORE_EXPORT QTextStream &noforcepoint(QTextStream &s);
+
+Q_CORE_EXPORT QTextStream &uppercasebase(QTextStream &s);
+Q_CORE_EXPORT QTextStream &uppercasedigits(QTextStream &s);
+Q_CORE_EXPORT QTextStream &lowercasebase(QTextStream &s);
+Q_CORE_EXPORT QTextStream &lowercasedigits(QTextStream &s);
+
+Q_CORE_EXPORT QTextStream &fixed(QTextStream &s);
+Q_CORE_EXPORT QTextStream &scientific(QTextStream &s);
+
+Q_CORE_EXPORT QTextStream &left(QTextStream &s);
+Q_CORE_EXPORT QTextStream &right(QTextStream &s);
+Q_CORE_EXPORT QTextStream &center(QTextStream &s);
+
+Q_CORE_EXPORT QTextStream &endl(QTextStream &s);
+Q_CORE_EXPORT QTextStream &flush(QTextStream &s);
+Q_CORE_EXPORT QTextStream &reset(QTextStream &s);
+
+Q_CORE_EXPORT QTextStream &bom(QTextStream &s);
+
+Q_CORE_EXPORT QTextStream &ws(QTextStream &s);
+
+inline QTextStreamManipulator qSetFieldWidth(int width)
+{
+    QTSMFI func = &QTextStream::setFieldWidth;
+    return QTextStreamManipulator(func,width);
+}
+
+inline QTextStreamManipulator qSetPadChar(QChar ch)
+{
+    QTSMFC func = &QTextStream::setPadChar;
+    return QTextStreamManipulator(func, ch);
+}
+
+inline QTextStreamManipulator qSetRealNumberPrecision(int precision)
+{
+    QTSMFI func = &QTextStream::setRealNumberPrecision;
+    return QTextStreamManipulator(func, precision);
+}
+
+#ifdef QT3_SUPPORT
+typedef QTextStream QTS;
+
+class Q_CORE_EXPORT QTextIStream : public QTextStream
+{
+public:
+    inline explicit QTextIStream(const QString *s) : QTextStream(const_cast<QString *>(s), QIODevice::ReadOnly) {}
+    inline explicit QTextIStream(QByteArray *a) : QTextStream(a, QIODevice::ReadOnly) {}
+    inline QTextIStream(FILE *f) : QTextStream(f, QIODevice::ReadOnly) {}
+
+private:
+    Q_DISABLE_COPY(QTextIStream)
+};
+
+class Q_CORE_EXPORT QTextOStream : public QTextStream
+{
+public:
+    inline explicit QTextOStream(QString *s) : QTextStream(s, QIODevice::WriteOnly) {}
+    inline explicit QTextOStream(QByteArray *a) : QTextStream(a, QIODevice::WriteOnly) {}
+    inline QTextOStream(FILE *f) : QTextStream(f, QIODevice::WriteOnly) {}
+
+private:
+    Q_DISABLE_COPY(QTextOStream)
+};
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QTEXTSTREAM_H
diff --git a/src/corelib/io/qurl.cpp b/src/corelib/io/qurl.cpp
new file mode 100644
index 0000000..9ce9a2e
--- /dev/null
+++ b/src/corelib/io/qurl.cpp
@@ -0,0 +1,5999 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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$
+**
+****************************************************************************/
+
+/*!
+    \class QUrl
+
+    \brief The QUrl class provides a convenient interface for working
+    with URLs.
+
+    \reentrant
+    \ingroup io
+    \ingroup misc
+    \ingroup shared
+    \mainclass
+
+    It can parse and construct URLs in both encoded and unencoded
+    form. QUrl also has support for internationalized domain names
+    (IDNs).
+
+    The most common way to use QUrl is to initialize it via the
+    constructor by passing a QString. Otherwise, setUrl() and
+    setEncodedUrl() can also be used.
+
+    URLs can be represented in two forms: encoded or unencoded. The
+    unencoded representation is suitable for showing to users, but
+    the encoded representation is typically what you would send to
+    a web server. For example, the unencoded URL
+    "http://b\uuml\c{}hler.example.com" would be sent to the server as
+    "http://xn--bhler-kva.example.com/List%20of%20applicants.xml".
+
+    A URL can also be constructed piece by piece by calling
+    setScheme(), setUserName(), setPassword(), setHost(), setPort(),
+    setPath(), setEncodedQuery() and setFragment(). Some convenience
+    functions are also available: setAuthority() sets the user name,
+    password, host and port. setUserInfo() sets the user name and
+    password at once.
+
+    Call isValid() to check if the URL is valid. This can be done at
+    any point during the constructing of a URL.
+
+    Constructing a query is particularly convenient through the use
+    of setQueryItems(), addQueryItem() and removeQueryItem(). Use
+    setQueryDelimiters() to customize the delimiters used for
+    generating the query string.
+
+    For the convenience of generating encoded URL strings or query
+    strings, there are two static functions called
+    fromPercentEncoding() and toPercentEncoding() which deal with
+    percent encoding and decoding of QStrings.
+
+    Calling isRelative() will tell whether or not the URL is
+    relative. A relative URL can be resolved by passing it as argument
+    to resolved(), which returns an absolute URL. isParentOf() is used
+    for determining whether one URL is a parent of another.
+
+    fromLocalFile() constructs a QUrl by parsing a local
+    file path. toLocalFile() converts a URL to a local file path.
+
+    The human readable representation of the URL is fetched with
+    toString(). This representation is appropriate for displaying a
+    URL to a user in unencoded form. The encoded form however, as
+    returned by toEncoded(), is for internal use, passing to web
+    servers, mail clients and so on.
+
+    QUrl conforms to the URI specification from
+    \l{RFC 3986} (Uniform Resource Identifier: Generic Syntax), and includes
+    scheme extensions from \l{RFC 1738} (Uniform Resource Locators). Case
+    folding rules in QUrl conform to \l{RFC 3491} (Nameprep: A Stringprep
+    Profile for Internationalized Domain Names (IDN)).
+
+    \sa QUrlInfo
+*/
+
+/*!
+    \enum QUrl::ParsingMode
+
+    The parsing mode controls the way QUrl parses strings.
+
+    \value TolerantMode QUrl will try to correct some common errors in URLs.
+                        This mode is useful when processing URLs entered by
+                        users.
+
+    \value StrictMode Only valid URLs are accepted. This mode is useful for
+                      general URL validation.
+
+    In TolerantMode, the parser corrects the following invalid input:
+
+    \list
+
+    \o Spaces and "%20": If an encoded URL contains a space, this will be
+    replaced with "%20". If a decoded URL contains "%20", this will be
+    replaced with a single space before the URL is parsed.
+
+    \o Single "%" characters: Any occurrences of a percent character "%" not
+    followed by exactly two hexadecimal characters (e.g., "13% coverage.html")
+    will be replaced by "%25".
+
+    \o Reserved and unreserved characters: An encoded URL should only
+    contain a few characters as literals; all other characters should
+    be percent-encoded. In TolerantMode, these characters will be
+    automatically percent-encoded where they are not allowed:
+            space / double-quote / "<" / ">" / "[" / "\" /
+            "]" / "^" / "`" / "{" / "|" / "}"
+
+    \endlist
+*/
+
+/*!
+    \enum QUrl::FormattingOption
+
+    The formatting options define how the URL is formatted when written out
+    as text.
+
+    \value None The format of the URL is unchanged.
+    \value RemoveScheme  The scheme is removed from the URL.
+    \value RemovePassword  Any password in the URL is removed.
+    \value RemoveUserInfo  Any user information in the URL is removed.
+    \value RemovePort      Any specified port is removed from the URL.
+    \value RemoveAuthority
+    \value RemovePath   The URL's path is removed, leaving only the scheme,
+                        host address, and port (if present).
+    \value RemoveQuery  The query part of the URL (following a '?' character)
+                        is removed.
+    \value RemoveFragment
+    \value StripTrailingSlash  The trailing slash is removed if one is present.
+
+    Note that the case folding rules in \l{RFC 3491}{Nameprep}, which QUrl
+    conforms to, require host names to always be converted to lower case,
+    regardless of the Qt::FormattingOptions used.
+*/
+
+#include "qplatformdefs.h"
+#include "qurl.h"
+#include "private/qunicodetables_p.h"
+#include "qatomic.h"
+#include "qbytearray.h"
+#include "qlist.h"
+#ifndef QT_NO_REGEXP
+#include "qregexp.h"
+#endif
+#include "qstring.h"
+#include "qstringlist.h"
+#include "qstack.h"
+#include "qvarlengtharray.h"
+#include "qdebug.h"
+#if defined QT3_SUPPORT
+#include "qfileinfo.h"
+#endif
+
+#if defined(Q_OS_WINCE_WM)
+#pragma optimize("g", off)
+#endif
+
+QT_BEGIN_NAMESPACE
+
+extern void q_normalizePercentEncoding(QByteArray *ba, const char *exclude);
+extern void q_toPercentEncoding(QByteArray *ba, const char *exclude, const char *include = 0);
+extern void q_fromPercentEncoding(QByteArray *ba);
+
+static QByteArray toPercentEncodingHelper(const QString &s, const char *exclude, const char *include = 0)
+{
+    if (s.isNull())
+        return QByteArray();    // null
+    QByteArray ba = s.toUtf8();
+    q_toPercentEncoding(&ba, exclude, include);
+    return ba;
+}
+
+static QString fromPercentEncodingHelper(const QByteArray &ba)
+{
+    if (ba.isNull())
+        return QString();       // null
+    QByteArray copy = ba;
+    q_fromPercentEncoding(&copy);
+    return QString::fromUtf8(copy.constData(), copy.length());
+}
+
+static QString fromPercentEncodingMutable(QByteArray *ba)
+{
+    if (ba->isNull())
+        return QString();       // null
+    q_fromPercentEncoding(ba);
+    return QString::fromUtf8(ba->constData(), ba->length());
+}
+
+// ### Qt 5: Consider accepting empty strings as valid. See task 144227.
+
+//#define QURL_DEBUG
+
+// implemented in qvsnprintf.cpp
+Q_CORE_EXPORT int qsnprintf(char *str, size_t n, const char *fmt, ...);
+
+// needed by the punycode encoder/decoder
+#define Q_MAXINT ((uint)((uint)(-1)>>1))
+static const uint base = 36;
+static const uint tmin = 1;
+static const uint tmax = 26;
+static const uint skew = 38;
+static const uint damp = 700;
+static const uint initial_bias = 72;
+static const uint initial_n = 128;
+
+#define QURL_SETFLAG(a, b) { (a) |= (b); }
+#define QURL_UNSETFLAG(a, b) { (a) &= ~(b); }
+#define QURL_HASFLAG(a, b) (((a) & (b)) == (b))
+
+struct QUrlErrorInfo {
+    inline QUrlErrorInfo() : _source(0), _message(0), _expected(0), _found(0)
+    { }
+
+    const char *_source;
+    const char *_message;
+    char _expected;
+    char _found;
+
+    inline void setParams(const char *source, const char *message, char expected, char found)
+    {
+        _source = source;
+        _message = message;
+        _expected = expected;
+        _found = found;
+    }
+};
+
+struct QUrlParseData
+{
+    const char *scheme;
+    int schemeLength;
+    
+    const char *userInfo;
+    int userInfoDelimIndex;
+    int userInfoLength;
+    
+    const char *host;
+    int hostLength;
+    int port;
+
+    const char *path;
+    int pathLength;
+    const char *query;
+    int queryLength;
+    const char *fragment;
+    int fragmentLength;
+};
+
+
+class QUrlPrivate
+{
+public:
+    QUrlPrivate();
+    QUrlPrivate(const QUrlPrivate &other);
+
+    bool setUrl(const QString &url);
+
+    QString canonicalHost() const;
+    void ensureEncodedParts() const;
+    QString authority(QUrl::FormattingOptions options = QUrl::None) const;
+    void setAuthority(const QString &auth);
+    void setUserInfo(const QString &userInfo);
+    QString userInfo(QUrl::FormattingOptions options = QUrl::None) const;
+    void setEncodedAuthority(const QByteArray &authority);
+    void setEncodedUserInfo(const QUrlParseData *parseData);
+
+    QByteArray mergePaths(const QByteArray &relativePath) const;
+
+    void queryItem(int pos, int *value, int *end);
+
+    enum ParseOptions {
+        ParseAndSet,
+        ParseOnly
+    };
+
+    void validate() const;
+    void parse(ParseOptions parseOptions = ParseAndSet) const;
+    void clear();
+
+    QByteArray toEncoded(QUrl::FormattingOptions options = QUrl::None) const;
+
+    QAtomicInt ref;
+
+    QString scheme;
+    QString userName;
+    QString password;
+    QString host;
+    QString path;
+    QByteArray query;
+    QString fragment;
+
+    QByteArray encodedOriginal;
+    QByteArray encodedUserName;
+    QByteArray encodedPassword;
+    QByteArray encodedPath;
+    QByteArray encodedFragment;
+
+    int port;
+    QUrl::ParsingMode parsingMode;
+
+    bool hasQuery;
+    bool hasFragment;
+    bool isValid;
+
+    char valueDelimiter;
+    char pairDelimiter;
+
+    enum State {
+        Parsed = 0x1,
+        Validated = 0x2,
+        Normalized = 0x4,
+        HostCanonicalized = 0x8
+    };
+    int stateFlags;
+
+    QByteArray encodedNormalized;
+    const QByteArray & normalized();
+
+    mutable QUrlErrorInfo errorInfo;
+    QString createErrorString();
+};
+
+
+static bool QT_FASTCALL _HEXDIG(const char **ptr)
+{
+    char ch = **ptr;
+    if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {
+        ++(*ptr);
+        return true;
+    }
+
+    return false;
+}
+
+// pct-encoded = "%" HEXDIG HEXDIG
+static bool QT_FASTCALL _pctEncoded(const char **ptr)
+{
+    const char *ptrBackup = *ptr;
+
+    if (**ptr != '%')
+        return false;
+    ++(*ptr);
+    
+    if (!_HEXDIG(ptr)) {
+        *ptr = ptrBackup;
+        return false;
+    }
+    if (!_HEXDIG(ptr)) {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    return true;
+}
+
+#if 0
+// gen-delims  = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+static bool QT_FASTCALL _genDelims(const char **ptr, char *c)
+{
+    char ch = **ptr;
+    switch (ch) {
+    case ':': case '/': case '?': case '#':
+    case '[': case ']': case '@':
+        *c = ch;
+        ++(*ptr);
+        return true;
+    default:
+        return false;
+    }
+}
+#endif
+
+// sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"
+//             / "*" / "+" / "," / ";" / "="
+static bool QT_FASTCALL _subDelims(const char **ptr)
+{
+    char ch = **ptr;
+    switch (ch) {
+    case '!': case '$': case '&': case '\'':
+    case '(': case ')': case '*': case '+':
+    case ',': case ';': case '=':
+        ++(*ptr);
+        return true;
+    default:
+        return false;
+    }
+}
+
+// unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+static bool QT_FASTCALL _unreserved(const char **ptr)
+{
+    char ch = **ptr;
+    if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
+        || (ch >= '0' && ch <= '9')
+        || ch == '-' || ch == '.' || ch == '_' || ch == '~') {
+        ++(*ptr);
+        return true;
+    } 
+    return false;
+}
+
+// scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+static void QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)
+{
+    bool first = true;
+
+    parseData->scheme = *ptr;
+    for (;;) {
+        char ch = **ptr;
+        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
+            ;
+        } else if (!first && ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')) {
+            ;
+        } else {
+            break;
+        }
+
+        ++(*ptr);
+        first = false;
+    }
+
+    if (**ptr != ':') {
+        *ptr = parseData->scheme;
+    } else {
+        parseData->schemeLength = *ptr - parseData->scheme;
+        ++(*ptr); // skip ':'
+    }
+}
+
+// IPvFuture  = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
+static bool QT_FASTCALL _IPvFuture(const char **ptr)
+{
+    if (**ptr != 'v')
+        return false;
+
+    const char *ptrBackup = *ptr;
+    ++(*ptr);
+    
+    if (!_HEXDIG(ptr)) {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    while (_HEXDIG(ptr))
+        ;
+
+    if (**ptr != '.') {
+        *ptr = ptrBackup;
+        return false;
+    }
+    ++(*ptr);
+
+    if (!_unreserved(ptr) && !_subDelims(ptr) && *((*ptr)++) != ':') {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+
+    while (_unreserved(ptr) || _subDelims(ptr) || *((*ptr)++) == ':')
+        ;
+
+    return true;
+}
+
+// h16         = 1*4HEXDIG
+//             ; 16 bits of address represented in hexadecimal
+static bool QT_FASTCALL _h16(const char **ptr)
+{
+    int i = 0;
+    for (; i < 4; ++i) {
+        if (!_HEXDIG(ptr))
+            break;
+    }
+    return (i != 0);
+}
+
+// dec-octet   = DIGIT                 ; 0-9
+//             / %x31-39 DIGIT         ; 10-99
+//             / "1" 2DIGIT            ; 100-199
+//             / "2" %x30-34 DIGIT     ; 200-249
+//             / "25" %x30-35          ; 250-255
+static bool QT_FASTCALL _decOctet(const char **ptr)
+{
+    const char *ptrBackup = *ptr;
+    char c1 = **ptr;
+
+    if (c1 < '0' || c1 > '9') 
+        return false;
+
+    ++(*ptr);
+
+    if (c1 == '0')
+        return true;
+
+    char c2 = **ptr;
+
+    if (c2 < '0' || c2 > '9')
+        return true;
+
+    ++(*ptr);
+
+    char c3 = **ptr;
+    if (c3 < '0' || c3 > '9')
+        return true;
+
+    // If there is a three digit number larger than 255, reject the
+    // whole token.
+    if (c1 >= '2' && c2 >= '5' && c3 > '5') {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    ++(*ptr);
+
+    return true;
+}
+
+// IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+static bool QT_FASTCALL _IPv4Address(const char **ptr)
+{
+    const char *ptrBackup = *ptr;
+
+    if (!_decOctet(ptr)) {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    for (int i = 0; i < 3; ++i) {
+        char ch = *((*ptr)++);
+        if (ch != '.') {
+            *ptr = ptrBackup;
+            return false;
+        }
+
+        if (!_decOctet(ptr)) {
+            *ptr = ptrBackup;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// ls32        = ( h16 ":" h16 ) / IPv4address
+//             ; least-significant 32 bits of address
+static bool QT_FASTCALL _ls32(const char **ptr)
+{
+    const char *ptrBackup = *ptr;
+    if (_h16(ptr) && *((*ptr)++) == ':' && _h16(ptr)) 
+        return true;
+
+    *ptr = ptrBackup;
+    return _IPv4Address(ptr);
+}
+
+// IPv6address =                            6( h16 ":" ) ls32 // case 1
+//             /                       "::" 5( h16 ":" ) ls32 // case 2
+//             / [               h16 ] "::" 4( h16 ":" ) ls32 // case 3
+//             / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 // case 4
+//             / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 // case 5
+//             / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32 // case 6
+//             / [ *4( h16 ":" ) h16 ] "::"              ls32 // case 7
+//             / [ *5( h16 ":" ) h16 ] "::"              h16  // case 8
+//             / [ *6( h16 ":" ) h16 ] "::"                   // case 9
+static bool QT_FASTCALL _IPv6Address(const char **ptr)
+{
+    const char *ptrBackup = *ptr;
+
+    // count of (h16 ":") to the left of and including ::
+    int leftHexColons = 0;
+    // count of (h16 ":") to the right of ::
+    int rightHexColons = 0;
+
+    // first count the number of (h16 ":") on the left of ::
+    while (_h16(ptr)) {
+
+        // an h16 not followed by a colon is considered an
+        // error.
+        if (**ptr != ':') {
+            *ptr = ptrBackup;
+            return false;
+        }
+        ++(*ptr);
+        ++leftHexColons;
+
+        // check for case 1, the only time when there can be no ::
+        if (leftHexColons == 6 && _ls32(ptr)) {
+            return true;
+        }
+    }
+
+    // check for case 2 where the address starts with a :
+    if (leftHexColons == 0 && *((*ptr)++) != ':') {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    // check for the second colon in ::
+    if (*((*ptr)++) != ':') {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    int canBeCase = -1;
+    bool ls32WasRead = false;
+
+    const char *tmpBackup = *ptr;
+
+    // count the number of (h16 ":") on the right of ::
+    for (;;) {
+        tmpBackup = *ptr;
+        if (!_h16(ptr)) {
+            if (!_ls32(ptr)) {
+                if (rightHexColons != 0) {
+                    *ptr = ptrBackup;
+                    return false;
+                }
+
+                // the address ended with :: (case 9)
+                // only valid if 1 <= leftHexColons <= 7
+                canBeCase = 9;
+            } else {
+                ls32WasRead = true;
+            }
+            break;
+        }
+        ++rightHexColons;
+        if (**ptr != ':') {
+            // no colon could mean that what was read as an h16
+            // was in fact the first part of an ls32. we backtrack
+            // and retry.
+            const char *pb = *ptr;
+            *ptr = tmpBackup;
+            if (_ls32(ptr)) {
+                ls32WasRead = true;
+                --rightHexColons;
+            } else {
+                *ptr = pb;
+                // address ends with only 1 h16 after :: (case 8)
+                if (rightHexColons == 1)
+                    canBeCase = 8;
+            }
+            break;
+        }
+        ++(*ptr);
+    }
+
+    // determine which case it is based on the number of rightHexColons
+    if (canBeCase == -1) {
+
+        // check if a ls32 was read. If it wasn't and rightHexColons >= 2 then the
+        // last 2 HexColons are in fact a ls32
+        if (!ls32WasRead && rightHexColons >= 2)
+            rightHexColons -= 2;
+
+        canBeCase = 7 - rightHexColons;
+    }
+
+    // based on the case we need to check that the number of leftHexColons is valid
+    if (leftHexColons > (canBeCase - 2)) {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    return true;
+}
+
+// IP-literal = "[" ( IPv6address / IPvFuture  ) "]"
+static bool QT_FASTCALL _IPLiteral(const char **ptr)
+{
+    const char *ptrBackup = *ptr;
+    if (**ptr != '[')
+        return false;
+    ++(*ptr);
+
+    if (!_IPv6Address(ptr) && !_IPvFuture(ptr)) {
+        *ptr = ptrBackup;
+        return false;
+    }
+
+    if (**ptr != ']') {
+        *ptr = ptrBackup;
+        return false;
+    }
+    ++(*ptr);
+
+    return true;
+}
+
+// reg-name    = *( unreserved / pct-encoded / sub-delims )
+static void QT_FASTCALL _regName(const char **ptr)
+{
+    for (;;) {
+        if (!_unreserved(ptr) && !_subDelims(ptr)) {
+            if (!_pctEncoded(ptr))
+                break;
+        }
+    }
+}
+
+// host        = IP-literal / IPv4address / reg-name
+static void QT_FASTCALL _host(const char **ptr, QUrlParseData *parseData)
+{
+    parseData->host = *ptr;
+    if (!_IPLiteral(ptr)) {
+        if (_IPv4Address(ptr)) {
+            char ch = **ptr;
+            if (ch && ch != ':' && ch != '/') {
+                // reset
+                *ptr = parseData->host;
+                _regName(ptr);
+            }
+        } else {
+            _regName(ptr);
+        }
+    }
+    parseData->hostLength = *ptr - parseData->host;
+}
+
+// userinfo    = *( unreserved / pct-encoded / sub-delims / ":" )
+static void QT_FASTCALL _userInfo(const char **ptr, QUrlParseData *parseData)
+{
+    parseData->userInfo = *ptr;
+    for (;;) {
+        if (_unreserved(ptr) || _subDelims(ptr)) {
+            ;
+        } else {
+            if (_pctEncoded(ptr)) {
+                ;
+            } else if (**ptr == ':') {
+                parseData->userInfoDelimIndex = *ptr - parseData->userInfo;
+                ++(*ptr);
+            } else {
+                break;
+            }
+        }
+    }
+    if (**ptr != '@') {
+        *ptr = parseData->userInfo;
+        parseData->userInfoDelimIndex = -1;
+        return;
+    }
+    parseData->userInfoLength = *ptr - parseData->userInfo;
+    ++(*ptr);
+}
+
+// port        = *DIGIT
+static void QT_FASTCALL _port(const char **ptr, int *port)
+{
+    bool first = true;
+
+    for (;;) {
+        const char *ptrBackup = *ptr;
+        char ch = *((*ptr)++);
+        if (ch < '0' || ch > '9') {
+            *ptr = ptrBackup;
+            break;
+        }
+
+        if (first) {
+            first = false;
+            *port = 0;
+        }
+
+        *port *= 10;
+        *port += ch - '0';
+    }
+}
+
+// authority   = [ userinfo "@" ] host [ ":" port ]
+static void QT_FASTCALL _authority(const char **ptr, QUrlParseData *parseData)
+{
+    _userInfo(ptr, parseData);
+    _host(ptr, parseData);
+
+    if (**ptr != ':') 
+        return;
+
+    ++(*ptr);
+    _port(ptr, &parseData->port);
+}
+
+// pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+static bool QT_FASTCALL _pchar(const char **ptr)
+{
+    char c = *(*ptr);
+
+    switch (c) {
+    case '!': case '$': case '&': case '\'': case '(': case ')': case '*':
+    case '+': case ',': case ';': case '=': case ':': case '@':
+    case '-': case '.': case '_': case '~':
+        ++(*ptr);
+        return true;
+    default:
+        break;
+    };
+
+    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {
+        ++(*ptr);
+        return true;
+    }
+
+    if (_pctEncoded(ptr))
+        return true;
+
+    return false;
+}
+
+// segment       = *pchar
+static bool QT_FASTCALL _segmentNZ(const char **ptr)
+{
+    if (!_pchar(ptr))
+        return false;
+
+    while(_pchar(ptr))
+        ;
+
+    return true;
+}
+
+// path-abempty  = *( "/" segment )
+static void QT_FASTCALL _pathAbEmpty(const char **ptr)
+{
+    for (;;) {
+        if (**ptr != '/') 
+            break;
+        ++(*ptr);
+
+        while (_pchar(ptr))
+            ;
+    }
+}
+
+// path-abs      = "/" [ segment-nz *( "/" segment ) ]
+static bool QT_FASTCALL _pathAbs(const char **ptr)
+{
+    // **ptr == '/' already checked in caller
+    ++(*ptr);
+
+    // we might be able to unnest this to gain some performance.
+    if (!_segmentNZ(ptr))
+        return true;
+
+    _pathAbEmpty(ptr);
+
+    return true;
+}
+
+// path-rootless = segment-nz *( "/" segment )
+static bool QT_FASTCALL _pathRootless(const char **ptr)
+{
+    // we might be able to unnest this to gain some performance.
+    if (!_segmentNZ(ptr))
+        return false;
+
+    _pathAbEmpty(ptr);
+
+    return true;
+}
+
+
+// hier-part   = "//" authority path-abempty
+//             / path-abs
+//             / path-rootless
+//             / path-empty
+static void QT_FASTCALL _hierPart(const char **ptr, QUrlParseData *parseData)
+{
+    const char *ptrBackup = *ptr;
+    const char *pathStart = 0;
+    if (*((*ptr)++) == '/' && *((*ptr)++) == '/') {
+        _authority(ptr, parseData);
+        pathStart = *ptr;
+        _pathAbEmpty(ptr);
+    } else {
+        *ptr = ptrBackup;
+        pathStart = *ptr;
+        if (**ptr == '/')
+            _pathAbs(ptr);
+        else
+            _pathRootless(ptr);
+    }
+    parseData->path = pathStart;
+    parseData->pathLength = *ptr - pathStart;
+}
+
+// query       = *( pchar / "/" / "?" )
+static void QT_FASTCALL _query(const char **ptr, QUrlParseData *parseData)
+{
+    parseData->query = *ptr;
+    for (;;) {
+        if (_pchar(ptr)) {
+            ;
+        } else if (**ptr == '/' || **ptr == '?') {
+            ++(*ptr);
+        } else {
+            break;
+        }
+    }
+    parseData->queryLength = *ptr - parseData->query;
+}
+
+// fragment    = *( pchar / "/" / "?" )
+static void QT_FASTCALL _fragment(const char **ptr, QUrlParseData *parseData)
+{
+    parseData->fragment = *ptr;
+    for (;;) {
+        if (_pchar(ptr)) {
+            ;
+        } else if (**ptr == '/' || **ptr == '?' || **ptr == '#') {
+            ++(*ptr);
+        } else {
+            break;
+        }
+    }
+    parseData->fragmentLength = *ptr - parseData->fragment;
+}
+
+struct NameprepCaseFoldingEntry {
+    int uc;
+    ushort mapping[4];
+};
+
+inline bool operator<(int one, const NameprepCaseFoldingEntry &other)
+{ return one < other.uc; }
+
+inline bool operator<(const NameprepCaseFoldingEntry &one, int other)
+{ return one.uc < other; }
+
+static const NameprepCaseFoldingEntry NameprepCaseFolding[] = {
+/*	{ 0x0041, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0042, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0043, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0044, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0045, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0046, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0047, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0048, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0049, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x004A, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x004B, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x004C, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x004D, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x004E, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x004F, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0050, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0051, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0052, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0053, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0054, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0055, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0056, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0057, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0058, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0059, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x005A, { 0x007A, 0x0000, 0x0000, 0x0000 } },*/
+	{ 0x00B5, { 0x03BC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C0, { 0x00E0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C1, { 0x00E1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C2, { 0x00E2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C3, { 0x00E3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C4, { 0x00E4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C5, { 0x00E5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C6, { 0x00E6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C7, { 0x00E7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C8, { 0x00E8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00C9, { 0x00E9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00CA, { 0x00EA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00CB, { 0x00EB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00CC, { 0x00EC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00CD, { 0x00ED, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00CE, { 0x00EE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00CF, { 0x00EF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D0, { 0x00F0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D1, { 0x00F1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D2, { 0x00F2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D3, { 0x00F3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D4, { 0x00F4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D5, { 0x00F5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D6, { 0x00F6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D8, { 0x00F8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00D9, { 0x00F9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00DA, { 0x00FA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00DB, { 0x00FB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00DC, { 0x00FC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00DD, { 0x00FD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00DE, { 0x00FE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x00DF, { 0x0073, 0x0073, 0x0000, 0x0000 } },
+	{ 0x0100, { 0x0101, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0102, { 0x0103, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0104, { 0x0105, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0106, { 0x0107, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0108, { 0x0109, 0x0000, 0x0000, 0x0000 } },
+	{ 0x010A, { 0x010B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x010C, { 0x010D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x010E, { 0x010F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0110, { 0x0111, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0112, { 0x0113, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0114, { 0x0115, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0116, { 0x0117, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0118, { 0x0119, 0x0000, 0x0000, 0x0000 } },
+	{ 0x011A, { 0x011B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x011C, { 0x011D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x011E, { 0x011F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0120, { 0x0121, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0122, { 0x0123, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0124, { 0x0125, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0126, { 0x0127, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0128, { 0x0129, 0x0000, 0x0000, 0x0000 } },
+	{ 0x012A, { 0x012B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x012C, { 0x012D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x012E, { 0x012F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0130, { 0x0069, 0x0307, 0x0000, 0x0000 } },
+	{ 0x0132, { 0x0133, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0134, { 0x0135, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0136, { 0x0137, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0139, { 0x013A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x013B, { 0x013C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x013D, { 0x013E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x013F, { 0x0140, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0141, { 0x0142, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0143, { 0x0144, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0145, { 0x0146, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0147, { 0x0148, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0149, { 0x02BC, 0x006E, 0x0000, 0x0000 } },
+	{ 0x014A, { 0x014B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x014C, { 0x014D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x014E, { 0x014F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0150, { 0x0151, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0152, { 0x0153, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0154, { 0x0155, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0156, { 0x0157, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0158, { 0x0159, 0x0000, 0x0000, 0x0000 } },
+	{ 0x015A, { 0x015B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x015C, { 0x015D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x015E, { 0x015F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0160, { 0x0161, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0162, { 0x0163, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0164, { 0x0165, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0166, { 0x0167, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0168, { 0x0169, 0x0000, 0x0000, 0x0000 } },
+	{ 0x016A, { 0x016B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x016C, { 0x016D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x016E, { 0x016F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0170, { 0x0171, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0172, { 0x0173, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0174, { 0x0175, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0176, { 0x0177, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0178, { 0x00FF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0179, { 0x017A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x017B, { 0x017C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x017D, { 0x017E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x017F, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0181, { 0x0253, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0182, { 0x0183, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0184, { 0x0185, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0186, { 0x0254, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0187, { 0x0188, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0189, { 0x0256, 0x0000, 0x0000, 0x0000 } },
+	{ 0x018A, { 0x0257, 0x0000, 0x0000, 0x0000 } },
+	{ 0x018B, { 0x018C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x018E, { 0x01DD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x018F, { 0x0259, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0190, { 0x025B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0191, { 0x0192, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0193, { 0x0260, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0194, { 0x0263, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0196, { 0x0269, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0197, { 0x0268, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0198, { 0x0199, 0x0000, 0x0000, 0x0000 } },
+	{ 0x019C, { 0x026F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x019D, { 0x0272, 0x0000, 0x0000, 0x0000 } },
+	{ 0x019F, { 0x0275, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01A0, { 0x01A1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01A2, { 0x01A3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01A4, { 0x01A5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01A6, { 0x0280, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01A7, { 0x01A8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01A9, { 0x0283, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01AC, { 0x01AD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01AE, { 0x0288, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01AF, { 0x01B0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01B1, { 0x028A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01B2, { 0x028B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01B3, { 0x01B4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01B5, { 0x01B6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01B7, { 0x0292, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01B8, { 0x01B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01BC, { 0x01BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01C4, { 0x01C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01C5, { 0x01C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01C7, { 0x01C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01C8, { 0x01C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01CA, { 0x01CC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01CB, { 0x01CC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01CD, { 0x01CE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01CF, { 0x01D0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01D1, { 0x01D2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01D3, { 0x01D4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01D5, { 0x01D6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01D7, { 0x01D8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01D9, { 0x01DA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01DB, { 0x01DC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01DE, { 0x01DF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01E0, { 0x01E1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01E2, { 0x01E3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01E4, { 0x01E5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01E6, { 0x01E7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01E8, { 0x01E9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01EA, { 0x01EB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01EC, { 0x01ED, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01EE, { 0x01EF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01F0, { 0x006A, 0x030C, 0x0000, 0x0000 } },
+	{ 0x01F1, { 0x01F3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01F2, { 0x01F3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01F4, { 0x01F5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01F6, { 0x0195, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01F7, { 0x01BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01F8, { 0x01F9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01FA, { 0x01FB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01FC, { 0x01FD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x01FE, { 0x01FF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0200, { 0x0201, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0202, { 0x0203, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0204, { 0x0205, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0206, { 0x0207, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0208, { 0x0209, 0x0000, 0x0000, 0x0000 } },
+	{ 0x020A, { 0x020B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x020C, { 0x020D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x020E, { 0x020F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0210, { 0x0211, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0212, { 0x0213, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0214, { 0x0215, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0216, { 0x0217, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0218, { 0x0219, 0x0000, 0x0000, 0x0000 } },
+	{ 0x021A, { 0x021B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x021C, { 0x021D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x021E, { 0x021F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0220, { 0x019E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0222, { 0x0223, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0224, { 0x0225, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0226, { 0x0227, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0228, { 0x0229, 0x0000, 0x0000, 0x0000 } },
+	{ 0x022A, { 0x022B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x022C, { 0x022D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x022E, { 0x022F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0230, { 0x0231, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0232, { 0x0233, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0345, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x037A, { 0x0020, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x0386, { 0x03AC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0388, { 0x03AD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0389, { 0x03AE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x038A, { 0x03AF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x038C, { 0x03CC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x038E, { 0x03CD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x038F, { 0x03CE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0390, { 0x03B9, 0x0308, 0x0301, 0x0000 } },
+	{ 0x0391, { 0x03B1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0392, { 0x03B2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0393, { 0x03B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0394, { 0x03B4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0395, { 0x03B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0396, { 0x03B6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0397, { 0x03B7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0398, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0399, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x039A, { 0x03BA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x039B, { 0x03BB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x039C, { 0x03BC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x039D, { 0x03BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x039E, { 0x03BE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x039F, { 0x03BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A0, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A1, { 0x03C1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A3, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A4, { 0x03C4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A5, { 0x03C5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A6, { 0x03C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A7, { 0x03C7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A8, { 0x03C8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03A9, { 0x03C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03AA, { 0x03CA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03AB, { 0x03CB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03B0, { 0x03C5, 0x0308, 0x0301, 0x0000 } },
+	{ 0x03C2, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D0, { 0x03B2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D1, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D2, { 0x03C5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D3, { 0x03CD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D4, { 0x03CB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D5, { 0x03C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D6, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03D8, { 0x03D9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03DA, { 0x03DB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03DC, { 0x03DD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03DE, { 0x03DF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03E0, { 0x03E1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03E2, { 0x03E3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03E4, { 0x03E5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03E6, { 0x03E7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03E8, { 0x03E9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03EA, { 0x03EB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03EC, { 0x03ED, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03EE, { 0x03EF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03F0, { 0x03BA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03F1, { 0x03C1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03F2, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03F4, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x03F5, { 0x03B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0400, { 0x0450, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0401, { 0x0451, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0402, { 0x0452, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0403, { 0x0453, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0404, { 0x0454, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0405, { 0x0455, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0406, { 0x0456, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0407, { 0x0457, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0408, { 0x0458, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0409, { 0x0459, 0x0000, 0x0000, 0x0000 } },
+	{ 0x040A, { 0x045A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x040B, { 0x045B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x040C, { 0x045C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x040D, { 0x045D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x040E, { 0x045E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x040F, { 0x045F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0410, { 0x0430, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0411, { 0x0431, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0412, { 0x0432, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0413, { 0x0433, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0414, { 0x0434, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0415, { 0x0435, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0416, { 0x0436, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0417, { 0x0437, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0418, { 0x0438, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0419, { 0x0439, 0x0000, 0x0000, 0x0000 } },
+	{ 0x041A, { 0x043A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x041B, { 0x043B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x041C, { 0x043C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x041D, { 0x043D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x041E, { 0x043E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x041F, { 0x043F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0420, { 0x0440, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0421, { 0x0441, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0422, { 0x0442, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0423, { 0x0443, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0424, { 0x0444, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0425, { 0x0445, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0426, { 0x0446, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0427, { 0x0447, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0428, { 0x0448, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0429, { 0x0449, 0x0000, 0x0000, 0x0000 } },
+	{ 0x042A, { 0x044A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x042B, { 0x044B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x042C, { 0x044C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x042D, { 0x044D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x042E, { 0x044E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x042F, { 0x044F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0460, { 0x0461, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0462, { 0x0463, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0464, { 0x0465, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0466, { 0x0467, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0468, { 0x0469, 0x0000, 0x0000, 0x0000 } },
+	{ 0x046A, { 0x046B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x046C, { 0x046D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x046E, { 0x046F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0470, { 0x0471, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0472, { 0x0473, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0474, { 0x0475, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0476, { 0x0477, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0478, { 0x0479, 0x0000, 0x0000, 0x0000 } },
+	{ 0x047A, { 0x047B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x047C, { 0x047D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x047E, { 0x047F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0480, { 0x0481, 0x0000, 0x0000, 0x0000 } },
+	{ 0x048A, { 0x048B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x048C, { 0x048D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x048E, { 0x048F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0490, { 0x0491, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0492, { 0x0493, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0494, { 0x0495, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0496, { 0x0497, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0498, { 0x0499, 0x0000, 0x0000, 0x0000 } },
+	{ 0x049A, { 0x049B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x049C, { 0x049D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x049E, { 0x049F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04A0, { 0x04A1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04A2, { 0x04A3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04A4, { 0x04A5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04A6, { 0x04A7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04A8, { 0x04A9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04AA, { 0x04AB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04AC, { 0x04AD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04AE, { 0x04AF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04B0, { 0x04B1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04B2, { 0x04B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04B4, { 0x04B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04B6, { 0x04B7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04B8, { 0x04B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04BA, { 0x04BB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04BC, { 0x04BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04BE, { 0x04BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04C1, { 0x04C2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04C3, { 0x04C4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04C5, { 0x04C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04C7, { 0x04C8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04C9, { 0x04CA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04CB, { 0x04CC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04CD, { 0x04CE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04D0, { 0x04D1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04D2, { 0x04D3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04D4, { 0x04D5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04D6, { 0x04D7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04D8, { 0x04D9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04DA, { 0x04DB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04DC, { 0x04DD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04DE, { 0x04DF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04E0, { 0x04E1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04E2, { 0x04E3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04E4, { 0x04E5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04E6, { 0x04E7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04E8, { 0x04E9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04EA, { 0x04EB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04EC, { 0x04ED, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04EE, { 0x04EF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04F0, { 0x04F1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04F2, { 0x04F3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04F4, { 0x04F5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x04F8, { 0x04F9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0500, { 0x0501, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0502, { 0x0503, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0504, { 0x0505, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0506, { 0x0507, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0508, { 0x0509, 0x0000, 0x0000, 0x0000 } },
+	{ 0x050A, { 0x050B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x050C, { 0x050D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x050E, { 0x050F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0531, { 0x0561, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0532, { 0x0562, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0533, { 0x0563, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0534, { 0x0564, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0535, { 0x0565, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0536, { 0x0566, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0537, { 0x0567, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0538, { 0x0568, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0539, { 0x0569, 0x0000, 0x0000, 0x0000 } },
+	{ 0x053A, { 0x056A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x053B, { 0x056B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x053C, { 0x056C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x053D, { 0x056D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x053E, { 0x056E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x053F, { 0x056F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0540, { 0x0570, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0541, { 0x0571, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0542, { 0x0572, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0543, { 0x0573, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0544, { 0x0574, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0545, { 0x0575, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0546, { 0x0576, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0547, { 0x0577, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0548, { 0x0578, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0549, { 0x0579, 0x0000, 0x0000, 0x0000 } },
+	{ 0x054A, { 0x057A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x054B, { 0x057B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x054C, { 0x057C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x054D, { 0x057D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x054E, { 0x057E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x054F, { 0x057F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0550, { 0x0580, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0551, { 0x0581, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0552, { 0x0582, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0553, { 0x0583, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0554, { 0x0584, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0555, { 0x0585, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0556, { 0x0586, 0x0000, 0x0000, 0x0000 } },
+	{ 0x0587, { 0x0565, 0x0582, 0x0000, 0x0000 } },
+	{ 0x1E00, { 0x1E01, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E02, { 0x1E03, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E04, { 0x1E05, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E06, { 0x1E07, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E08, { 0x1E09, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E0A, { 0x1E0B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E0C, { 0x1E0D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E0E, { 0x1E0F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E10, { 0x1E11, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E12, { 0x1E13, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E14, { 0x1E15, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E16, { 0x1E17, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E18, { 0x1E19, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E1A, { 0x1E1B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E1C, { 0x1E1D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E1E, { 0x1E1F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E20, { 0x1E21, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E22, { 0x1E23, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E24, { 0x1E25, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E26, { 0x1E27, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E28, { 0x1E29, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E2A, { 0x1E2B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E2C, { 0x1E2D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E2E, { 0x1E2F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E30, { 0x1E31, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E32, { 0x1E33, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E34, { 0x1E35, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E36, { 0x1E37, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E38, { 0x1E39, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E3A, { 0x1E3B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E3C, { 0x1E3D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E3E, { 0x1E3F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E40, { 0x1E41, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E42, { 0x1E43, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E44, { 0x1E45, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E46, { 0x1E47, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E48, { 0x1E49, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E4A, { 0x1E4B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E4C, { 0x1E4D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E4E, { 0x1E4F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E50, { 0x1E51, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E52, { 0x1E53, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E54, { 0x1E55, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E56, { 0x1E57, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E58, { 0x1E59, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E5A, { 0x1E5B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E5C, { 0x1E5D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E5E, { 0x1E5F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E60, { 0x1E61, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E62, { 0x1E63, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E64, { 0x1E65, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E66, { 0x1E67, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E68, { 0x1E69, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E6A, { 0x1E6B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E6C, { 0x1E6D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E6E, { 0x1E6F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E70, { 0x1E71, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E72, { 0x1E73, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E74, { 0x1E75, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E76, { 0x1E77, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E78, { 0x1E79, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E7A, { 0x1E7B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E7C, { 0x1E7D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E7E, { 0x1E7F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E80, { 0x1E81, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E82, { 0x1E83, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E84, { 0x1E85, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E86, { 0x1E87, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E88, { 0x1E89, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E8A, { 0x1E8B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E8C, { 0x1E8D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E8E, { 0x1E8F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E90, { 0x1E91, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E92, { 0x1E93, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E94, { 0x1E95, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1E96, { 0x0068, 0x0331, 0x0000, 0x0000 } },
+	{ 0x1E97, { 0x0074, 0x0308, 0x0000, 0x0000 } },
+	{ 0x1E98, { 0x0077, 0x030A, 0x0000, 0x0000 } },
+	{ 0x1E99, { 0x0079, 0x030A, 0x0000, 0x0000 } },
+	{ 0x1E9A, { 0x0061, 0x02BE, 0x0000, 0x0000 } },
+	{ 0x1E9B, { 0x1E61, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EA0, { 0x1EA1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EA2, { 0x1EA3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EA4, { 0x1EA5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EA6, { 0x1EA7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EA8, { 0x1EA9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EAA, { 0x1EAB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EAC, { 0x1EAD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EAE, { 0x1EAF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EB0, { 0x1EB1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EB2, { 0x1EB3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EB4, { 0x1EB5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EB6, { 0x1EB7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EB8, { 0x1EB9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EBA, { 0x1EBB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EBC, { 0x1EBD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EBE, { 0x1EBF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EC0, { 0x1EC1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EC2, { 0x1EC3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EC4, { 0x1EC5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EC6, { 0x1EC7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EC8, { 0x1EC9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ECA, { 0x1ECB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ECC, { 0x1ECD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ECE, { 0x1ECF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ED0, { 0x1ED1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ED2, { 0x1ED3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ED4, { 0x1ED5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ED6, { 0x1ED7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1ED8, { 0x1ED9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EDA, { 0x1EDB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EDC, { 0x1EDD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EDE, { 0x1EDF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EE0, { 0x1EE1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EE2, { 0x1EE3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EE4, { 0x1EE5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EE6, { 0x1EE7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EE8, { 0x1EE9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EEA, { 0x1EEB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EEC, { 0x1EED, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EEE, { 0x1EEF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EF0, { 0x1EF1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EF2, { 0x1EF3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EF4, { 0x1EF5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EF6, { 0x1EF7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1EF8, { 0x1EF9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F08, { 0x1F00, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F09, { 0x1F01, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F0A, { 0x1F02, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F0B, { 0x1F03, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F0C, { 0x1F04, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F0D, { 0x1F05, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F0E, { 0x1F06, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F0F, { 0x1F07, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F18, { 0x1F10, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F19, { 0x1F11, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F1A, { 0x1F12, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F1B, { 0x1F13, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F1C, { 0x1F14, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F1D, { 0x1F15, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F28, { 0x1F20, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F29, { 0x1F21, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F2A, { 0x1F22, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F2B, { 0x1F23, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F2C, { 0x1F24, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F2D, { 0x1F25, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F2E, { 0x1F26, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F2F, { 0x1F27, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F38, { 0x1F30, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F39, { 0x1F31, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F3A, { 0x1F32, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F3B, { 0x1F33, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F3C, { 0x1F34, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F3D, { 0x1F35, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F3E, { 0x1F36, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F3F, { 0x1F37, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F48, { 0x1F40, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F49, { 0x1F41, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F4A, { 0x1F42, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F4B, { 0x1F43, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F4C, { 0x1F44, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F4D, { 0x1F45, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F50, { 0x03C5, 0x0313, 0x0000, 0x0000 } },
+	{ 0x1F52, { 0x03C5, 0x0313, 0x0300, 0x0000 } },
+	{ 0x1F54, { 0x03C5, 0x0313, 0x0301, 0x0000 } },
+	{ 0x1F56, { 0x03C5, 0x0313, 0x0342, 0x0000 } },
+	{ 0x1F59, { 0x1F51, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F5B, { 0x1F53, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F5D, { 0x1F55, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F5F, { 0x1F57, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F68, { 0x1F60, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F69, { 0x1F61, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F6A, { 0x1F62, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F6B, { 0x1F63, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F6C, { 0x1F64, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F6D, { 0x1F65, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F6E, { 0x1F66, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F6F, { 0x1F67, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1F80, { 0x1F00, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F81, { 0x1F01, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F82, { 0x1F02, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F83, { 0x1F03, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F84, { 0x1F04, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F85, { 0x1F05, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F86, { 0x1F06, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F87, { 0x1F07, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F88, { 0x1F00, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F89, { 0x1F01, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F8A, { 0x1F02, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F8B, { 0x1F03, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F8C, { 0x1F04, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F8D, { 0x1F05, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F8E, { 0x1F06, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F8F, { 0x1F07, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F90, { 0x1F20, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F91, { 0x1F21, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F92, { 0x1F22, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F93, { 0x1F23, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F94, { 0x1F24, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F95, { 0x1F25, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F96, { 0x1F26, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F97, { 0x1F27, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F98, { 0x1F20, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F99, { 0x1F21, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F9A, { 0x1F22, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F9B, { 0x1F23, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F9C, { 0x1F24, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F9D, { 0x1F25, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F9E, { 0x1F26, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1F9F, { 0x1F27, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA0, { 0x1F60, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA1, { 0x1F61, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA2, { 0x1F62, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA3, { 0x1F63, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA4, { 0x1F64, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA5, { 0x1F65, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA6, { 0x1F66, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA7, { 0x1F67, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA8, { 0x1F60, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FA9, { 0x1F61, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FAA, { 0x1F62, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FAB, { 0x1F63, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FAC, { 0x1F64, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FAD, { 0x1F65, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FAE, { 0x1F66, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FAF, { 0x1F67, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FB2, { 0x1F70, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FB3, { 0x03B1, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FB4, { 0x03AC, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FB6, { 0x03B1, 0x0342, 0x0000, 0x0000 } },
+	{ 0x1FB7, { 0x03B1, 0x0342, 0x03B9, 0x0000 } },
+	{ 0x1FB8, { 0x1FB0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FB9, { 0x1FB1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FBA, { 0x1F70, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FBB, { 0x1F71, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FBC, { 0x03B1, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FBE, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FC2, { 0x1F74, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FC3, { 0x03B7, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FC4, { 0x03AE, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FC6, { 0x03B7, 0x0342, 0x0000, 0x0000 } },
+	{ 0x1FC7, { 0x03B7, 0x0342, 0x03B9, 0x0000 } },
+	{ 0x1FC8, { 0x1F72, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FC9, { 0x1F73, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FCA, { 0x1F74, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FCB, { 0x1F75, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FCC, { 0x03B7, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FD2, { 0x03B9, 0x0308, 0x0300, 0x0000 } },
+	{ 0x1FD3, { 0x03B9, 0x0308, 0x0301, 0x0000 } },
+	{ 0x1FD6, { 0x03B9, 0x0342, 0x0000, 0x0000 } },
+	{ 0x1FD7, { 0x03B9, 0x0308, 0x0342, 0x0000 } },
+	{ 0x1FD8, { 0x1FD0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FD9, { 0x1FD1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FDA, { 0x1F76, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FDB, { 0x1F77, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FE2, { 0x03C5, 0x0308, 0x0300, 0x0000 } },
+	{ 0x1FE3, { 0x03C5, 0x0308, 0x0301, 0x0000 } },
+	{ 0x1FE4, { 0x03C1, 0x0313, 0x0000, 0x0000 } },
+	{ 0x1FE6, { 0x03C5, 0x0342, 0x0000, 0x0000 } },
+	{ 0x1FE7, { 0x03C5, 0x0308, 0x0342, 0x0000 } },
+	{ 0x1FE8, { 0x1FE0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FE9, { 0x1FE1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FEA, { 0x1F7A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FEB, { 0x1F7B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FEC, { 0x1FE5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FF2, { 0x1F7C, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FF3, { 0x03C9, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FF4, { 0x03CE, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x1FF6, { 0x03C9, 0x0342, 0x0000, 0x0000 } },
+	{ 0x1FF7, { 0x03C9, 0x0342, 0x03B9, 0x0000 } },
+	{ 0x1FF8, { 0x1F78, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FF9, { 0x1F79, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FFA, { 0x1F7C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FFB, { 0x1F7D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1FFC, { 0x03C9, 0x03B9, 0x0000, 0x0000 } },
+	{ 0x20A8, { 0x0072, 0x0073, 0x0000, 0x0000 } },
+	{ 0x2102, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2103, { 0x00B0, 0x0063, 0x0000, 0x0000 } },
+	{ 0x2107, { 0x025B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2109, { 0x00B0, 0x0066, 0x0000, 0x0000 } },
+	{ 0x210B, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x210C, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x210D, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2110, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2111, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2112, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2115, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2116, { 0x006E, 0x006F, 0x0000, 0x0000 } },
+	{ 0x2119, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x211A, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x211B, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x211C, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x211D, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2120, { 0x0073, 0x006D, 0x0000, 0x0000 } },
+	{ 0x2121, { 0x0074, 0x0065, 0x006C, 0x0000 } },
+	{ 0x2122, { 0x0074, 0x006D, 0x0000, 0x0000 } },
+	{ 0x2124, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2126, { 0x03C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2128, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x212A, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x212B, { 0x00E5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x212C, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x212D, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2130, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2131, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2133, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x213E, { 0x03B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x213F, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2145, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2160, { 0x2170, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2161, { 0x2171, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2162, { 0x2172, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2163, { 0x2173, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2164, { 0x2174, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2165, { 0x2175, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2166, { 0x2176, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2167, { 0x2177, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2168, { 0x2178, 0x0000, 0x0000, 0x0000 } },
+	{ 0x2169, { 0x2179, 0x0000, 0x0000, 0x0000 } },
+	{ 0x216A, { 0x217A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x216B, { 0x217B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x216C, { 0x217C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x216D, { 0x217D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x216E, { 0x217E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x216F, { 0x217F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24B6, { 0x24D0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24B7, { 0x24D1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24B8, { 0x24D2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24B9, { 0x24D3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24BA, { 0x24D4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24BB, { 0x24D5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24BC, { 0x24D6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24BD, { 0x24D7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24BE, { 0x24D8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24BF, { 0x24D9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C0, { 0x24DA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C1, { 0x24DB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C2, { 0x24DC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C3, { 0x24DD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C4, { 0x24DE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C5, { 0x24DF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C6, { 0x24E0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C7, { 0x24E1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C8, { 0x24E2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24C9, { 0x24E3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24CA, { 0x24E4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24CB, { 0x24E5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24CC, { 0x24E6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24CD, { 0x24E7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24CE, { 0x24E8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x24CF, { 0x24E9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x3371, { 0x0068, 0x0070, 0x0061, 0x0000 } },
+	{ 0x3373, { 0x0061, 0x0075, 0x0000, 0x0000 } },
+	{ 0x3375, { 0x006F, 0x0076, 0x0000, 0x0000 } },
+	{ 0x3380, { 0x0070, 0x0061, 0x0000, 0x0000 } },
+	{ 0x3381, { 0x006E, 0x0061, 0x0000, 0x0000 } },
+	{ 0x3382, { 0x03BC, 0x0061, 0x0000, 0x0000 } },
+	{ 0x3383, { 0x006D, 0x0061, 0x0000, 0x0000 } },
+	{ 0x3384, { 0x006B, 0x0061, 0x0000, 0x0000 } },
+	{ 0x3385, { 0x006B, 0x0062, 0x0000, 0x0000 } },
+	{ 0x3386, { 0x006D, 0x0062, 0x0000, 0x0000 } },
+	{ 0x3387, { 0x0067, 0x0062, 0x0000, 0x0000 } },
+	{ 0x338A, { 0x0070, 0x0066, 0x0000, 0x0000 } },
+	{ 0x338B, { 0x006E, 0x0066, 0x0000, 0x0000 } },
+	{ 0x338C, { 0x03BC, 0x0066, 0x0000, 0x0000 } },
+	{ 0x3390, { 0x0068, 0x007A, 0x0000, 0x0000 } },
+	{ 0x3391, { 0x006B, 0x0068, 0x007A, 0x0000 } },
+	{ 0x3392, { 0x006D, 0x0068, 0x007A, 0x0000 } },
+	{ 0x3393, { 0x0067, 0x0068, 0x007A, 0x0000 } },
+	{ 0x3394, { 0x0074, 0x0068, 0x007A, 0x0000 } },
+	{ 0x33A9, { 0x0070, 0x0061, 0x0000, 0x0000 } },
+	{ 0x33AA, { 0x006B, 0x0070, 0x0061, 0x0000 } },
+	{ 0x33AB, { 0x006D, 0x0070, 0x0061, 0x0000 } },
+	{ 0x33AC, { 0x0067, 0x0070, 0x0061, 0x0000 } },
+	{ 0x33B4, { 0x0070, 0x0076, 0x0000, 0x0000 } },
+	{ 0x33B5, { 0x006E, 0x0076, 0x0000, 0x0000 } },
+	{ 0x33B6, { 0x03BC, 0x0076, 0x0000, 0x0000 } },
+	{ 0x33B7, { 0x006D, 0x0076, 0x0000, 0x0000 } },
+	{ 0x33B8, { 0x006B, 0x0076, 0x0000, 0x0000 } },
+	{ 0x33B9, { 0x006D, 0x0076, 0x0000, 0x0000 } },
+	{ 0x33BA, { 0x0070, 0x0077, 0x0000, 0x0000 } },
+	{ 0x33BB, { 0x006E, 0x0077, 0x0000, 0x0000 } },
+	{ 0x33BC, { 0x03BC, 0x0077, 0x0000, 0x0000 } },
+	{ 0x33BD, { 0x006D, 0x0077, 0x0000, 0x0000 } },
+	{ 0x33BE, { 0x006B, 0x0077, 0x0000, 0x0000 } },
+	{ 0x33BF, { 0x006D, 0x0077, 0x0000, 0x0000 } },
+	{ 0x33C0, { 0x006B, 0x03C9, 0x0000, 0x0000 } },
+	{ 0x33C1, { 0x006D, 0x03C9, 0x0000, 0x0000 } },
+	{ 0x33C3, { 0x0062, 0x0071, 0x0000, 0x0000 } },
+	{ 0x33C6, { 0x0063, 0x2215, 0x006B, 0x0067 } },
+	{ 0x33C7, { 0x0063, 0x006F, 0x002E, 0x0000 } },
+	{ 0x33C8, { 0x0064, 0x0062, 0x0000, 0x0000 } },
+	{ 0x33C9, { 0x0067, 0x0079, 0x0000, 0x0000 } },
+	{ 0x33CB, { 0x0068, 0x0070, 0x0000, 0x0000 } },
+	{ 0x33CD, { 0x006B, 0x006B, 0x0000, 0x0000 } },
+	{ 0x33CE, { 0x006B, 0x006D, 0x0000, 0x0000 } },
+	{ 0x33D7, { 0x0070, 0x0068, 0x0000, 0x0000 } },
+	{ 0x33D9, { 0x0070, 0x0070, 0x006D, 0x0000 } },
+	{ 0x33DA, { 0x0070, 0x0072, 0x0000, 0x0000 } },
+	{ 0x33DC, { 0x0073, 0x0076, 0x0000, 0x0000 } },
+	{ 0x33DD, { 0x0077, 0x0062, 0x0000, 0x0000 } },
+	{ 0xFB00, { 0x0066, 0x0066, 0x0000, 0x0000 } },
+	{ 0xFB01, { 0x0066, 0x0069, 0x0000, 0x0000 } },
+	{ 0xFB02, { 0x0066, 0x006C, 0x0000, 0x0000 } },
+	{ 0xFB03, { 0x0066, 0x0066, 0x0069, 0x0000 } },
+	{ 0xFB04, { 0x0066, 0x0066, 0x006C, 0x0000 } },
+	{ 0xFB05, { 0x0073, 0x0074, 0x0000, 0x0000 } },
+	{ 0xFB06, { 0x0073, 0x0074, 0x0000, 0x0000 } },
+	{ 0xFB13, { 0x0574, 0x0576, 0x0000, 0x0000 } },
+	{ 0xFB14, { 0x0574, 0x0565, 0x0000, 0x0000 } },
+	{ 0xFB15, { 0x0574, 0x056B, 0x0000, 0x0000 } },
+	{ 0xFB16, { 0x057E, 0x0576, 0x0000, 0x0000 } },
+	{ 0xFB17, { 0x0574, 0x056D, 0x0000, 0x0000 } },
+	{ 0xFF21, { 0xFF41, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF22, { 0xFF42, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF23, { 0xFF43, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF24, { 0xFF44, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF25, { 0xFF45, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF26, { 0xFF46, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF27, { 0xFF47, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF28, { 0xFF48, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF29, { 0xFF49, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF2A, { 0xFF4A, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF2B, { 0xFF4B, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF2C, { 0xFF4C, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF2D, { 0xFF4D, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF2E, { 0xFF4E, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF2F, { 0xFF4F, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF30, { 0xFF50, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF31, { 0xFF51, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF32, { 0xFF52, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF33, { 0xFF53, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF34, { 0xFF54, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF35, { 0xFF55, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF36, { 0xFF56, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF37, { 0xFF57, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF38, { 0xFF58, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF39, { 0xFF59, 0x0000, 0x0000, 0x0000 } },
+	{ 0xFF3A, { 0xFF5A, 0x0000, 0x0000, 0x0000 } },
+        // #####
+/*	{ 0x10400, { 0x10428, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10401, { 0x10429, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10402, { 0x1042A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10403, { 0x1042B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10404, { 0x1042C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10405, { 0x1042D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10406, { 0x1042E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10407, { 0x1042F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10408, { 0x10430, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10409, { 0x10431, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1040A, { 0x10432, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1040B, { 0x10433, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1040C, { 0x10434, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1040D, { 0x10435, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1040E, { 0x10436, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1040F, { 0x10437, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10410, { 0x10438, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10411, { 0x10439, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10412, { 0x1043A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10413, { 0x1043B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10414, { 0x1043C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10415, { 0x1043D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10416, { 0x1043E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10417, { 0x1043F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10418, { 0x10440, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10419, { 0x10441, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1041A, { 0x10442, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1041B, { 0x10443, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1041C, { 0x10444, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1041D, { 0x10445, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1041E, { 0x10446, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1041F, { 0x10447, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10420, { 0x10448, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10421, { 0x10449, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10422, { 0x1044A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10423, { 0x1044B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10424, { 0x1044C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x10425, { 0x1044D, 0x0000, 0x0000, 0x0000 } },*/
+	{ 0x1D400, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D401, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D402, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D403, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D404, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D405, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D406, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D407, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D408, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D409, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D40A, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D40B, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D40C, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D40D, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D40E, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D40F, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D410, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D411, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D412, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D413, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D414, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D415, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D416, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D417, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D418, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D419, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D434, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D435, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D436, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D437, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D438, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D439, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D43A, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D43B, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D43C, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D43D, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D43E, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D43F, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D440, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D441, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D442, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D443, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D444, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D445, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D446, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D447, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D448, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D449, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D44A, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D44B, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D44C, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D44D, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D468, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D469, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D46A, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D46B, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D46C, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D46D, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D46E, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D46F, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D470, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D471, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D472, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D473, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D474, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D475, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D476, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D477, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D478, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D479, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D47A, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D47B, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D47C, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D47D, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D47E, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D47F, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D480, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D481, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D49C, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D49E, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D49F, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4A2, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4A5, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4A6, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4A9, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4AA, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4AB, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4AC, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4AE, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4AF, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4B0, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4B1, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4B2, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4B3, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4B4, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4B5, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D0, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D1, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D2, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D3, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D4, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D5, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D6, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D7, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D8, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4D9, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4DA, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4DB, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4DC, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4DD, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4DE, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4DF, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E0, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E1, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E2, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E3, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E4, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E5, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E6, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E7, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E8, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D4E9, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D504, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D505, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D507, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D508, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D509, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D50A, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D50D, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D50E, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D50F, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D510, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D511, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D512, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D513, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D514, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D516, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D517, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D518, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D519, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D51A, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D51B, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D51C, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D538, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D539, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D53B, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D53C, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D53D, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D53E, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D540, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D541, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D542, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D543, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D544, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D546, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D54A, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D54B, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D54C, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D54D, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D54E, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D54F, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D550, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D56C, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D56D, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D56E, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D56F, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D570, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D571, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D572, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D573, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D574, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D575, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D576, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D577, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D578, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D579, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D57A, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D57B, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D57C, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D57D, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D57E, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D57F, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D580, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D581, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D582, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D583, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D584, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D585, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A0, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A1, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A2, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A3, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A4, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A5, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A6, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A7, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A8, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5A9, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5AA, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5AB, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5AC, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5AD, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5AE, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5AF, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B0, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B1, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B2, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B3, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B4, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B5, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B6, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B7, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B8, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5B9, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5D4, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5D5, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5D6, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5D7, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5D8, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5D9, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5DA, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5DB, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5DC, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5DD, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5DE, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5DF, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E0, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E1, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E2, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E3, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E4, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E5, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E6, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E7, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E8, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5E9, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5EA, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5EB, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5EC, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D5ED, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D608, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D609, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D60A, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D60B, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D60C, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D60D, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D60E, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D60F, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D610, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D611, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D612, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D613, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D614, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D615, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D616, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D617, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D618, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D619, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D61A, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D61B, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D61C, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D61D, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D61E, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D61F, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D620, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D621, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D63C, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D63D, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D63E, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D63F, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D640, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D641, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D642, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D643, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D644, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D645, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D646, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D647, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D648, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D649, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D64A, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D64B, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D64C, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D64D, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D64E, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D64F, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D650, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D651, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D652, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D653, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D654, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D655, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D670, { 0x0061, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D671, { 0x0062, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D672, { 0x0063, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D673, { 0x0064, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D674, { 0x0065, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D675, { 0x0066, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D676, { 0x0067, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D677, { 0x0068, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D678, { 0x0069, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D679, { 0x006A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D67A, { 0x006B, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D67B, { 0x006C, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D67C, { 0x006D, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D67D, { 0x006E, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D67E, { 0x006F, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D67F, { 0x0070, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D680, { 0x0071, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D681, { 0x0072, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D682, { 0x0073, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D683, { 0x0074, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D684, { 0x0075, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D685, { 0x0076, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D686, { 0x0077, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D687, { 0x0078, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D688, { 0x0079, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D689, { 0x007A, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6A8, { 0x03B1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6A9, { 0x03B2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6AA, { 0x03B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6AB, { 0x03B4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6AC, { 0x03B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6AD, { 0x03B6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6AE, { 0x03B7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6AF, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B0, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B1, { 0x03BA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B2, { 0x03BB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B3, { 0x03BC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B4, { 0x03BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B5, { 0x03BE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B6, { 0x03BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B7, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B8, { 0x03C1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6B9, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6BA, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6BB, { 0x03C4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6BC, { 0x03C5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6BD, { 0x03C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6BE, { 0x03C7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6BF, { 0x03C8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6C0, { 0x03C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6D3, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E2, { 0x03B1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E3, { 0x03B2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E4, { 0x03B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E5, { 0x03B4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E6, { 0x03B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E7, { 0x03B6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E8, { 0x03B7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6E9, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6EA, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6EB, { 0x03BA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6EC, { 0x03BB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6ED, { 0x03BC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6EE, { 0x03BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6EF, { 0x03BE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F0, { 0x03BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F1, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F2, { 0x03C1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F3, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F4, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F5, { 0x03C4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F6, { 0x03C5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F7, { 0x03C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F8, { 0x03C7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6F9, { 0x03C8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D6FA, { 0x03C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D70D, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D71C, { 0x03B1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D71D, { 0x03B2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D71E, { 0x03B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D71F, { 0x03B4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D720, { 0x03B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D721, { 0x03B6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D722, { 0x03B7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D723, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D724, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D725, { 0x03BA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D726, { 0x03BB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D727, { 0x03BC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D728, { 0x03BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D729, { 0x03BE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D72A, { 0x03BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D72B, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D72C, { 0x03C1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D72D, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D72E, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D72F, { 0x03C4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D730, { 0x03C5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D731, { 0x03C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D732, { 0x03C7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D733, { 0x03C8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D734, { 0x03C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D747, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D756, { 0x03B1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D757, { 0x03B2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D758, { 0x03B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D759, { 0x03B4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D75A, { 0x03B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D75B, { 0x03B6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D75C, { 0x03B7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D75D, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D75E, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D75F, { 0x03BA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D760, { 0x03BB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D761, { 0x03BC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D762, { 0x03BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D763, { 0x03BE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D764, { 0x03BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D765, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D766, { 0x03C1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D767, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D768, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D769, { 0x03C4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D76A, { 0x03C5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D76B, { 0x03C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D76C, { 0x03C7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D76D, { 0x03C8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D76E, { 0x03C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D781, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D790, { 0x03B1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D791, { 0x03B2, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D792, { 0x03B3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D793, { 0x03B4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D794, { 0x03B5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D795, { 0x03B6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D796, { 0x03B7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D797, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D798, { 0x03B9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D799, { 0x03BA, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D79A, { 0x03BB, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D79B, { 0x03BC, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D79C, { 0x03BD, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D79D, { 0x03BE, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D79E, { 0x03BF, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D79F, { 0x03C0, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A0, { 0x03C1, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A1, { 0x03B8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A2, { 0x03C3, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A3, { 0x03C4, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A4, { 0x03C5, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A5, { 0x03C6, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A6, { 0x03C7, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A7, { 0x03C8, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7A8, { 0x03C9, 0x0000, 0x0000, 0x0000 } },
+	{ 0x1D7BB, { 0x03C3, 0x0000, 0x0000, 0x0000 } }
+};
+
+static void mapToLowerCase(QString *str)
+{
+    int N = sizeof(NameprepCaseFolding) / sizeof(NameprepCaseFolding[0]);
+
+    QChar *d = 0;
+    for (int i = 0; i < str->size(); ++i) {
+        int uc = str->at(i).unicode();
+        if (uc < 0x80) {
+            if (uc <= 'Z' && uc >= 'A') {
+                uc |= 0x20;
+                if (!d)
+                    d = str->data();
+                d[i] = QChar(uc);
+            }
+        } else {
+            const NameprepCaseFoldingEntry *entry = qBinaryFind(NameprepCaseFolding,
+                                                                NameprepCaseFolding + N,
+                                                                uc);
+            if ((entry - NameprepCaseFolding) != N) {
+                int l = 1;
+                while (l < 4 && entry->mapping[l])
+                    ++l;
+                if (l > 1) {
+                    str->replace(i, 1, (const QChar *)&entry->mapping[0], l);
+                    d = 0;
+                } else {
+                    if (!d)
+                        d = str->data();
+                    d[i] = QChar(entry->mapping[0]);
+                }
+            }
+        }
+    }
+}
+
+static bool isMappedToNothing(const QChar &ch)
+{
+    if (ch.unicode() < 0xad)
+        return false;
+    switch (ch.unicode()) {
+    case 0x00AD: case 0x034F: case 0x1806: case 0x180B: case 0x180C: case 0x180D:
+    case 0x200B: case 0x200C: case 0x200D: case 0x2060: case 0xFE00: case 0xFE01:
+    case 0xFE02: case 0xFE03: case 0xFE04: case 0xFE05: case 0xFE06: case 0xFE07:
+    case 0xFE08: case 0xFE09: case 0xFE0A: case 0xFE0B: case 0xFE0C: case 0xFE0D:
+    case 0xFE0E: case 0xFE0F: case 0xFEFF:
+        return true;
+    default:
+        return false;
+    }
+}
+
+
+static void stripProhibitedOutput(QString *str)
+{
+    ushort *out = (ushort *)str->data(); 
+    const ushort *in = out;
+    const ushort *end = out + str->size();
+    while (in < end) {
+        ushort uc = *in;
+        if (uc < 0x80 ||
+            !(uc <= 0x009F
+            || uc == 0x00A0
+            || uc == 0x0340
+            || uc == 0x0341
+            || uc == 0x06DD
+            || uc == 0x070F
+            || uc == 0x1680
+            || uc == 0x180E
+            || (uc >= 0x2000 && uc <= 0x200B)
+            || uc == 0x200C
+            || uc == 0x200D
+            || uc == 0x200E
+            || uc == 0x200F
+            || (uc >= 0x2028 && uc <= 0x202F)
+            || uc == 0x205F
+            || (uc >= 0x2060 && uc <= 0x2063)
+            || uc == 0x206A
+            || (uc >= 0x206A && uc <= 0x206F)
+            || (uc >= 0x2FF0 && uc <= 0x2FFB)
+            || uc == 0x3000
+            || (uc >= 0xD800 && uc <= 0xDFFF)
+            || (uc >= 0xE000 && uc <= 0xF8FF)
+            || (uc >= 0xFDD0 && uc <= 0xFDEF)
+            || uc == 0xFEFF
+            || (uc >= 0xFFF9 && uc <= 0xFFFC)
+            || (uc >= 0xFFFA && (uc <= 0xFFFE || uc == 0xFFFF))
+              /* ### Add NAMEPREP support for surrogates
+            || uc == 0xE0001
+            || (uc >= 0x2FFFE && uc <= 0x2FFFF)
+            || (uc >= 0x1D173 && uc <= 0x1D17A)
+            || (uc >= 0x1FFFE && uc <= 0x1FFFF)
+            || (uc >= 0x3FFFE && uc <= 0x3FFFF)
+            || (uc >= 0x4FFFE && uc <= 0x4FFFF)
+            || (uc >= 0x5FFFE && uc <= 0x5FFFF)
+            || (uc >= 0x6FFFE && uc <= 0x6FFFF)
+            || (uc >= 0x7FFFE && uc <= 0x7FFFF)
+            || (uc >= 0x8FFFE && uc <= 0x8FFFF)
+            || (uc >= 0x9FFFE && uc <= 0x9FFFF)
+            || (uc >= 0xAFFFE && uc <= 0xAFFFF)
+            || (uc >= 0xBFFFE && uc <= 0xBFFFF)
+            || (uc >= 0xCFFFE && uc <= 0xCFFFF)
+            || (uc >= 0xDFFFE && uc <= 0xDFFFF)
+            || (uc >= 0xE0020 && uc <= 0xE007F)
+            || (uc >= 0xEFFFE && uc <= 0xEFFFF)
+            || (uc >= 0xF0000 && uc <= 0xFFFFD)
+            || (uc >= 0xFFFFE && uc <= 0xFFFFF)
+            || (uc >= 0x100000 && uc <= 0x10FFFD)
+            || (uc >= 0x10FFFE && uc <= 0x10FFFF)*/))
+            *out++ = *in;
+        ++in;
+    }
+    if (in != out)
+        str->truncate(out - str->utf16());
+}
+
+static bool isBidirectionalRorAL(const QChar &c)
+{
+    ushort uc = c.unicode();
+    if (uc < 0x5b0)
+        return false;
+    return uc == 0x05BE
+        || uc == 0x05C0
+        || uc == 0x05C3
+        || (uc >= 0x05D0 && uc <= 0x05EA)
+        || (uc >= 0x05F0 && uc <= 0x05F4)
+        || uc == 0x061B
+        || uc == 0x061F
+        || (uc >= 0x0621 && uc <= 0x063A)
+        || (uc >= 0x0640 && uc <= 0x064A)
+        || (uc >= 0x066D && uc <= 0x066F)
+        || (uc >= 0x0671 && uc <= 0x06D5)
+        || uc == 0x06DD
+        || (uc >= 0x06E5 && uc <= 0x06E6)
+        || (uc >= 0x06FA && uc <= 0x06FE)
+        || (uc >= 0x0700 && uc <= 0x070D)
+        || uc == 0x0710
+        || (uc >= 0x0712 && uc <= 0x072C)
+        || (uc >= 0x0780 && uc <= 0x07A5)
+        || uc == 0x07B1
+        || uc == 0x200F
+        || uc == 0xFB1D
+        || (uc >= 0xFB1F && uc <= 0xFB28)
+        || (uc >= 0xFB2A && uc <= 0xFB36)
+        || (uc >= 0xFB38 && uc <= 0xFB3C)
+        || uc == 0xFB3E
+        || (uc >= 0xFB40 && uc <= 0xFB41)
+        || (uc >= 0xFB43 && uc <= 0xFB44)
+        || (uc >= 0xFB46 && uc <= 0xFBB1)
+        || (uc >= 0xFBD3 && uc <= 0xFD3D)
+        || (uc >= 0xFD50 && uc <= 0xFD8F)
+        || (uc >= 0xFD92 && uc <= 0xFDC7)
+        || (uc >= 0xFDF0 && uc <= 0xFDFC)
+        || (uc >= 0xFE70 && uc <= 0xFE74)
+        || (uc >= 0xFE76 && uc <= 0xFEFC);
+}
+
+static bool isBidirectionalL(const QChar &ch)
+{
+    ushort uc = ch.unicode();
+    if (uc < 0xaa)
+        return (uc >= 0x0041 && uc <= 0x005A)
+            || (uc >= 0x0061 && uc <= 0x007A);
+    
+    if (uc == 0x00AA
+        || uc == 0x00B5
+        || uc == 0x00BA
+        || (uc >= 0x00C0 && uc <= 0x00D6)
+        || (uc >= 0x00D8 && uc <= 0x00F6)
+        || (uc >= 0x00F8 && uc <= 0x0220)
+        || (uc >= 0x0222 && uc <= 0x0233)
+        || (uc >= 0x0250 && uc <= 0x02AD)
+        || (uc >= 0x02B0 && uc <= 0x02B8)
+        || (uc >= 0x02BB && uc <= 0x02C1)
+        || (uc >= 0x02D0 && uc <= 0x02D1)
+        || (uc >= 0x02E0 && uc <= 0x02E4)
+        || uc == 0x02EE
+        || uc == 0x037A
+        || uc == 0x0386
+        || (uc >= 0x0388 && uc <= 0x038A)) {
+        return true;
+    }
+
+    if (uc == 0x038C
+        || (uc >= 0x038E && uc <= 0x03A1)
+        || (uc >= 0x03A3 && uc <= 0x03CE)
+        || (uc >= 0x03D0 && uc <= 0x03F5)
+        || (uc >= 0x0400 && uc <= 0x0482)
+        || (uc >= 0x048A && uc <= 0x04CE)
+        || (uc >= 0x04D0 && uc <= 0x04F5)
+        || (uc >= 0x04F8 && uc <= 0x04F9)
+        || (uc >= 0x0500 && uc <= 0x050F)
+        || (uc >= 0x0531 && uc <= 0x0556)
+        || (uc >= 0x0559 && uc <= 0x055F)
+        || (uc >= 0x0561 && uc <= 0x0587)
+        || uc == 0x0589
+        || uc == 0x0903
+        || (uc >= 0x0905 && uc <= 0x0939)
+        || (uc >= 0x093D && uc <= 0x0940)
+        || (uc >= 0x0949 && uc <= 0x094C)
+        || uc == 0x0950) {
+        return true;
+    }
+
+    if ((uc >= 0x0958 && uc <= 0x0961)
+        || (uc >= 0x0964 && uc <= 0x0970)
+        || (uc >= 0x0982 && uc <= 0x0983)
+        || (uc >= 0x0985 && uc <= 0x098C)
+        || (uc >= 0x098F && uc <= 0x0990)
+        || (uc >= 0x0993 && uc <= 0x09A8)
+        || (uc >= 0x09AA && uc <= 0x09B0)
+        || uc == 0x09B2
+        || (uc >= 0x09B6 && uc <= 0x09B9)
+        || (uc >= 0x09BE && uc <= 0x09C0)
+        || (uc >= 0x09C7 && uc <= 0x09C8)
+        || (uc >= 0x09CB && uc <= 0x09CC)
+        || uc == 0x09D7
+        || (uc >= 0x09DC && uc <= 0x09DD)
+        || (uc >= 0x09DF && uc <= 0x09E1)
+        || (uc >= 0x09E6 && uc <= 0x09F1)
+        || (uc >= 0x09F4 && uc <= 0x09FA)
+        || (uc >= 0x0A05 && uc <= 0x0A0A)
+        || (uc >= 0x0A0F && uc <= 0x0A10)
+        || (uc >= 0x0A13 && uc <= 0x0A28)
+        || (uc >= 0x0A2A && uc <= 0x0A30)
+        || (uc >= 0x0A32 && uc <= 0x0A33)) {
+        return true;
+    }
+
+    if ((uc >= 0x0A35 && uc <= 0x0A36)
+        || (uc >= 0x0A38 && uc <= 0x0A39)
+        || (uc >= 0x0A3E && uc <= 0x0A40)
+        || (uc >= 0x0A59 && uc <= 0x0A5C)
+        || uc == 0x0A5E
+        || (uc >= 0x0A66 && uc <= 0x0A6F)
+        || (uc >= 0x0A72 && uc <= 0x0A74)
+        || uc == 0x0A83
+        || (uc >= 0x0A85 && uc <= 0x0A8B)
+        || uc == 0x0A8D
+        || (uc >= 0x0A8F && uc <= 0x0A91)
+        || (uc >= 0x0A93 && uc <= 0x0AA8)
+        || (uc >= 0x0AAA && uc <= 0x0AB0)
+        || (uc >= 0x0AB2 && uc <= 0x0AB3)
+        || (uc >= 0x0AB5 && uc <= 0x0AB9)
+        || (uc >= 0x0ABD && uc <= 0x0AC0)
+        || uc == 0x0AC9
+        || (uc >= 0x0ACB && uc <= 0x0ACC)
+        || uc == 0x0AD0
+        || uc == 0x0AE0
+        || (uc >= 0x0AE6 && uc <= 0x0AEF)
+        || (uc >= 0x0B02 && uc <= 0x0B03)
+        || (uc >= 0x0B05 && uc <= 0x0B0C)
+        || (uc >= 0x0B0F && uc <= 0x0B10)
+        || (uc >= 0x0B13 && uc <= 0x0B28)
+        || (uc >= 0x0B2A && uc <= 0x0B30)) {
+        return true;
+    }
+
+    if ((uc >= 0x0B32 && uc <= 0x0B33)
+        || (uc >= 0x0B36 && uc <= 0x0B39)
+        || (uc >= 0x0B3D && uc <= 0x0B3E)
+        || uc == 0x0B40
+        || (uc >= 0x0B47 && uc <= 0x0B48)
+        || (uc >= 0x0B4B && uc <= 0x0B4C)
+        || uc == 0x0B57
+        || (uc >= 0x0B5C && uc <= 0x0B5D)
+        || (uc >= 0x0B5F && uc <= 0x0B61)
+        || (uc >= 0x0B66 && uc <= 0x0B70)
+        || uc == 0x0B83
+        || (uc >= 0x0B85 && uc <= 0x0B8A)
+        || (uc >= 0x0B8E && uc <= 0x0B90)
+        || (uc >= 0x0B92 && uc <= 0x0B95)
+        || (uc >= 0x0B99 && uc <= 0x0B9A)
+        || uc == 0x0B9C
+        || (uc >= 0x0B9E && uc <= 0x0B9F)
+        || (uc >= 0x0BA3 && uc <= 0x0BA4)
+        || (uc >= 0x0BA8 && uc <= 0x0BAA)
+        || (uc >= 0x0BAE && uc <= 0x0BB5)
+        || (uc >= 0x0BB7 && uc <= 0x0BB9)
+        || (uc >= 0x0BBE && uc <= 0x0BBF)
+        || (uc >= 0x0BC1 && uc <= 0x0BC2)
+        || (uc >= 0x0BC6 && uc <= 0x0BC8)
+        || (uc >= 0x0BCA && uc <= 0x0BCC)
+        || uc == 0x0BD7
+        || (uc >= 0x0BE7 && uc <= 0x0BF2)
+        || (uc >= 0x0C01 && uc <= 0x0C03)
+        || (uc >= 0x0C05 && uc <= 0x0C0C)
+        || (uc >= 0x0C0E && uc <= 0x0C10)
+        || (uc >= 0x0C12 && uc <= 0x0C28)
+        || (uc >= 0x0C2A && uc <= 0x0C33)
+        || (uc >= 0x0C35 && uc <= 0x0C39)) {
+        return true;
+    }
+    if ((uc >= 0x0C41 && uc <= 0x0C44)
+        || (uc >= 0x0C60 && uc <= 0x0C61)
+        || (uc >= 0x0C66 && uc <= 0x0C6F)
+        || (uc >= 0x0C82 && uc <= 0x0C83)
+        || (uc >= 0x0C85 && uc <= 0x0C8C)
+        || (uc >= 0x0C8E && uc <= 0x0C90)
+        || (uc >= 0x0C92 && uc <= 0x0CA8)
+        || (uc >= 0x0CAA && uc <= 0x0CB3)
+        || (uc >= 0x0CB5 && uc <= 0x0CB9)
+        || uc == 0x0CBE
+        || (uc >= 0x0CC0 && uc <= 0x0CC4)
+        || (uc >= 0x0CC7 && uc <= 0x0CC8)
+        || (uc >= 0x0CCA && uc <= 0x0CCB)
+        || (uc >= 0x0CD5 && uc <= 0x0CD6)
+        || uc == 0x0CDE
+        || (uc >= 0x0CE0 && uc <= 0x0CE1)
+        || (uc >= 0x0CE6 && uc <= 0x0CEF)
+        || (uc >= 0x0D02 && uc <= 0x0D03)
+        || (uc >= 0x0D05 && uc <= 0x0D0C)
+        || (uc >= 0x0D0E && uc <= 0x0D10)
+        || (uc >= 0x0D12 && uc <= 0x0D28)
+        || (uc >= 0x0D2A && uc <= 0x0D39)
+        || (uc >= 0x0D3E && uc <= 0x0D40)
+        || (uc >= 0x0D46 && uc <= 0x0D48)
+        || (uc >= 0x0D4A && uc <= 0x0D4C)
+        || uc == 0x0D57
+        || (uc >= 0x0D60 && uc <= 0x0D61)
+        || (uc >= 0x0D66 && uc <= 0x0D6F)
+        || (uc >= 0x0D82 && uc <= 0x0D83)
+        || (uc >= 0x0D85 && uc <= 0x0D96)
+        || (uc >= 0x0D9A && uc <= 0x0DB1)
+        || (uc >= 0x0DB3 && uc <= 0x0DBB)
+        || uc == 0x0DBD) {
+        return true;
+    }
+    if ((uc >= 0x0DC0 && uc <= 0x0DC6)
+        || (uc >= 0x0DCF && uc <= 0x0DD1)
+        || (uc >= 0x0DD8 && uc <= 0x0DDF)
+        || (uc >= 0x0DF2 && uc <= 0x0DF4)
+        || (uc >= 0x0E01 && uc <= 0x0E30)
+        || (uc >= 0x0E32 && uc <= 0x0E33)
+        || (uc >= 0x0E40 && uc <= 0x0E46)
+        || (uc >= 0x0E4F && uc <= 0x0E5B)
+        || (uc >= 0x0E81 && uc <= 0x0E82)
+        || uc == 0x0E84
+        || (uc >= 0x0E87 && uc <= 0x0E88)
+        || uc == 0x0E8A
+        || uc == 0x0E8D
+        || (uc >= 0x0E94 && uc <= 0x0E97)
+        || (uc >= 0x0E99 && uc <= 0x0E9F)
+        || (uc >= 0x0EA1 && uc <= 0x0EA3)
+        || uc == 0x0EA5
+        || uc == 0x0EA7
+        || (uc >= 0x0EAA && uc <= 0x0EAB)
+        || (uc >= 0x0EAD && uc <= 0x0EB0)
+        || (uc >= 0x0EB2 && uc <= 0x0EB3)
+        || uc == 0x0EBD
+        || (uc >= 0x0EC0 && uc <= 0x0EC4)
+        || uc == 0x0EC6
+        || (uc >= 0x0ED0 && uc <= 0x0ED9)
+        || (uc >= 0x0EDC && uc <= 0x0EDD)
+        || (uc >= 0x0F00 && uc <= 0x0F17)
+        || (uc >= 0x0F1A && uc <= 0x0F34)
+        || uc == 0x0F36
+        || uc == 0x0F38
+        || (uc >= 0x0F3E && uc <= 0x0F47)
+        || (uc >= 0x0F49 && uc <= 0x0F6A)
+        || uc == 0x0F7F
+        || uc == 0x0F85
+        || (uc >= 0x0F88 && uc <= 0x0F8B)
+        || (uc >= 0x0FBE && uc <= 0x0FC5)
+        || (uc >= 0x0FC7 && uc <= 0x0FCC)
+        || uc == 0x0FCF) {
+        return true;
+    }
+
+    if ((uc >= 0x1000 && uc <= 0x1021)
+        || (uc >= 0x1023 && uc <= 0x1027)
+        || (uc >= 0x1029 && uc <= 0x102A)
+        || uc == 0x102C
+        || uc == 0x1031
+        || uc == 0x1038
+        || (uc >= 0x1040 && uc <= 0x1057)
+        || (uc >= 0x10A0 && uc <= 0x10C5)
+        || (uc >= 0x10D0 && uc <= 0x10F8)
+        || uc == 0x10FB
+        || (uc >= 0x1100 && uc <= 0x1159)
+        || (uc >= 0x115F && uc <= 0x11A2)
+        || (uc >= 0x11A8 && uc <= 0x11F9)
+        || (uc >= 0x1200 && uc <= 0x1206)
+        || (uc >= 0x1208 && uc <= 0x1246)
+        || uc == 0x1248
+        || (uc >= 0x124A && uc <= 0x124D)
+        || (uc >= 0x1250 && uc <= 0x1256)
+        || uc == 0x1258
+        || (uc >= 0x125A && uc <= 0x125D)
+        || (uc >= 0x1260 && uc <= 0x1286)
+        || uc == 0x1288
+        || (uc >= 0x128A && uc <= 0x128D)
+        || (uc >= 0x1290 && uc <= 0x12AE)
+        || uc == 0x12B0
+        || (uc >= 0x12B2 && uc <= 0x12B5)
+        || (uc >= 0x12B8 && uc <= 0x12BE)
+        || uc == 0x12C0
+        || (uc >= 0x12C2 && uc <= 0x12C5)
+        || (uc >= 0x12C8 && uc <= 0x12CE)
+        || (uc >= 0x12D0 && uc <= 0x12D6)
+        || (uc >= 0x12D8 && uc <= 0x12EE)
+        || (uc >= 0x12F0 && uc <= 0x130E)
+        || uc == 0x1310) {
+        return true;
+    }
+
+    if ((uc >= 0x1312 && uc <= 0x1315)
+        || (uc >= 0x1318 && uc <= 0x131E)
+        || (uc >= 0x1320 && uc <= 0x1346)
+        || (uc >= 0x1348 && uc <= 0x135A)
+        || (uc >= 0x1361 && uc <= 0x137C)
+        || (uc >= 0x13A0 && uc <= 0x13F4)
+        || (uc >= 0x1401 && uc <= 0x1676)
+        || (uc >= 0x1681 && uc <= 0x169A)
+        || (uc >= 0x16A0 && uc <= 0x16F0)
+        || (uc >= 0x1700 && uc <= 0x170C)
+        || (uc >= 0x170E && uc <= 0x1711)
+        || (uc >= 0x1720 && uc <= 0x1731)
+        || (uc >= 0x1735 && uc <= 0x1736)
+        || (uc >= 0x1740 && uc <= 0x1751)
+        || (uc >= 0x1760 && uc <= 0x176C)
+        || (uc >= 0x176E && uc <= 0x1770)
+        || (uc >= 0x1780 && uc <= 0x17B6)
+        || (uc >= 0x17BE && uc <= 0x17C5)
+        || (uc >= 0x17C7 && uc <= 0x17C8)
+        || (uc >= 0x17D4 && uc <= 0x17DA)
+        || uc == 0x17DC
+        || (uc >= 0x17E0 && uc <= 0x17E9)
+        || (uc >= 0x1810 && uc <= 0x1819)
+        || (uc >= 0x1820 && uc <= 0x1877)
+        || (uc >= 0x1880 && uc <= 0x18A8)
+        || (uc >= 0x1E00 && uc <= 0x1E9B)
+        || (uc >= 0x1EA0 && uc <= 0x1EF9)
+        || (uc >= 0x1F00 && uc <= 0x1F15)
+        || (uc >= 0x1F18 && uc <= 0x1F1D)
+        || (uc >= 0x1F20 && uc <= 0x1F45)
+        || (uc >= 0x1F48 && uc <= 0x1F4D)
+        || (uc >= 0x1F50 && uc <= 0x1F57)
+        || uc == 0x1F59
+        || uc == 0x1F5B
+        || uc == 0x1F5D) {
+        return true;
+    }
+
+    if ((uc >= 0x1F5F && uc <= 0x1F7D)
+        || (uc >= 0x1F80 && uc <= 0x1FB4)
+        || (uc >= 0x1FB6 && uc <= 0x1FBC)
+        || uc == 0x1FBE
+        || (uc >= 0x1FC2 && uc <= 0x1FC4)
+        || (uc >= 0x1FC6 && uc <= 0x1FCC)
+        || (uc >= 0x1FD0 && uc <= 0x1FD3)
+        || (uc >= 0x1FD6 && uc <= 0x1FDB)
+        || (uc >= 0x1FE0 && uc <= 0x1FEC)
+        || (uc >= 0x1FF2 && uc <= 0x1FF4)
+        || (uc >= 0x1FF6 && uc <= 0x1FFC)
+        || uc == 0x200E
+        || uc == 0x2071
+        || uc == 0x207F
+        || uc == 0x2102
+        || uc == 0x2107
+        || (uc >= 0x210A && uc <= 0x2113)
+        || uc == 0x2115
+        || (uc >= 0x2119 && uc <= 0x211D)) {
+        return true;
+    }
+
+    if (uc == 0x2124
+        || uc == 0x2126
+        || uc == 0x2128
+        || (uc >= 0x212A && uc <= 0x212D)
+        || (uc >= 0x212F && uc <= 0x2131)
+        || (uc >= 0x2133 && uc <= 0x2139)
+        || (uc >= 0x213D && uc <= 0x213F)
+        || (uc >= 0x2145 && uc <= 0x2149)
+        || (uc >= 0x2160 && uc <= 0x2183)
+        || (uc >= 0x2336 && uc <= 0x237A)
+        || uc == 0x2395
+        || (uc >= 0x249C && uc <= 0x24E9)
+        || (uc >= 0x3005 && uc <= 0x3007)
+        || (uc >= 0x3021 && uc <= 0x3029)
+        || (uc >= 0x3031 && uc <= 0x3035)
+        || (uc >= 0x3038 && uc <= 0x303C)
+        || (uc >= 0x3041 && uc <= 0x3096)
+        || (uc >= 0x309D && uc <= 0x309F)
+        || (uc >= 0x30A1 && uc <= 0x30FA)) {
+        return true;
+    }
+
+    if ((uc >= 0x30FC && uc <= 0x30FF)
+        || (uc >= 0x3105 && uc <= 0x312C)
+        || (uc >= 0x3131 && uc <= 0x318E)
+        || (uc >= 0x3190 && uc <= 0x31B7)
+        || (uc >= 0x31F0 && uc <= 0x321C)
+        || (uc >= 0x3220 && uc <= 0x3243)) {
+        return true;
+    }
+
+    if ((uc >= 0x3260 && uc <= 0x327B)
+        || (uc >= 0x327F && uc <= 0x32B0)
+        || (uc >= 0x32C0 && uc <= 0x32CB)
+        || (uc >= 0x32D0 && uc <= 0x32FE)
+        || (uc >= 0x3300 && uc <= 0x3376)
+        || (uc >= 0x337B && uc <= 0x33DD)) {
+        return true;
+    }
+    if  ((uc >= 0x33E0 && uc <= 0x33FE)
+         || (uc >= 0x3400 && uc <= 0x4DB5)
+         || (uc >= 0x4E00 && uc <= 0x9FA5)
+         || (uc >= 0xA000 && uc <= 0xA48C)
+         || (uc >= 0xAC00 && uc <= 0xD7A3)
+         || (uc >= 0xD800 && uc <= 0xFA2D)
+         || (uc >= 0xFA30 && uc <= 0xFA6A)
+         || (uc >= 0xFB00 && uc <= 0xFB06)
+         || (uc >= 0xFB13 && uc <= 0xFB17)
+         || (uc >= 0xFF21 && uc <= 0xFF3A)
+         || (uc >= 0xFF41 && uc <= 0xFF5A)
+         || (uc >= 0xFF66 && uc <= 0xFFBE)
+         || (uc >= 0xFFC2 && uc <= 0xFFC7)
+         || (uc >= 0xFFCA && uc <= 0xFFCF)
+         || (uc >= 0xFFD2 && uc <= 0xFFD7)
+         || (uc >= 0xFFDA && uc <= 0xFFDC)) {
+        return true;
+    }
+
+    /* ### Add NAMEPREP support for surrogates
+       || (uc >= 0x10300 && uc <= 0x1031E)
+       || (uc >= 0x10320 && uc <= 0x10323)
+       || (uc >= 0x10330 && uc <= 0x1034A)
+       || (uc >= 0x10400 && uc <= 0x10425)
+       || (uc >= 0x10428 && uc <= 0x1044D)
+       || (uc >= 0x1D000 && uc <= 0x1D0F5)
+       || (uc >= 0x1D100 && uc <= 0x1D126)
+       || (uc >= 0x1D12A && uc <= 0x1D166)
+       || (uc >= 0x1D16A && uc <= 0x1D172)
+       || (uc >= 0x1D183 && uc <= 0x1D184)
+       || (uc >= 0x1D18C && uc <= 0x1D1A9)
+       || (uc >= 0x1D1AE && uc <= 0x1D1DD)
+       || (uc >= 0x1D400 && uc <= 0x1D454)
+       || (uc >= 0x1D456 && uc <= 0x1D49C)
+       || (uc >= 0x1D49E && uc <= 0x1D49F)
+       || uc == 0x1D4A2
+       || (uc >= 0x1D4A5 && uc <= 0x1D4A6)
+       || (uc >= 0x1D4A9 && uc <= 0x1D4AC)
+       || (uc >= 0x1D4AE && uc <= 0x1D4B9)
+       || uc == 0x1D4BB
+       || (uc >= 0x1D4BD && uc <= 0x1D4C0)
+       || (uc >= 0x1D4C2 && uc <= 0x1D4C3)
+       || (uc >= 0x1D4C5 && uc <= 0x1D505)
+       || (uc >= 0x1D507 && uc <= 0x1D50A)
+       || (uc >= 0x1D50D && uc <= 0x1D514)
+       || (uc >= 0x1D516 && uc <= 0x1D51C)
+       || (uc >= 0x1D51E && uc <= 0x1D539)
+       || (uc >= 0x1D53B && uc <= 0x1D53E)
+       || (uc >= 0x1D540 && uc <= 0x1D544)
+       || uc == 0x1D546
+       || (uc >= 0x1D54A && uc <= 0x1D550)
+       || (uc >= 0x1D552 && uc <= 0x1D6A3)
+       || (uc >= 0x1D6A8 && uc <= 0x1D7C9)
+       || (uc >= 0x20000 && uc <= 0x2A6D6)
+       || (uc >= 0x2F800 && uc <= 0x2FA1D)
+       || (uc >= 0xF0000 && uc <= 0xFFFFD)
+       || (uc >= 0x100000 && uc <= 0x10FFFD)*/
+
+    return false;
+}
+
+
+Q_AUTOTEST_EXPORT QString qt_nameprep(const QString &source)
+{
+    QString mapped = source;
+    
+    bool simple = true;
+    for (int i = 0; i < mapped.size(); ++i) {
+        ushort uc = mapped.at(i).unicode();
+        if (uc > 0x80) {
+            simple = false;
+            break;
+        } else if (uc >= 'A' && uc <= 'Z') {
+            mapped[i] = QChar(uc | 0x20);
+        }
+    }
+    if (simple)
+        return mapped;
+    
+    // Characters commonly mapped to nothing are simply removed
+    // (Table B.1)
+    QChar *out = mapped.data();
+    const QChar *in = out;
+    const QChar *e = in + mapped.size();
+    while (in < e) {
+        if (!isMappedToNothing(*in))
+            *out++ = *in;
+        ++in;
+    }
+    if (out != in)
+        mapped.truncate(out - mapped.constData());
+
+    // Map to lowercase (Table B.2)
+    mapToLowerCase(&mapped);
+
+    // Normalize to Unicode 3.2 form KC
+    mapped = mapped.normalized(QString::NormalizationForm_KC, QChar::Unicode_3_2);
+
+    // Strip prohibited output
+    stripProhibitedOutput(&mapped);
+
+    // Check for valid bidirectional characters
+    bool containsLCat = false;
+    bool containsRandALCat = false;
+    for (int j = 0; j < mapped.size() && (!containsLCat || !containsRandALCat); ++j) {
+        if (isBidirectionalL(mapped.at(j)))
+            containsLCat = true;
+        else if (isBidirectionalRorAL(mapped.at(j)))
+            containsRandALCat = true;
+    }
+    if (containsRandALCat) {
+        if (containsLCat || (!isBidirectionalRorAL(mapped.at(0))
+                             || !isBidirectionalRorAL(mapped.at(mapped.size() - 1))))
+            mapped.clear();
+    }
+
+    return mapped;
+}
+
+
+static inline char encodeDigit(uint digit)
+{
+  return digit + 22 + 75 * (digit < 26);
+}
+
+static inline uint adapt(uint delta, uint numpoints, bool firsttime)
+{
+    delta /= (firsttime ? damp : 2);
+    delta += (delta / numpoints);
+
+    uint k = 0;
+    for (; delta > ((base - tmin) * tmax) / 2; k += base)
+        delta /= (base - tmin);
+
+    return k + (((base - tmin + 1) * delta) / (delta + skew));
+}
+
+static inline void appendEncode(QByteArray* output, uint& delta, uint& bias, uint& b, uint& h)
+{
+    uint qq;
+    uint k;
+    uint t;
+
+    // insert the variable length delta integer; fail on
+    // overflow.
+    for (qq = delta, k = base;; k += base) {
+        // stop generating digits when the threshold is
+        // detected.
+        t = (k <= bias) ? tmin : (k >= bias + tmax) ? tmax : k - bias;
+        if (qq < t) break;
+
+        *output += encodeDigit(t + (qq - t) % (base - t));
+        qq = (qq - t) / (base - t);
+    }
+
+    *output += encodeDigit(qq);
+    bias = adapt(delta, h + 1, h == b);
+    delta = 0;
+    ++h;
+}
+
+static void toPunycodeHelper(const QChar *s, int ucLength, QByteArray *output)
+{
+    uint n = initial_n;
+    uint delta = 0;
+    uint bias = initial_bias;
+
+    int outLen = output->length();
+    output->resize(outLen + ucLength);
+
+    char *d = output->data() + outLen;
+    bool skipped = false;
+    // copy all basic code points verbatim to output.
+    for (uint j = 0; j < (uint) ucLength; ++j) {
+        ushort js = s[j].unicode();
+        if (js < 0x80)
+            *d++ = js;
+        else
+            skipped = true;
+    }
+
+    // if there were only basic code points, just return them
+    // directly; don't do any encoding.
+    if (!skipped)
+        return;
+
+    output->truncate(d - output->constData());
+    int copied = output->size() - outLen;
+
+    // h and b now contain the number of basic code points in input.
+    uint b = copied;
+    uint h = copied;
+
+    // if basic code points were copied, add the delimiter character.
+    if (h > 0)
+        *output += 0x2d;
+
+    // while there are still unprocessed non-basic code points left in
+    // the input string...
+    while (h < (uint) ucLength) {
+        // find the character in the input string with the lowest
+        // unicode value.
+        uint m = Q_MAXINT;
+        uint j;
+        for (j = 0; j < (uint) ucLength; ++j) {
+            if (s[j].unicode() >= n && s[j].unicode() < m)
+                m = (uint) s[j].unicode();
+        }
+
+        // reject out-of-bounds unicode characters
+        if (m - n > (Q_MAXINT - delta) / (h + 1)) {
+            output->truncate(outLen);
+            return; // punycode_overflow
+        }
+
+        delta += (m - n) * (h + 1);
+        n = m;
+
+        // for each code point in the input string
+        for (j = 0; j < (uint) ucLength; ++j) {
+
+            // increase delta until we reach the character with the
+            // lowest unicode code. fail if delta overflows.
+            if (s[j].unicode() < n) {
+                ++delta;
+                if (!delta) {
+                    output->truncate(outLen);
+                    return; // punycode_overflow
+                }
+            }
+
+            // if j is the index of the character with the lowest
+            // unicode code...
+            if (s[j].unicode() == n) {
+                appendEncode(output, delta, bias, b, h);
+            }
+        }
+
+        ++delta;
+        ++n;
+    }
+
+    // prepend ACE prefix
+    output->insert(outLen, "xn--");
+    return;
+}
+
+
+static const char * const idn_whitelist[] = {
+    "ac", "at",
+    "br",
+    "cat", "ch", "cl", "cn",
+    "de", "dk",
+    "fi",
+    "gr",
+    "hu",
+    "info", "io", "is",
+    "jp",
+    "kr",
+    "li", "lt",
+    "museum",
+    "no",
+    "org",
+    "se", "sh",
+    "th", "tm", "tw",
+    "vn",
+};
+
+static QStringList *user_idn_whitelist = 0;
+
+static bool lessThan(const QChar *a, int l, const char *c)
+{
+    const ushort *uc = (const ushort *)a;
+    const ushort *e = uc + l;
+
+    if (!c || *c == 0)
+        return false;
+
+    while (*c) {
+        if (uc == e || *uc != *c)
+            break;
+        ++uc;
+        ++c;
+    }
+    return (uc == e ? *c : *uc < *c);
+}
+
+static bool equal(const QChar *a, int l, const char *b)
+{
+    while (l && a->unicode() && *b) {
+        if (*a != QLatin1Char(*b))
+            return false;
+        ++a;
+        ++b;
+        --l;
+    }
+    return l == 0;
+}
+
+static bool qt_is_idn_enabled(const QString &domain)
+{
+    int idx = domain.lastIndexOf(QLatin1Char('.'));
+    if (idx == -1)
+        return false;
+    const QChar *tld = domain.constData() + idx + 1;
+    int len = domain.size() - idx - 1;
+
+    if (user_idn_whitelist)
+        return user_idn_whitelist->contains(QString(tld, len));
+
+    int l = 0;
+    int r = sizeof(idn_whitelist)/sizeof(const char *) - 1;
+    int i = (l + r + 1) / 2;
+
+    while (r != l) {
+        if (lessThan(tld, len, idn_whitelist[i]))
+            r = i - 1;
+        else
+            l = i;
+        i = (l + r + 1) / 2;
+    }
+    return equal(tld, len, idn_whitelist[i]);
+}
+
+static QString qt_from_ACE(const QString &domainMC)
+{
+    QString domain = domainMC.toLower();
+    int idx = domain.indexOf(QLatin1Char('.'));
+    if (idx != -1) {
+        if (!domain.contains(QLatin1String("xn--"))) {
+            bool simple = true;
+            for (int i = 0; i < domain.size(); ++i) {
+                ushort ch = domain.at(i).unicode();
+                if (ch > 'z' || ch < '-' || ch == '/' || (ch > '9' && ch < 'A') || (ch > 'Z' && ch < 'a')) {
+                    simple = false;
+                    break;
+                }
+            }
+            if (simple)
+                return domain;
+        }
+        
+        const bool isIdnEnabled = qt_is_idn_enabled(domain);
+        int lastIdx = 0;
+        QString result;
+        while (1) {
+            // Nameprep the host. If the labels in the hostname are Punycode
+            // encoded, we decode them immediately, then nameprep them.
+            QByteArray label;
+            toPunycodeHelper(domain.constData() + lastIdx, idx - lastIdx, &label);
+            result += qt_nameprep(isIdnEnabled ? QUrl::fromPunycode(label) : QString::fromLatin1(label));
+            lastIdx = idx + 1;
+            if (lastIdx < domain.size() + 1)
+                result += QLatin1Char('.');
+            else
+                break;
+            idx = domain.indexOf(QLatin1Char('.'), lastIdx);
+            if (idx == -1)
+                idx = domain.size();
+        }
+        return result;
+    } else {
+        return qt_nameprep(domain);
+    }
+}
+
+
+QUrlPrivate::QUrlPrivate()
+{
+    ref = 1;
+    port = -1;
+    isValid = false;
+    parsingMode = QUrl::TolerantMode;
+    valueDelimiter = '=';
+    pairDelimiter = '&';
+    stateFlags = 0;
+    hasFragment = false;
+    hasQuery = false;
+}
+
+QUrlPrivate::QUrlPrivate(const QUrlPrivate &copy)
+    : scheme(copy.scheme),
+      userName(copy.userName),
+      password(copy.password),
+      host(copy.host),
+      path(copy.path),
+      query(copy.query),
+      fragment(copy.fragment),
+      encodedOriginal(copy.encodedOriginal),
+      encodedUserName(copy.encodedUserName),
+      encodedPassword(copy.encodedPassword),
+      encodedPath(copy.encodedPath),
+      encodedFragment(copy.encodedFragment),
+      port(copy.port),
+      parsingMode(copy.parsingMode),
+      hasQuery(copy.hasQuery),
+      hasFragment(copy.hasFragment),
+      isValid(copy.isValid),
+      valueDelimiter(copy.valueDelimiter),
+      pairDelimiter(copy.pairDelimiter),
+      stateFlags(copy.stateFlags),
+      encodedNormalized(copy.encodedNormalized)
+{ ref = 1; }
+
+QString QUrlPrivate::canonicalHost() const
+{
+    if (QURL_HASFLAG(stateFlags, HostCanonicalized))
+        return host;
+
+    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
+    QURL_SETFLAG(that->stateFlags, HostCanonicalized);
+    that->host = qt_from_ACE(host);
+    return that->host;
+}
+
+// From RFC 3896, Appendix A Collected ABNF for URI
+//    authority     = [ userinfo "@" ] host [ ":" port ]
+//    userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
+//    host          = IP-literal / IPv4address / reg-name
+//    port          = *DIGIT
+//[...]
+//    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+//
+//    query         = *( pchar / "/" / "?" )
+//
+//    fragment      = *( pchar / "/" / "?" )
+//
+//    pct-encoded   = "%" HEXDIG HEXDIG
+//
+//    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+//    reserved      = gen-delims / sub-delims
+//    gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+//    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
+//                  / "*" / "+" / "," / ";" / "="
+
+// use defines for concatenation:
+#define ABNF_sub_delims         "!$&'()*+,;="
+#define ABNF_gen_delims         ":/?#[]@"
+#define ABNF_pchar              ABNF_sub_delims ":@"
+#define ABNF_reserved           ABNF_sub_delims ABNF_gen_delims
+
+// list the characters that don't have to be converted according to the list above.
+// "unreserved" is already automatically not encoded, so we don't have to list it.
+// the path component has a complex ABNF that basically boils down to
+// slash-separated segments of "pchar"
+
+static const char userNameExcludeChars[] = ABNF_sub_delims;
+static const char passwordExcludeChars[] = ABNF_sub_delims ":";
+static const char pathExcludeChars[]     = ABNF_pchar "/";
+static const char queryExcludeChars[]    = ABNF_pchar "/?";
+static const char fragmentExcludeChars[] = ABNF_pchar "/?";
+
+void QUrlPrivate::ensureEncodedParts() const
+{
+    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
+
+    if (encodedUserName.isNull())
+        // userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
+        that->encodedUserName = toPercentEncodingHelper(userName, userNameExcludeChars);
+    if (encodedPassword.isNull())
+        // userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
+        that->encodedPassword = toPercentEncodingHelper(password, passwordExcludeChars);
+    if (encodedPath.isNull())
+        // pchar = unreserved / pct-encoded / sub-delims / ":" / "@" ... also "/"
+        that->encodedPath = toPercentEncodingHelper(path, pathExcludeChars);
+    if (encodedFragment.isNull())
+        // fragment      = *( pchar / "/" / "?" )
+        that->encodedFragment = toPercentEncodingHelper(fragment, fragmentExcludeChars);
+}
+
+QString QUrlPrivate::authority(QUrl::FormattingOptions options) const
+{
+    if ((options & QUrl::RemoveAuthority) == QUrl::RemoveAuthority)
+        return QString();
+
+    QString tmp = userInfo(options);
+    if (!tmp.isEmpty())
+        tmp += QLatin1Char('@');
+    tmp += canonicalHost();
+    if (!(options & QUrl::RemovePort) && port != -1)
+        tmp += QLatin1Char(':') + QString::number(port);
+
+    return tmp;
+}
+
+void QUrlPrivate::setAuthority(const QString &auth)
+{
+    if (auth.isEmpty())
+        return;
+
+    // find the port section of the authority by searching from the
+    // end towards the beginning for numbers until a ':' is reached.
+    int portIndex = auth.length() - 1;
+    if (portIndex == 0) {
+        portIndex = -1;
+    } else {
+        short c = auth.at(portIndex--).unicode();
+        if (c < '0' || c > '9') {
+            portIndex = -1;
+        } else while (portIndex >= 0) {
+            c = auth.at(portIndex).unicode();
+            if (c == ':') {
+                break;
+            } else if (c == '.') {
+                portIndex = -1;
+                break;
+            }
+            --portIndex;
+        }
+    }
+
+    if (portIndex != -1) {
+        port = 0;
+        for (int i = portIndex + 1; i < auth.length(); ++i) 
+            port = (port * 10) + (auth.at(i).unicode() - '0');
+    } else {
+        port = -1;
+    }
+
+    int userInfoIndex = auth.indexOf(QLatin1Char('@'));
+    if (userInfoIndex != -1 && (portIndex == -1 || userInfoIndex < portIndex))
+        setUserInfo(auth.left(userInfoIndex));
+
+    int hostIndex = 0;
+    if (userInfoIndex != -1)
+        hostIndex = userInfoIndex + 1;
+    int hostLength = auth.length() - hostIndex;
+    if (portIndex != -1)
+        hostLength -= (auth.length() - portIndex);
+
+    host = auth.mid(hostIndex, hostLength).trimmed();
+}
+
+void QUrlPrivate::setUserInfo(const QString &userInfo)
+{
+    encodedUserName.clear();
+    encodedPassword.clear();
+
+    int delimIndex = userInfo.indexOf(QLatin1Char(':'));
+    if (delimIndex == -1) {
+        userName = userInfo;
+        password.clear();
+        return;
+    }
+    userName = userInfo.left(delimIndex);
+    password = userInfo.right(userInfo.length() - delimIndex - 1);
+}
+
+void QUrlPrivate::setEncodedUserInfo(const QUrlParseData *parseData)
+{
+    userName.clear();
+    password.clear();
+    if (!parseData->userInfoLength) {
+        encodedUserName.clear();
+        encodedPassword.clear();
+    } else if (parseData->userInfoDelimIndex == -1) {
+        encodedUserName = QByteArray(parseData->userInfo, parseData->userInfoLength);
+        encodedPassword.clear();
+    } else {
+        encodedUserName = QByteArray(parseData->userInfo, parseData->userInfoDelimIndex);
+        encodedPassword = QByteArray(parseData->userInfo + parseData->userInfoDelimIndex + 1,
+                                     parseData->userInfoLength - parseData->userInfoDelimIndex - 1);
+    }
+}
+
+QString QUrlPrivate::userInfo(QUrl::FormattingOptions options) const
+{
+    if ((options & QUrl::RemoveUserInfo) == QUrl::RemoveUserInfo)
+        return QString();
+
+    QUrlPrivate *that = const_cast<QUrlPrivate *>(this);
+    if (userName.isNull())
+        that->userName = fromPercentEncodingHelper(encodedUserName);
+    if (password.isNull())
+        that->password = fromPercentEncodingHelper(encodedPassword);
+
+    QString tmp = userName;
+
+    if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
+        tmp += QLatin1Char(':');
+        tmp += password;
+    }
+    
+    return tmp;
+}
+
+/*
+    From http://www.ietf.org/rfc/rfc3986.txt, 5.2.3: Merge paths
+
+    Returns a merge of the current path with the relative path passed
+    as argument.
+*/
+QByteArray QUrlPrivate::mergePaths(const QByteArray &relativePath) const
+{
+    if (encodedPath.isNull())
+        ensureEncodedParts();
+
+    // If the base URI has a defined authority component and an empty
+    // path, then return a string consisting of "/" concatenated with
+    // the reference's path; otherwise,
+    if (!authority().isEmpty() && encodedPath.isEmpty())
+        return '/' + relativePath;
+
+    // Return a string consisting of the reference's path component
+    // appended to all but the last segment of the base URI's path
+    // (i.e., excluding any characters after the right-most "/" in the
+    // base URI path, or excluding the entire base URI path if it does
+    // not contain any "/" characters).
+    QByteArray newPath;
+    if (!encodedPath.contains('/'))
+        newPath = relativePath;
+    else
+        newPath = encodedPath.left(encodedPath.lastIndexOf('/') + 1) + relativePath;
+
+    return newPath;
+}
+
+void QUrlPrivate::queryItem(int pos, int *value, int *end)
+{
+    *end = query.indexOf(pairDelimiter, pos);
+    if (*end == -1)
+        *end = query.size();
+    *value = pos;
+    while (*value < *end) {
+        if (query[*value] == valueDelimiter)
+            break;
+        ++*value;
+    }
+}
+
+/*
+    From http://www.ietf.org/rfc/rfc3986.txt, 5.2.4: Remove dot segments
+
+    Removes unnecessary ../ and ./ from the path. Used for normalizing
+    the URL.
+*/
+static void removeDotsFromPath(QByteArray *path)
+{
+    // The input buffer is initialized with the now-appended path
+    // components and the output buffer is initialized to the empty
+    // string.
+    char *out = path->data();
+    const char *in = out;
+    const char *end = out + path->size();
+
+    // If the input buffer consists only of
+    // "." or "..", then remove that from the input
+    // buffer;
+    if (path->size() == 1 && in[0] == '.')
+        ++in;
+    else if (path->size() == 2 && in[0] == '.' && in[1] == '.')
+        in += 2;
+    // While the input buffer is not empty, loop:
+    while (in < end) {
+
+        // otherwise, if the input buffer begins with a prefix of "../" or "./",
+        // then remove that prefix from the input buffer;
+        if (path->size() >= 2 && in[0] == '.' && in[1] == '/')
+            in += 2;
+        else if (path->size() >= 3 && in[0] == '.' && in[1] == '.' && in[2] == '/')
+            in += 3;
+
+        // otherwise, if the input buffer begins with a prefix of
+        // "/./" or "/.", where "." is a complete path segment,
+        // then replace that prefix with "/" in the input buffer;
+        if (in <= end - 3 && in[0] == '/' && in[1] == '.' && in[2] == '/') {
+            in += 2;
+            continue;
+        } else if (in == end - 2 && in[0] == '/' && in[1] == '.') {
+            *out++ = '/';
+            in += 2;
+            break;
+        }
+        
+        // otherwise, if the input buffer begins with a prefix
+        // of "/../" or "/..", where ".." is a complete path
+        // segment, then replace that prefix with "/" in the
+        // input buffer and remove the last //segment and its
+        // preceding "/" (if any) from the output buffer;
+        if (in <= end - 4 && in[0] == '/' && in[1] == '.' && in[2] == '.' && in[3] == '/') {
+            while (out > path->constData() && *(--out) != '/')
+                ;
+            if (out == path->constData() && *out != '/')
+                ++in;
+            in += 3;
+            continue;
+        } else if (in == end - 3 && in[0] == '/' && in[1] == '.' && in[2] == '.') {
+            while (out > path->constData() && *(--out) != '/')
+                ;
+            if (*out == '/')
+                ++out;
+            in += 3;
+            break;
+        }
+        
+        // otherwise move the first path segment in
+        // the input buffer to the end of the output
+        // buffer, including the initial "/" character
+        // (if any) and any subsequent characters up
+        // to, but not including, the next "/"
+        // character or the end of the input buffer.
+        *out++ = *in++;
+        while (in < end && *in != '/')
+            *out++ = *in++;
+    }
+    path->truncate(out - path->constData());
+}
+
+void QUrlPrivate::validate() const
+{
+    QUrlPrivate *that = (QUrlPrivate *)this;
+    that->encodedOriginal = that->toEncoded(); // may detach
+    parse(ParseOnly);
+
+    QURL_SETFLAG(that->stateFlags, Validated);
+
+    if (!isValid)
+        return;
+
+    QString auth = authority(); // causes the non-encoded forms to be valid
+
+    if (scheme == QLatin1String("mailto")) {
+        if (!host.isEmpty() || port != -1 || !userName.isEmpty() || !password.isEmpty()) {
+            that->isValid = false;
+            that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "expected empty host, username,"
+                                                           "port and password"),
+                                      0, 0);
+        }
+    } else if (scheme == QLatin1String("ftp") || scheme == QLatin1String("http")) {
+        if (host.isEmpty() && !(path.isEmpty() && encodedPath.isEmpty())) {
+            that->isValid = false;
+            that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "the host is empty, but not the path"),
+                                      0, 0);
+        }
+    }
+}
+
+void QUrlPrivate::parse(ParseOptions parseOptions) const
+{
+    QUrlPrivate *that = (QUrlPrivate *)this;
+    that->errorInfo.setParams(0, 0, 0, 0);
+    if (encodedOriginal.isEmpty()) {
+        that->isValid = false;
+        that->errorInfo.setParams(0, QT_TRANSLATE_NOOP(QUrl, "empty"),
+                                  0, 0);
+        QURL_SETFLAG(that->stateFlags, Validated | Parsed);
+        return;
+    }
+
+
+    QUrlParseData parseData;
+    memset(&parseData, 0, sizeof(parseData));
+    parseData.userInfoDelimIndex = -1;
+    parseData.port = -1;
+
+    const char *pptr = (char *) encodedOriginal.constData();
+    const char **ptr = &pptr;
+
+#if defined (QURL_DEBUG)
+    qDebug("QUrlPrivate::parse(), parsing \"%s\"", pptr);
+#endif
+
+    // optional scheme
+    _scheme(ptr, &parseData);
+
+    // hierpart
+    _hierPart(ptr, &parseData);
+
+    // optional query
+    char ch = *((*ptr)++);
+    if (ch == '?') {
+        that->hasQuery = true;
+        _query(ptr, &parseData);
+        ch = *((*ptr)++);
+    }
+
+    // optional fragment
+    if (ch == '#') {
+        that->hasFragment = true;
+        _fragment(ptr, &parseData);
+    } else if (ch != '\0') {
+        that->isValid = false;
+        that->errorInfo.setParams(*ptr, QT_TRANSLATE_NOOP(QUrl, "expected end of URL"),
+                                  0, ch);
+        QURL_SETFLAG(that->stateFlags, Validated | Parsed);
+#if defined (QURL_DEBUG)
+        qDebug("QUrlPrivate::parse(), unrecognized: %c%s", ch, *ptr);
+#endif
+        return;
+    }
+
+    // when doing lazy validation, this function is called after
+    // encodedOriginal has been constructed from the individual parts,
+    // only to see if the constructed URL can be parsed. in that case,
+    // parse() is called in ParseOnly mode; we don't want to set all
+    // the members over again.
+    if (parseOptions == ParseAndSet) {
+        QURL_UNSETFLAG(that->stateFlags, HostCanonicalized);
+
+        if (parseData.scheme) {
+            QByteArray s(parseData.scheme, parseData.schemeLength);
+            that->scheme = fromPercentEncodingMutable(&s);
+        }
+
+        that->setEncodedUserInfo(&parseData);
+
+        QByteArray h(parseData.host, parseData.hostLength);
+        that->host = fromPercentEncodingMutable(&h);
+        that->port = parseData.port;
+
+        that->path.clear();
+        that->encodedPath = QByteArray(parseData.path, parseData.pathLength);
+
+        if (that->hasQuery)
+            that->query = QByteArray(parseData.query, parseData.queryLength);
+        else
+            that->query.clear();
+
+        that->fragment.clear();
+        if (that->hasFragment) {
+            that->encodedFragment = QByteArray(parseData.fragment, parseData.fragmentLength);
+        } else {
+            that->encodedFragment.clear();
+        }
+    }
+
+    that->isValid = true;
+    QURL_SETFLAG(that->stateFlags, Parsed);
+
+#if defined (QURL_DEBUG)
+    qDebug("QUrl::setUrl(), scheme = %s", that->scheme.toLatin1().constData());
+    qDebug("QUrl::setUrl(), userInfo = %s", that->userInfo.toLatin1().constData());
+    qDebug("QUrl::setUrl(), host = %s", that->host.toLatin1().constData());
+    qDebug("QUrl::setUrl(), port = %i", that->port);
+    qDebug("QUrl::setUrl(), path = %s", fromPercentEncodingHelper(__path).toLatin1().constData());
+    qDebug("QUrl::setUrl(), query = %s", __query.constData());
+    qDebug("QUrl::setUrl(), fragment = %s", fromPercentEncodingHelper(__fragment).toLatin1().constData());
+#endif
+}
+
+void QUrlPrivate::clear()
+{
+    scheme.clear();
+    userName.clear();
+    password.clear();
+    host.clear();
+    port = -1;
+    path.clear();
+    query.clear();
+    fragment.clear();
+
+    encodedOriginal.clear();
+    encodedUserName.clear();
+    encodedPassword.clear();
+    encodedPath.clear();
+    encodedFragment.clear();
+    encodedNormalized.clear();
+
+    isValid = false;
+    hasQuery = false;
+    hasFragment = false;
+
+    valueDelimiter = '=';
+    pairDelimiter = '&';
+
+    QURL_UNSETFLAG(stateFlags, Parsed | Validated | Normalized | HostCanonicalized);
+}
+
+QByteArray QUrlPrivate::toEncoded(QUrl::FormattingOptions options) const
+{
+    if (!QURL_HASFLAG(stateFlags, Parsed)) parse();
+    else ensureEncodedParts();
+
+    QByteArray url;
+
+    if (!(options & QUrl::RemoveScheme) && !scheme.isEmpty()) {
+        url += scheme.toLatin1();
+        url += ':';
+    }
+    QString auth = authority();
+    bool doFileScheme = scheme == QLatin1String("file") && encodedPath.startsWith('/');
+    if ((options & QUrl::RemoveAuthority) != QUrl::RemoveAuthority && (!auth.isEmpty() || doFileScheme)) {
+        if (doFileScheme && !encodedPath.startsWith('/'))
+            url += '/';
+        url += "//";
+
+        if ((options & QUrl::RemoveUserInfo) != QUrl::RemoveUserInfo) {
+            if (!userName.isEmpty()) {
+                url += encodedUserName;
+                if (!(options & QUrl::RemovePassword) && !password.isEmpty()) {
+                    url += ':';
+                    url += encodedPassword;
+                }
+                url += '@';
+            }
+        }
+
+        url += QUrl::toAce(host);
+        if (!(options & QUrl::RemovePort) && port != -1) {
+            url += ':';
+            url += QString::number(port).toAscii();
+        }
+    }
+
+    if (!(options & QUrl::RemovePath)) {
+        // check if we need to insert a slash
+        if (!encodedPath.isEmpty() && !auth.isEmpty()) {
+            if (!encodedPath.startsWith('/'))
+                url += '/';
+        }
+        url += encodedPath;
+
+        // check if we need to remove trailing slashes
+        while ((options & QUrl::StripTrailingSlash) && url.endsWith('/'))
+            url.chop(1);
+    }
+
+    if (!(options & QUrl::RemoveQuery) && hasQuery) {
+        url += '?';
+        url += query;
+    }
+    if (!(options & QUrl::RemoveFragment) && hasFragment) {
+        url += '#';
+        url += encodedFragment;
+    }
+
+    return url;
+}
+
+#define qToLower(ch) (((ch|32) >= 'a' && (ch|32) <= 'z') ? (ch|32) : ch)
+
+const QByteArray &QUrlPrivate::normalized()
+{
+    if (QURL_HASFLAG(stateFlags, QUrlPrivate::Normalized))
+        return encodedNormalized;
+
+    QURL_SETFLAG(stateFlags, QUrlPrivate::Normalized);
+
+    QUrlPrivate tmp = *this;
+    tmp.scheme = tmp.scheme.toLower();
+    tmp.host = tmp.canonicalHost();
+
+    // ensure the encoded and normalized parts of the URL
+    tmp.ensureEncodedParts();
+    if (tmp.encodedUserName.contains('%'))
+        q_normalizePercentEncoding(&tmp.encodedUserName, userNameExcludeChars);
+    if (tmp.encodedPassword.contains('%'))
+        q_normalizePercentEncoding(&tmp.encodedPassword, passwordExcludeChars);
+    if (tmp.encodedFragment.contains('%'))
+        q_normalizePercentEncoding(&tmp.encodedFragment, fragmentExcludeChars);
+
+    if (tmp.encodedPath.contains('%')) {
+        // the path is a bit special:
+        // the slashes shouldn't be encoded or decoded.
+        // They should remain exactly like they are right now
+        //
+        // treat the path as a slash-separated sequence of pchar
+        QByteArray result;
+        result.reserve(tmp.encodedPath.length());
+        if (tmp.encodedPath.startsWith('/'))
+            result.append('/');
+
+        const char *data = tmp.encodedPath.constData();
+        int lastSlash = 0;
+        int nextSlash;
+        do {
+            ++lastSlash;
+            nextSlash = tmp.encodedPath.indexOf('/', lastSlash);
+            int len;
+            if (nextSlash == -1)
+                len = tmp.encodedPath.length() - lastSlash;
+            else
+                len = nextSlash - lastSlash;
+
+            if (memchr(data + lastSlash, '%', len)) {
+                // there's at least one percent before the next slash
+                QByteArray block = QByteArray(data + lastSlash, len);
+                q_normalizePercentEncoding(&block, pathExcludeChars);
+                result.append(block);
+            } else {
+                // no percents in this path segment, append wholesale
+                result.append(data + lastSlash, len);
+            }
+
+            // append the slash too, if it's there
+            if (nextSlash != -1)
+                result.append('/');
+
+            lastSlash = nextSlash;
+        } while (lastSlash != -1);
+
+        tmp.encodedPath = result;
+    }
+
+    if (!tmp.scheme.isEmpty()) // relative test
+        removeDotsFromPath(&tmp.encodedPath);
+
+    int qLen = tmp.query.length();
+    for (int i = 0; i < qLen; i++) {
+        if (qLen - i > 2 && tmp.query.at(i) == '%') {
+            ++i;
+            tmp.query[i] = qToLower(tmp.query.at(i));
+            ++i;
+            tmp.query[i] = qToLower(tmp.query.at(i));
+        }
+    }
+    encodedNormalized = tmp.toEncoded();
+
+    return encodedNormalized;
+}
+
+QString QUrlPrivate::createErrorString()
+{
+    if (isValid)
+        return QString();
+
+    QString errorString(QLatin1String(QT_TRANSLATE_NOOP(QUrl, "Invalid URL \"")));
+    errorString += QLatin1String(encodedOriginal.constData());
+    errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "\""));
+
+    if (errorInfo._source) {
+        int position = encodedOriginal.indexOf(errorInfo._source) - 1;
+        if (position > 0) {
+            errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": error at position "));
+            errorString += QString::number(position);
+        } else {
+            errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": "));
+            errorString += QLatin1String(errorInfo._source);
+        }
+    }
+
+    if (errorInfo._expected) {
+        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": expected \'"));
+        errorString += QLatin1Char(errorInfo._expected);
+        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "\'"));
+    } else {
+        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ": "));
+        errorString += QLatin1String(errorInfo._message);
+    }
+    if (errorInfo._found) {
+        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, ", but found \'"));
+        errorString += QLatin1Char(errorInfo._found);
+        errorString += QLatin1String(QT_TRANSLATE_NOOP(QUrl, "\'"));
+    }
+    return errorString;
+}
+
+/*!
+    Constructs a URL by parsing \a url. \a url is assumed to be in human
+    readable representation, with no percent encoding. QUrl will automatically
+    percent encode all characters that are not allowed in a URL.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 0
+
+    To construct a URL from an encoded string, call fromEncoded():
+
+    \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 1
+
+    \sa setUrl(), setEncodedUrl(), fromEncoded(), TolerantMode
+*/
+QUrl::QUrl(const QString &url) : d(new QUrlPrivate)
+{
+    if (!url.isEmpty())
+        setUrl(url);
+}
+
+/*!
+    \overload
+
+    Parses the \a url using the parser mode \a parsingMode.
+
+    \sa setUrl()
+*/
+QUrl::QUrl(const QString &url, ParsingMode parsingMode) : d(new QUrlPrivate)
+{
+    if (!url.isEmpty())
+        setUrl(url, parsingMode);
+    else
+        d->parsingMode = parsingMode;
+}
+
+/*!
+    Constructs an empty QUrl object.
+*/
+QUrl::QUrl() : d(new QUrlPrivate)
+{
+}
+
+/*!
+    Constructs a copy of \a other.
+*/
+QUrl::QUrl(const QUrl &other) : d(other.d)
+{
+    d->ref.ref();
+}
+
+/*!
+    Destructor; called immediately before the object is deleted.
+*/
+QUrl::~QUrl()
+{
+    if (!d->ref.deref())
+        delete d;
+}
+
+/*!
+    Returns true if the URL is valid; otherwise returns false.
+
+    The URL is run through a conformance test. Every part of the URL
+    must conform to the standard encoding rules of the URI standard
+    for the URL to be reported as valid.
+
+    \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 2
+*/
+bool QUrl::isValid() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Validated)) d->validate();
+
+    return d->isValid;
+}
+
+/*!
+    Returns true if the URL has no data; otherwise returns false.
+*/
+bool QUrl::isEmpty() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed))
+        return d->encodedOriginal.isEmpty();
+    else
+        return d->scheme.isEmpty()   // no encodedScheme
+        && d->userName.isEmpty() && d->encodedUserName.isEmpty()
+        && d->password.isEmpty() && d->encodedPassword.isEmpty()
+        && d->host.isEmpty()   // no encodedHost
+        && d->port == -1
+        && d->path.isEmpty() && d->encodedPath.isEmpty()
+        && d->query.isEmpty()
+        && d->fragment.isEmpty() && d->encodedFragment.isEmpty();
+}
+
+/*!
+    Resets the content of the QUrl. After calling this function, the
+    QUrl is equal to one that has been constructed with the default
+    empty constructor.
+*/
+void QUrl::clear()
+{
+    detach();
+    d->clear();
+}
+
+/*!
+    Constructs a URL by parsing the contents of \a url.
+
+    \a url is assumed to be in unicode format, with no percent
+    encoding.
+
+    Calling isValid() will tell whether or not a valid URL was
+    constructed.
+
+    \sa setEncodedUrl()
+*/
+void QUrl::setUrl(const QString &url)
+{
+    setUrl(url, TolerantMode);
+}
+
+/*!
+    \overload
+
+    Parses \a url using the parsing mode \a parsingMode.
+
+    \sa setEncodedUrl()
+*/
+void QUrl::setUrl(const QString &url, ParsingMode parsingMode)
+{
+    // escape all reserved characters and delimiters
+    // reserved      = gen-delims / sub-delims
+    if (parsingMode != TolerantMode) {
+        setEncodedUrl(toPercentEncodingHelper(url, ABNF_reserved), parsingMode);
+        return;
+    }
+
+    // Tolerant preprocessing
+    QString tmp = url;
+
+    // Allow %20 in the QString variant
+    tmp.replace(QLatin1String("%20"), QLatin1String(" "));
+
+    // Percent-encode unsafe ASCII characters after host part
+    int start = tmp.indexOf(QLatin1String("//"));
+    if (start != -1) {
+        // Has host part, find delimiter
+        start += 2; // skip "//"
+        const char delims[] = "/#?";
+        const char *d = delims;
+        int hostEnd = -1;
+        while (*d && (hostEnd = tmp.indexOf(QLatin1Char(*d), start)) == -1)
+            ++d;
+        start = (hostEnd == -1) ? -1 : hostEnd + 1;
+    } else {
+        start = 0; // Has no host part
+    }
+    QByteArray encodedUrl;
+    if (start != -1) {
+        QString hostPart = tmp.left(start);
+        QString otherPart = tmp.mid(start);
+        encodedUrl = toPercentEncodingHelper(hostPart, ":/?#[]@!$&'()*+,;=")
+                   + toPercentEncodingHelper(otherPart, ":/?#@!$&'()*+,;=");
+    } else {
+        encodedUrl = toPercentEncodingHelper(tmp, ABNF_reserved);
+    }
+    setEncodedUrl(encodedUrl, StrictMode);
+}
+
+/*!
+    Constructs a URL by parsing the contents of \a encodedUrl.
+
+    \a encodedUrl is assumed to be a URL string in percent encoded
+    form, containing only ASCII characters.
+
+    Use isValid() to determine if a valid URL was constructed.
+
+    \sa setUrl()
+*/
+void QUrl::setEncodedUrl(const QByteArray &encodedUrl)
+{
+    setEncodedUrl(encodedUrl, TolerantMode);
+}
+
+inline static bool isHex(char c)
+{
+    c |= 0x20;
+    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f');
+}
+
+static inline char toHex(quint8 c)
+{
+    return c > 9 ? c - 10 + 'A' : c + '0';
+}
+
+/*!
+    Constructs a URL by parsing the contents of \a encodedUrl using
+    the given \a parsingMode.
+*/
+void QUrl::setEncodedUrl(const QByteArray &encodedUrl, ParsingMode parsingMode)
+{
+    clear();
+    QByteArray tmp = encodedUrl;
+    if ((d->parsingMode = parsingMode) == TolerantMode) {
+        // Replace stray % with %25
+        QByteArray copy = tmp;
+        for (int i = 0, j = 0; i < copy.size(); ++i, ++j) {
+            if (copy.at(i) == '%') {
+                if (i + 2 >= copy.size() || !isHex(copy.at(i + 1)) || !isHex(copy.at(i + 2))) {
+                    tmp.replace(j, 1, "%25");
+                    j += 2;
+                }
+            }
+        }
+
+        // Find the host part
+        int hostStart = tmp.indexOf("//");
+        int hostEnd = -1;
+        if (hostStart != -1) {
+            // Has host part, find delimiter
+            hostStart += 2; // skip "//"
+            hostEnd = tmp.indexOf('/', hostStart);
+            if (hostEnd == -1)
+                hostEnd = tmp.indexOf('#', hostStart);
+            if (hostEnd == -1)
+                hostEnd = tmp.indexOf('?');
+            if (hostEnd == -1)
+                hostEnd = tmp.length() - 1;
+        }
+
+        // Reserved and unreserved characters are fine
+//         unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+//         reserved      = gen-delims / sub-delims
+//         gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+//         sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
+//                         / "*" / "+" / "," / ";" / "="
+        // Replace everything else with percent encoding
+        static const char doEncode[] = " \"<>[\\]^`{|}";
+        static const char doEncodeHost[] = " \"<>\\^`{|}";
+        for (int i = 0; i < tmp.size(); ++i) {
+            quint8 c = quint8(tmp.at(i));
+            if (c < 32 || c > 127 ||
+                strchr(hostStart <= i && i <= hostEnd ? doEncodeHost : doEncode, c)) {
+                char buf[4];
+                buf[0] = '%';
+                buf[1] = toHex(c >> 4);
+                buf[2] = toHex(c & 0xf);
+                buf[3] = '\0';
+                tmp.replace(i, 1, buf);
+                i += 2;
+            }
+        }
+    }
+
+    d->encodedOriginal = tmp;
+}
+
+/*!
+    Sets the scheme of the URL to \a scheme. As a scheme can only
+    contain ASCII characters, no conversion or encoding is done on the
+    input.
+
+    The scheme describes the type (or protocol) of the URL. It's
+    represented by one or more ASCII characters at the start the URL,
+    and is followed by a ':'. The following example shows a URL where
+    the scheme is "ftp":
+
+    \img qurl-authority2.png
+
+    The scheme can also be empty, in which case the URL is interpreted
+    as relative.
+
+    \sa scheme(), isRelative()
+*/
+void QUrl::setScheme(const QString &scheme)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->scheme = scheme;
+}
+
+/*!
+    Returns the scheme of the URL. If an empty string is returned,
+    this means the scheme is undefined and the URL is then relative.
+
+    \sa setScheme(), isRelative()
+*/
+QString QUrl::scheme() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    return d->scheme;
+}
+
+/*!
+    Sets the authority of the URL to \a authority.
+
+    The authority of a URL is the combination of user info, a host
+    name and a port. All of these elements are optional; an empty
+    authority is therefore valid.
+
+    The user info and host are separated by a '@', and the host and
+    port are separated by a ':'. If the user info is empty, the '@'
+    must be omitted; although a stray ':' is permitted if the port is
+    empty.
+
+    The following example shows a valid authority string:
+
+    \img qurl-authority.png
+*/
+void QUrl::setAuthority(const QString &authority)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->setAuthority(authority);
+}
+
+/*!
+    Returns the authority of the URL if it is defined; otherwise
+    an empty string is returned.
+
+    \sa setAuthority()
+*/
+QString QUrl::authority() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    return d->authority();
+}
+
+/*!
+    Sets the user info of the URL to \a userInfo. The user info is an
+    optional part of the authority of the URL, as described in
+    setAuthority().
+
+    The user info consists of a user name and optionally a password,
+    separated by a ':'. If the password is empty, the colon must be
+    omitted. The following example shows a valid user info string:
+
+    \img qurl-authority3.png
+
+    \sa userInfo(), setUserName(), setPassword(), setAuthority()
+*/
+void QUrl::setUserInfo(const QString &userInfo)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->setUserInfo(userInfo.trimmed());
+}
+
+/*!
+    Returns the user info of the URL, or an empty string if the user
+    info is undefined.
+*/
+QString QUrl::userInfo() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    return d->userInfo();
+}
+
+/*!
+    Sets the URL's user name to \a userName. The \a userName is part
+    of the user info element in the authority of the URL, as described
+    in setUserInfo().
+
+    \sa setEncodedUserName(), userName(), setUserInfo()
+*/
+void QUrl::setUserName(const QString &userName)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->userName = userName;
+    d->encodedUserName.clear();
+}
+
+/*!
+    Returns the user name of the URL if it is defined; otherwise
+    an empty string is returned.
+
+    \sa setUserName(), encodedUserName()
+*/
+QString QUrl::userName() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    d->userInfo();              // causes the unencoded form to be set
+    return d->userName;
+}
+
+/*!
+    \since 4.4
+
+    Sets the URL's user name to the percent-encoded \a userName. The \a
+    userName is part of the user info element in the authority of the
+    URL, as described in setUserInfo().
+
+    Note: this function does not verify that \a userName is properly
+    encoded. It is the caller's responsibility to ensure that the any
+    delimiters (such as colons or slashes) are properly encoded.
+
+    \sa setUserName(), encodedUserName(), setUserInfo()
+*/
+void QUrl::setEncodedUserName(const QByteArray &userName)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->encodedUserName = userName;
+    d->userName.clear();
+}
+
+/*!
+    \since 4.4
+
+    Returns the user name of the URL if it is defined; otherwise
+    an empty string is returned. The returned value will have its
+    non-ASCII and other control characters percent-encoded, as in
+    toEncoded().
+
+    \sa setEncodedUserName()
+*/
+QByteArray QUrl::encodedUserName() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    d->ensureEncodedParts();
+    return d->encodedUserName;
+}
+
+/*!
+    Sets the URL's password to \a password. The \a password is part of
+    the user info element in the authority of the URL, as described in
+    setUserInfo().
+
+    \sa password(), setUserInfo()
+*/
+void QUrl::setPassword(const QString &password)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->password = password;
+    d->encodedPassword.clear();
+}
+
+/*!
+    Returns the password of the URL if it is defined; otherwise
+    an empty string is returned.
+
+    \sa setPassword()
+*/
+QString QUrl::password() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    d->userInfo();              // causes the unencoded form to be set
+    return d->password;
+}
+
+/*!
+    \since 4.4
+
+    Sets the URL's password to the percent-encoded \a password. The \a
+    password is part of the user info element in the authority of the
+    URL, as described in setUserInfo().
+
+    Note: this function does not verify that \a password is properly
+    encoded. It is the caller's responsibility to ensure that the any
+    delimiters (such as colons or slashes) are properly encoded.
+
+    \sa setPassword(), encodedPassword(), setUserInfo()
+*/
+void QUrl::setEncodedPassword(const QByteArray &password)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->encodedPassword = password;
+    d->password.clear();
+}
+
+/*!
+    \since 4.4
+
+    Returns the password of the URL if it is defined; otherwise an
+    empty string is returned. The returned value will have its
+    non-ASCII and other control characters percent-encoded, as in
+    toEncoded().
+
+    \sa setEncodedPassword(), toEncoded()
+*/
+QByteArray QUrl::encodedPassword() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    d->ensureEncodedParts();
+    return d->encodedPassword;
+}
+
+/*!
+    Sets the host of the URL to \a host. The host is part of the
+    authority.
+
+    \sa host(), setAuthority()
+*/
+void QUrl::setHost(const QString &host)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized | QUrlPrivate::HostCanonicalized);
+
+    d->host = host;
+    if (d->host.contains(QLatin1Char(':')))
+        d->host = QLatin1Char('[') + d->host + QLatin1Char(']');
+}
+
+/*!
+    Returns the host of the URL if it is defined; otherwise
+    an empty string is returned.
+*/
+QString QUrl::host() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    if (d->host.isEmpty() || d->host.at(0) != QLatin1Char('['))
+        return d->canonicalHost();
+    QString tmp = d->host.mid(1);
+    tmp.truncate(tmp.length() - 1);
+    return tmp;
+}
+
+/*!
+    \since 4.4
+
+    Sets the URL's host to the ACE- or percent-encoded \a host. The \a
+    host is part of the user info element in the authority of the
+    URL, as described in setAuthority().
+
+    \sa setHost(), encodedHost(), setAuthority(), fromAce()
+*/
+void QUrl::setEncodedHost(const QByteArray &host)
+{
+    setHost(fromPercentEncodingHelper(host));
+}
+
+/*!
+    \since 4.4
+
+    Returns the host part of the URL if it is defined; otherwise
+    an empty string is returned.
+
+    Note: encodedHost() does not return percent-encoded hostnames. Instead,
+    the ACE-encoded (bare ASCII in Punycode encoding) form will be
+    returned for any non-ASCII hostname.
+
+    This function is equivalent to calling QUrl::toAce() on the return
+    value of host().
+
+    \sa setEncodedHost()
+*/
+QByteArray QUrl::encodedHost() const
+{
+    // should we cache this in d->encodedHost?
+    return QUrl::toAce(host());
+}
+
+/*!
+    Sets the port of the URL to \a port. The port is part of the
+    authority of the URL, as described in setAuthority().
+
+    \a port must be between 0 and 65535 inclusive. Setting the
+    port to -1 indicates that the port is unspecified.
+*/
+void QUrl::setPort(int port)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    if (port < -1 || port > 65535) {
+        qWarning("QUrl::setPort: Out of range");
+        port = -1;
+    }
+
+    d->port = port;
+}
+
+/*!
+    Returns the port of the URL, or -1 if the port is unspecified.
+*/
+int QUrl::port() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Validated)) d->validate();
+    return d->port;
+}
+
+/*!
+    \overload
+    \since 4.1
+
+    Returns the port of the URL, or \a defaultPort if the port is
+    unspecified.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 3
+*/
+int QUrl::port(int defaultPort) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    return d->port == -1 ? defaultPort : d->port;
+}
+
+/*!
+    Sets the path of the URL to \a path. The path is the part of the
+    URL that comes after the authority but before the query string.
+
+    \img qurl-ftppath.png
+
+    For non-hierarchical schemes, the path will be everything
+    following the scheme declaration, as in the following example:
+
+    \img qurl-mailtopath.png
+
+    \sa path()
+*/
+void QUrl::setPath(const QString &path)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->path = path;
+    d->encodedPath.clear();
+}
+
+/*!
+    Returns the path of the URL.
+
+    \sa setPath()
+*/
+QString QUrl::path() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    if (d->path.isNull()) {
+        QUrlPrivate *that = const_cast<QUrlPrivate *>(d);
+        that->path = fromPercentEncodingHelper(d->encodedPath);
+    }
+    return d->path;
+}
+
+/*!
+    \since 4.4
+
+    Sets the URL's path to the percent-encoded \a path.  The path is
+    the part of the URL that comes after the authority but before the
+    query string.
+
+    \img qurl-ftppath.png
+
+    For non-hierarchical schemes, the path will be everything
+    following the scheme declaration, as in the following example:
+
+    \img qurl-mailtopath.png
+
+    Note: this function does not verify that \a path is properly
+    encoded. It is the caller's responsibility to ensure that the any
+    delimiters (such as '?' and '#') are properly encoded.
+
+    \sa setPath(), encodedPath(), setUserInfo()
+*/
+void QUrl::setEncodedPath(const QByteArray &path)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->encodedPath = path;
+    d->path.clear();
+}
+
+/*!
+    \since 4.4
+
+    Returns the path of the URL if it is defined; otherwise an
+    empty string is returned. The returned value will have its
+    non-ASCII and other control characters percent-encoded, as in
+    toEncoded().
+
+    \sa setEncodedPath(), toEncoded()
+*/
+QByteArray QUrl::encodedPath() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    d->ensureEncodedParts();
+    return d->encodedPath;
+}
+
+/*!
+    \since 4.2
+
+    Returns true if this URL contains a Query (i.e., if ? was seen on it).
+
+    \sa hasQueryItem(), encodedQuery()
+*/
+bool QUrl::hasQuery() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    return d->hasQuery;
+}
+
+/*!
+    Sets the characters used for delimiting between keys and values,
+    and between key-value pairs in the URL's query string. The default
+    value delimiter is '=' and the default pair delimiter is '&'.
+
+    \img qurl-querystring.png
+
+    \a valueDelimiter will be used for separating keys from values,
+    and \a pairDelimiter will be used to separate key-value pairs.
+    Any occurrences of these delimiting characters in the encoded
+    representation of the keys and values of the query string are
+    percent encoded.
+
+    If \a valueDelimiter is set to '-' and \a pairDelimiter is '/',
+    the above query string would instead be represented like this:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 4
+
+    Calling this function does not change the delimiters of the
+    current query string. It only affects queryItems(),
+    setQueryItems() and addQueryItems().
+*/
+void QUrl::setQueryDelimiters(char valueDelimiter, char pairDelimiter)
+{
+    detach();
+
+    d->valueDelimiter = valueDelimiter;
+    d->pairDelimiter = pairDelimiter;
+}
+
+/*!
+    Returns the character used to delimit between key-value pairs in
+    the query string of the URL.
+*/
+char QUrl::queryPairDelimiter() const
+{
+    return d->pairDelimiter;
+}
+
+/*!
+    Returns the character used to delimit between keys and values in
+    the query string of the URL.
+*/
+char QUrl::queryValueDelimiter() const
+{
+    return d->valueDelimiter;
+}
+
+/*!
+    Sets the query string of the URL to \a query. The string is
+    inserted as-is, and no further encoding is performed when calling
+    toEncoded().
+
+    This function is useful if you need to pass a query string that
+    does not fit into the key-value pattern, or that uses a different
+    scheme for encoding special characters than what is suggested by
+    QUrl.
+
+    Passing a value of QByteArray() to \a query (a null QByteArray) unsets
+    the query completely. However, passing a value of QByteArray("")
+    will set the query to an empty value, as if the original URL
+    had a lone "?".
+
+    \sa encodedQuery(), hasQuery()
+*/
+void QUrl::setEncodedQuery(const QByteArray &query)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->query = query;
+    d->hasQuery = !query.isNull();
+}
+
+/*!
+    Sets the query string of the URL to an encoded version of \a
+    query. The contents of \a query are converted to a string
+    internally, each pair delimited by the character returned by
+    pairDelimiter(), and the key and value are delimited by
+    valueDelimiter().
+
+    \sa setQueryDelimiters(), queryItems(), setEncodedQueryItems()
+*/
+void QUrl::setQueryItems(const QList<QPair<QString, QString> > &query)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+
+    char alsoEncode[3];
+    alsoEncode[0] = d->valueDelimiter;
+    alsoEncode[1] = d->pairDelimiter;
+    alsoEncode[2] = 0;
+
+    QByteArray queryTmp;
+    for (int i = 0; i < query.size(); i++) {
+        if (i) queryTmp += d->pairDelimiter;
+        // query = *( pchar / "/" / "?" )
+        queryTmp += toPercentEncodingHelper(query.at(i).first, queryExcludeChars, alsoEncode);
+        queryTmp += d->valueDelimiter;
+        // query = *( pchar / "/" / "?" )
+        queryTmp += toPercentEncodingHelper(query.at(i).second, queryExcludeChars, alsoEncode);
+    }
+
+    d->query = queryTmp;
+    d->hasQuery = !query.isEmpty();
+}
+
+/*!
+    \since 4.4
+
+    Sets the query string of the URL to the encoded version of \a
+    query. The contents of \a query are converted to a string
+    internally, each pair delimited by the character returned by
+    pairDelimiter(), and the key and value are delimited by
+    valueDelimiter().
+
+    Note: this function does not verify that the key-value pairs
+    are properly encoded. It is the caller's responsibility to ensure
+    that the query delimiters are properly encoded, if any.
+
+    \sa setQueryDelimiters(), encodedQueryItems(), setQueryItems()
+*/
+void QUrl::setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+
+    QByteArray queryTmp;
+    for (int i = 0; i < query.size(); i++) {
+        if (i) queryTmp += d->pairDelimiter;
+        queryTmp += query.at(i).first;
+        queryTmp += d->valueDelimiter;
+        queryTmp += query.at(i).second;
+    }
+
+    d->query = queryTmp;
+    d->hasQuery = !query.isEmpty();
+}
+
+/*!
+    Inserts the pair \a key = \a value into the query string of the
+    URL.
+
+    \sa addEncodedQueryItem()
+*/
+void QUrl::addQueryItem(const QString &key, const QString &value)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+
+    char alsoEncode[3];
+    alsoEncode[0] = d->valueDelimiter;
+    alsoEncode[1] = d->pairDelimiter;
+    alsoEncode[2] = 0;
+
+    if (!d->query.isEmpty())
+        d->query += d->pairDelimiter;
+
+    // query = *( pchar / "/" / "?" )
+    d->query += toPercentEncodingHelper(key, queryExcludeChars, alsoEncode);
+    d->query += d->valueDelimiter;
+    // query = *( pchar / "/" / "?" )
+    d->query += toPercentEncodingHelper(value, queryExcludeChars, alsoEncode);
+
+    d->hasQuery = !d->query.isEmpty();
+}
+
+/*!
+    \since 4.4
+
+    Inserts the pair \a key = \a value into the query string of the
+    URL.
+
+    Note: this function does not verify that either \a key or \a value
+    are properly encoded. It is the caller's responsibility to ensure
+    that the query delimiters are properly encoded, if any.
+
+    \sa addQueryItem(), setQueryDelimiters()
+*/
+void QUrl::addEncodedQueryItem(const QByteArray &key, const QByteArray &value)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+
+    if (!d->query.isEmpty())
+        d->query += d->pairDelimiter;
+
+    d->query += key;
+    d->query += d->valueDelimiter;
+    d->query += value;
+
+    d->hasQuery = !d->query.isEmpty();
+}
+
+/*!
+    Returns the query string of the URL, as a map of keys and values.
+
+    \sa setQueryItems(), setEncodedQuery()
+*/
+QList<QPair<QString, QString> > QUrl::queryItems() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    QList<QPair<QString, QString> > itemMap;
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        QByteArray q(query + pos, valuedelim - pos);
+        if (valuedelim < end) {
+            QByteArray v(query + valuedelim + 1, end - valuedelim - 1);
+            itemMap += qMakePair(fromPercentEncodingMutable(&q),
+                                 fromPercentEncodingMutable(&v));
+        } else {
+            itemMap += qMakePair(fromPercentEncodingMutable(&q), QString());
+        }
+        pos = end + 1;
+    }
+
+    return itemMap;
+}
+
+/*!
+    \since 4.4
+
+    Returns the query string of the URL, as a map of encoded keys and values.
+
+    \sa setEncodedQueryItems(), setQueryItems(), setEncodedQuery()
+*/
+QList<QPair<QByteArray, QByteArray> > QUrl::encodedQueryItems() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    QList<QPair<QByteArray, QByteArray> > itemMap;
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        if (valuedelim < end)
+            itemMap += qMakePair(QByteArray(query + pos, valuedelim - pos),
+                                 QByteArray(query + valuedelim + 1, end - valuedelim - 1));
+        else
+            itemMap += qMakePair(QByteArray(query + pos, valuedelim - pos), QByteArray());
+        pos = end + 1;
+    }
+
+    return itemMap;
+}
+
+/*!
+    Returns true if there is a query string pair whose key is equal
+    to \a key from the URL.
+
+    \sa hasEncodedQueryItem()
+*/
+bool QUrl::hasQueryItem(const QString &key) const
+{
+    return hasEncodedQueryItem(toPercentEncoding(key, queryExcludeChars));
+}
+
+/*!
+    \since 4.4
+
+    Returns true if there is a query string pair whose key is equal
+    to \a key from the URL.
+
+    Note: if the encoded \a key does not match the encoded version of
+    the query, this function will return false. That is, if the
+    encoded query of this URL is "search=Qt%20Rules", calling this
+    function with \a key = "%73earch" will return false.
+
+    \sa hasQueryItem()
+*/
+bool QUrl::hasEncodedQueryItem(const QByteArray &key) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        if (key == QByteArray::fromRawData(query + pos, valuedelim - pos))
+            return true;
+        pos = end + 1;
+    }
+    return false;
+}
+
+/*!
+    Returns the first query string value whose key is equal to \a key
+    from the URL.
+
+    \sa allQueryItemValues()
+*/
+QString QUrl::queryItemValue(const QString &key) const
+{
+    QByteArray tmp = encodedQueryItemValue(toPercentEncoding(key, queryExcludeChars));
+    return fromPercentEncodingMutable(&tmp);
+}
+
+/*!
+    \since 4.4
+
+    Returns the first query string value whose key is equal to \a key
+    from the URL.
+
+    Note: if the encoded \a key does not match the encoded version of
+    the query, this function will not work. That is, if the
+    encoded query of this URL is "search=Qt%20Rules", calling this
+    function with \a key = "%73earch" will return an empty string.
+
+    \sa queryItemValue(), allQueryItemValues()
+*/
+QByteArray QUrl::encodedQueryItemValue(const QByteArray &key) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        if (key == QByteArray::fromRawData(query + pos, valuedelim - pos))
+            return valuedelim < end ?
+                QByteArray(query + valuedelim + 1, end - valuedelim - 1) : QByteArray();
+        pos = end + 1;
+    }
+    return QByteArray();
+}
+
+/*!
+    Returns the a list of query string values whose key is equal to
+    \a key from the URL.
+
+    \sa queryItemValue()
+*/
+QStringList QUrl::allQueryItemValues(const QString &key) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    QByteArray encodedKey = toPercentEncoding(key, queryExcludeChars);
+    QStringList values;
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        if (encodedKey == QByteArray::fromRawData(query + pos, valuedelim - pos)) {
+            QByteArray v(query + valuedelim + 1, end - valuedelim - 1);
+            values += valuedelim < end ?
+                      fromPercentEncodingMutable(&v)
+                      : QString();
+        }
+        pos = end + 1;
+    }
+
+    return values;
+}
+
+/*!
+    \since 4.4
+
+    Returns the a list of query string values whose key is equal to
+    \a key from the URL.
+
+    Note: if the encoded \a key does not match the encoded version of
+    the query, this function will not work. That is, if the
+    encoded query of this URL is "search=Qt%20Rules", calling this
+    function with \a key = "%73earch" will return an empty list.
+
+    \sa allQueryItemValues(), queryItemValue(), encodedQueryItemValue()
+*/
+QList<QByteArray> QUrl::allEncodedQueryItemValues(const QByteArray &key) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    QList<QByteArray> values;
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        if (key == QByteArray::fromRawData(query + pos, valuedelim - pos))
+            values += valuedelim < end ?
+                      QByteArray(query + valuedelim + 1, end - valuedelim - 1)
+                      : QByteArray();
+        pos = end + 1;
+    }
+
+    return values;
+}
+
+/*!
+    Removes the first query string pair whose key is equal to \a key
+    from the URL.
+
+    \sa removeAllQueryItems()
+*/
+void QUrl::removeQueryItem(const QString &key)
+{
+    removeEncodedQueryItem(toPercentEncoding(key, queryExcludeChars));
+}
+
+/*!
+    \since 4.4
+
+    Removes the first query string pair whose key is equal to \a key
+    from the URL.
+
+    Note: if the encoded \a key does not match the encoded version of
+    the query, this function will not work. That is, if the
+    encoded query of this URL is "search=Qt%20Rules", calling this
+    function with \a key = "%73earch" will do nothing.
+
+    \sa removeQueryItem(), removeAllQueryItems()
+*/
+void QUrl::removeEncodedQueryItem(const QByteArray &key)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        if (key == QByteArray::fromRawData(query + pos, valuedelim - pos)) {
+            if (end < d->query.size())
+                ++end; // remove additional '%'
+            d->query.remove(pos, end - pos);
+            return;
+        }
+        pos = end + 1;
+    }
+}
+
+/*!
+    Removes all the query string pairs whose key is equal to \a key
+    from the URL.
+
+   \sa removeQueryItem()
+*/
+void QUrl::removeAllQueryItems(const QString &key)
+{
+    removeAllEncodedQueryItems(toPercentEncoding(key, queryExcludeChars));
+}
+
+/*!
+    \since 4.4
+
+    Removes all the query string pairs whose key is equal to \a key
+    from the URL.
+
+    Note: if the encoded \a key does not match the encoded version of
+    the query, this function will not work. That is, if the
+    encoded query of this URL is "search=Qt%20Rules", calling this
+    function with \a key = "%73earch" will do nothing.
+
+   \sa removeQueryItem()
+*/
+void QUrl::removeAllEncodedQueryItems(const QByteArray &key)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+
+    int pos = 0;
+    const char *query = d->query.constData();
+    while (pos < d->query.size()) {
+        int valuedelim, end;
+        d->queryItem(pos, &valuedelim, &end);
+        if (key == QByteArray::fromRawData(query + pos, valuedelim - pos)) {
+            if (end < d->query.size())
+                ++end; // remove additional '%'
+            d->query.remove(pos, end - pos);
+        } else {
+            pos = end + 1;
+        }
+    }
+}
+
+/*!
+    Returns the query string of the URL in percent encoded form.
+*/
+QByteArray QUrl::encodedQuery() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    return d->query;
+}
+
+/*!
+    Sets the fragment of the URL to \a fragment. The fragment is the
+    last part of the URL, represented by a '#' followed by a string of
+    characters. It is typically used in HTTP for referring to a
+    certain link or point on a page:
+
+    \img qurl-fragment.png
+
+    The fragment is sometimes also referred to as the URL "reference".
+
+    Passing an argument of QString() (a null QString) will unset the fragment.
+    Passing an argument of QString("") (an empty but not null QString)
+    will set the fragment to an empty string (as if the original URL
+    had a lone "#").
+
+    \sa fragment(), hasFragment()
+*/
+void QUrl::setFragment(const QString &fragment)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->fragment = fragment;
+    d->hasFragment = !fragment.isNull();
+    d->encodedFragment.clear();
+}
+
+/*!
+    Returns the fragment of the URL.
+
+    \sa setFragment()
+*/
+QString QUrl::fragment() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    if (d->fragment.isNull() && !d->encodedFragment.isNull()) {
+        QUrlPrivate *that = const_cast<QUrlPrivate *>(d);
+        that->fragment = fromPercentEncodingHelper(d->encodedFragment);
+    }
+    return d->fragment;
+}
+
+/*!
+    \since 4.4
+
+    Sets the URL's fragment to the percent-encoded \a fragment. The fragment is the
+    last part of the URL, represented by a '#' followed by a string of
+    characters. It is typically used in HTTP for referring to a
+    certain link or point on a page:
+
+    \img qurl-fragment.png
+
+    The fragment is sometimes also referred to as the URL "reference".
+
+    Passing an argument of QByteArray() (a null QByteArray) will unset
+    the fragment.  Passing an argument of QByteArray("") (an empty but
+    not null QByteArray) will set the fragment to an empty string (as
+    if the original URL had a lone "#").
+
+    \sa setFragment(), encodedFragment()
+*/
+void QUrl::setEncodedFragment(const QByteArray &fragment)
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    detach();
+    QURL_UNSETFLAG(d->stateFlags, QUrlPrivate::Validated | QUrlPrivate::Normalized);
+
+    d->encodedFragment = fragment;
+    d->hasFragment = !fragment.isNull();
+    d->fragment.clear();
+}
+
+/*!
+    \since 4.4
+
+    Returns the fragment of the URL if it is defined; otherwise an
+    empty string is returned. The returned value will have its
+    non-ASCII and other control characters percent-encoded, as in
+    toEncoded().
+
+    \sa setEncodedFragment(), toEncoded()
+*/
+QByteArray QUrl::encodedFragment() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    d->ensureEncodedParts();
+    return d->encodedFragment;
+}
+
+/*!
+    \since 4.2
+
+    Returns true if this URL contains a fragment (i.e., if # was seen on it).
+
+    \sa fragment(), setFragment()
+*/
+bool QUrl::hasFragment() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    return d->hasFragment;
+}
+
+/*!
+    Returns the result of the merge of this URL with \a relative. This
+    URL is used as a base to convert \a relative to an absolute URL.
+
+    If \a relative is not a relative URL, this function will return \a
+    relative directly. Otherwise, the paths of the two URLs are
+    merged, and the new URL returned has the scheme and authority of
+    the base URL, but with the merged path, as in the following
+    example:
+
+    \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 5
+
+    Calling resolved() with ".." returns a QUrl whose directory is
+    one level higher than the original. Similarly, calling resolved()
+    with "../.." removes two levels from the path. If \a relative is
+    "/", the path becomes "/".
+
+    \sa isRelative()
+*/
+QUrl QUrl::resolved(const QUrl &relative) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    if (!QURL_HASFLAG(relative.d->stateFlags, QUrlPrivate::Parsed))
+        relative.d->parse();
+
+    d->ensureEncodedParts();
+    relative.d->ensureEncodedParts();
+
+    QUrl t;
+    // be non strict and allow scheme in relative url
+    if (!relative.d->scheme.isEmpty() && relative.d->scheme != d->scheme) {
+        t = relative;
+    } else {
+        if (!relative.authority().isEmpty()) {
+            t = relative;
+        } else {
+            if (relative.d->encodedPath.isEmpty()) {
+                t.d->encodedPath = d->encodedPath;
+                t.setEncodedQuery(relative.d->hasQuery ? relative.d->query : d->query);
+            } else {
+                t.d->encodedPath = relative.d->encodedPath.at(0) == '/'
+                                       ? relative.d->encodedPath
+                                       : d->mergePaths(relative.d->encodedPath);
+                t.setEncodedQuery(relative.d->query);
+            }
+            t.d->encodedUserName = d->encodedUserName;
+            t.d->encodedPassword = d->encodedPassword;
+            t.d->host = d->host;
+            t.d->port = d->port;
+        }
+        t.setScheme(d->scheme);
+    }
+    t.setFragment(relative.fragment());
+    removeDotsFromPath(&t.d->encodedPath);
+    t.d->path.clear();
+
+    return t;
+}
+
+/*!
+    Returns true if the URL is relative; otherwise returns false. A
+    URL is relative if its scheme is undefined; this function is
+    therefore equivalent to calling scheme().isEmpty().
+*/
+bool QUrl::isRelative() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    return d->scheme.isEmpty();
+}
+
+/*!
+    Returns the human-displayable string representation of the
+    URL. The output can be customized by passing flags with \a
+    options.
+
+    \sa FormattingOptions, toEncoded()
+*/
+QString QUrl::toString(FormattingOptions options) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    QString url;
+
+    if (!(options & QUrl::RemoveScheme) && !d->scheme.isEmpty())
+        url += d->scheme + QLatin1Char(':');
+    QString ourPath = path();
+    if ((options & QUrl::RemoveAuthority) != QUrl::RemoveAuthority) {
+        bool doFileScheme = d->scheme == QLatin1String("file") && ourPath.startsWith(QLatin1Char('/'));
+        QString tmp = d->authority(options);
+        if (!tmp.isEmpty() || doFileScheme) {
+            if (doFileScheme && !ourPath.startsWith(QLatin1Char('/')))
+                url += QLatin1Char('/');
+            url += QLatin1String("//");
+            url += tmp;
+        }
+    }
+    if (!(options & QUrl::RemovePath)) {
+        // check if we need to insert a slash
+        if ((options & QUrl::RemoveAuthority) != QUrl::RemoveAuthority
+            && !d->authority(options).isEmpty() && !ourPath.isEmpty() && ourPath.at(0) != QLatin1Char('/'))
+            url += QLatin1Char('/');
+        url += ourPath;
+        // check if we need to remove trailing slashes
+        while ((options & StripTrailingSlash) && url.right(1) == QLatin1String("/"))
+            url.chop(1);
+    }
+
+    if (!(options & QUrl::RemoveQuery) && d->hasQuery) {
+        url += QLatin1Char('?');
+        url += fromPercentEncoding(d->query);
+    }
+    if (!(options & QUrl::RemoveFragment) && d->hasFragment) {
+        url += QLatin1Char('#');
+        url += fragment();
+    }
+
+    return url;
+}
+
+/*!
+    Returns the encoded representation of the URL if it's valid;
+    otherwise an empty QByteArray is returned. The output can be
+    customized by passing flags with \a options.
+
+    The user info, path and fragment are all converted to UTF-8, and
+    all non-ASCII characters are then percent encoded. The host name
+    is encoded using Punycode.
+*/
+QByteArray QUrl::toEncoded(FormattingOptions options) const
+{
+    return d->toEncoded(options);
+}
+
+/*!
+    Parses \a input and returns the corresponding QUrl. \a input is
+    assumed to be in encoded form, containing only ASCII characters.
+
+    The URL is parsed using TolerantMode.
+
+    \sa toEncoded(), setUrl()
+*/
+QUrl QUrl::fromEncoded(const QByteArray &input)
+{
+    QUrl tmp;
+    tmp.setEncodedUrl(input, TolerantMode);
+    return tmp;
+}
+
+/*!
+    \overload
+
+    Parses the URL using \a parsingMode.
+
+    \sa toEncoded(), setUrl()
+*/
+QUrl QUrl::fromEncoded(const QByteArray &input, ParsingMode parsingMode)
+{
+    QUrl tmp;
+    tmp.setEncodedUrl(input, parsingMode);
+    return tmp;
+}
+
+/*!
+    Returns a decoded copy of \a input. \a input is first decoded from
+    percent encoding, then converted from UTF-8 to unicode.
+*/
+QString QUrl::fromPercentEncoding(const QByteArray &input)
+{
+    return fromPercentEncodingHelper(input);
+}
+
+/*!
+    Returns an encoded copy of \a input. \a input is first converted
+    to UTF-8, and all ASCII-characters that are not in the unreserved group
+    are percent encoded. To prevent characters from being percent encoded
+    pass them to \a exclude. To force characters to be percent encoded pass
+    them to \a include.
+
+    Unreserved is defined as:
+       ALPHA / DIGIT / "-" / "." / "_" / "~"
+
+    \snippet doc/src/snippets/code/src_corelib_io_qurl.cpp 6
+*/
+QByteArray QUrl::toPercentEncoding(const QString &input, const QByteArray &exclude, const QByteArray &include)
+{
+    return toPercentEncodingHelper(input, exclude.constData(), include.constData());
+}
+
+/*!
+    \obsolete
+    Returns a \a uc in Punycode encoding.
+
+    Punycode is a Unicode encoding used for internationalized domain
+    names, as defined in RFC3492. If you want to convert a domain name from
+    Unicode to its ASCII-compatible representation, use toAce().
+*/
+QByteArray QUrl::toPunycode(const QString &uc)
+{
+    QByteArray output;
+    toPunycodeHelper(uc.constData(), uc.size(), &output);
+    return output;
+}
+
+/*!
+    \obsolete
+    Returns the Punycode decoded representation of \a pc.
+
+    Punycode is a Unicode encoding used for internationalized domain
+    names, as defined in RFC3492. If you want to convert a domain from
+    its ASCII-compatible encoding to the Unicode representation, use
+    fromAce().
+*/
+QString QUrl::fromPunycode(const QByteArray &pc)
+{
+    uint n = initial_n;
+    uint i = 0;
+    uint bias = initial_bias;
+
+    // strip any ACE prefix
+    int start = pc.startsWith("xn--") ? 4 : 0;
+    if (!start)
+        return QString::fromLatin1(pc);
+
+    // find the last delimiter character '-' in the input array. copy
+    // all data before this delimiter directly to the output array.
+    int delimiterPos = pc.lastIndexOf(0x2d);
+    QString output = delimiterPos < 4 ?
+                     QString() : QString::fromLatin1(pc.constData() + start, delimiterPos - start);
+
+    // if a delimiter was found, skip to the position after it;
+    // otherwise start at the front of the input string. everything
+    // before the delimiter is assumed to be basic code points.
+    uint cnt = delimiterPos + 1;
+
+    // loop through the rest of the input string, inserting non-basic
+    // characters into output as we go.
+    while (cnt < (uint) pc.size()) {
+        uint oldi = i;
+        uint w = 1;
+
+        // find the next index for inserting a non-basic character.
+        for (uint k = base; cnt < (uint) pc.size(); k += base) {
+            // grab a character from the punycode input and find its
+            // delta digit (each digit code is part of the
+            // variable-length integer delta)
+            uint digit = pc.at(cnt++);
+            if (digit - 48 < 10) digit -= 22;
+            else if (digit - 65 < 26) digit -= 65;
+            else if (digit - 97 < 26) digit -= 97;
+            else digit = base;
+
+            // reject out of range digits
+            if (digit >= base || digit > (Q_MAXINT - i) / w)
+                return QLatin1String("");
+
+            i += (digit * w);
+
+            // detect threshold to stop reading delta digits
+            uint t;
+            if (k <= bias) t = tmin;
+            else if (k >= bias + tmax) t = tmax;
+            else t = k - bias;
+            if (digit < t) break;
+
+            w *= (base - t);
+        }
+
+        // find new bias and calculate the next non-basic code
+        // character.
+        bias = adapt(i - oldi, output.length() + 1, oldi == 0);
+        n += i / (output.length() + 1);
+
+        // allow the deltas to wrap around
+        i %= (output.length() + 1);
+
+        // insert the character n at position i
+        output.insert((uint) i, QChar((ushort) n));
+        ++i;
+    }
+
+    return output;
+}
+
+/*!
+    \since 4.2
+
+    Returns the Unicode form of the given domain name
+    \a domain, which is encoded in the ASCII Compatible Encoding (ACE).
+    The result of this function is considered equivalent to \a domain.
+
+    If the value in \a domain cannot be encoded, it will be converted
+    to QString and returned.
+
+    The ASCII Compatible Encoding (ACE) is defined by RFC 3490, RFC 3491
+    and RFC 3492. It is part of the Internationalizing Domain Names in
+    Applications (IDNA) specification, which allows for domain names
+    (like \c "qtsoftware.com") to be written using international
+    characters.
+*/
+QString QUrl::fromAce(const QByteArray &domain)
+{
+    return qt_from_ACE(QString::fromLatin1(domain));
+}
+
+/*!
+    \since 4.2
+
+    Returns the ASCII Compatible Encoding of the given domain name \a domain.
+    The result of this function is considered equivalent to \a domain.
+
+    The ASCII-Compatible Encoding (ACE) is defined by RFC 3490, RFC 3491
+    and RFC 3492. It is part of the Internationalizing Domain Names in
+    Applications (IDNA) specification, which allows for domain names
+    (like \c "qtsoftware.com") to be written using international
+    characters.
+*/
+QByteArray QUrl::toAce(const QString &domain)
+{
+    // IDNA / rfc3490 describes these four delimiters used for
+    // separating labels in unicode international domain
+    // names.
+    QString nameprepped = qt_nameprep(domain);
+    int lastIdx = 0;
+    QByteArray result;
+    for (int i = 0; i < nameprepped.size(); ++i) {
+        ushort uc = nameprepped.at(i).unicode();
+        if (uc == 0x2e || uc == 0x3002 || uc == 0xff0e || uc == 0xff61) {
+            if (lastIdx)
+                result += '.';
+            toPunycodeHelper(nameprepped.constData() + lastIdx, i - lastIdx, &result);
+            lastIdx = i + 1;
+        }
+    }
+    if (lastIdx)
+        result += '.';
+    toPunycodeHelper(nameprepped.constData() + lastIdx, nameprepped.size() - lastIdx, &result);
+    
+    return result;
+}
+
+/*!
+    \since 4.2
+
+    Returns the current whitelist of top-level domains that are allowed
+    to have non-ASCII characters in their compositions.
+
+    See setIdnWhitelist() for the rationale of this list.
+*/
+QStringList QUrl::idnWhitelist()
+{
+    if (user_idn_whitelist)
+        return *user_idn_whitelist;
+    QStringList list;
+    unsigned int i = 0;
+    while (i < sizeof(idn_whitelist)/sizeof(const char *)) {
+        list << QLatin1String(idn_whitelist[i]);
+        ++i;
+    }
+    return list;
+}
+
+/*!
+    \since 4.2
+
+    Sets the whitelist of Top-Level Domains (TLDs) that are allowed to have
+    non-ASCII characters in domains to the value of \a list.
+
+    Qt has comes a default list that contains the Internet top-level domains
+    that have published support for Internationalized Domain Names (IDNs)
+    and rules to guarantee that no deception can happen between similarly-looking
+    characters (such as the Latin lowercase letter \c 'a' and the Cyrillic
+    equivalent, which in most fonts are visually identical).
+
+    This list is periodically maintained, as registrars publish new rules.
+
+    This function is provided for those who need to manipulate the list, in
+    order to add or remove a TLD. It is not recommended to change its value
+    for purposes other than testing, as it may expose users to security risks.
+*/
+void QUrl::setIdnWhitelist(const QStringList &list)
+{
+    if (!user_idn_whitelist)
+        user_idn_whitelist = new QStringList;
+    *user_idn_whitelist = list;
+}
+
+/*!
+    \internal
+
+    Returns true if this URL is "less than" the given \a url. This
+    provides a means of ordering URLs.
+*/
+bool QUrl::operator <(const QUrl &url) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    if (!QURL_HASFLAG(url.d->stateFlags, QUrlPrivate::Parsed)) url.d->parse();
+    return d->normalized() < url.d->normalized();
+}
+
+/*!
+    Returns true if this URL and the given \a url are equal;
+    otherwise returns false.
+*/
+bool QUrl::operator ==(const QUrl &url) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+    if (!QURL_HASFLAG(url.d->stateFlags, QUrlPrivate::Parsed)) url.d->parse();
+    return d->normalized() == url.d->normalized();
+}
+
+/*!
+    Returns true if this URL and the given \a url are not equal;
+    otherwise returns false.
+*/
+bool QUrl::operator !=(const QUrl &url) const
+{
+    return !(*this == url);
+}
+
+/*!
+    Assigns the specified \a url to this object.
+*/
+QUrl &QUrl::operator =(const QUrl &url)
+{
+    qAtomicAssign(d, url.d);
+    return *this;
+}
+
+/*!
+    Assigns the specified \a url to this object.
+*/
+QUrl &QUrl::operator =(const QString &url)
+{
+    QUrl tmp(url);
+    qAtomicAssign(d, tmp.d);
+    return *this;
+}
+
+/*! \internal
+
+    Forces a detach.
+*/
+void QUrl::detach()
+{ qAtomicDetach(d); }
+
+/*!
+    \internal
+*/
+bool QUrl::isDetached() const
+{
+    return d->ref == 1;
+}
+
+
+/*!
+    Returns a QUrl representation of \a localFile, interpreted as a
+    local file.
+
+    \sa toLocalFile()
+*/
+QUrl QUrl::fromLocalFile(const QString &localFile)
+{
+    QUrl url;
+    url.setScheme(QLatin1String("file"));
+    QString deslashified = localFile;
+    deslashified.replace(QLatin1Char('\\'), QLatin1Char('/'));
+
+
+
+    // magic for drives on windows
+    if (deslashified.length() > 1 && deslashified.at(1) == QLatin1Char(':') && deslashified.at(0) != QLatin1Char('/')) {
+        url.setPath(QLatin1String("/") + deslashified);
+    // magic for shared drive on windows
+    } else if (deslashified.startsWith(QLatin1String("//"))) {
+        int indexOfPath = deslashified.indexOf(QLatin1Char('/'), 2);
+        url.setHost(deslashified.mid(2, indexOfPath - 2));
+        if (indexOfPath > 2)
+            url.setPath(deslashified.right(deslashified.length() - indexOfPath));
+    } else {
+        url.setPath(deslashified);
+    }
+
+    return url;
+}
+
+/*!
+    Returns the path of this URL formatted as a local file path.
+
+    \sa fromLocalFile()
+*/
+QString QUrl::toLocalFile() const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    QString tmp;
+    QString ourPath = path();
+    if (d->scheme.isEmpty() || d->scheme.toLower() == QLatin1String("file")) {
+
+        // magic for shared drive on windows
+        if (!d->host.isEmpty()) {
+            tmp = QLatin1String("//") + d->host + (ourPath.length() > 0 && ourPath.at(0) != QLatin1Char('/')
+                                                  ? QLatin1String("/") + ourPath :  ourPath);
+        } else {
+            tmp = ourPath;
+            // magic for drives on windows
+            if (ourPath.length() > 2 && ourPath.at(0) == QLatin1Char('/') && ourPath.at(2) == QLatin1Char(':'))
+                tmp.remove(0, 1);
+        }
+    }
+
+    return tmp;
+}
+
+/*!
+    Returns true if this URL is a parent of \a childUrl. \a childUrl is a child
+    of this URL if the two URLs share the same scheme and authority,
+    and this URL's path is a parent of the path of \a childUrl.
+*/
+bool QUrl::isParentOf(const QUrl &childUrl) const
+{
+    if (!QURL_HASFLAG(d->stateFlags, QUrlPrivate::Parsed)) d->parse();
+
+    QString childPath = childUrl.path();
+    QString ourPath = path();
+
+    return ((childUrl.scheme().isEmpty() || d->scheme == childUrl.scheme())
+            && (childUrl.authority().isEmpty() || d->authority() == childUrl.authority())
+            &&  childPath.startsWith(ourPath)
+            && ((ourPath.endsWith(QLatin1Char('/')) && childPath.length() > ourPath.length())
+                || (!ourPath.endsWith(QLatin1Char('/'))
+                    && childPath.length() > ourPath.length() && childPath.at(ourPath.length()) == QLatin1Char('/'))));
+}
+
+/*!
+    \fn void QUrl::setProtocol(const QString &s)
+
+    Use setScheme() instead.
+*/
+
+/*!
+    \fn void QUrl::setUser(const QString &s)
+
+    Use setUserName() instead.
+*/
+
+/*!
+    \fn bool QUrl::hasUser() const
+
+    Use !userName().isEmpty() instead.
+*/
+
+/*!
+    \fn bool QUrl::hasPassword() const
+
+    Use !password().isEmpty() instead.
+*/
+
+/*!
+    \fn bool QUrl::hasHost() const
+
+    Use !host().isEmpty() instead.
+*/
+
+/*!
+    \fn bool QUrl::hasPort() const
+
+    Use port() != -1 instead.
+*/
+
+/*!
+    \fn bool QUrl::hasPath() const
+
+    Use !path().isEmpty() instead.
+*/
+
+/*!
+    \fn void QUrl::setQuery(const QString &txt)
+
+    Use setEncodedQuery() instead.
+*/
+
+/*!
+    \fn void QUrl::setRef(const QString &txt)
+
+    Use setFragment() instead.
+*/
+
+/*!
+    \fn bool QUrl::hasRef() const
+
+    Use !fragment().isEmpty() instead.
+*/
+
+/*!
+    \fn void QUrl::addPath(const QString &p)
+
+    Use setPath() instead.
+*/
+
+/*!
+    \fn void QUrl::setFileName(const QString &txt)
+
+    Use setPath() instead.
+*/
+
+/*!
+    \fn void QUrl::decode(QString &url)
+
+    Use fromPercentEncoding() instead.
+*/
+
+/*!
+    \fn void QUrl::encode(QString &url)
+
+    Use toPercentEncoding() instead.
+*/
+
+/*!
+    \fn bool QUrl::cdUp()
+
+    Use resolved("..") instead.
+
+    \oldcode
+        QUrl url("http://qtsoftware.com/Developer/");
+        url.cdUp();
+    \newcode
+        QUrl url("http://qtsoftware.com/Developer/");
+        url = url.resolved("..");
+    \endcode
+*/
+
+/*!
+    \fn bool QUrl::isRelativeUrl(const QString &url)
+
+    Use isRelative() instead.
+*/
+
+/*!
+    \fn void QUrl::reset()
+
+    Use clear() instead.
+*/
+
+/*!
+    \fn  QUrl::operator QString() const
+
+    Use toString() instead.
+*/
+
+/*!
+    \fn QString QUrl::protocol() const
+
+    Use scheme() instead.
+*/
+
+/*!
+    \fn QString QUrl::user() const
+
+    Use userName() instead.
+*/
+
+/*!
+    \fn QString QUrl::query() const
+
+    Use encodedQuery() instead.
+*/
+
+/*!
+    \fn QString QUrl::ref() const
+
+    Use fragment() instead.
+*/
+
+/*!
+    \fn QString QUrl::fileName() const
+
+    Use QFileInfo(path()).fileName() instead.
+*/
+
+/*!
+    \fn QString QUrl::dirPath() const
+
+    Use QFileInfo(path()).absolutePath() or QFileInfo(path()) instead.
+*/
+
+#ifdef QT3_SUPPORT
+void QUrl::setFileName(const QString &txt)
+{
+    QFileInfo fileInfo(path());
+    fileInfo.setFile(txt);
+    setPath(fileInfo.filePath());
+}
+
+QString QUrl::fileName() const
+{
+    QFileInfo fileInfo(path());
+    return fileInfo.fileName();
+}
+
+QString QUrl::dirPath() const
+{
+    QFileInfo fileInfo(path());
+    if (fileInfo.isAbsolute()) {
+        QString absPath = fileInfo.absolutePath();
+#ifdef Q_OS_WIN
+        if (absPath.size() > 1 && absPath.at(1) == QLatin1Char(':'))
+            absPath = absPath.mid(2);
+#endif
+        return absPath;
+    }
+    return fileInfo.path();
+}
+#endif
+
+
+#ifndef QT_NO_DATASTREAM
+/*! \relates QUrl
+
+    Writes url \a url to the stream \a out and returns a reference
+    to the stream.
+
+    \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+QDataStream &operator<<(QDataStream &out, const QUrl &url)
+{
+    QByteArray u = url.toEncoded();
+    out << u;
+    return out;
+}
+
+/*! \relates QUrl
+
+    Reads a url into \a url from the stream \a in and returns a
+    reference to the stream.
+
+    \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+QDataStream &operator>>(QDataStream &in, QUrl &url)
+{
+    QByteArray u;
+    in >> u;
+    url = QUrl::fromEncoded(u);
+    return in;
+}
+#endif // QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug d, const QUrl &url)
+{
+    d.maybeSpace() << "QUrl(" << url.toString() << ")";
+    return d.space();
+}
+#endif
+
+/*!
+    \since 4.2
+
+    Returns a text string that explains why an URL is invalid in the case being;
+    otherwise returns an empty string.
+*/
+QString QUrl::errorString() const
+{
+    return d->createErrorString();
+}
+
+/*!
+    \typedef QUrl::DataPtr
+    \internal
+*/
+
+/*!
+    \fn DataPtr &QUrl::data_ptr()
+    \internal
+*/
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qurl.h b/src/corelib/io/qurl.h
new file mode 100644
index 0000000..9242092
--- /dev/null
+++ b/src/corelib/io/qurl.h
@@ -0,0 +1,281 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QURL_H
+#define QURL_H
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qobjectdefs.h>
+#include <QtCore/qpair.h>
+#include <QtCore/qstring.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QUrlPrivate;
+class QDataStream;
+
+class Q_CORE_EXPORT QUrl
+{
+public:
+    enum ParsingMode {
+        TolerantMode,
+        StrictMode
+    };
+
+    // encoding / toString values
+    enum FormattingOption {
+        None = 0x0,
+        RemoveScheme = 0x1,
+        RemovePassword = 0x2,
+        RemoveUserInfo = RemovePassword | 0x4,
+        RemovePort = 0x8,
+        RemoveAuthority = RemoveUserInfo | RemovePort | 0x10,
+        RemovePath = 0x20,
+        RemoveQuery = 0x40,
+        RemoveFragment = 0x80,
+
+        StripTrailingSlash = 0x10000
+    };
+    Q_DECLARE_FLAGS(FormattingOptions, FormattingOption)
+
+    QUrl();
+    QUrl(const QString &url);
+    QUrl(const QString &url, ParsingMode mode);
+    // ### Qt 5: merge the two constructors, with mode = TolerantMode
+    QUrl(const QUrl &copy);
+    QUrl &operator =(const QUrl &copy);
+    QUrl &operator =(const QString &url);
+    ~QUrl();
+
+    void setUrl(const QString &url);
+    void setUrl(const QString &url, ParsingMode mode);
+    // ### Qt 5: merge the two setUrl() functions, with mode = TolerantMode
+    void setEncodedUrl(const QByteArray &url);
+    void setEncodedUrl(const QByteArray &url, ParsingMode mode);
+    // ### Qt 5: merge the two setEncodedUrl() functions, with mode = TolerantMode
+
+    bool isValid() const;
+
+    bool isEmpty() const;
+
+    void clear();
+
+    void setScheme(const QString &scheme);
+    QString scheme() const;
+
+    void setAuthority(const QString &authority);
+    QString authority() const;
+
+    void setUserInfo(const QString &userInfo);
+    QString userInfo() const;
+
+    void setUserName(const QString &userName);
+    QString userName() const;
+    void setEncodedUserName(const QByteArray &userName);
+    QByteArray encodedUserName() const;
+
+    void setPassword(const QString &password);
+    QString password() const;
+    void setEncodedPassword(const QByteArray &password);
+    QByteArray encodedPassword() const;
+
+    void setHost(const QString &host);
+    QString host() const;
+    void setEncodedHost(const QByteArray &host);
+    QByteArray encodedHost() const;
+
+    void setPort(int port);
+    int port() const;
+    int port(int defaultPort) const;
+    // ### Qt 5: merge the two port() functions, with defaultPort = -1
+
+    void setPath(const QString &path);
+    QString path() const;
+    void setEncodedPath(const QByteArray &path);
+    QByteArray encodedPath() const;
+
+    bool hasQuery() const;
+
+    void setEncodedQuery(const QByteArray &query);
+    QByteArray encodedQuery() const;
+
+    void setQueryDelimiters(char valueDelimiter, char pairDelimiter);
+    char queryValueDelimiter() const;
+    char queryPairDelimiter() const;
+
+    void setQueryItems(const QList<QPair<QString, QString> > &query);
+    void addQueryItem(const QString &key, const QString &value);
+    QList<QPair<QString, QString> > queryItems() const;
+    bool hasQueryItem(const QString &key) const;
+    QString queryItemValue(const QString &key) const;
+    QStringList allQueryItemValues(const QString &key) const;
+    void removeQueryItem(const QString &key);
+    void removeAllQueryItems(const QString &key);
+
+    void setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query);
+    void addEncodedQueryItem(const QByteArray &key, const QByteArray &value);
+    QList<QPair<QByteArray, QByteArray> > encodedQueryItems() const;
+    bool hasEncodedQueryItem(const QByteArray &key) const;
+    QByteArray encodedQueryItemValue(const QByteArray &key) const;
+    QList<QByteArray> allEncodedQueryItemValues(const QByteArray &key) const;
+    void removeEncodedQueryItem(const QByteArray &key);
+    void removeAllEncodedQueryItems(const QByteArray &key);
+
+    void setFragment(const QString &fragment);
+    QString fragment() const;
+    void setEncodedFragment(const QByteArray &fragment);
+    QByteArray encodedFragment() const;
+    bool hasFragment() const;
+
+    QUrl resolved(const QUrl &relative) const;
+
+    bool isRelative() const;
+    bool isParentOf(const QUrl &url) const;
+
+    static QUrl fromLocalFile(const QString &localfile);
+    QString toLocalFile() const;
+
+    QString toString(FormattingOptions options = None) const;
+
+    QByteArray toEncoded(FormattingOptions options = None) const;
+    static QUrl fromEncoded(const QByteArray &url);
+    static QUrl fromEncoded(const QByteArray &url, ParsingMode mode);
+    // ### Qt 5: merge the two fromEncoded() functions, with mode = TolerantMode
+
+    void detach();
+    bool isDetached() const;
+
+    bool operator <(const QUrl &url) const;
+    bool operator ==(const QUrl &url) const;
+    bool operator !=(const QUrl &url) const;
+
+    static QString fromPercentEncoding(const QByteArray &);
+    static QByteArray toPercentEncoding(const QString &,
+                                        const QByteArray &exclude = QByteArray(),
+                                        const QByteArray &include = QByteArray());
+    static QString fromPunycode(const QByteArray &);
+    static QByteArray toPunycode(const QString &);
+    static QString fromAce(const QByteArray &);
+    static QByteArray toAce(const QString &);
+    static QStringList idnWhitelist();
+    static void setIdnWhitelist(const QStringList &);
+
+#if defined QT3_SUPPORT
+    inline QT3_SUPPORT QString protocol() const { return scheme(); }
+    inline QT3_SUPPORT void setProtocol(const QString &s) { setScheme(s); }
+    inline QT3_SUPPORT void setUser(const QString &s) { setUserName(s); }
+    inline QT3_SUPPORT QString user() const { return userName(); }
+    inline QT3_SUPPORT bool hasUser() const { return !userName().isEmpty(); }
+    inline QT3_SUPPORT bool hasPassword() const { return !password().isEmpty(); }
+    inline QT3_SUPPORT bool hasHost() const { return !host().isEmpty(); }
+    inline QT3_SUPPORT bool hasPort() const { return port() != -1; }
+    inline QT3_SUPPORT bool hasPath() const { return !path().isEmpty(); }
+    inline QT3_SUPPORT void setQuery(const QString &txt)
+    {
+        setEncodedQuery(txt.toLatin1());
+    }
+    inline QT3_SUPPORT QString query() const
+    {
+        return QString::fromLatin1(encodedQuery().constData());
+    }
+    inline QT3_SUPPORT QString ref() const { return fragment(); }
+    inline QT3_SUPPORT void setRef(const QString &txt) { setFragment(txt); }
+    inline QT3_SUPPORT bool hasRef() const { return !fragment().isEmpty(); }
+    inline QT3_SUPPORT void addPath(const QString &p) { setPath(path() + QLatin1String("/") + p); }
+    QT3_SUPPORT void setFileName(const QString &txt);
+    QT3_SUPPORT QString fileName() const;
+    QT3_SUPPORT QString dirPath() const;
+    static inline QT3_SUPPORT void decode(QString &url)
+    {
+        url = QUrl::fromPercentEncoding(url.toLatin1());
+    }
+    static inline QT3_SUPPORT void encode(QString &url)
+    {
+        url = QString::fromLatin1(QUrl::toPercentEncoding(url).constData());
+    }
+    inline QT3_SUPPORT operator QString() const { return toString(); }
+    inline QT3_SUPPORT bool cdUp()
+    {
+        *this = resolved(QUrl(QLatin1String("..")));
+        return true;
+    }
+    static inline QT3_SUPPORT bool isRelativeUrl(const QString &url)
+    {
+        return QUrl(url).isRelative();
+    }
+#endif
+
+    QString errorString() const;
+
+protected:
+#if defined (QT3_SUPPORT)
+    inline QT3_SUPPORT void reset() { clear(); }
+#endif
+
+private:
+    QUrlPrivate *d;
+public:
+    typedef QUrlPrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+Q_DECLARE_TYPEINFO(QUrl, Q_MOVABLE_TYPE);
+Q_DECLARE_SHARED(QUrl)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QUrl::FormattingOptions)
+
+#ifndef QT_NO_DATASTREAM
+Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QUrl &);
+Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QUrl &);
+#endif
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_CORE_EXPORT QDebug operator<<(QDebug, const QUrl &);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QURL_H
diff --git a/src/corelib/io/qwindowspipewriter.cpp b/src/corelib/io/qwindowspipewriter.cpp
new file mode 100644
index 0000000..5971987
--- /dev/null
+++ b/src/corelib/io/qwindowspipewriter.cpp
@@ -0,0 +1,170 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 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 "qwindowspipewriter_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_THREAD
+
+QWindowsPipeWriter::QWindowsPipeWriter(HANDLE pipe, QObject * parent)
+    : QThread(parent),
+      writePipe(INVALID_HANDLE_VALUE),
+      quitNow(false),
+      hasWritten(false)
+{
+#if !defined(Q_OS_WINCE) || (_WIN32_WCE >= 0x600)
+    DuplicateHandle(GetCurrentProcess(), pipe, GetCurrentProcess(),
+                         &writePipe, 0, FALSE, DUPLICATE_SAME_ACCESS);
+#else
+    Q_UNUSED(pipe);
+    writePipe = GetCurrentProcess();
+#endif
+}
+
+QWindowsPipeWriter::~QWindowsPipeWriter()
+{
+    lock.lock();
+    quitNow = true;
+    waitCondition.wakeOne();
+    lock.unlock();
+    if (!wait(100))
+        terminate();
+#if !defined(Q_OS_WINCE) || (_WIN32_WCE >= 0x600)
+    CloseHandle(writePipe);
+#endif
+}
+
+bool QWindowsPipeWriter::waitForWrite(int msecs)
+{
+    QMutexLocker locker(&lock);
+    bool hadWritten = hasWritten;
+    hasWritten = false;
+    if (hadWritten)
+        return true;
+    if (!waitCondition.wait(&lock, msecs))
+        return false;
+    hadWritten = hasWritten;
+    hasWritten = false;
+    return hadWritten;
+}
+
+qint64 QWindowsPipeWriter::write(const char *ptr, qint64 maxlen)
+{
+    if (!isRunning())
+        return -1;
+
+    QMutexLocker locker(&lock);
+    data.append(QByteArray(ptr, maxlen));
+    waitCondition.wakeOne();
+    return maxlen;
+}
+
+void QWindowsPipeWriter::run()
+{
+    OVERLAPPED overl = {0, 0, 0, 0, NULL};
+    overl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+    forever {
+        lock.lock();
+        while(data.isEmpty() && (!quitNow)) {
+            waitCondition.wakeOne();
+            waitCondition.wait(&lock);
+        }
+
+        if (quitNow) {
+            lock.unlock();
+            quitNow = false;
+	    break;
+        }
+
+        QByteArray copy = data;
+
+        lock.unlock();
+
+        const char *ptrData = copy.data();
+        qint64 maxlen = copy.size();
+        qint64 totalWritten = 0;
+        overl.Offset = 0;
+        overl.OffsetHigh = 0;
+        while ((!quitNow) && totalWritten < maxlen) {
+            DWORD written = 0;
+            // Write 2k at a time to prevent flooding the pipe. If you
+            // write too much (4k-8k), the pipe can close
+            // unexpectedly.
+            if (!WriteFile(writePipe, ptrData + totalWritten,
+                    qMin<int>(2048, maxlen - totalWritten), &written, &overl)) {
+                if (GetLastError() == 0xE8/*NT_STATUS_INVALID_USER_BUFFER*/) {
+                    // give the os a rest
+                    msleep(100);
+                    continue;
+                }
+#ifndef Q_OS_WINCE
+                if (GetLastError() == ERROR_IO_PENDING) {
+                  if (!GetOverlappedResult(writePipe, &overl, &written, TRUE)) {
+                      CloseHandle(overl.hEvent);
+                      return;
+                  }
+                } else {
+                    CloseHandle(overl.hEvent);
+                    return;
+                }
+#else
+                return;
+#endif
+            }
+            totalWritten += written;
+#if defined QPIPEWRITER_DEBUG
+            qDebug("QWindowsPipeWriter::run() wrote %d %d/%d bytes",
+			    written, int(totalWritten), int(maxlen));
+#endif
+            lock.lock();
+            data.remove(0, written);
+            hasWritten = true;
+            lock.unlock();
+        }
+        emit canWrite();
+    }
+    CloseHandle(overl.hEvent);
+}
+
+#endif //QT_NO_THREAD
+
+QT_END_NAMESPACE
diff --git a/src/corelib/io/qwindowspipewriter_p.h b/src/corelib/io/qwindowspipewriter_p.h
new file mode 100644
index 0000000..ce0c7f9
--- /dev/null
+++ b/src/corelib/io/qwindowspipewriter_p.h
@@ -0,0 +1,161 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSPIPEWRITER_P_H
+#define QWINDOWSPIPEWRITER_P_H
+
+//
+//  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.
+//
+
+#include <qdatetime.h>
+#include <qthread.h>
+#include <qmutex.h>
+#include <qwaitcondition.h>
+#include <qt_windows.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_THREAD
+
+#define SLEEPMIN 10
+#define SLEEPMAX 500
+
+class QIncrementalSleepTimer
+{
+
+public:
+    QIncrementalSleepTimer(int msecs)
+        : totalTimeOut(msecs)
+        , nextSleep(qMin(SLEEPMIN, totalTimeOut))
+    {
+        if (totalTimeOut == -1)
+            nextSleep = SLEEPMIN;
+        timer.start();
+    }
+
+    int nextSleepTime()
+    {
+        int tmp = nextSleep;
+        nextSleep = qMin(nextSleep * 2, qMin(SLEEPMAX, timeLeft()));
+        return tmp;
+    }
+
+    int timeLeft() const
+    {
+        if (totalTimeOut == -1)
+            return SLEEPMAX;
+        return qMax(totalTimeOut - timer.elapsed(), 0);
+    }
+
+    bool hasTimedOut() const
+    {
+        if (totalTimeOut == -1)
+            return false;
+        return timer.elapsed() >= totalTimeOut;
+    }
+
+    void resetIncrements()
+    {
+        nextSleep = qMin(SLEEPMIN, timeLeft());
+    }
+
+private:
+    QTime timer;
+    int totalTimeOut;
+    int nextSleep;
+};
+
+class Q_CORE_EXPORT QWindowsPipeWriter : public QThread
+{
+    Q_OBJECT
+
+Q_SIGNALS:
+    void canWrite();
+
+public:
+    QWindowsPipeWriter(HANDLE writePipe, QObject * parent = 0);
+    ~QWindowsPipeWriter();
+
+    bool waitForWrite(int msecs);
+    qint64 write(const char *data, qint64 maxlen);
+
+    qint64 bytesToWrite() const
+    {
+        QMutexLocker locker(&lock);
+        return data.size();
+    }
+
+    bool hadWritten() const
+    {
+        return hasWritten;
+    }
+
+protected:
+   void run();
+
+private:
+    QByteArray data;
+    QWaitCondition waitCondition;
+    mutable QMutex lock;
+    HANDLE writePipe;
+    volatile bool quitNow;
+    bool hasWritten;
+};
+
+#endif //QT_NO_THREAD
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_PROCESS