Merge branch 'master' of scm.dev.nokia.troll.no:qt/qt into earth-master

Conflicts:
	src/corelib/thread/qthread_unix.cpp

34 files changed, 1296 insertions, 454 deletions

diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
index 2d5cfab..602cf8a 100644
--- a/src/corelib/animation/qabstractanimation.cpp
+++ b/src/corelib/animation/qabstractanimation.cpp
@@ -167,7 +167,7 @@ Q_GLOBAL_STATIC(QThreadStorage<QUnifiedTimer *>, unifiedTimer)
 
 QUnifiedTimer::QUnifiedTimer() :
     QObject(), defaultDriver(this), lastTick(0), timingInterval(DEFAULT_TIMER_INTERVAL),
-    currentAnimationIdx(0), consistentTiming(false), slowMode(false),
+    currentAnimationIdx(0), insideTick(false), consistentTiming(false), slowMode(false),
     slowdownFactor(5.0f), isPauseTimerActive(false), runningLeafAnimations(0)
 {
     time.invalidate();
@@ -206,6 +206,10 @@ void QUnifiedTimer::ensureTimerUpdate()
 
 void QUnifiedTimer::updateAnimationsTime()
 {
+    //setCurrentTime can get this called again while we're the for loop. At least with pauseAnimations
+    if(insideTick)
+        return;
+
     qint64 totalElapsed = time.elapsed();
     // ignore consistentTiming in case the pause timer is active
     int delta = (consistentTiming && !isPauseTimerActive) ?
@@ -223,12 +227,14 @@ void QUnifiedTimer::updateAnimationsTime()
     //it might happen in some cases that the time doesn't change because events are delayed
     //when the CPU load is high
     if (delta) {
+        insideTick = true;
         for (currentAnimationIdx = 0; currentAnimationIdx < animations.count(); ++currentAnimationIdx) {
             QAbstractAnimation *animation = animations.at(currentAnimationIdx);
             int elapsed = QAbstractAnimationPrivate::get(animation)->totalCurrentTime
                           + (animation->direction() == QAbstractAnimation::Forward ? delta : -delta);
             animation->setCurrentTime(elapsed);
         }
+        insideTick = false;
         currentAnimationIdx = 0;
     }
 }
diff --git a/src/corelib/animation/qabstractanimation_p.h b/src/corelib/animation/qabstractanimation_p.h
index 1ab05cd..ba92960 100644
--- a/src/corelib/animation/qabstractanimation_p.h
+++ b/src/corelib/animation/qabstractanimation_p.h
@@ -202,6 +202,7 @@ private:
     qint64 lastTick;
     int timingInterval;
     int currentAnimationIdx;
+    bool insideTick;
     bool consistentTiming;
     bool slowMode;
 
diff --git a/src/corelib/concurrent/qfutureinterface.cpp b/src/corelib/concurrent/qfutureinterface.cpp
index 627d0c7..c5bd802 100644
--- a/src/corelib/concurrent/qfutureinterface.cpp
+++ b/src/corelib/concurrent/qfutureinterface.cpp
@@ -219,7 +219,7 @@ QString QFutureInterfaceBase::progressText() const
 bool QFutureInterfaceBase::isProgressUpdateNeeded() const
 {
     QMutexLocker locker(&d->m_mutex);
-    return (d->progressTime.elapsed() > (1000 / MaxProgressEmitsPerSecond));
+    return !d->progressTime.isValid() || (d->progressTime.elapsed() > (1000 / MaxProgressEmitsPerSecond));
 }
 
 void QFutureInterfaceBase::reportStarted()
diff --git a/src/corelib/global/global.pri b/src/corelib/global/global.pri
index d80706a..68582bf 100644
--- a/src/corelib/global/global.pri
+++ b/src/corelib/global/global.pri
@@ -26,6 +26,9 @@ linux*:!static:!symbian-gcce:!*-armcc* {
 }
 
 # Compensate for lack of platform defines in Symbian3 and Symbian4
-symbian: DEFINES += SYMBIAN_VERSION_$$upper($$replace(SYMBIAN_VERSION,\\.,_))
+symbian {
+    DEFINES += SYMBIAN_VERSION_$$upper($$replace(SYMBIAN_VERSION,\\.,_)) \
+               S60_VERSION_$$upper($$replace(S60_VERSION,\\.,_))
+}
 
 include(../../../tools/shared/symbian/epocroot.pri)
diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp
index 54b9d89..97b4407 100644
--- a/src/corelib/global/qglobal.cpp
+++ b/src/corelib/global/qglobal.cpp
@@ -86,7 +86,6 @@
 # include "private/qcore_symbian_p.h"
 
 _LIT(qt_S60Filter, "Series60v?.*.sis");
-_LIT(qt_symbianFilter, "Symbianv*.sis");
 _LIT(qt_symbianSystemInstallDir, "z:\\system\\install\\");
 #endif
 
@@ -1203,7 +1202,7 @@ bool qSharedBuild()
     \value SV_SF_1 Symbian^1
     \value SV_SF_2 Symbian^2
     \value SV_SF_3 Symbian^3
-    \value SV_SF_4 Symbian^4
+    \value SV_SF_4 \e{This enum value is deprecated.}
     \value SV_Unknown An unknown and currently unsupported platform
 
     \sa S60Version, WinVersion, MacVersion
@@ -1221,7 +1220,8 @@ bool qSharedBuild()
     \value SV_S60_3_2 S60 3rd Edition Feature Pack 2
     \value SV_S60_5_0 S60 5th Edition
     \value SV_S60_5_1 S60 5th Edition Feature Pack 1
-    \value SV_S60_5_2 S60 5th Edition Feature Pack 2
+    \value SV_S60_5_2 Symbian^3
+    \value SV_S60_5_3 To be determined - FIXME
     \value SV_S60_Unknown An unknown and currently unsupported platform
     \omitvalue SV_S60_None
 
@@ -1829,12 +1829,10 @@ const QSysInfo::WinVersion QSysInfo::WindowsVersion = QSysInfo::windowsVersion()
 
 #ifdef Q_OS_SYMBIAN
 static QSysInfo::SymbianVersion cachedSymbianVersion = QSysInfo::SymbianVersion(-1);
+static QSysInfo::S60Version cachedS60Version = QSysInfo::S60Version(-1);
 
-QSysInfo::SymbianVersion QSysInfo::symbianVersion()
+static void symbianInitVersions()
 {
-    if (cachedSymbianVersion != -1)
-        return cachedSymbianVersion;
-
     // Use pure Symbian code, because if done using QDir, there will be a call back
     // to this method, resulting doing this expensive operation twice before the cache kicks in.
     // Pure Symbian code also makes this method ~10x faster, speeding up the application launch.
@@ -1842,21 +1840,8 @@ QSysInfo::SymbianVersion QSysInfo::symbianVersion()
     TFindFile fileFinder(rfs);
     CDir* contents;
 
-    // Check for Symbian4
-    TInt err = fileFinder.FindWildByDir(qt_symbianFilter, qt_symbianSystemInstallDir, contents);
-    if (err == KErrNone) {
-        QScopedPointer<CDir> contentsDeleter(contents);
-        err = contents->Sort(EDescending|ESortByName);
-        if (err == KErrNone && contents->Count() > 0 && (*contents)[0].iName.Length() >= 9) {
-            TInt major = (*contents)[0].iName[8] - '0';
-            if (major == 4) {
-                return cachedSymbianVersion = SV_SF_4;
-            }
-        }
-    }
-
-    // Check for S60 and Symbian3 platforms, which use older .sis naming scheme
-    err = fileFinder.FindWildByDir(qt_S60Filter, qt_symbianSystemInstallDir, contents);
+    // Check for platform version
+    TInt err = fileFinder.FindWildByDir(qt_S60Filter, qt_symbianSystemInstallDir, contents);
     if (err == KErrNone) {
         QScopedPointer<CDir> contentsDeleter(contents);
         err = contents->Sort(EDescending|ESortByName);
@@ -1865,61 +1850,76 @@ QSysInfo::SymbianVersion QSysInfo::symbianVersion()
             TInt minor = (*contents)[0].iName[11] - '0';
             if (major == 3) {
                 if (minor == 1) {
-                    return cachedSymbianVersion = SV_9_2;
+                    cachedS60Version = QSysInfo::SV_S60_3_1;
+                    cachedSymbianVersion = QSysInfo::SV_9_2;
                 } else if (minor == 2) {
-                    return cachedSymbianVersion = SV_9_3;
+                    cachedS60Version = QSysInfo::SV_S60_3_2;
+                    cachedSymbianVersion = QSysInfo::SV_9_3;
                 }
             } else if (major == 5) {
                 if (minor == 0) {
-                    return cachedSymbianVersion = SV_9_4;
-                }
-                else if (minor == 1) {
-                    return cachedSymbianVersion = SV_SF_2;
-                }
-                else if (minor >= 2) {
-                    return cachedSymbianVersion = SV_SF_3;
+                    cachedS60Version = QSysInfo::SV_S60_5_0;
+                    cachedSymbianVersion = QSysInfo::SV_9_4;
+                } else if (minor == 1) {
+                    cachedS60Version = QSysInfo::SV_S60_5_1;
+                    cachedSymbianVersion = QSysInfo::SV_SF_2;
+                } else if (minor == 2) {
+                    cachedS60Version = QSysInfo::SV_S60_5_2;
+                    cachedSymbianVersion = QSysInfo::SV_SF_3;
+                } else if (minor >= 3) {
+                    cachedS60Version = QSysInfo::SV_S60_5_3;
+                    cachedSymbianVersion = QSysInfo::SV_SF_3;
                 }
             }
         }
     }
 
 #  ifdef Q_CC_NOKIAX86
-    // Some emulator environments may not contain the version specific .sis files, so
-    // simply hardcode the version on those environments. Note that can't use
-    // SYMBIAN_VERSION_* defines for S60 3.x/5.0 platforms, as they do not define them
-    // right anyway in case .sis files are not found.
+    if (cachedS60Version == -1) {
+        // Some emulator environments may not contain the version specific .sis files, so
+        // simply hardcode the version on those environments. Note that can't use
+        // S60_VERSION_* defines for S60 3.x/5.0 platforms, as they do not define them
+        // right anyway in case .sis files are not found.
 #   if defined(__SERIES60_31__)
-    return cachedSymbianVersion = SV_9_2;
+        cachedS60Version = QSysInfo::SV_S60_3_1;
+        cachedSymbianVersion = QSysInfo::SV_9_2;
 #   elif defined(__S60_32__)
-    return cachedSymbianVersion = SV_9_3;
+        cachedS60Version = QSysInfo::SV_S60_3_2;
+        cachedSymbianVersion = QSysInfo::SV_9_3;
 #   elif defined(__S60_50__)
-    return cachedSymbianVersion = SV_9_4;
-#   elif defined(SYMBIAN_VERSION_SYMBIAN3)
-    return cachedSymbianVersion = SV_SF_3;
-#   elif defined(SYMBIAN_VERSION_SYMBIAN4)
-    return cachedSymbianVersion = SV_SF_4;
+        cachedS60Version = QSysInfo::SV_S60_5_0;
+        cachedSymbianVersion = QSysInfo::SV_9_4;
+#   elif defined(S60_VERSION_5_2)
+        cachedS60Version = QSysInfo::SV_S60_5_2;
+        cachedSymbianVersion = QSysInfo::SV_SF_3;
+#   elif defined(S60_VERSION_5_3)
+        cachedS60Version = QSysInfo::SV_S60_5_3;
+        cachedSymbianVersion = QSysInfo::SV_SF_3;
 #   endif
+    }
 #  endif
-    //If reaching here, it was not possible to determine the version
-    return cachedSymbianVersion = SV_Unknown;
+
+    if (cachedS60Version == -1) {
+        //If reaching here, it was not possible to determine the version
+        cachedS60Version = QSysInfo::SV_S60_Unknown;
+        cachedSymbianVersion = QSysInfo::SV_Unknown;
+    }
+}
+
+QSysInfo::SymbianVersion QSysInfo::symbianVersion()
+{
+    if (cachedSymbianVersion == -1)
+        symbianInitVersions();
+
+    return cachedSymbianVersion;
 }
 
 QSysInfo::S60Version QSysInfo::s60Version()
 {
-    switch (symbianVersion()) {
-    case SV_9_2:
-        return SV_S60_3_1;
-    case SV_9_3:
-        return SV_S60_3_2;
-    case SV_9_4:
-        return SV_S60_5_0;
-    case SV_SF_2:
-        return SV_S60_5_1;
-    case SV_SF_3:
-        return SV_S60_5_2;
-    default:
-        return SV_S60_Unknown;
-    }
+    if (cachedS60Version == -1)
+        symbianInitVersions();
+
+    return cachedS60Version;
 }
 #endif // ifdef Q_OS_SYMBIAN
 
@@ -2870,6 +2870,40 @@ int qrand()
 */
 
 /*!
+    \macro Q_LIKELY(expr)
+    \relates <QtGlobal>
+    \since 4.8
+
+    \brief Hints the compiler that the enclosed condition is likely to evaluate
+    to \c true.
+
+    Use of this macro can help the compiler to optimize the code.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp qlikely
+
+    \sa Q_UNLIKELY()
+*/
+
+/*!
+    \macro Q_UNLIKELY(expr)
+    \relates <QtGlobal>
+    \since 4.8
+
+    \brief Hints the compiler that the enclosed condition is likely to evaluate
+    to \c false.
+
+    Use of this macro can help the compiler to optimize the code.
+
+    Example:
+
+    \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp qunlikely
+
+    \sa Q_LIKELY()
+*/
+
+/*!
     \macro QT_POINTER_SIZE
     \relates <QtGlobal>
 
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index cf63943..6469b46 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -497,6 +497,10 @@ namespace QT_NAMESPACE {}
 #    define Q_TYPEOF(expr)    __typeof__(expr)
 #    define Q_DECL_ALIGN(n)   __attribute__((__aligned__(n)))
 #  endif
+#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+#    define Q_LIKELY(expr)    __builtin_expect(!!(expr), true)
+#    define Q_UNLIKELY(expr)  __builtin_expect(!!(expr), false)
+#  endif
 /* GCC 3.1 and GCC 3.2 wrongly define _SB_CTYPE_MACROS on HP-UX */
 #  if defined(Q_OS_HPUX) && __GNUC__ == 3 && __GNUC_MINOR__ >= 1
 #    define Q_WRONG_SB_CTYPE_MACROS
@@ -802,6 +806,13 @@ namespace QT_NAMESPACE {}
 #  undef Q_NO_PACKED_REFERENCE
 #endif
 
+#ifndef Q_LIKELY
+#  define Q_LIKELY(x) (x)
+#endif
+#ifndef Q_UNLIKELY
+#  define Q_UNLIKELY(x) (x)
+#endif
+
 #ifndef Q_CONSTRUCTOR_FUNCTION
 # define Q_CONSTRUCTOR_FUNCTION0(AFUNC) \
    static const int AFUNC ## __init_variable__ = AFUNC();
@@ -1606,7 +1617,7 @@ public:
         SV_SF_1 = SV_9_4,
         SV_SF_2 = 40,
         SV_SF_3 = 50,
-        SV_SF_4 = 60
+        SV_SF_4 = 60  // Deprecated
     };
     static SymbianVersion symbianVersion();
     enum S60Version {
@@ -1615,9 +1626,9 @@ public:
         SV_S60_3_1 = SV_9_2,
         SV_S60_3_2 = SV_9_3,
         SV_S60_5_0 = SV_9_4,
-        //versions beyond 5.0 are to be confirmed - it is better to use symbian version
         SV_S60_5_1 = SV_SF_2,
-        SV_S60_5_2 = SV_SF_3
+        SV_S60_5_2 = SV_SF_3,
+        SV_S60_5_3 = 70
     };
     static S60Version s60Version();
 #endif
@@ -2524,6 +2535,10 @@ QT3_SUPPORT Q_CORE_EXPORT const char *qInstallPathSysconf();
 #define Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS
 #endif
 
+#ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION
+#define Q_SYMBIAN_SUPPORTS_FIXNATIVEORIENTATION
+#endif
+
 //Symbian does not support data imports from a DLL
 #define Q_NO_DATA_RELOCATION
 
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index bc15514..07a9503 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -242,81 +242,25 @@
 /*!
     \enum Qt::GlobalColor
 
-    \raw HTML
-    <style type="text/css" id="colorstyles">
-     #white { background-color: #ffffff; color: #000000 }
-     #black { background-color: #000000; color: #ffffff }
-     #red { background-color: #ff0000; color: #000000 }
-     #darkRed { background-color: #800000; color: #ffffff }
-     #green { background-color: #00ff00; color: #000000 }
-     #darkGreen { background-color: #008000; color: #ffffff }
-     #blue { background-color: #0000ff; color: #ffffff }
-     #darkBlue { background-color: #000080; color: #ffffff }
-     #cyan { background-color: #00ffff; color: #000000 }
-     #darkCyan { background-color: #008080; color: #ffffff }
-     #magenta { background-color: #ff00ff; color: #000000 }
-     #darkMagenta { background-color: #800080; color: #ffffff }
-     #yellow { background-color: #ffff00; color: #000000 }
-     #darkYellow { background-color: #808000; color: #ffffff }
-     #gray { background-color: #a0a0a4; color: #000000 }
-     #darkGray { background-color: #808080; color: #ffffff }
-     #lightGray { background-color: #c0c0c0; color: #000000 }
-    </style>
-    \endraw
-
     Qt's predefined QColor objects:
 
-    \value white       \raw HTML
-    White <tt id="white">(#ffffff)</tt>
-    \endraw
-    \value black       \raw HTML
-    Black <tt id="black">(#000000)</tt>
-    \endraw
-    \value red         \raw HTML
-    Red <tt id="red">(#ff0000)</tt>
-    \endraw
-    \value darkRed     \raw HTML
-    Dark red <tt id="darkRed">(#800000)</tt>
-    \endraw
-    \value green       \raw HTML
-    Green <tt id="green">(#00ff00)</tt>
-    \endraw
-    \value darkGreen   \raw HTML
-    Dark green <tt id="darkGreen">(#008000)</tt>
-    \endraw
-    \value blue        \raw HTML
-    Blue <tt id="blue">(#0000ff)</tt>
-    \endraw
-    \value darkBlue    \raw HTML
-    Dark blue <tt id="darkBlue">(#000080)</tt>
-    \endraw
-    \value cyan        \raw HTML
-    Cyan <tt id="cyan">(#00ffff)</tt>
-    \endraw
-    \value darkCyan    \raw HTML
-    Dark cyan <tt id="darkCyan">(#008080)</tt>
-    \endraw
-    \value magenta     \raw HTML
-    Magenta <tt id="magenta">(#ff00ff)</tt>
-    \endraw
-    \value darkMagenta \raw HTML
-    Dark magenta <tt id="darkMagenta">(#800080)</tt>
-    \endraw
-    \value yellow      \raw HTML
-    Yellow <tt id="yellow">(#ffff00)</tt>
-    \endraw
-    \value darkYellow  \raw HTML
-    Dark yellow <tt id="darkYellow">(#808000)</tt>
-    \endraw
-    \value gray        \raw HTML
-    Gray <tt id="gray">(#a0a0a4)</tt>
-    \endraw
-    \value darkGray    \raw HTML
-    Dark gray <tt id="darkGray">(#808080)</tt>
-    \endraw
-    \value lightGray   \raw HTML
-    Light gray <tt id="lightGray">(#c0c0c0)</tt>
-    \endraw
+    \value white       \span {id="color-white"} {White (#ffffff) }
+    \value black       \span {id="color-black"} {Black (#000000) }
+    \value red         \span {id="color-red"} {Red (#ff0000) }
+    \value darkRed     \span {id="color-darkRed"} {Dark red (#800000) }
+    \value green       \span {id="color-green"} {Green (#00ff00) }
+    \value darkGreen   \span {id="color-darkGreen"} {Dark green (#008000) }
+    \value blue        \span {id="color-blue"} {Blue (#0000ff) }
+    \value darkBlue    \span {id="color-darkBlue"} {Dark blue (#000080) }
+    \value cyan        \span {id="color-cyan"} {Cyan (#00ffff) }
+    \value darkCyan    \span {id="color-darkCyan"} {Dark cyan (#008080) }
+    \value magenta     \span {id="color-magenta"} {Magenta (#ff00ff) }
+    \value darkMagenta \span {id="color-darkMagenta"} {Dark magenta (#800080) }
+    \value yellow      \span {id="color-yellow"} {Yellow (#ffff00) }
+    \value darkYellow  \span {id="color-darkYellow"} {Dark yellow (#808000) }
+    \value gray        \span {id="color-gray"} {Gray (#a0a0a4) }
+    \value darkGray    \span {id="color-darkGray"} {Dark gray (#808080) }
+    \value lightGray   \span {id="color-lightGray"} {Light gray (#c0c0c0) }
     \value transparent a transparent black value (i.e., QColor(0, 0, 0, 0))
     \value color0 0 pixel value (for bitmaps)
     \value color1 1 pixel value (for bitmaps)
@@ -2882,7 +2826,7 @@
     INT_MIN, inclusive. For example, you can define custom priorities
     as being relative to each other:
 
-    \snippet doc/src/snippets/code/doc_src_qnamespace.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qnamespace.cpp 1
 
     \sa QCoreApplication::postEvent()
 */
diff --git a/src/corelib/io/qfilesystemwatcher_symbian.cpp b/src/corelib/io/qfilesystemwatcher_symbian.cpp
index 29ec77a..8e8dfe5 100644
--- a/src/corelib/io/qfilesystemwatcher_symbian.cpp
+++ b/src/corelib/io/qfilesystemwatcher_symbian.cpp
@@ -95,7 +95,10 @@ void QNotifyChangeEvent::RunL()
         SetActive();
 
         if (!failureCount) {
-            QT_TRYCATCH_LEAVING(engine->emitPathChanged(this));
+            int err;
+            QT_TRYCATCH_ERROR(err, engine->emitPathChanged(this));
+            if (err != KErrNone)
+                qWarning("QNotifyChangeEvent::RunL() - emitPathChanged threw exception (Converted error code: %d)", err);
         }
     }
 }
diff --git a/src/corelib/io/qiodevice.cpp b/src/corelib/io/qiodevice.cpp
index 76e8409..8759f8b 100644
--- a/src/corelib/io/qiodevice.cpp
+++ b/src/corelib/io/qiodevice.cpp
@@ -1628,10 +1628,11 @@ QString QIODevice::errorString() const
     \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).
+    returns the number of bytes read or -1 if an error occurred.
+
+    If there are no bytes to be read and there can never be more bytes
+    available (examples include socket closed, pipe closed, sub-process
+    finished), this function returns -1.
 
     This function is called by QIODevice. Reimplement this function
     when creating a subclass of QIODevice.
diff --git a/src/corelib/io/qprocess.cpp b/src/corelib/io/qprocess.cpp
index e11cef9..a45225f 100644
--- a/src/corelib/io/qprocess.cpp
+++ b/src/corelib/io/qprocess.cpp
@@ -221,6 +221,24 @@ QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list
     return env;
 }
 
+QStringList QProcessEnvironmentPrivate::keys() const
+{
+    QStringList result;
+    QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
+                                    end = hash.constEnd();
+    for ( ; it != end; ++it)
+        result << nameToString(it.key());
+    return result;
+}
+
+void QProcessEnvironmentPrivate::insert(const Hash &h)
+{
+    QHash<Unit, Unit>::ConstIterator it = h.constBegin(),
+                                    end = h.constEnd();
+    for ( ; it != end; ++it)
+        hash.insert(it.key(), it.value());
+}
+
 /*!
     Creates a new QProcessEnvironment object. This constructor creates an
     empty environment. If set on a QProcess, this will cause the current
@@ -396,6 +414,33 @@ QStringList QProcessEnvironment::toStringList() const
     return d ? d->toList() : QStringList();
 }
 
+/*!
+    \since 4.8
+
+    Returns a list containing all the variable names in this QProcessEnvironment
+    object.
+*/
+QStringList QProcessEnvironment::keys() const
+{
+    return d ? d->keys() : QStringList();
+}
+
+/*!
+    \overload
+    \since 4.8
+
+    Inserts the contents of \a e in this QProcessEnvironment object. Variables in
+    this object that also exist in \a e will be overwritten.
+*/
+void QProcessEnvironment::insert(const QProcessEnvironment &e)
+{
+    if (!e.d)
+        return;
+
+    // d detaches from null
+    d->insert(e.d->hash);
+}
+
 void QProcessPrivate::Channel::clear()
 {
     switch (type) {
@@ -2082,6 +2127,9 @@ void QProcess::terminate()
     On Symbian, this function requires platform security capability
     \c PowerMgmt. If absent, the process will panic with KERN-EXEC 46.
 
+    \note Killing running processes from other processes will typically
+    cause a panic in Symbian due to platform security.
+
     \sa {Symbian Platform Security Requirements}
     \sa terminate()
 */
diff --git a/src/corelib/io/qprocess.h b/src/corelib/io/qprocess.h
index baa67f7..664992f 100644
--- a/src/corelib/io/qprocess.h
+++ b/src/corelib/io/qprocess.h
@@ -87,6 +87,10 @@ public:
 
     QStringList toStringList() const;
 
+    QStringList keys() const;
+
+    void insert(const QProcessEnvironment &e);
+
     static QProcessEnvironment systemEnvironment();
 
 private:
diff --git a/src/corelib/io/qprocess_p.h b/src/corelib/io/qprocess_p.h
index be4f2a0..7bfcb31 100644
--- a/src/corelib/io/qprocess_p.h
+++ b/src/corelib/io/qprocess_p.h
@@ -94,6 +94,8 @@ public:
 
     static QProcessEnvironment fromList(const QStringList &list);
     QStringList toList() const;
+    QStringList keys() const;
+    void insert(const Hash &hash);
 };
 
 class QProcessPrivate : public QIODevicePrivate
diff --git a/src/corelib/io/qprocess_symbian.cpp b/src/corelib/io/qprocess_symbian.cpp
index d22d1ed..8a74c7b 100644
--- a/src/corelib/io/qprocess_symbian.cpp
+++ b/src/corelib/io/qprocess_symbian.cpp
@@ -961,16 +961,15 @@ bool QProcessPrivate::waitForFinished(int msecs)
             User::WaitForRequest(logonStatus, timerStatus);
             QPROCESS_DEBUG_PRINT("QProcessPrivate::waitForFinished() - Wait completed");
 
-            if (timerStatus == KErrNone)
+            if (logonStatus != KRequestPending) {
+                timer.Cancel();
+                User::WaitForRequest(timerStatus);
+            } else {
                 timeoutOccurred = true;
-
-            timer.Cancel();
+                symbianProcess->LogonCancel(logonStatus);
+                User::WaitForRequest(logonStatus);
+            }
             timer.Close();
-
-            symbianProcess->LogonCancel(logonStatus);
-
-            // Eat cancel request completion so that it won't mess up main thread scheduling later
-            User::WaitForRequest(logonStatus, timerStatus);
         }
     } else {
         QPROCESS_DEBUG_PRINT("QProcessPrivate::waitForFinished(), qt_rprocess_running returned false");
diff --git a/src/corelib/io/qresource.cpp b/src/corelib/io/qresource.cpp
index 0435256..cd8c1a3 100644
--- a/src/corelib/io/qresource.cpp
+++ b/src/corelib/io/qresource.cpp
@@ -373,7 +373,7 @@ QResourcePrivate::ensureChildren() const
     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()
+    \sa QFileInfo, QDir::searchPaths(), setFileName(), setLocale()
 */
 
 QResource::QResource(const QString &file, const QLocale &locale) : d_ptr(new QResourcePrivate(this))
@@ -418,7 +418,7 @@ QLocale QResource::locale() const
 /*!
     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().
+    tried to be found in QDir::searchPaths().
 
     \sa absoluteFilePath()
 */
@@ -446,7 +446,7 @@ QString QResource::fileName() const
 
 /*!
     Returns the real path that this QResource represents, if the resource
-    was found via the searchPaths() it will be indicated in the path.
+    was found via the QDir::searchPaths() it will be indicated in the path.
 
     \sa fileName()
 */
diff --git a/src/corelib/kernel/qeventdispatcher_symbian.cpp b/src/corelib/kernel/qeventdispatcher_symbian.cpp
index 53796be..4c01bde 100644
--- a/src/corelib/kernel/qeventdispatcher_symbian.cpp
+++ b/src/corelib/kernel/qeventdispatcher_symbian.cpp
@@ -43,6 +43,7 @@
 #include <private/qthread_p.h>
 #include <qcoreapplication.h>
 #include <private/qcoreapplication_p.h>
+#include <qsemaphore.h>
 
 #include <unistd.h>
 #include <errno.h>
@@ -654,34 +655,54 @@ class QIdleDetectorThread
 {
 public:
     QIdleDetectorThread()
-    : m_state(STATE_RUN), m_stop(false)
+    : m_state(STATE_RUN), m_stop(false), m_running(false)
     {
-        qt_symbian_throwIfError(m_lock.CreateLocal(0));
+        start();
+    }
+
+    ~QIdleDetectorThread()
+    {
+        stop();
+    }
+
+    void start()
+    {
+        QMutexLocker lock(&m_mutex);
+        if (m_running)
+            return;
+        m_stop = false;
+        m_state = STATE_RUN;
         TInt err = m_idleDetectorThread.Create(KNullDesC(), &idleDetectorThreadFunc, 1024, &User::Allocator(), this);
         if (err != KErrNone)
-            m_lock.Close();
-        qt_symbian_throwIfError(err);
+            return;     // Fail silently on error. Next kick will try again. Exception might stop the event being processed
         m_idleDetectorThread.SetPriority(EPriorityAbsoluteBackgroundNormal);
         m_idleDetectorThread.Resume();
+        m_running = true;
+        // get a callback from QCoreApplication destruction to stop this thread
+        qAddPostRoutine(StopIdleDetectorThread);
     }
 
-    ~QIdleDetectorThread()
+    void stop()
     {
+        QMutexLocker lock(&m_mutex);
+        if (!m_running)
+            return;
         // close down the idle thread because if corelib is loaded temporarily, this would leak threads into the host process
         m_stop = true;
-        m_lock.Signal();
+        m_kick.release();
         m_idleDetectorThread.SetPriority(EPriorityNormal);
         TRequestStatus s;
         m_idleDetectorThread.Logon(s);
         User::WaitForRequest(s);
         m_idleDetectorThread.Close();
-        m_lock.Close();
+        m_running = false;
     }
 
     void kick()
     {
+        start();
         m_state = STATE_KICKED;
-        m_lock.Signal();
+        m_kick.release();
     }
 
     bool hasRun()
@@ -700,20 +721,29 @@ private:
     void IdleLoop()
     {
         while (!m_stop) {
-            m_lock.Wait();
+            m_kick.acquire();
             m_state = STATE_RUN;
         }
     }
 
+    static void StopIdleDetectorThread();
+
 private:
     enum IdleStates {STATE_KICKED, STATE_RUN} m_state;
     bool m_stop;
+    bool m_running;
     RThread m_idleDetectorThread;
-    RSemaphore m_lock;
+    QSemaphore m_kick;
+    QMutex m_mutex;
 };
 
 Q_GLOBAL_STATIC(QIdleDetectorThread, idleDetectorThread);
 
+void QIdleDetectorThread::StopIdleDetectorThread()
+{
+    idleDetectorThread()->stop();
+}
+
 const int maxBusyTime = 2000; // maximum time we allow idle detector to be blocked before worrying, in milliseconds
 const int baseDelay = 1000; // minimum delay time used when backing off to allow idling, in microseconds
 #endif
diff --git a/src/corelib/kernel/qtranslator.cpp b/src/corelib/kernel/qtranslator.cpp
index 4e9e6ca..22b06a5 100644
--- a/src/corelib/kernel/qtranslator.cpp
+++ b/src/corelib/kernel/qtranslator.cpp
@@ -357,10 +357,15 @@ QTranslator::~QTranslator()
 }
 
 /*!
-    Loads \a filename + \a suffix (".qm" if the \a suffix is
-    not specified), which may be an absolute file name or relative
-    to \a directory. Returns true if the translation is successfully
-    loaded; otherwise returns false.
+
+    Loads \a filename + \a suffix (".qm" if the \a suffix is not
+    specified), which may be an absolute file name or relative to \a
+    directory. Returns true if the translation is successfully loaded;
+    otherwise returns false.
+
+    If \a directory is not specified, the directory of the
+    application's executable is used (i.e., as
+    \l{QCoreApplication::}{applicationDirPath()}). 
 
     The previous contents of this translator object are discarded.
 
diff --git a/src/corelib/plugin/qplugin.qdoc b/src/corelib/plugin/qplugin.qdoc
index 54b2b38..7043fa0 100644
--- a/src/corelib/plugin/qplugin.qdoc
+++ b/src/corelib/plugin/qplugin.qdoc
@@ -51,7 +51,7 @@
     If you want to use Q_DECLARE_INTERFACE with interface classes
     declared in a namespace then you have to make sure the Q_DECLARE_INTERFACE
     is not inside a namespace though. For example:
-    \snippet doc/src/snippets/code/doc_src_qplugin.qdoc 0
+    \snippet doc/src/snippets/code/doc_src_qplugin.cpp 0
 
     \sa Q_INTERFACES(), Q_EXPORT_PLUGIN2(), {How to Create Qt Plugins}
 */
@@ -82,7 +82,7 @@
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qplugin.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qplugin.cpp 1
 
     See the \l{tools/plugandpaint}{Plug & Paint} example for details.
 
@@ -102,14 +102,14 @@
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qplugin.qdoc 2
+    \snippet doc/src/snippets/code/doc_src_qplugin.cpp 2
 
     Static plugins must also be included by the linker when your
     application is built. For Qt's predefined plugins,
     you can use the \c QTPLUGIN to add
     the required plugins to your build. For example:
 
-    \snippet doc/src/snippets/code/doc_src_qplugin.qdoc 3
+    \snippet doc/src/snippets/code/doc_src_qplugin.pro 3
 
     \sa {Static Plugins}, {How to Create Qt Plugins}, {Using qmake}
 */
diff --git a/src/corelib/statemachine/qhistorystate.cpp b/src/corelib/statemachine/qhistorystate.cpp
index 350c1a0..7093c32 100644
--- a/src/corelib/statemachine/qhistorystate.cpp
+++ b/src/corelib/statemachine/qhistorystate.cpp
@@ -168,6 +168,9 @@ QAbstractState *QHistoryState::defaultState() const
 /*!
   Sets this history state's default state to be the given \a state.
   \a state must be a sibling of this history state.
+
+  Note that this function does not set \a state as the initial state
+  of its parent.
 */
 void QHistoryState::setDefaultState(QAbstractState *state)
 {
diff --git a/src/corelib/thread/qmutex_p.h b/src/corelib/thread/qmutex_p.h
index 1a31c87..70860b1 100644
--- a/src/corelib/thread/qmutex_p.h
+++ b/src/corelib/thread/qmutex_p.h
@@ -62,6 +62,10 @@
 # include <mach/semaphore.h>
 #endif
 
+#if defined(Q_OS_SYMBIAN)
+# include <e32std.h>
+#endif
+
 QT_BEGIN_NAMESPACE
 
 class QMutexPrivate : public QMutexData {
@@ -81,12 +85,14 @@ public:
 
 #if defined(Q_OS_MAC)
     semaphore_t mach_semaphore;
-#elif defined(Q_OS_UNIX) && !defined(Q_OS_LINUX)
+#elif defined(Q_OS_UNIX) && !defined(Q_OS_LINUX) && !defined(Q_OS_SYMBIAN)
     volatile bool wakeup;
     pthread_mutex_t mutex;
     pthread_cond_t cond;
 #elif defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
     HANDLE event;
+#elif defined(Q_OS_SYMBIAN)
+    RSemaphore lock;
 #endif
 };
 
diff --git a/src/corelib/thread/qmutex_symbian.cpp b/src/corelib/thread/qmutex_symbian.cpp
new file mode 100644
index 0000000..288c576
--- /dev/null
+++ b/src/corelib/thread/qmutex_symbian.cpp
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qmutex.h"
+
+#ifndef QT_NO_THREAD
+#include "qatomic.h"
+#include "qelapsedtimer.h"
+#include "qthread.h"
+#include "qmutex_p.h"
+
+QT_BEGIN_NAMESPACE
+
+
+QMutexPrivate::QMutexPrivate(QMutex::RecursionMode mode)
+    : QMutexData(mode), maximumSpinTime(MaximumSpinTimeThreshold), averageWaitTime(0), owner(0), count(0)
+{
+    int r = lock.CreateLocal(0);
+    if (r != KErrNone)
+        qWarning("QMutex: failed to create lock, error %d", r);
+    qt_symbian_throwIfError(r);
+}
+
+QMutexPrivate::~QMutexPrivate()
+{
+    lock.Close();
+}
+
+bool QMutexPrivate::wait(int timeout)
+{
+    if (contenders.fetchAndAddAcquire(1) == 0) {
+        // lock acquired without waiting
+        return true;
+    }
+    int r = KErrTimedOut;
+    if (timeout < 0) {
+        lock.Wait();
+        r = KErrNone;
+    } else {
+        // Symbian lock waits are specified in microseconds.
+        // The wait is therefore chunked.
+        // KErrNone indicates success, KErrGeneral and KErrArgument are real fails, anything else is a timeout
+        do {
+            int waitTime = qMin(KMaxTInt / 1000, timeout);
+            timeout -= waitTime;
+            // Symbian undocumented feature - 0us means no timeout! Use a minimum of 1
+            r = lock.Wait(qMax(1, waitTime * 1000));
+        } while (r != KErrNone && r != KErrGeneral && r != KErrArgument && timeout > 0);
+    }
+    bool returnValue = (r == KErrNone);
+    contenders.deref();
+    return returnValue;
+}
+
+void QMutexPrivate::wakeUp()
+{
+    lock.Signal();
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_THREAD
diff --git a/src/corelib/thread/qthread_symbian.cpp b/src/corelib/thread/qthread_symbian.cpp
new file mode 100644
index 0000000..1474b36
--- /dev/null
+++ b/src/corelib/thread/qthread_symbian.cpp
@@ -0,0 +1,599 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qthread.h"
+#include "qplatformdefs.h"
+#include <private/qcoreapplication_p.h>
+#include <private/qeventdispatcher_symbian_p.h>
+#include "qthreadstorage.h"
+#include "qthread_p.h"
+#include <private/qsystemerror_p.h>
+
+#include <sched.h>
+#include <hal.h>
+#include <hal_data.h>
+
+// You only find these enumerations on Symbian^3 onwards, so we need to provide our own
+// to remain compatible with older releases. They won't be called by pre-Sym^3 SDKs.
+
+// HALData::ENumCpus
+#define QT_HALData_ENumCpus 119
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_THREAD
+
+enum { ThreadPriorityResetFlag = 0x80000000 };
+
+// Utility functions for getting, setting and clearing thread specific data.
+static QThreadData *get_thread_data()
+{
+    return reinterpret_cast<QThreadData *>(Dll::Tls());
+}
+
+static void set_thread_data(QThreadData *data)
+{
+    qt_symbian_throwIfError(Dll::SetTls(data));
+}
+
+static void clear_thread_data()
+{
+    Dll::FreeTls();
+}
+
+
+static void init_symbian_thread_handle(RThread &thread)
+{
+    thread = RThread();
+    TThreadId threadId = thread.Id();
+    qt_symbian_throwIfError(thread.Open(threadId, EOwnerProcess));
+}
+
+QThreadData *QThreadData::current()
+{
+    QThreadData *data = get_thread_data();
+    if (!data) {
+        void *a;
+        if (QInternal::activateCallbacks(QInternal::AdoptCurrentThread, &a)) {
+            QThread *adopted = static_cast<QThread*>(a);
+            Q_ASSERT(adopted);
+            data = QThreadData::get2(adopted);
+            set_thread_data(data);
+            adopted->d_func()->running = true;
+            adopted->d_func()->finished = false;
+            static_cast<QAdoptedThread *>(adopted)->init();
+        } else {
+            data = new QThreadData;
+            QT_TRY {
+                set_thread_data(data);
+                data->thread = new QAdoptedThread(data);
+            } QT_CATCH(...) {
+                clear_thread_data();
+                data->deref();
+                data = 0;
+                QT_RETHROW;
+            }
+            data->deref();
+        }
+        if (!QCoreApplicationPrivate::theMainThread)
+            QCoreApplicationPrivate::theMainThread = data->thread;
+    }
+    return data;
+}
+
+
+class QCAdoptedThreadMonitor : public CActive
+{
+public:
+    QCAdoptedThreadMonitor(QThread *thread)
+    : CActive(EPriorityStandard), data(QThreadData::get2(thread))
+    {
+        CActiveScheduler::Add(this);
+        data->symbian_thread_handle.Logon(iStatus);
+        SetActive();
+    }
+    ~QCAdoptedThreadMonitor()
+    {
+        Cancel();
+    }
+    void DoCancel()
+    {
+        data->symbian_thread_handle.LogonCancel(iStatus);
+    }
+    void RunL();
+private:
+    QThreadData* data;
+};
+
+class QCAddAdoptedThread : public CActive
+{
+public:
+    QCAddAdoptedThread()
+    : CActive(EPriorityStandard)
+    {
+        CActiveScheduler::Add(this);
+    }
+    void ConstructL()
+    {
+        User::LeaveIfError(monitorThread.Open(RThread().Id()));
+        start();
+    }
+    ~QCAddAdoptedThread()
+    {
+        Cancel();
+        monitorThread.Close();
+    }
+    void DoCancel()
+    {
+        User::RequestComplete(stat, KErrCancel);
+    }
+    void start()
+    {
+        iStatus = KRequestPending;
+        SetActive();
+        stat = &iStatus;
+    }
+    void RunL()
+    {
+        if (iStatus.Int() != KErrNone)
+            return;
+
+        QMutexLocker adoptedThreadMonitorMutexlock(&adoptedThreadMonitorMutex);
+        for (int i=threadsToAdd.size()-1; i>=0; i--) {
+            // Create an active object to monitor the thread
+            new (ELeave) QCAdoptedThreadMonitor(threadsToAdd[i]);
+            count++;
+            threadsToAdd.pop_back();
+        }
+        start();
+    }
+    static void add(QThread *thread)
+    {
+        QMutexLocker adoptedThreadMonitorMutexlock(&adoptedThreadMonitorMutex);
+        if (!adoptedThreadAdder) {
+            RThread monitorThread;
+            qt_symbian_throwIfError(monitorThread.Create(KNullDesC(), &monitorThreadFunc, 1024, &User::Allocator(), 0));
+            TRequestStatus started;
+            monitorThread.Rendezvous(started);
+            monitorThread.Resume();
+            User::WaitForRequest(started);
+            monitorThread.Close();
+        }
+        if (RThread().Id() == adoptedThreadAdder->monitorThread.Id())
+            return;
+        adoptedThreadAdder->threadsToAdd.push_back(thread);
+        if (adoptedThreadAdder->stat) {
+            adoptedThreadAdder->monitorThread.RequestComplete(adoptedThreadAdder->stat, KErrNone);
+        }
+    }
+    static void monitorThreadFuncL()
+    {
+        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
+        CleanupStack::PushL(scheduler);
+        CActiveScheduler::Install(scheduler);
+
+        adoptedThreadAdder = new(ELeave) QCAddAdoptedThread();
+        CleanupStack::PushL(adoptedThreadAdder);
+        adoptedThreadAdder->ConstructL();
+        QCAddAdoptedThread *adder = adoptedThreadAdder;
+
+        RThread::Rendezvous(KErrNone);
+        CActiveScheduler::Start();
+
+        CleanupStack::PopAndDestroy(adder);
+        CleanupStack::PopAndDestroy(scheduler);
+    }
+    static int monitorThreadFunc(void *)
+    {
+        _LIT(KMonitorThreadName, "adoptedMonitorThread");
+        RThread::RenameMe(KMonitorThreadName());
+        CTrapCleanup* cleanup = CTrapCleanup::New();
+        TRAPD(ret, monitorThreadFuncL());
+        delete cleanup;
+        return ret;
+    }
+    static void threadDied()
+    {
+        QMutexLocker adoptedThreadMonitorMutexlock(&adoptedThreadMonitorMutex);
+        if (adoptedThreadAdder) {
+            adoptedThreadAdder->count--;
+            if (adoptedThreadAdder->count <= 0 && adoptedThreadAdder->threadsToAdd.size() == 0) {
+                CActiveScheduler::Stop();
+                adoptedThreadAdder = 0;
+            }
+        }
+    }
+
+private:
+    QVector<QThread*> threadsToAdd;
+    RThread monitorThread;
+    static QMutex adoptedThreadMonitorMutex;
+    static QCAddAdoptedThread *adoptedThreadAdder;
+    int count;
+    TRequestStatus *stat;
+};
+
+QMutex QCAddAdoptedThread::adoptedThreadMonitorMutex;
+QCAddAdoptedThread* QCAddAdoptedThread::adoptedThreadAdder = 0;
+
+void QCAdoptedThreadMonitor::RunL()
+{
+    data->deref();
+    QCAddAdoptedThread::threadDied();
+    delete this;
+}
+
+void QAdoptedThread::init()
+{
+    Q_D(QThread);
+    d->thread_id = RThread().Id();  // type operator to TUint
+    init_symbian_thread_handle(d->data->symbian_thread_handle);
+    QCAddAdoptedThread::add(this);
+}
+
+/*
+   QThreadPrivate
+*/
+
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+
+typedef void*(*QtThreadCallback)(void*);
+
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+
+#endif // QT_NO_THREAD
+
+void QThreadPrivate::createEventDispatcher(QThreadData *data)
+{
+    data->eventDispatcher = new QEventDispatcherSymbian;
+    data->eventDispatcher->startingUp();
+}
+
+#ifndef QT_NO_THREAD
+
+void *QThreadPrivate::start(void *arg)
+{
+    QThread *thr = reinterpret_cast<QThread *>(arg);
+    QThreadData *data = QThreadData::get2(thr);
+
+    // do we need to reset the thread priority?
+    if (int(thr->d_func()->priority) & ThreadPriorityResetFlag) {
+        thr->setPriority(QThread::Priority(thr->d_func()->priority & ~ThreadPriorityResetFlag));
+    }
+
+    // On symbian, threads other than the main thread are non critical by default
+    // This means a worker thread can crash without crashing the application - to
+    // use this feature, we would need to use RThread::Logon in the main thread
+    // to catch abnormal thread exit and emit the finished signal.
+    // For the sake of cross platform consistency, we set the thread as process critical
+    // - advanced users who want the symbian behaviour can change the critical
+    // attribute of the thread again once the app gains control in run()
+    User::SetCritical(User::EProcessCritical);
+
+    set_thread_data(data);
+
+    {
+        QMutexLocker locker(&thr->d_func()->mutex);
+        data->quitNow = thr->d_func()->exited;
+    }
+
+    // ### TODO: allow the user to create a custom event dispatcher
+    createEventDispatcher(data);
+
+    emit thr->started();
+    thr->run();
+
+    QThreadPrivate::finish(arg);
+
+    return 0;
+}
+
+void QThreadPrivate::finish(void *arg, bool lockAnyway, bool closeNativeHandle)
+{
+    QThread *thr = reinterpret_cast<QThread *>(arg);
+    QThreadPrivate *d = thr->d_func();
+
+    QMutexLocker locker(lockAnyway ? &d->mutex : 0);
+
+    d->isInFinish = true;
+    d->priority = QThread::InheritPriority;
+    bool terminated = d->terminated;
+    void *data = &d->data->tls;
+    locker.unlock();
+    if (terminated)
+        emit thr->terminated();
+    emit thr->finished();
+    QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
+    QThreadStorageData::finish((void **)data);
+    locker.relock();
+    d->terminated = false;
+
+    QAbstractEventDispatcher *eventDispatcher = d->data->eventDispatcher;
+    if (eventDispatcher) {
+        d->data->eventDispatcher = 0;
+        locker.unlock();
+        eventDispatcher->closingDown();
+        delete eventDispatcher;
+        locker.relock();
+    }
+
+    d->thread_id = 0;
+    if (closeNativeHandle)
+        d->data->symbian_thread_handle.Close();
+    d->running = false;
+    d->finished = true;
+
+    d->isInFinish = false;
+    d->thread_done.wakeAll();
+}
+
+
+
+
+/**************************************************************************
+ ** QThread
+ *************************************************************************/
+
+Qt::HANDLE QThread::currentThreadId()
+{
+    return (Qt::HANDLE) (TUint) RThread().Id();
+}
+
+int QThread::idealThreadCount()
+{
+    int cores = 1;
+
+    if (QSysInfo::symbianVersion() >= QSysInfo::SV_SF_3) {
+        TInt inumcpus;
+        TInt err;
+        err = HAL::Get((HALData::TAttribute)QT_HALData_ENumCpus, inumcpus);
+        if (err == KErrNone) {
+            cores = qMax(inumcpus, 1);
+        }
+    }
+
+    return cores;
+}
+
+void QThread::yieldCurrentThread()
+{
+    sched_yield();
+}
+
+/*  \internal
+    helper function to do thread sleeps
+*/
+static void thread_sleep(unsigned long remaining, unsigned long scale)
+{
+    // maximum Symbian wait is 2^31 microseconds
+    unsigned long maxWait = KMaxTInt / scale;
+    do {
+        unsigned long waitTime = qMin(maxWait, remaining);
+        remaining -= waitTime;
+        User::AfterHighRes(waitTime * scale);
+    } while (remaining);
+}
+
+void QThread::sleep(unsigned long secs)
+{
+    thread_sleep(secs, 1000000ul);
+}
+
+void QThread::msleep(unsigned long msecs)
+{
+    thread_sleep(msecs, 1000ul);
+}
+
+void QThread::usleep(unsigned long usecs)
+{
+    thread_sleep(usecs, 1ul);
+}
+
+TThreadPriority calculateSymbianPriority(QThread::Priority priority)
+    {
+    // Both Qt & Symbian use limited enums; this matches the mapping previously done through conversion to Posix granularity
+    TThreadPriority symPriority;
+    switch (priority)
+    {
+        case QThread::IdlePriority:
+            symPriority = EPriorityMuchLess;
+            break;
+        case QThread::LowestPriority:
+        case QThread::LowPriority:
+            symPriority = EPriorityLess;
+            break;
+        case QThread::NormalPriority:
+            symPriority = EPriorityNormal;
+            break;
+        case QThread::HighPriority:
+            symPriority = EPriorityMore;
+            break;
+        case QThread::HighestPriority:
+        case QThread::TimeCriticalPriority:
+            symPriority = EPriorityMuchMore;
+            break;
+        case QThread::InheritPriority:
+        default:
+            symPriority = RThread().Priority();
+            break;
+    }
+    return symPriority;
+    }
+
+void QThread::start(Priority priority)
+{
+    Q_D(QThread);
+    QMutexLocker locker(&d->mutex);
+
+    if (d->isInFinish)
+        d->thread_done.wait(locker.mutex());
+
+    if (d->running)
+        return;
+
+    d->running = true;
+    d->finished = false;
+    d->terminated = false;
+    d->returnCode = 0;
+    d->exited = false;
+
+    d->priority = priority;
+
+    if (d->stackSize == 0)
+        // The default stack size on Symbian is very small, making even basic
+        // operations like file I/O fail, so we increase it by default.
+        d->stackSize = 0x14000; // Maximum stack size on Symbian.
+
+    int code = d->data->symbian_thread_handle.Create(KNullDesC, (TThreadFunction) QThreadPrivate::start, d->stackSize, NULL, this);
+    if (code == KErrNone) {
+        d->thread_id = d->data->symbian_thread_handle.Id();
+        TThreadPriority symPriority = calculateSymbianPriority(priority);
+        d->data->symbian_thread_handle.SetPriority(symPriority);
+        d->data->symbian_thread_handle.Resume();
+    } else {
+        qWarning("QThread::start: Thread creation error: %s", qPrintable(QSystemError(code, QSystemError::NativeError).toString()));
+
+        d->running = false;
+        d->finished = false;
+        d->thread_id = 0;
+        d->data->symbian_thread_handle.Close();
+    }
+}
+
+void QThread::terminate()
+{
+    Q_D(QThread);
+    QMutexLocker locker(&d->mutex);
+
+    if (!d->thread_id)
+        return;
+
+    if (!d->running)
+        return;
+    if (!d->terminationEnabled) {
+        d->terminatePending = true;
+        return;
+    }
+
+    d->terminated = true;
+    // "false, false" meaning:
+    // 1. lockAnyway = false. Don't lock the mutex because it's already locked
+    //    (see above).
+    // 2. closeNativeSymbianHandle = false. We don't want to close the thread handle,
+    //    because we need it here to terminate the thread.
+    QThreadPrivate::finish(this, false, false);
+    d->data->symbian_thread_handle.Terminate(KErrNone);
+    d->data->symbian_thread_handle.Close();
+}
+
+bool QThread::wait(unsigned long time)
+{
+    Q_D(QThread);
+    QMutexLocker locker(&d->mutex);
+
+    if (d->thread_id == (TUint) RThread().Id()) {
+        qWarning("QThread::wait: Thread tried to wait on itself");
+        return false;
+    }
+
+    if (d->finished || !d->running)
+        return true;
+
+    while (d->running) {
+        // Check if thread still exists. Needed because kernel will kill it without notification
+        // before global statics are deleted at application exit.
+        if (d->data->symbian_thread_handle.Handle()
+            && d->data->symbian_thread_handle.ExitType() != EExitPending) {
+            // Cannot call finish here as wait is typically called from another thread.
+            // It won't be necessary anyway, as we should never get here under normal operations;
+            // all QThreads are EProcessCritical and therefore cannot normally exit
+            // undetected (i.e. panic) as long as all thread control is via QThread.
+            return true;
+        }
+        if (!d->thread_done.wait(locker.mutex(), time))
+            return false;
+    }
+    return true;
+}
+
+void QThread::setTerminationEnabled(bool enabled)
+{
+    QThread *thr = currentThread();
+    Q_ASSERT_X(thr != 0, "QThread::setTerminationEnabled()",
+               "Current thread was not started with QThread.");
+    QThreadPrivate *d = thr->d_func();
+    QMutexLocker locker(&d->mutex);
+    d->terminationEnabled = enabled;
+    if (enabled && d->terminatePending) {
+        d->terminated = true;
+        // "false" meaning:
+        // -  lockAnyway = false. Don't lock the mutex because it's already locked
+        //    (see above).
+        QThreadPrivate::finish(thr, false);
+        locker.unlock(); // don't leave the mutex locked!
+        User::Exit(0);  // may be some other cleanup required? what if AS or cleanup stack?
+    }
+}
+
+void QThread::setPriority(Priority priority)
+{
+    Q_D(QThread);
+    QMutexLocker locker(&d->mutex);
+    if (!d->running) {
+        qWarning("QThread::setPriority: Cannot set priority, thread is not running");
+        return;
+    }
+
+    d->priority = priority;
+
+    // copied from start() with a few modifications:
+    TThreadPriority symPriority = calculateSymbianPriority(priority);
+    d->data->symbian_thread_handle.SetPriority(symPriority);
+}
+
+#endif // QT_NO_THREAD
+
+QT_END_NAMESPACE
+
diff --git a/src/corelib/thread/qthread_unix.cpp b/src/corelib/thread/qthread_unix.cpp
index 787c909..a8c5924 100644
--- a/src/corelib/thread/qthread_unix.cpp
+++ b/src/corelib/thread/qthread_unix.cpp
@@ -48,16 +48,7 @@
 #  include "../kernel/qeventdispatcher_glib_p.h"
 #endif
 
-#ifdef Q_OS_SYMBIAN
-#include <private/qeventdispatcher_symbian_p.h>
-#else
 #include <private/qeventdispatcher_unix_p.h>
-#endif
-
-#ifdef Q_OS_SYMBIAN
-#include <hal.h>
-#include <hal_data.h>
-#endif
 
 #include "qthreadstorage.h"
 
@@ -68,12 +59,6 @@
 #include <sched.h>
 #include <errno.h>
 
-// You only find these enumerations on Symbian^3 onwards, so we need to provide our own
-// to remain compatible with older releases. They won't be called by pre-Sym^3 SDKs.
-
-// HALData::ENumCpus
-#define QT_HALData_ENumCpus 119
-
 #ifdef Q_OS_BSD4
 #include <sys/sysctl.h>
 #endif
@@ -183,57 +168,23 @@ Q_DESTRUCTOR_FUNCTION(destroy_current_thread_data_key)
 
 
 // Utility functions for getting, setting and clearing thread specific data.
-// In Symbian, TLS access is significantly faster than pthread_getspecific.
-// However Symbian does not have the thread destruction cleanup functionality
-// that pthread has, so pthread_setspecific is also used.
 static QThreadData *get_thread_data()
 {
-#ifdef HAVE_TLS
-    return currentThreadData;
-#elif defined Q_OS_SYMBIAN
-    return reinterpret_cast<QThreadData *>(Dll::Tls());
-#else
     pthread_once(&current_thread_data_once, create_current_thread_data_key);
     return reinterpret_cast<QThreadData *>(pthread_getspecific(current_thread_data_key));
-#endif
 }
 
 static void set_thread_data(QThreadData *data)
 {
-#ifdef HAVE_TLS
-    currentThreadData = data;
-#elif defined Q_OS_SYMBIAN
-    qt_symbian_throwIfError(Dll::SetTls(data));
-#endif
     pthread_once(&current_thread_data_once, create_current_thread_data_key);
     pthread_setspecific(current_thread_data_key, data);
 }
 
 static void clear_thread_data()
 {
-#ifdef HAVE_TLS
-    currentThreadData = 0;
-#elif defined Q_OS_SYMBIAN
-    Dll::FreeTls();
-#endif
     pthread_setspecific(current_thread_data_key, 0);
 }
 
-
-#ifdef Q_OS_SYMBIAN
-static void init_symbian_thread_handle(RThread &thread)
-{
-    thread = RThread();
-    TThreadId threadId = thread.Id();
-    thread.Open(threadId);
-
-    // Make thread handle accessible process wide
-    RThread originalCloser = thread;
-    thread.Duplicate(thread, EOwnerProcess);
-    originalCloser.Close();
-}
-#endif
-
 QThreadData *QThreadData::current()
 {
     QThreadData *data = get_thread_data();
@@ -273,9 +224,6 @@ void QAdoptedThread::init()
 {
     Q_D(QThread);
     d->thread_id = pthread_self();
-#ifdef Q_OS_SYMBIAN
-    init_symbian_thread_handle(d->data->symbian_thread_handle);
-#endif
 }
 
 /*
@@ -303,11 +251,7 @@ void QThreadPrivate::createEventDispatcher(QThreadData *data)
         data->eventDispatcher = new QEventDispatcherGlib;
     else
 #endif
-#ifdef Q_OS_SYMBIAN
-        data->eventDispatcher = new QEventDispatcherSymbian;
-#else
-        data->eventDispatcher = new QEventDispatcherUNIX;
-#endif
+    data->eventDispatcher = new QEventDispatcherUNIX;
     data->eventDispatcher->startingUp();
 }
 
@@ -315,11 +259,8 @@ void QThreadPrivate::createEventDispatcher(QThreadData *data)
 
 void *QThreadPrivate::start(void *arg)
 {
-    // Symbian Open C supports neither thread cancellation nor cleanup_push.
-#ifndef Q_OS_SYMBIAN
     pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
     pthread_cleanup_push(QThreadPrivate::finish, arg);
-#endif
 
     QThread *thr = reinterpret_cast<QThread *>(arg);
     QThreadData *data = QThreadData::get2(thr);
@@ -358,35 +299,22 @@ void *QThreadPrivate::start(void *arg)
     createEventDispatcher(data);
 
     emit thr->started();
-#ifndef Q_OS_SYMBIAN
     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
     pthread_testcancel();
-#endif
     thr->run();
 
-#ifdef Q_OS_SYMBIAN
-    QThreadPrivate::finish(arg);
-#else
     pthread_cleanup_pop(1);
-#endif
 
     return 0;
 }
 
-#ifdef Q_OS_SYMBIAN
-void QThreadPrivate::finish(void *arg, bool lockAnyway, bool closeNativeHandle)
-#else
 void QThreadPrivate::finish(void *arg)
-#endif
 {
     QThread *thr = reinterpret_cast<QThread *>(arg);
     QThreadPrivate *d = thr->d_func();
 
-#ifdef Q_OS_SYMBIAN
-    QMutexLocker locker(lockAnyway ? &d->mutex : 0);
-#else
     QMutexLocker locker(&d->mutex);
-#endif
+
     d->isInFinish = true;
     d->priority = QThread::InheritPriority;
     bool terminated = d->terminated;
@@ -410,10 +338,6 @@ void QThreadPrivate::finish(void *arg)
     }
 
     d->thread_id = 0;
-#ifdef Q_OS_SYMBIAN
-    if (closeNativeHandle)
-        d->data->symbian_thread_handle.Close();
-#endif
     d->running = false;
     d->finished = true;
 
@@ -471,21 +395,6 @@ int QThread::idealThreadCount()
 #elif defined(Q_OS_INTEGRITY)
     // as of aug 2008 Integrity only supports one single core CPU
     cores = 1;
-#elif defined(Q_OS_SYMBIAN)
-    if (QSysInfo::symbianVersion() >= QSysInfo::SV_SF_3) {
-        TInt inumcpus;
-        TInt err;
-        err = HAL::Get((HALData::TAttribute)QT_HALData_ENumCpus, inumcpus);
-        if (err != KErrNone) {
-            cores = 1;
-        } else if ( inumcpus <= 0 ) {
-            cores = 1;
-        } else {
-            cores = inumcpus;
-        }
-    } else {
-        cores = 1;
-    }
 #elif defined(Q_OS_VXWORKS)
     // VxWorks
 #  if defined(QT_VXWORKS_HAS_CPUSET)
@@ -626,8 +535,7 @@ void QThread::start(Priority priority)
 
     d->priority = priority;
 
-#if defined(QT_HAS_THREAD_PRIORITY_SCHEDULING) && !defined(Q_OS_SYMBIAN)
-// ### Need to implement thread sheduling and priorities for symbian os. Implementation removed for now
+#if defined(QT_HAS_THREAD_PRIORITY_SCHEDULING)
     switch (priority) {
     case InheritPriority:
         {
@@ -669,12 +577,6 @@ void QThread::start(Priority priority)
     }
 #endif // QT_HAS_THREAD_PRIORITY_SCHEDULING
 
-#ifdef Q_OS_SYMBIAN
-    if (d->stackSize == 0)
-        // The default stack size on Symbian is very small, making even basic
-        // operations like file I/O fail, so we increase it by default.
-        d->stackSize = 0x14000; // Maximum stack size on Symbian.
-#endif
 
     if (d->stackSize > 0) {
 #if defined(_POSIX_THREAD_ATTR_STACKSIZE) && (_POSIX_THREAD_ATTR_STACKSIZE-0 > 0)
@@ -700,9 +602,7 @@ void QThread::start(Priority priority)
     if (code == EPERM) {
         // caller does not have permission to set the scheduling
         // parameters/policy
-#ifndef Q_OS_SYMBIAN
         pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
-#endif
         code =
             pthread_create(&d->thread_id, &attr, QThreadPrivate::start, this);
     }
@@ -715,9 +615,6 @@ void QThread::start(Priority priority)
         d->running = false;
         d->finished = false;
         d->thread_id = 0;
-#ifdef Q_OS_SYMBIAN
-        d->data->symbian_thread_handle.Close();
-#endif
     }
 }
 
@@ -729,7 +626,6 @@ void QThread::terminate()
     if (!d->thread_id)
         return;
 
-#ifndef Q_OS_SYMBIAN
     int code = pthread_cancel(d->thread_id);
     if (code) {
         qWarning("QThread::start: Thread termination error: %s",
@@ -737,26 +633,6 @@ void QThread::terminate()
     } else {
         d->terminated = true;
     }
-#else
-    if (!d->running)
-        return;
-    if (!d->terminationEnabled) {
-        d->terminatePending = true;
-        return;
-    }
-
-    d->terminated = true;
-    // "false, false" meaning:
-    // 1. lockAnyway = false. Don't lock the mutex because it's already locked
-    //    (see above).
-    // 2. closeNativeSymbianHandle = false. We don't want to close the thread handle,
-    //    because we need it here to terminate the thread.
-    QThreadPrivate::finish(this, false, false);
-    d->data->symbian_thread_handle.Terminate(KErrNone);
-    d->data->symbian_thread_handle.Close();
-#endif
-
-
 }
 
 bool QThread::wait(unsigned long time)
@@ -773,18 +649,6 @@ bool QThread::wait(unsigned long time)
         return true;
 
     while (d->running) {
-#ifdef Q_OS_SYMBIAN
-        // Check if thread still exists. Needed because kernel will kill it without notification
-        // before global statics are deleted at application exit.
-        if (d->data->symbian_thread_handle.Handle()
-            && d->data->symbian_thread_handle.ExitType() != EExitPending) {
-            // Cannot call finish here as wait is typically called from another thread.
-            // It won't be necessary anyway, as we should never get here under normal operations;
-            // all QThreads are EProcessCritical and therefore cannot normally exit
-            // undetected (i.e. panic) as long as all thread control is via QThread.
-            return true;
-        }
-#endif
         if (!d->thread_done.wait(locker.mutex(), time))
             return false;
     }
@@ -796,25 +660,11 @@ void QThread::setTerminationEnabled(bool enabled)
     QThread *thr = currentThread();
     Q_ASSERT_X(thr != 0, "QThread::setTerminationEnabled()",
                "Current thread was not started with QThread.");
-#ifndef Q_OS_SYMBIAN
+
     Q_UNUSED(thr)
     pthread_setcancelstate(enabled ? PTHREAD_CANCEL_ENABLE : PTHREAD_CANCEL_DISABLE, NULL);
     if (enabled)
         pthread_testcancel();
-#else
-    QThreadPrivate *d = thr->d_func();
-    QMutexLocker locker(&d->mutex);
-    d->terminationEnabled = enabled;
-    if (enabled && d->terminatePending) {
-        d->terminated = true;
-        // "false" meaning:
-        // -  lockAnyway = false. Don't lock the mutex because it's already locked
-        //    (see above).
-        QThreadPrivate::finish(thr, false);
-        locker.unlock(); // don't leave the mutex locked!
-        pthread_exit(NULL);
-    }
-#endif
 }
 
 void QThread::setPriority(Priority priority)
diff --git a/src/corelib/thread/qwaitcondition_symbian.cpp b/src/corelib/thread/qwaitcondition_symbian.cpp
new file mode 100644
index 0000000..9967382
--- /dev/null
+++ b/src/corelib/thread/qwaitcondition_symbian.cpp
@@ -0,0 +1,196 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qwaitcondition.h"
+#include "qmutex.h"
+#include "qreadwritelock.h"
+#include "qatomic.h"
+#include "qstring.h"
+#include "qelapsedtimer.h"
+
+#include "qmutex_p.h"
+#include "qreadwritelock_p.h"
+
+#ifndef QT_NO_THREAD
+
+QT_BEGIN_NAMESPACE
+
+static void report_error(int err, const char *where, const char *what)
+{
+    if (err != KErrNone)
+        qWarning("%s: %s failure: %d", where, what, err);
+}
+
+class QWaitConditionPrivate {
+public:
+    RMutex mutex;
+    RCondVar cond;
+    int waiters;
+    int wakeups;
+
+    QWaitConditionPrivate()
+    : waiters(0), wakeups(0)
+    {
+        qt_symbian_throwIfError(mutex.CreateLocal());
+        int err = cond.CreateLocal();
+        if (err != KErrNone) {
+            mutex.Close();
+            qt_symbian_throwIfError(err);
+        }
+    }
+
+    ~QWaitConditionPrivate()
+    {
+        cond.Close();
+        mutex.Close();
+    }
+
+    bool wait(unsigned long time)
+    {
+        TInt err = KErrNone;
+        if (time == ULONG_MAX) {
+            // untimed wait, loop because RCondVar::Wait may return before the condition is triggered
+            do {
+                err = cond.Wait(mutex);
+            } while (err == KErrNone && wakeups == 0);
+        } else {
+            unsigned long maxWait = KMaxTInt / 1000;
+            QElapsedTimer waitTimer;
+            do {
+                waitTimer.start();
+                unsigned long waitTime = qMin(maxWait, time);
+                // wait at least 1ms, as 0 means no wait
+                err = cond.TimedWait(mutex, qMax(1ul, waitTime) * 1000);
+                // RCondVar::TimedWait may return before the condition is triggered, update the timeout with actual wait time
+                time -= qMin((unsigned long)waitTimer.elapsed(), waitTime);
+            } while ((err == KErrNone && wakeups == 0) || (err == KErrTimedOut && time > 0));
+        }
+
+        Q_ASSERT_X(waiters > 0, "QWaitCondition::wait", "internal error (waiters)");
+        --waiters;
+        if (err == KErrNone) {
+            Q_ASSERT_X(wakeups > 0, "QWaitCondition::wait", "internal error (wakeups)");
+            --wakeups;
+        }
+
+        mutex.Signal();
+
+        if (err && err != KErrTimedOut)
+            report_error(err, "QWaitCondition::wait()", "cv wait");
+        return err == KErrNone;
+    }
+};
+
+QWaitCondition::QWaitCondition()
+{
+    d = new QWaitConditionPrivate;
+}
+
+QWaitCondition::~QWaitCondition()
+{
+    delete d;
+}
+
+void QWaitCondition::wakeOne()
+{
+    d->mutex.Wait();
+    d->wakeups = qMin(d->wakeups + 1, d->waiters);
+    d->cond.Signal();
+    d->mutex.Signal();
+}
+
+void QWaitCondition::wakeAll()
+{
+    d->mutex.Wait();
+    d->wakeups = d->waiters;
+    d->cond.Broadcast();
+    d->mutex.Signal();
+}
+
+bool QWaitCondition::wait(QMutex *mutex, unsigned long time)
+{
+    if (! mutex)
+        return false;
+    if (mutex->d->recursive) {
+        qWarning("QWaitCondition: cannot wait on recursive mutexes");
+        return false;
+    }
+
+    d->mutex.Wait();
+    ++d->waiters;
+    mutex->unlock();
+
+    bool returnValue = d->wait(time);
+
+    mutex->lock();
+
+    return returnValue;
+}
+
+bool QWaitCondition::wait(QReadWriteLock *readWriteLock, unsigned long time)
+{
+    if (!readWriteLock || readWriteLock->d->accessCount == 0)
+        return false;
+    if (readWriteLock->d->accessCount < -1) {
+        qWarning("QWaitCondition: cannot wait on QReadWriteLocks with recursive lockForWrite()");
+        return false;
+    }
+
+    d->mutex.Wait();
+    ++d->waiters;
+
+    int previousAccessCount = readWriteLock->d->accessCount;
+    readWriteLock->unlock();
+
+    bool returnValue = d->wait(time);
+
+    if (previousAccessCount < 0)
+        readWriteLock->lockForWrite();
+    else
+        readWriteLock->lockForRead();
+
+    return returnValue;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_THREAD
diff --git a/src/corelib/thread/qwaitcondition_unix.cpp b/src/corelib/thread/qwaitcondition_unix.cpp
index f06a158..d0f23b5 100644
--- a/src/corelib/thread/qwaitcondition_unix.cpp
+++ b/src/corelib/thread/qwaitcondition_unix.cpp
@@ -61,8 +61,6 @@ static void report_error(int code, const char *where, const char *what)
         qWarning("%s: %s failure: %s", where, what, qPrintable(qt_error_string(code)));
 }
 
-
-
 class QWaitConditionPrivate {
 public:
     pthread_mutex_t mutex;
diff --git a/src/corelib/thread/thread.pri b/src/corelib/thread/thread.pri
index 90583bb..592ab16 100644
--- a/src/corelib/thread/thread.pri
+++ b/src/corelib/thread/thread.pri
@@ -4,11 +4,11 @@
 HEADERS += thread/qmutex.h \
            thread/qreadwritelock.h \
            thread/qsemaphore.h \
- 	   thread/qthread.h \
- 	   thread/qthreadstorage.h \
- 	   thread/qwaitcondition.h \
-	   thread/qatomic.h
-	
+           thread/qthread.h \
+           thread/qthreadstorage.h \
+           thread/qwaitcondition.h \
+           thread/qatomic.h
+
 # private headers
 HEADERS += thread/qmutex_p.h \
            thread/qmutexpool_p.h \
@@ -19,14 +19,18 @@ HEADERS += thread/qmutex_p.h \
 SOURCES += thread/qatomic.cpp \
            thread/qmutex.cpp \
            thread/qreadwritelock.cpp \
-	   thread/qmutexpool.cpp \
-	   thread/qsemaphore.cpp \
- 	   thread/qthread.cpp \
-           thread/qthreadstorage.cpp 
+           thread/qmutexpool.cpp \
+           thread/qsemaphore.cpp \
+           thread/qthread.cpp \
+           thread/qthreadstorage.cpp
 
-unix:SOURCES += thread/qmutex_unix.cpp \
-                thread/qthread_unix.cpp \
-		thread/qwaitcondition_unix.cpp
+unix:!symbian:SOURCES += thread/qmutex_unix.cpp \
+                         thread/qthread_unix.cpp \
+                         thread/qwaitcondition_unix.cpp
+
+symbian:SOURCES += thread/qmutex_symbian.cpp \
+                   thread/qthread_symbian.cpp \
+                   thread/qwaitcondition_symbian.cpp
 
 win32:SOURCES += thread/qmutex_win.cpp \
                  thread/qthread_win.cpp \
diff --git a/src/corelib/tools/qalgorithms.qdoc b/src/corelib/tools/qalgorithms.qdoc
index 34918a3..a9b7ddc 100644
--- a/src/corelib/tools/qalgorithms.qdoc
+++ b/src/corelib/tools/qalgorithms.qdoc
@@ -60,14 +60,14 @@
     a particular value. If you need that functionality, you can use
     qFill():
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 0
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 0
 
     qFill() takes a begin iterator, an end iterator, and a value.
     In the example above, we pass \c list.begin() and \c list.end()
     as the begin and end iterators, but this doesn't have to be
     the case:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 1
 
     Different algorithms can have different requirements for the
     iterators they accept. For example, qFill() accepts two 
@@ -98,13 +98,13 @@
     name_table array and return the corresponding Unicode value from
     the \c value_table if the entity is recognized:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 2
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 2
 
     This kind of code is for advanced users only; for most
     applications, a QMap- or QHash-based approach would work just as
     well:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 3
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 3
 
     \section1 Types of Iterators
 
@@ -185,7 +185,7 @@
     position \a begin2 + 1; and so on.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 4
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 4
 
     \sa qCopyBackward(), {input iterators}, {output iterators}
 */
@@ -201,7 +201,7 @@
     at position \a end2 - 2; and so on.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 5
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 5
 
     \sa qCopy(), {bidirectional iterators}
 */
@@ -214,7 +214,7 @@
     items compare equal; otherwise returns false.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 6
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 6
 
     This function requires the item type (in the example above,
     QString) to implement \c operator==().
@@ -228,7 +228,7 @@
     Fills the range [\a begin, \a end) with \a value.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 7
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 7
 
     \sa qCopy(), {forward iterators}
 */
@@ -249,7 +249,7 @@
     value isn't found.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 8
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 8
 
     This function requires the item type (in the example above,
     QString) to implement \c operator==().
@@ -278,7 +278,7 @@
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 9
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 9
 
     This function requires the item type (in the example above,
     \c int) to implement \c operator==().
@@ -302,7 +302,7 @@ of \a value in the variable passed as a reference in argument \a n.
     Exchanges the values of variables \a var1 and \a var2.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 10
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 10
 */
 
 /*! \fn void qSort(RandomAccessIterator begin, RandomAccessIterator end)
@@ -312,7 +312,7 @@ of \a value in the variable passed as a reference in argument \a n.
     using the quicksort algorithm.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 11
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 11
 
     The sort algorithm is efficient on large data sets. It operates
     in \l {linear-logarithmic time}, O(\e{n} log \e{n}).
@@ -338,13 +338,13 @@ of \a value in the variable passed as a reference in argument \a n.
     For example, here's how to sort the strings in a QStringList
     in case-insensitive alphabetical order:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 12
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 12
 
     To sort values in reverse order, pass
     \l{qGreater()}{qGreater<T>()} as the \a lessThan parameter. For
     example:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 13
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 13
 
     If neither of the two items is "less than" the other, the items are
     taken to be equal. It is then undefined which one of the two
@@ -356,7 +356,7 @@ of \a value in the variable passed as a reference in argument \a n.
     following code shows how to sort a list of strings case
     insensitively using QMap:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 14
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 14
 
     \sa QMap
 */
@@ -382,7 +382,7 @@ of \a value in the variable passed as a reference in argument \a n.
     property is often useful when sorting user-visible data.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 15
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 15
 
     The sort algorithm is efficient on large data sets. It operates
     in \l {linear-logarithmic time}, O(\e{n} log \e{n}).
@@ -405,7 +405,7 @@ of \a value in the variable passed as a reference in argument \a n.
     For example, here's how to sort the strings in a QStringList
     in case-insensitive alphabetical order:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 16
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 16
     
     Note that earlier versions of Qt allowed using a lessThan function that took its
     arguments by non-const reference. From 4.3 and on this is no longer possible,
@@ -415,7 +415,7 @@ of \a value in the variable passed as a reference in argument \a n.
     \l{qGreater()}{qGreater<T>()} as the \a lessThan parameter. For
     example:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 17
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 17
 
     If neither of the two items is "less than" the other, the items are
     taken to be equal. The item that appeared before the other in the
@@ -444,7 +444,7 @@ of \a value in the variable passed as a reference in argument \a n.
     ascending order; see qSort().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 18
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 18
 
     This function requires the item type (in the example above,
     \c{int}) to implement \c operator<().
@@ -452,7 +452,7 @@ of \a value in the variable passed as a reference in argument \a n.
     qLowerBound() can be used in conjunction with qUpperBound() to
     iterate over all occurrences of the same value:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 19
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 19
 
     \sa qUpperBound(), qBinaryFind()
 */
@@ -494,7 +494,7 @@ of \a value in the variable passed as a reference in argument \a n.
     ascending order; see qSort().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 20
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 20
 
     This function requires the item type (in the example above,
     \c{int}) to implement \c operator<().
@@ -502,7 +502,7 @@ of \a value in the variable passed as a reference in argument \a n.
     qUpperBound() can be used in conjunction with qLowerBound() to
     iterate over all occurrences of the same value:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 21
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 21
 
     \sa qLowerBound(), qBinaryFind()
 */
@@ -545,7 +545,7 @@ of \a value in the variable passed as a reference in argument \a n.
     finer control.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 22
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 22
 
     This function requires the item type (in the example above,
     QString) to implement \c operator<().
@@ -587,7 +587,7 @@ of \a value in the variable passed as a reference in argument \a n.
     example, \c{QWidget *}).
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 23
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 23
 
     Notice that qDeleteAll() doesn't remove the items from the
     container; it merely calls \c delete on them. In the example
@@ -618,7 +618,7 @@ of \a value in the variable passed as a reference in argument \a n.
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 24
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 24
 
     \sa {qGreater()}{qGreater<T>()}
 */
@@ -631,7 +631,7 @@ of \a value in the variable passed as a reference in argument \a n.
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qalgorithms.qdoc 25
+    \snippet doc/src/snippets/code/doc_src_qalgorithms.cpp 25
 
     \sa {qLess()}{qLess<T>()}
 */
diff --git a/src/corelib/tools/qbytearray.cpp b/src/corelib/tools/qbytearray.cpp
index 4799abd..1c9b654 100644
--- a/src/corelib/tools/qbytearray.cpp
+++ b/src/corelib/tools/qbytearray.cpp
@@ -1387,7 +1387,7 @@ QByteArray::QByteArray(int size, Qt::Initialization)
     If \a size is less than the current size, bytes are removed from
     the end.
 
-    \sa size()
+    \sa size(), truncate()
 */
 
 void QByteArray::resize(int size)
diff --git a/src/corelib/tools/qcache.qdoc b/src/corelib/tools/qcache.qdoc
index 991238b..9e12c92 100644
--- a/src/corelib/tools/qcache.qdoc
+++ b/src/corelib/tools/qcache.qdoc
@@ -39,11 +39,11 @@
     definition of a cache that stores objects of type Employee
     associated with an integer key:
 
-    \snippet doc/src/snippets/code/doc_src_qcache.qdoc 0
+    \snippet doc/src/snippets/code/doc_src_qcache.cpp 0
 
     Here's how to insert an object in the cache:
 
-    \snippet doc/src/snippets/code/doc_src_qcache.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qcache.cpp 1
 
     The advantage of using QCache over some other key-based data
     structure (such as QMap or QHash) is that QCache automatically
@@ -59,7 +59,7 @@
     By default, QCache's maxCost() is 100. You can specify a
     different value in the QCache constructor:
 
-    \snippet doc/src/snippets/code/doc_src_qcache.qdoc 2
+    \snippet doc/src/snippets/code/doc_src_qcache.cpp 2
 
     Each time you call insert(), you can specify a cost as third
     argument (after the key and a pointer to the object to insert).
diff --git a/src/corelib/tools/qiterator.qdoc b/src/corelib/tools/qiterator.qdoc
index d651343..6830442 100644
--- a/src/corelib/tools/qiterator.qdoc
+++ b/src/corelib/tools/qiterator.qdoc
@@ -50,7 +50,7 @@
     the list (before the first item). Here's how to iterate over all
     the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 0
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 0
 
     The next() function returns the next item in the list and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -65,7 +65,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 1
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop.
@@ -98,7 +98,7 @@
     beginning of the list (before the first item). Here's how to
     iterate over all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 2
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 2
 
     The next() function returns the next item in the list and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -113,7 +113,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 3
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 3
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop.
@@ -150,7 +150,7 @@
     of the vector (before the first item). Here's how to iterate over
     all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 4
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 4
 
     The next() function returns the next item in the vector and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -165,7 +165,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 5
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 5
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop.
@@ -197,7 +197,7 @@
     the first item). Here's how to iterate over all the elements
     sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 6
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 6
 
     The next() function returns the next item in the set and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -212,7 +212,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 7
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 7
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop.
@@ -251,7 +251,7 @@
     of the list (before the first item). Here's how to iterate over
     all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 8
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 8
 
     The next() function returns the next item in the list and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -266,7 +266,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 9
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 9
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop.
@@ -277,7 +277,7 @@
     insert().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 10
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 10
 
     The example traverses a list, replacing negative numbers with
     their absolute values, and eliminating zeroes.
@@ -312,7 +312,7 @@
     beginning of the list (before the first item). Here's how to
     iterate over all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 11
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 11
 
     The next() function returns the next item in the list and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -327,7 +327,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 12
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 12
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop.
@@ -338,7 +338,7 @@
     insert().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 13
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 13
 
     The example traverses a list, replacing negative numbers with
     their absolute values, and eliminating zeroes.
@@ -378,7 +378,7 @@
     beginning of the list (before the first item). Here's how to
     iterate over all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 14
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 14
 
     The next() function returns the next item in the vector and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -393,7 +393,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 15
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 15
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop.
@@ -404,7 +404,7 @@
     insert().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 16
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 16
 
     The example traverses a vector, replacing negative numbers with
     their absolute values, and eliminating zeroes.
@@ -440,7 +440,7 @@
     of the set (before the first item). Here's how to iterate over
     all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 17
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 17
 
     The next() function returns the next item in the set and
     advances the iterator. Unlike STL-style iterators, Java-style
@@ -455,7 +455,7 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 18
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 18
 
     If you want to remove items as you iterate over the set, use
     remove().
@@ -755,7 +755,7 @@
     traversal functions (next(), previous(), findNext(), findPrevious()).
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 19
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 19
 
     \sa insert(), setValue()
 */
@@ -766,7 +766,7 @@
     traversal functions (next(), previous(), findNext(), findPrevious()).
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 20
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 20
 
     \sa insert(), setValue()
 */
@@ -777,7 +777,7 @@
     traversal functions (next(), previous(), findNext(), findPrevious()).
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 21
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 21
 
     \sa insert(), setValue()
 */
@@ -788,7 +788,7 @@
     traversal functions (next(), previous(), findNext(), findPrevious()).
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 22
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 22
 
     \sa value()
 */
@@ -802,7 +802,7 @@
     findPrevious().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 23
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 23
 
     \sa value(), remove(), insert()
 */
@@ -816,7 +816,7 @@
     findPrevious().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 24
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 24
 
     \sa value(), remove(), insert()
 */
@@ -830,7 +830,7 @@
     findPrevious().
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 25
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 25
 
     \sa value(), remove(), insert()
 */
@@ -889,7 +889,7 @@
     the map (before the first item). Here's how to iterate over all
     the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 26
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 26
 
     The next() function returns the next item in the map and
     advances the iterator. The key() and value() functions return the
@@ -906,12 +906,12 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 27
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 27
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop. For example:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 28
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 28
 
     Multiple iterators can be used on the same map. If the map is
     modified while a QMapIterator is active, the QMapIterator will
@@ -941,7 +941,7 @@
     the hash (before the first item). Here's how to iterate over all
     the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 29
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 29
 
     The next() function returns the next item in the hash and
     advances the iterator. The key() and value() functions return the
@@ -958,12 +958,12 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 30
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 30
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop. For example:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 31
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 31
 
     Multiple iterators can be used on the same hash. If the hash is
     modified while a QHashIterator is active, the QHashIterator will
@@ -994,7 +994,7 @@
     of the map (before the first item). Here's how to iterate over
     all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 32
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 32
 
     The next() function returns the next item in the map and
     advances the iterator. The key() and value() functions return the
@@ -1011,12 +1011,12 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 33
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 33
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop. For example:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 34
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 34
 
     If you want to remove items as you iterate over the map, use
     remove(). If you want to modify the value of an item, use
@@ -1024,7 +1024,7 @@
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 35
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 35
 
     The example removes all (key, value) pairs where the key and the
     value are the same.
@@ -1059,7 +1059,7 @@
     of the hash (before the first item). Here's how to iterate over
     all the elements sequentially:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 36
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 36
 
     The next() function returns the next item in the hash and
     advances the iterator. The key() and value() functions return the
@@ -1076,12 +1076,12 @@
 
     Here's how to iterate over the elements in reverse order:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 37
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 37
 
     If you want to find all occurrences of a particular value, use
     findNext() or findPrevious() in a loop. For example:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 38
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 38
 
     If you want to remove items as you iterate over the hash, use
     remove(). If you want to modify the value of an item, use
@@ -1089,7 +1089,7 @@
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 39
+    \snippet doc/src/snippets/code/doc_src_qiterator.cpp 39
 
     The example removes all (key, value) pairs where the key and the
     value are the same.
diff --git a/src/corelib/tools/qmap.cpp b/src/corelib/tools/qmap.cpp
index c548663..9e13fcc 100644
--- a/src/corelib/tools/qmap.cpp
+++ b/src/corelib/tools/qmap.cpp
@@ -1087,7 +1087,7 @@ void QMapData::dump()
 
     \overload
 
-    The prefix -- operator (\c{--i}) makes the preceding item
+    The postfix -- operator (\c{i--}) makes the preceding item
     current and returns an iterator pointing to the previously
     current item.
 */
diff --git a/src/corelib/tools/qpair.qdoc b/src/corelib/tools/qpair.qdoc
index b900c4f..925100d 100644
--- a/src/corelib/tools/qpair.qdoc
+++ b/src/corelib/tools/qpair.qdoc
@@ -40,12 +40,12 @@
     Here's an example of a QPair that stores one QString and one \c
     double value:
 
-    \snippet doc/src/snippets/code/doc_src_qpair.qdoc 0
+    \snippet doc/src/snippets/code/doc_src_qpair.cpp 0
 
     The components are accessible as public data members called \l
     first and \l second. For example:
 
-    \snippet doc/src/snippets/code/doc_src_qpair.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qpair.cpp 1
 
     QPair's template data types (T1 and T2) must be \l{assignable
     data types}. You cannot, for example, store a QWidget as a value;
@@ -186,7 +186,7 @@
     Returns a QPair\<T1, T2\> that contains \a value1 and \a value2.
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qpair.qdoc 2
+    \snippet doc/src/snippets/code/doc_src_qpair.cpp 2
 
     This is equivalent to QPair<T1, T2>(\a value1, \a value2), but
     usually requires less typing.
diff --git a/src/corelib/tools/qset.qdoc b/src/corelib/tools/qset.qdoc
index 30880d5..8748fd9 100644
--- a/src/corelib/tools/qset.qdoc
+++ b/src/corelib/tools/qset.qdoc
@@ -40,19 +40,19 @@
 
     Here's an example QSet with QString values:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 0
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 0
 
     To insert a value into the set, use insert():
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 1
 
     Another way to insert items into the set is to use operator<<():
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 2
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 2
 
     To test whether an item belongs to the set or not, use contains():
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 3
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 3
 
     If you want to navigate through all the values stored in a QSet,
     you can use an iterator. QSet supports both \l{Java-style
@@ -60,18 +60,18 @@
     iterators} (QSet::iterator and QSet::const_iterator). Here's how
     to iterate over a QSet<QWidget *> using a Java-style iterator:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 4
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 4
 
     Here's the same code, but using an STL-style iterator:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 5
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 5
 
     QSet is unordered, so an iterator's sequence cannot be assumed to
     be predictable. If ordering by key is required, use a QMap.
 
     To navigate through a QSet, you can also use \l{foreach}:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 6
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 6
 
     Items can be removed from the set using remove(). There is also a
     clear() function that removes all items.
@@ -194,7 +194,7 @@
     This function is useful for code that needs to build a huge set
     and wants to avoid repeated reallocation. For example:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 7
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 7
 
     Ideally, \a size should be slightly more than the maximum number
     of elements expected in the set. \a size doesn't have to be prime,
@@ -610,18 +610,18 @@
     start iterating. Here's a typical loop that prints all the items
     stored in a set:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 8
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 8
 
     Here's a loop that removes certain items (all those that start
     with 'J') from a set while iterating:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 9
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 9
 
     STL-style iterators can be used as arguments to \l{generic
     algorithms}. For example, here's how to find an item in the set
     using the qFind() algorithm:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 10
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 10
 
     Multiple iterators can be used on the same set. However, you may
     not attempt to modify the container while iterating on it.
@@ -653,13 +653,13 @@
     start iterating. Here's a typical loop that prints all the items
     stored in a set:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 11
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 11
 
     STL-style iterators can be used as arguments to \l{generic
     algorithms}. For example, here's how to find an item in the set
     using the qFind() algorithm:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 12
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 12
 
     Multiple iterators can be used on the same set. However, you may
     not attempt to modify the container while iterating on it.
@@ -893,7 +893,7 @@
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 13
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 13
 
     \sa fromList(), QList::fromSet(), qSort()
 */
@@ -918,7 +918,7 @@
 
     Example:
 
-    \snippet doc/src/snippets/code/doc_src_qset.qdoc 14
+    \snippet doc/src/snippets/code/doc_src_qset.cpp 14
 
     \sa toList(), QList::toSet()
 */
diff --git a/src/corelib/tools/qtextboundaryfinder.cpp b/src/corelib/tools/qtextboundaryfinder.cpp
index c2bb094..34bc406 100644
--- a/src/corelib/tools/qtextboundaryfinder.cpp
+++ b/src/corelib/tools/qtextboundaryfinder.cpp
@@ -457,33 +457,23 @@ QTextBoundaryFinder::BoundaryReasons QTextBoundaryFinder::boundaryReasons() cons
             return NotAtBoundary;
         return StartWord;
     }
-    if (pos >= length - 1) {
+    if (pos == length) {
         if (d->attributes[length-1].whiteSpace)
             return NotAtBoundary;
         return EndWord;
     }
 
-    BoundaryReasons answer;
-    const bool nextIsSpace = d->attributes[pos + 1].whiteSpace;
+    const bool nextIsSpace = d->attributes[pos].whiteSpace;
     const bool prevIsSpace = d->attributes[pos - 1].whiteSpace;
 
-    if (d->attributes[pos].whiteSpace)
-        answer = EndWord;
-    else if (!prevIsSpace) {
-        answer = StartWord;
-        answer |= EndWord;
-    }
-
-    if (prevIsSpace)
-        answer |= StartWord;
-    if (nextIsSpace)
-        answer |= EndWord;
-    if (answer == 0) {
-        answer = StartWord;
-        answer |= EndWord;
-    }
-
-    return answer;
+    if (prevIsSpace && !nextIsSpace)
+        return StartWord;
+    else if (!prevIsSpace && nextIsSpace)
+        return EndWord;
+    else if (!prevIsSpace && !nextIsSpace)
+        return BoundaryReasons(StartWord | EndWord);
+    else
+        return NotAtBoundary;
 }
 
 QT_END_NAMESPACE
diff --git a/src/corelib/tools/qvarlengtharray.qdoc b/src/corelib/tools/qvarlengtharray.qdoc
index 957bca7..3c80c1c 100644
--- a/src/corelib/tools/qvarlengtharray.qdoc
+++ b/src/corelib/tools/qvarlengtharray.qdoc
@@ -35,12 +35,12 @@
     The C++ language doesn't support variable-length arrays on the stack.
     For example, the following code won't compile:
 
-    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.qdoc 0
+    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.cpp 0
 
     The alternative is to allocate the array on the heap (with
     \c{new}):
 
-    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.qdoc 1
+    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.cpp 1
 
     However, if myfunc() is called very frequently from the
     application's inner loop, heap allocation can be a major source
@@ -53,7 +53,7 @@
     it is much faster than heap allocation.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.qdoc 2
+    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.cpp 2
 
     In the example above, QVarLengthArray will preallocate 1024
     elements on the stack and use them unless \c{n + 1} is greater
@@ -223,7 +223,7 @@
     be used to access and modify the items in the array.
 
     Example:
-    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.qdoc 3
+    \snippet doc/src/snippets/code/doc_src_qvarlengtharray.cpp 3
 
     The pointer remains valid as long as the array isn't reallocated.