Merge branch '4.6' of git@scm.dev.nokia.troll.no:qt/qt into 4.6

21 files changed, 978 insertions, 176 deletions

diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
index be99b3b..ef4989b 100644
--- a/src/corelib/animation/qabstractanimation.cpp
+++ b/src/corelib/animation/qabstractanimation.cpp
@@ -665,7 +665,7 @@ int QAbstractAnimation::currentLoopTime() const
 
     The animation's current time starts at 0, and ends at totalDuration().
 
-    \sa loopCount, currentLoopTime
+    \sa loopCount, currentLoopTime()
  */
 int QAbstractAnimation::currentTime() const
 {
diff --git a/src/corelib/animation/qpropertyanimation.cpp b/src/corelib/animation/qpropertyanimation.cpp
index 3065083..013ff7f 100644
--- a/src/corelib/animation/qpropertyanimation.cpp
+++ b/src/corelib/animation/qpropertyanimation.cpp
@@ -58,12 +58,12 @@
     an example:
 
     \code
-        QPropertyAnimation animation(myWidget, "geometry");
-        animation.setDuration(10000);
-        animation.setStartValue(QRect(0, 0, 100, 30));
-        animation.setEndValue(QRect(250, 250, 100, 30));
+        QPropertyAnimation *animation = new QPropertyAnimation(myWidget, "geometry");
+        animation->setDuration(10000);
+        animation->setStartValue(QRect(0, 0, 100, 30));
+        animation->setEndValue(QRect(250, 250, 100, 30));
 
-        animation.start();
+        animation->start();
     \endcode
 
     The property name and the QObject instance of which property
diff --git a/src/corelib/animation/qsequentialanimationgroup.cpp b/src/corelib/animation/qsequentialanimationgroup.cpp
index 861e26e..5dbb8c3 100644
--- a/src/corelib/animation/qsequentialanimationgroup.cpp
+++ b/src/corelib/animation/qsequentialanimationgroup.cpp
@@ -63,12 +63,12 @@
     pause to a sequential animation group.
 
     \code
-        QSequentialAnimationGroup group;
+        QSequentialAnimationGroup *group = new QSequentialAnimationGroup;
 
-        group.addAnimation(anim1);
-        group.addAnimation(anim2);
+        group->addAnimation(anim1);
+        group->addAnimation(anim2);
 
-        group.start();
+        group->start();
     \endcode
 
     In this example, \c anim1 and \c anim2 are two already set up
diff --git a/src/corelib/arch/armv6/qatomic_generic_armv6.cpp b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp
new file mode 100644
index 0000000..3078662
--- /dev/null
+++ b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp
@@ -0,0 +1,260 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+** This file implements the generic atomics interface using ARMv6 assembly
+** instructions. It is more efficent than the inline versions when Qt is
+** built for the THUMB instruction set, as the required instructions are
+** only available in ARM state.
+****************************************************************************/
+
+#include <QtCore/qglobal.h>
+
+#ifdef QT_HAVE_ARMV6
+
+QT_BEGIN_NAMESPACE
+
+QT_USE_NAMESPACE
+
+#ifdef Q_CC_RVCT
+#pragma push
+#pragma arm
+Q_CORE_EXPORT asm
+bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+retry_testAndSetOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    EORS     r3,r3,r1       //if (r3 == expectedValue) {
+    STREXEQ  r3,r2,[r0]     //*_q_value = newvalue, r3 = error
+    TEQEQ    r3,#1          //if error
+    BEQ      retry_testAndSetOrdered          //then goto retry }
+    RSBS     r0,r3,#1       //return (r3 == 0)
+    MOVCC    r0,#0
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
+{
+    CODE32
+//R0 = _q_value
+//R1 = newValue
+retry_fetchAndStoreOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    STREX    r2,r1,[r0]     //*_q_value = newValue, r2 = error
+    TEQ      r2,#0          //if error
+    BNE      retry_fetchAndStoreOrdered          //then goto retry
+    MOV      r0,r3          //return r3
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = valueToAdd
+    STMDB    sp!,{r12,lr}
+retry_fetchAndAddOrdered
+    LDREX    r2,[r0]        //r2 = *_q_value
+    ADD      r3,r2,r1       //r3 = r2 + r1
+    STREX    r12,r3,[r0]    //*_q_value = r3, r12 = error
+    TEQ      r12,#0         //if error
+    BNE      retry_fetchAndAddOrdered          //then retry
+    MOV      r0,r2          //return r2
+    LDMIA    sp!,{r12,pc}
+}
+
+Q_CORE_EXPORT asm
+bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+retryPointer_testAndSetOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    EORS     r3,r3,r1       //if (r3 == expectedValue) {
+    STREXEQ  r3,r2,[r0]     //*_q_value = newvalue, r3 = error
+    TEQEQ    r3,#1          //if error
+    BEQ      retryPointer_testAndSetOrdered          //then goto retry }
+    RSBS     r0,r3,#1       //return (r3 == 0)
+    MOVCC    r0,#0
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = newValue
+retryPointer_fetchAndStoreOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    STREX    r2,r1,[r0]     //*_q_value = newValue, r2 = error
+    TEQ      r2,#0          //if error
+    BNE      retryPointer_fetchAndStoreOrdered          //then goto retry
+    MOV      r0,r3          //return r3
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = valueToAdd
+    STMDB    sp!,{r12,lr}
+retryPointer_fetchAndAddOrdered
+    LDREX    r2,[r0]        //r2 = *_q_value
+    ADD      r3,r2,r1       //r3 = r2 + r1
+    STREX    r12,r3,[r0]    //*_q_value = r3, r12 = error
+    TEQ      r12,#0         //if error
+    BNE      retryPointer_fetchAndAddOrdered          //then retry
+    MOV      r0,r2          //return r2
+    LDMIA    sp!,{r12,pc}
+}
+
+#pragma pop
+#elif defined (Q_CC_GCCE)
+Q_CORE_EXPORT __declspec( naked )
+bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
+{
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+    asm("retry_testAndSetOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    EORS     r3,r3,r1");       //if (r3 == expectedValue) {
+    asm("    STREXEQ  r3,r2,[r0]");     //*_q_value = newvalue, r3 = error
+    asm("    TEQEQ    r3,#1");          //if error
+    asm("    BEQ      retry_testAndSetOrdered");          //then goto retry }
+    asm("    RSBS     r0,r3,#1");       //return (r3 == 0)
+    asm("    MOVCC    r0,#0");
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
+{
+//R0 = _q_value
+//R1 = newValue
+    asm("retry_fetchAndStoreOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    STREX    r2,r1,[r0]");     //*_q_value = newValue, r2 = error
+    asm("    TEQ      r2,#0");          //if error
+    asm("    BNE      retry_fetchAndStoreOrdered");          //then goto retry
+    asm("    MOV      r0,r3");          //return r3
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
+{
+    //R0 = _q_value
+    //R1 = valueToAdd
+    asm("    STMDB    sp!,{r12,lr}");
+    asm("retry_fetchAndAddOrdered:");
+    asm("    LDREX    r2,[r0]");        //r2 = *_q_value
+    asm("    ADD      r3,r2,r1 ");      //r3 = r2 + r1
+    asm("    STREX    r12,r3,[r0]");    //*_q_value = r3, r12 = error
+    asm("    TEQ      r12,#0");         //if error
+    asm("    BNE      retry_fetchAndAddOrdered");          //then retry
+    asm("    MOV      r0,r2");          //return r2
+    asm("    LDMIA    sp!,{r12,pc}");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+    asm("retryPointer_testAndSetOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    EORS     r3,r3,r1");       //if (r3 == expectedValue) {
+    asm("    STREXEQ  r3,r2,[r0]");     //*_q_value = newvalue, r3 = error
+    asm("    TEQEQ    r3,#1");          //if error
+    asm("    BEQ      retryPointer_testAndSetOrdered");          //then goto retry }
+    asm("    RSBS     r0,r3,#1");       //return (r3 == 0)
+    asm("    MOVCC    r0,#0");
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
+{
+    //R0 = _q_value
+    //R1 = newValue
+    asm("retryPointer_fetchAndStoreOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    STREX    r2,r1,[r0]");     //*_q_value = newValue, r2 = error
+    asm("    TEQ      r2,#0");          //if error
+    asm("    BNE      retryPointer_fetchAndStoreOrdered");          //then goto retry
+    asm("    MOV      r0,r3");          //return r3
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    //R0 = _q_value
+    //R1 = valueToAdd
+    asm("    STMDB    sp!,{r12,lr}");
+    asm("retryPointer_fetchAndAddOrdered:");
+    asm("    LDREX    r2,[r0]");        //r2 = *_q_value
+    asm("    ADD      r3,r2,r1");       //r3 = r2 + r1
+    asm("    STREX    r12,r3,[r0]");    //*_q_value = r3, r12 = error
+    asm("    TEQ      r12,#0");         //if error
+    asm("    BNE      retryPointer_fetchAndAddOrdered");          //then retry
+    asm("    MOV      r0,r2");          //return r2
+    asm("    LDMIA    sp!,{r12,pc}");
+}
+#else
+#error unknown arm compiler
+#endif
+QT_END_NAMESPACE
+#endif
diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h
index 6862638..1e9f0c4 100644
--- a/src/corelib/arch/qatomic_armv6.h
+++ b/src/corelib/arch/qatomic_armv6.h
@@ -45,7 +45,6 @@
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
-
 #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
 
 inline bool QBasicAtomicInt::isReferenceCountingNative()
@@ -101,6 +100,8 @@ template <typename T>
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
 { return false; }
 
+#ifndef Q_CC_RVCT
+
 inline bool QBasicAtomicInt::ref()
 {
     register int newValue;
@@ -155,21 +156,6 @@ inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
     return result == 0;
 }
 
-inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
 inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
 {
     register int originalValue;
@@ -188,21 +174,6 @@ inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
     return originalValue;
 }
 
-inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
 inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
 {
     register int originalValue;
@@ -224,21 +195,6 @@ inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
     return originalValue;
 }
 
-inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
-{
-    return fetchAndAddOrdered(valueToAdd);
-}
-
-inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
-{
-    return fetchAndAddOrdered(valueToAdd);
-}
-
-inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
-{
-    return fetchAndAddOrdered(valueToAdd);
-}
-
 template <typename T>
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
 {
@@ -259,24 +215,6 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValu
 }
 
 template <typename T>
-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
 {
     register T *originalValue;
@@ -296,24 +234,6 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
 }
 
 template <typename T>
-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
 {
     register T *originalValue;
@@ -335,6 +255,226 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueTo
     return originalValue;
 }
 
+#else
+// This is Q_CC_RVCT
+
+// RVCT inline assembly documentation:
+// http://www.keil.com/support/man/docs/armcc/armcc_chdcffdb.htm
+// RVCT embedded assembly documentation:
+// http://www.keil.com/support/man/docs/armcc/armcc_chddbeib.htm
+
+// save our pragma state and switch to ARM mode
+#pragma push
+#pragma arm
+
+inline bool QBasicAtomicInt::ref()
+{
+    register int newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   newValue, [&_q_value]
+        add     newValue, newValue, #1
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return newValue != 0;
+}
+
+inline bool QBasicAtomicInt::deref()
+{
+    register int newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   newValue, [&_q_value]
+        sub     newValue, newValue, #1
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return newValue != 0;
+}
+
+inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+{
+    register int result;
+    retry:
+    __asm {
+        ldrex   result, [&_q_value]
+        eors    result, result, expectedValue
+        strexeq result, newValue, [&_q_value]
+        teqeq   result, #1
+        beq     retry
+    }
+    return result == 0;
+}
+
+inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+{
+    register int originalValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
+{
+    register int originalValue;
+    register int newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        add     newValue, originalValue, valueToAdd
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+{
+    register T *result;
+    retry:
+    __asm {
+        ldrex   result, [&_q_value]
+        eors    result, result, expectedValue
+        strexeq result, newValue, [&_q_value]
+        teqeq   result, #1
+        beq     retry
+    }
+    return result == 0;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+{
+    register T *originalValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+{
+    register T *originalValue;
+    register T *newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        add     newValue, originalValue, valueToAdd * sizeof(T)
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+// go back to the previous pragma state (probably Thumb mode)
+#pragma pop
+#endif
+
+// common code
+
+inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
 {
diff --git a/src/corelib/arch/qatomic_symbian.h b/src/corelib/arch/qatomic_symbian.h
index 3721aca..92f6ef9 100644
--- a/src/corelib/arch/qatomic_symbian.h
+++ b/src/corelib/arch/qatomic_symbian.h
@@ -42,12 +42,8 @@
 #ifndef QATOMIC_SYMBIAN_H
 #define QATOMIC_SYMBIAN_H
 
-#if defined(Q_CC_RVCT)
-#  define QT_NO_ARM_EABI
-#  include <QtCore/qatomic_arm.h>
-#elif defined(Q_CC_NOKIAX86) || defined(Q_CC_GCCE)
-#  include <QtCore/qatomic_generic.h>
-#endif
+#include <qglobal.h>
+#include <e32std.h>
 
 QT_BEGIN_HEADER
 
@@ -55,7 +51,232 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Core)
 
-// Empty, but needed to avoid warnings
+#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isTestAndSetWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_SOMETIMES_NATIVE
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative();
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetNative()
+{ return QBasicAtomicPointer_isTestAndSetNative(); }
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative();
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
+{ return QBasicAtomicPointer_isFetchAndStoreNative(); }
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative();
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddNative()
+{ return QBasicAtomicPointer_isFetchAndAddNative(); }
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
+{ return false; }
+
+Q_CORE_EXPORT bool QBasicAtomicInt_testAndSetOrdered(volatile int *, int, int);
+Q_CORE_EXPORT int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *, int);
+Q_CORE_EXPORT int QBasicAtomicInt_fetchAndAddOrdered(volatile int *, int);
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *, void *, void *);
+Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *, void *);
+Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *, qptrdiff);
+
+// Reference counting
+
+//LockedInc and LockedDec are machine coded for ARMv6 (and future proof)
+inline bool QBasicAtomicInt::ref()
+{
+    int original = User::LockedInc((TInt&)_q_value);
+    return original != -1;
+}
+
+inline bool QBasicAtomicInt::deref()
+{
+    int original = User::LockedDec((TInt&)_q_value);
+    return original != 1;
+}
+
+// Test and set for integers
+
+inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+{
+    return QBasicAtomicInt_testAndSetOrdered(&_q_value, expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+// Fetch and store for integers
+
+inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+{
+    return QBasicAtomicInt_fetchAndStoreOrdered(&_q_value, newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+// Fetch and add for integers
+
+inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
+{
+    return QBasicAtomicInt_fetchAndAddOrdered(&_q_value, valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+// Test and set for pointers
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+{
+    union { T * volatile * typed; void * volatile * voidp; } pointer;
+    pointer.typed = &_q_value;
+    return QBasicAtomicPointer_testAndSetOrdered(pointer.voidp, expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+// Fetch and store for pointers
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+{
+    union { T * volatile * typed; void * volatile * voidp; } pointer;
+    union { T *typed; void *voidp; } returnValue;
+    pointer.typed = &_q_value;
+    returnValue.voidp = QBasicAtomicPointer_fetchAndStoreOrdered(pointer.voidp, newValue);
+    return returnValue.typed;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+// Fetch and add for pointers
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+{
+    union { T * volatile *typed; void * volatile *voidp; } pointer;
+    union { T *typed; void *voidp; } returnValue;
+    pointer.typed = &_q_value;
+    returnValue.voidp = QBasicAtomicPointer_fetchAndAddOrdered(pointer.voidp, valueToAdd * sizeof(T));
+    return returnValue.typed;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
 
 QT_END_NAMESPACE
 
diff --git a/src/corelib/arch/symbian/arch.pri b/src/corelib/arch/symbian/arch.pri
index deb94b1..3ef1c9e 100644
--- a/src/corelib/arch/symbian/arch.pri
+++ b/src/corelib/arch/symbian/arch.pri
@@ -2,4 +2,4 @@
 # Symbian architecture
 #
 SOURCES +=  $$QT_ARCH_CPP/qatomic_symbian.cpp \
-            $$QT_ARCH_CPP/../generic/qatomic_generic_unix.cpp
+            $$QT_ARCH_CPP/../armv6/qatomic_generic_armv6.cpp
diff --git a/src/corelib/arch/symbian/qatomic_symbian.cpp b/src/corelib/arch/symbian/qatomic_symbian.cpp
index 8f02155..91b49c7 100644
--- a/src/corelib/arch/symbian/qatomic_symbian.cpp
+++ b/src/corelib/arch/symbian/qatomic_symbian.cpp
@@ -50,7 +50,7 @@ QT_BEGIN_NAMESPACE
 // This way we can report on heap cells and handles that are really not owned by anything which still exists.
 // This information can be used to detect whether memory leaks are happening, particularly if these numbers grow as the app is used more.
 // This code is placed here as it happens to make it the very last static to be destroyed in a Qt app. The
-// reason assumed is that this file appears before any other file declaring static data in the generated 
+// reason assumed is that this file appears before any other file declaring static data in the generated
 // Symbian MMP file. This particular file was chosen as it is the earliest symbian specific file.
 struct QSymbianPrintExitInfo
 {
@@ -77,37 +77,158 @@ struct QSymbianPrintExitInfo
     TInt initThreadHandleCount;
 } symbian_printExitInfo;
 
-QT_END_NAMESPACE
+Q_CORE_EXPORT bool QBasicAtomicInt::isReferenceCountingNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
+Q_CORE_EXPORT bool QBasicAtomicInt::isTestAndSetNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-#if defined(Q_CC_RVCT)
+Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndStoreNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-#include "../arm/qatomic_arm.cpp"
+Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndAddNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-QT_BEGIN_NAMESPACE
+Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-Q_CORE_EXPORT __asm char q_atomic_swp(volatile char *ptr, char newval)
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative()
 {
-    add r2, pc, #0
-    bx r2
-    arm
-    swpb r2,r1,[r0]
-    mov r0, r2
-    bx lr
-    thumb
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
 }
 
-Q_CORE_EXPORT __asm int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative()
 {
-    add r2, pc, #0
-    bx r2
-    arm
-    swp r2,r1,[r0]
-    mov r0, r2
-    bx lr
-    thumb
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
 }
 
-QT_END_NAMESPACE
+//For ARMv6, the generic atomics are machine coded
+#ifndef QT_HAVE_ARMV6
+
+class QCriticalSection
+{
+public:
+        QCriticalSection()  { fastlock.CreateLocal(); }
+        ~QCriticalSection() { fastlock.Close(); }
+        void lock()         { fastlock.Wait(); }
+        void unlock()       { fastlock.Signal(); }
 
-#endif // Q_CC_RVCT
+private:
+        RFastLock fastlock;
+};
+
+QCriticalSection qAtomicCriticalSection;
+
+Q_CORE_EXPORT
+bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
+{
+    bool returnValue = false;
+    qAtomicCriticalSection.lock();
+    if (*_q_value == expectedValue) {
+        *_q_value = newValue;
+        returnValue = true;
+    }
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
+{
+    int returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value = newValue;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
+{
+    int returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value += valueToAdd;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    bool returnValue = false;
+        qAtomicCriticalSection.lock();
+    if (*_q_value == expectedValue) {
+        *_q_value = newValue;
+        returnValue = true;
+    }
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
+{
+    void *returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value = newValue;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    void *returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value = reinterpret_cast<char *>(returnValue) + valueToAdd;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+#endif // QT_HAVE_ARMV6
+
+QT_END_NAMESPACE
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index d113e02..9558256 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -437,13 +437,18 @@ namespace QT_NAMESPACE {}
 #elif defined(__GCCE__)
 #  define Q_CC_GCCE
 #  define QT_VISIBILITY_AVAILABLE
+#  if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__)
+#    define QT_HAVE_ARMV6
+#  endif
 
 /* ARM Realview Compiler Suite
    RVCT compiler also defines __EDG__ and __GNUC__ (if --gnu flag is given),
    so check for it before that */
 #elif defined(__ARMCC__) || defined(__CC_ARM)
 #  define Q_CC_RVCT
-
+#  if __TARGET_ARCH_ARM >= 6
+#    define QT_HAVE_ARMV6
+#  endif
 #elif defined(__GNUC__)
 #  define Q_CC_GNU
 #  define Q_C_CALLBACKS
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index ae47f13..7ee7a76 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -884,7 +884,7 @@
 
     \value WA_InputMethodEnabled Enables input methods for Asian languages.
     Must be set when creating custom text editing widgets.
-    On Windows CE this flag can be used in addition to
+    On Windows CE and Symbian this flag can be used in addition to
     QApplication::autoSipEnabled to automatically display the SIP when
     entering a widget.
 
diff --git a/src/corelib/io/qurl.cpp b/src/corelib/io/qurl.cpp
index 86680a5..fd51bcf 100644
--- a/src/corelib/io/qurl.cpp
+++ b/src/corelib/io/qurl.cpp
@@ -6210,8 +6210,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     \list
     \o qt.nokia.com becomes http://qt.nokia.com
     \o ftp.qt.nokia.com becomes ftp://ftp.qt.nokia.com
-    \o localhost becomes http://localhost
-    \o /home/user/test.html becomes file:///home/user/test.html (if exists)
+    \o hostname becomes http://hostname
+    \o /home/user/test.html becomes file:///home/user/test.html
     \endlist
 
     \section2 Tips to avoid erroneous character conversion when dealing with
@@ -6228,31 +6228,32 @@ QUrl QUrl::fromUserInput(const QString &userInput)
 {
     QString trimmedString = userInput.trimmed();
 
-    // Check the most common case of a valid url with scheme and host first
+    // Check first for files, since on Windows drive letters can be interpretted as schemes
+    if (QDir::isAbsolutePath(trimmedString))
+        return QUrl::fromLocalFile(trimmedString);
+
     QUrl url = QUrl::fromEncoded(trimmedString.toUtf8(), QUrl::TolerantMode);
-    if (url.isValid() && !url.scheme().isEmpty() && !url.host().isEmpty())
+    QUrl urlPrepended = QUrl::fromEncoded((QLatin1String("http://") + trimmedString).toUtf8(), QUrl::TolerantMode);
+
+    // Check the most common case of a valid url with scheme and host
+    // We check if the port would be valid by adding the scheme to handle the case host:port
+    // where the host would be interpretted as the scheme
+    if (url.isValid()
+        && !url.scheme().isEmpty()
+        && (!url.host().isEmpty() || !url.path().isEmpty())
+        && urlPrepended.port() == -1)
         return url;
 
-    // Absolute files that exists
-    if (QDir::isAbsolutePath(trimmedString) && QFile::exists(trimmedString))
-        return QUrl::fromLocalFile(trimmedString);
-
-    // If the string is missing the scheme or the scheme is not valid prepend a scheme
-    QString scheme = url.scheme();
-    if (scheme.isEmpty() || scheme.contains(QLatin1Char('.')) || scheme == QLatin1String("localhost")) {
-        // Do not do anything for strings such as "foo", only "foo.com"
+    // Else, try the prepended one and adjust the scheme from the host name
+    if (urlPrepended.isValid() && (!urlPrepended.host().isEmpty() || !urlPrepended.path().isEmpty()))
+    {
         int dotIndex = trimmedString.indexOf(QLatin1Char('.'));
-        if (dotIndex != -1 || trimmedString.startsWith(QLatin1String("localhost"))) {
-            const QString hostscheme = trimmedString.left(dotIndex).toLower();
-            QByteArray scheme = (hostscheme == QLatin1String("ftp")) ? "ftp" : "http";
-            trimmedString = QLatin1String(scheme) + QLatin1String("://") + trimmedString;
-        }
-        url = QUrl::fromEncoded(trimmedString.toUtf8(), QUrl::TolerantMode);
+        const QString hostscheme = trimmedString.left(dotIndex).toLower();
+        if (hostscheme == QLatin1String("ftp"))
+            urlPrepended.setScheme(QLatin1String("ftp"));
+        return urlPrepended;
     }
 
-    if (url.isValid())
-        return url;
-
     return QUrl();
 }
 // end of BSD code
diff --git a/src/corelib/kernel/qabstractitemmodel.cpp b/src/corelib/kernel/qabstractitemmodel.cpp
index 8e2273d..10a61ca 100644
--- a/src/corelib/kernel/qabstractitemmodel.cpp
+++ b/src/corelib/kernel/qabstractitemmodel.cpp
@@ -2475,10 +2475,8 @@ void QAbstractItemModel::endRemoveRows()
 bool QAbstractItemModelPrivate::allowMove(const QModelIndex &srcParent, int start, int end, const QModelIndex &destinationParent, int destinationStart, Qt::Orientation orientation)
 {
     // Don't move the range within itself.
-    if ( ( destinationParent == srcParent )
-            && ( destinationStart >= start )
-            && ( destinationStart <= end + 1) )
-        return false;
+    if (destinationParent == srcParent)
+        return !(destinationStart >= start && destinationStart <= end + 1);
 
     QModelIndex destinationAncestor = destinationParent;
     int pos = (Qt::Vertical == orientation) ? destinationAncestor.row() : destinationAncestor.column();
diff --git a/src/corelib/kernel/qeventdispatcher_win.cpp b/src/corelib/kernel/qeventdispatcher_win.cpp
index 3050b82..b3497b9 100644
--- a/src/corelib/kernel/qeventdispatcher_win.cpp
+++ b/src/corelib/kernel/qeventdispatcher_win.cpp
@@ -725,7 +725,7 @@ bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
                 }
             }
             if (haveMessage) {
-                if (msg.message == WM_QT_SENDPOSTEDEVENTS && !(flags & QEventLoop::EventLoopExec)) {
+                if (msg.message == WM_QT_SENDPOSTEDEVENTS) {
                     if (seenWM_QT_SENDPOSTEDEVENTS) {
                         needWM_QT_SENDPOSTEDEVENTS = true;
                         continue;
@@ -780,6 +780,11 @@ bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
         }
     } while (canWait);
 
+    if (!seenWM_QT_SENDPOSTEDEVENTS && (flags & QEventLoop::EventLoopExec) == 0) {
+        // when called "manually", always send posted events
+        QCoreApplicationPrivate::sendPostedEvents(0, 0, d->threadData);
+    }
+
     if (needWM_QT_SENDPOSTEDEVENTS)
         PostMessage(d->internalHwnd, WM_QT_SENDPOSTEDEVENTS, 0, 0);
 
diff --git a/src/corelib/kernel/qsharedmemory_unix.cpp b/src/corelib/kernel/qsharedmemory_unix.cpp
index 40b9f04..a850df0 100644
--- a/src/corelib/kernel/qsharedmemory_unix.cpp
+++ b/src/corelib/kernel/qsharedmemory_unix.cpp
@@ -49,6 +49,7 @@
 
 #include <errno.h>
 
+#ifndef QT_NO_SHAREDMEMORY
 #include <sys/types.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
@@ -56,6 +57,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
+#endif //QT_NO_SHAREDMEMORY
 
 #include "private/qcore_unix_p.h"
 
diff --git a/src/corelib/tools/qcontiguouscache.cpp b/src/corelib/tools/qcontiguouscache.cpp
index dd7cab6..dab7327 100644
--- a/src/corelib/tools/qcontiguouscache.cpp
+++ b/src/corelib/tools/qcontiguouscache.cpp
@@ -150,20 +150,45 @@ MyRecord record(int row) const
 */
 
 /*! \fn void QContiguousCache::detach()
-
     \internal
 */
 
 /*! \fn bool QContiguousCache::isDetached() const
-
     \internal
 */
 
 /*! \fn void QContiguousCache::setSharable(bool sharable)
-
     \internal
 */
 
+/*! \typedef QContiguousCache::value_type
+  \internal
+ */
+
+/*! \typedef QContiguousCache::pointer
+  \internal
+ */
+
+/*! \typedef QContiguousCache::const_pointer
+  \internal
+ */
+
+/*! \typedef QContiguousCache::reference
+  \internal
+ */
+
+/*! \typedef QContiguousCache::const_reference
+  \internal
+ */
+
+/*! \typedef QContiguousCache::difference_type
+  \internal
+ */
+
+/*! \typedef QContiguousCache::size_type
+  \internal
+ */
+
 /*! \fn QContiguousCache<T> &QContiguousCache::operator=(const QContiguousCache<T> &other)
 
     Assigns \a other to this cache and returns a reference to this cache.
diff --git a/src/corelib/tools/qscopedpointer.cpp b/src/corelib/tools/qscopedpointer.cpp
index a3ca2c3..22e9bdf 100644
--- a/src/corelib/tools/qscopedpointer.cpp
+++ b/src/corelib/tools/qscopedpointer.cpp
@@ -174,18 +174,20 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn bool QScopedPointer::operator==(const QScopedPointer<T, Cleanup> &other) const
+    \fn bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
 
-    Equality operator. Returns true if the scoped pointer \a other
-    is pointing to the same object as this pointer, otherwise returns false.
+    Equality operator. Returns true if the scoped pointers
+    \a lhs and \a rhs are pointing to the same object.
+    Otherwise returns false.
 */
 
 
 /*!
-    \fn bool QScopedPointer::operator!=(const QScopedPointer<T, Cleanup> &other) const
+    \fn bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
 
-    Inequality operator. Returns true if the scoped pointer \a other
-    is not pointing to the same object as this pointer, otherwise returns false.
+    Inequality operator. Returns true if the scoped pointers
+    \a lhs and \a rhs are \e not pointing to the same object.
+    Otherwise returns false.
 */
 
 /*!
diff --git a/src/corelib/tools/qscopedpointer_p.h b/src/corelib/tools/qscopedpointer_p.h
index b1636d5..fb627a4 100644
--- a/src/corelib/tools/qscopedpointer_p.h
+++ b/src/corelib/tools/qscopedpointer_p.h
@@ -76,6 +76,16 @@ public:
         return this->d;
     }
 
+    inline bool operator==(const QCustomScopedPointer<T, Cleanup> &other) const
+    {
+        return this->d == other.d;
+    }
+
+    inline bool operator!=(const QCustomScopedPointer<T, Cleanup> &other) const
+    {
+        return this->d != other.d;
+    }
+
 private:
     Q_DISABLE_COPY(QCustomScopedPointer)
 };
@@ -120,6 +130,16 @@ public:
         QScopedPointerSharedDeleter<T>::cleanup(oldD);
     }
 
+    inline bool operator==(const QScopedSharedPointer<T> &other) const
+    {
+        return this->d == other.d;
+    }
+
+    inline bool operator!=(const QScopedSharedPointer<T> &other) const
+    {
+        return this->d != other.d;
+    }
+
 private:
     Q_DISABLE_COPY(QScopedSharedPointer)
 };
diff --git a/src/corelib/tools/qvector.h b/src/corelib/tools/qvector.h
index 930b006..f0de98d 100644
--- a/src/corelib/tools/qvector.h
+++ b/src/corelib/tools/qvector.h
@@ -69,6 +69,7 @@ struct Q_CORE_EXPORT QVectorData
     // workaround for bug in gcc 3.4.2
     uint sharable;
     uint capacity;
+    uint reserved;
 #else
     uint sharable : 1;
     uint capacity : 1;
diff --git a/src/corelib/xml/make-parser.sh b/src/corelib/xml/make-parser.sh
index 9866555..35289d2 100755
--- a/src/corelib/xml/make-parser.sh
+++ b/src/corelib/xml/make-parser.sh
@@ -42,7 +42,7 @@
 
 me=$(dirname $0)
 mkdir -p $me/out
-(cd $me/out && ../../../../util/qlalr/qlalr --troll --no-debug --no-lines ../qxmlstream.g)
+(cd $me/out && ../../../../util/qlalr/qlalr --qt --no-debug --no-lines ../qxmlstream.g)
 
 for f in $me/out/*.h; do
     n=$(basename $f)
diff --git a/src/corelib/xml/qxmlstream.g b/src/corelib/xml/qxmlstream.g
index 6c0c0cf..22ba33d 100644
--- a/src/corelib/xml/qxmlstream.g
+++ b/src/corelib/xml/qxmlstream.g
@@ -158,6 +158,7 @@ public:
         if (tos + extraCapacity + 1 > cap) {
             cap = qMax(tos + extraCapacity + 1, cap << 1 );
             data = reinterpret_cast<T *>(qRealloc(data, cap * sizeof(T)));
+            Q_CHECK_PTR(data);
         }
     }
 
diff --git a/src/corelib/xml/qxmlstream_p.h b/src/corelib/xml/qxmlstream_p.h
index eee3a13..253f8bd 100644
--- a/src/corelib/xml/qxmlstream_p.h
+++ b/src/corelib/xml/qxmlstream_p.h
@@ -1,4 +1,3 @@
-// This file was generated by qlalr - DO NOT EDIT!
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
@@ -51,6 +50,7 @@
 // We mean it.
 //
 
+// This file was generated by qlalr - DO NOT EDIT!
 #ifndef QXMLSTREAM_P_H
 #define QXMLSTREAM_P_H
 
@@ -132,13 +132,13 @@ public:
   };
 
   static const char  *const    spell [];
-  static const qint16            lhs [];
-  static const qint16            rhs [];
-  static const qint16   goto_default [];
-  static const qint16 action_default [];
-  static const qint16   action_index [];
-  static const qint16    action_info [];
-  static const qint16   action_check [];
+  static const short             lhs [];
+  static const short             rhs [];
+  static const short    goto_default [];
+  static const short  action_default [];
+  static const short    action_index [];
+  static const short     action_info [];
+  static const short    action_check [];
 
   static inline int nt_action (int state, int nt)
   {
@@ -169,7 +169,7 @@ const char *const QXmlStreamReader_Table::spell [] = {
   "EMPTY", "ANY", "PCDATA", 0, 0, 0, 0, "CDATA", "ID", "IDREF", 
   "IDREFS", "ENTITIES", "NMTOKEN", "NMTOKENS", "<?xml", "version", 0};
 
-const qint16 QXmlStreamReader_Table::lhs [] = {
+const short QXmlStreamReader_Table::lhs [] = {
   57, 57, 59, 59, 59, 59, 59, 59, 59, 59, 
   67, 68, 64, 72, 72, 72, 75, 66, 66, 66, 
   66, 79, 78, 80, 80, 80, 80, 80, 80, 81, 
@@ -198,7 +198,7 @@ const qint16 QXmlStreamReader_Table::lhs [] = {
   58, 58, 58, 58, 58, 58, 58, 58, 74, 69, 
   69, 77, 111, 102, 102, 102, 102, 102, 140};
 
-const qint16 QXmlStreamReader_Table:: rhs[] = {
+const short QXmlStreamReader_Table::rhs [] = {
   2, 1, 4, 2, 2, 2, 2, 2, 2, 0, 
   1, 1, 9, 2, 4, 0, 4, 4, 6, 6, 
   4, 1, 3, 1, 1, 1, 2, 2, 2, 1, 
@@ -227,7 +227,7 @@ const qint16 QXmlStreamReader_Table:: rhs[] = {
   2, 2, 2, 2, 2, 2, 2, 0, 1, 0, 
   1, 1, 1, 1, 1, 1, 1, 1, 2};
 
-const qint16 QXmlStreamReader_Table::action_default [] = {
+const short QXmlStreamReader_Table::action_default [] = {
   10, 258, 0, 2, 1, 0, 124, 116, 118, 119, 
   126, 128, 122, 11, 113, 107, 0, 108, 127, 110, 
   114, 112, 120, 123, 125, 106, 109, 111, 117, 115, 
@@ -272,7 +272,7 @@ const qint16 QXmlStreamReader_Table::action_default [] = {
   260, 0, 230, 0, 0, 13, 269, 9, 5, 8, 
   4, 0, 7, 258, 6, 0, 3};
 
-const qint16 QXmlStreamReader_Table::goto_default [] = {
+const short QXmlStreamReader_Table::goto_default [] = {
   2, 4, 3, 49, 388, 43, 37, 52, 47, 41, 
   249, 53, 127, 84, 393, 81, 85, 126, 42, 46, 
   169, 130, 131, 146, 145, 149, 138, 136, 140, 147, 
@@ -283,7 +283,7 @@ const qint16 QXmlStreamReader_Table::goto_default [] = {
   264, 252, 251, 250, 339, 326, 325, 329, 398, 399, 
   50, 51, 59, 0};
 
-const qint16 QXmlStreamReader_Table::action_index [] = {
+const short QXmlStreamReader_Table::action_index [] = {
   -21, -57, 33, 119, 960, 70, -57, -57, -57, -57, 
   -57, -57, -57, -57, -57, -57, 105, -57, -57, -57, 
   -57, -57, -57, -57, -57, -57, -57, -57, -57, -57, 
@@ -372,7 +372,7 @@ const qint16 QXmlStreamReader_Table::action_index [] = {
   28, 15, 82, -84, -84, -84, -84, -84, -84, -84, 
   -84, -84, -84, 3, -84, 98, -84};
 
-const qint16 QXmlStreamReader_Table::action_info [] = {
+const short QXmlStreamReader_Table::action_info [] = {
   65, 332, 65, 405, 392, 385, 377, 65, 414, 410, 
   415, 55, 397, 374, 373, 217, 206, 408, 65, 65, 
   207, 211, 216, 1, 55, 199, 182, 192, 70, 70, 
@@ -506,7 +506,7 @@ const qint16 QXmlStreamReader_Table::action_info [] = {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
   0, 0, 0, 0, 0, 0, 0, 0};
 
-const qint16 QXmlStreamReader_Table::action_check [] = {
+const short QXmlStreamReader_Table::action_check [] = {
   26, 18, 26, 14, 4, 4, 4, 26, 24, 14, 
   4, 26, 4, 4, 4, 4, 22, 55, 26, 26, 
   42, 4, 4, 44, 26, 22, 19, 12, 2, 2,