Merge branch '4.8-upstream' into master-water

7 files changed, 241 insertions, 147 deletions

diff --git a/src/declarative/qml/qdeclarativecompiledbindings.cpp b/src/declarative/qml/qdeclarativecompiledbindings.cpp
index 313fe58..51ffc10 100644
--- a/src/declarative/qml/qdeclarativecompiledbindings.cpp
+++ b/src/declarative/qml/qdeclarativecompiledbindings.cpp
@@ -143,17 +143,17 @@ struct Register {
     void setNaN() { setqreal(qSNaN()); }
     bool isUndefined() const { return type == 0; }
 
-    void setQObject(QObject *o) { *((QObject **)data) = o; type = QMetaType::QObjectStar; }
-    QObject *getQObject() const { return *((QObject **)data); }
+    void setQObject(QObject *o) { qobjectValue = o; type = QMetaType::QObjectStar; }
+    QObject *getQObject() const { return qobjectValue; }
 
-    void setqreal(qreal v) { *((qreal *)data) = v; type = QMetaType::QReal; }
-    qreal getqreal() const { return *((qreal *)data); }
+    void setqreal(qreal v) { qrealValue = v; type = QMetaType::QReal; }
+    qreal getqreal() const { return qrealValue; }
 
-    void setint(int v) { *((int *)data) = v; type = QMetaType::Int; }
-    int getint() const { return *((int *)data); }
+    void setint(int v) { intValue = v; type = QMetaType::Int; }
+    int getint() const { return intValue; }
 
-    void setbool(bool v) { *((bool *)data) = v; type = QMetaType::Bool; }
-    bool getbool() const { return *((bool *)data); }
+    void setbool(bool v) { boolValue = v; type = QMetaType::Bool; }
+    bool getbool() const { return boolValue; }
 
     QVariant *getvariantptr() { return (QVariant *)typeDataPtr(); }
     QString *getstringptr() { return (QString *)typeDataPtr(); }
@@ -171,7 +171,15 @@ struct Register {
     void settype(int t) { type = t; }
 
     int type;          // Optional type
-    void *data[2];     // Object stored here
+    union {
+        QObject *qobjectValue;
+        qreal qrealValue;
+        int intValue;
+        bool boolValue;
+        char data[sizeof(QVariant)];
+        qint64 q_for_alignment_1;
+        double q_for_alignment_2;
+    };
 
 #ifdef REGISTER_CLEANUP_DEBUG
     Register() {
@@ -2388,7 +2396,7 @@ bool QDeclarativeBindingCompilerPrivate::parseConditional(QDeclarativeJS::AST::N
     skip.skip.reg = -1;
     bytecode << skip;
 
-    // Release to allow reuse of reg
+    // Release to allow reuse of reg in else path
     releaseReg(ok.reg);
     bytecode[skipIdx].skip.count = bytecode.count() - skipIdx - 1;
 
@@ -2398,8 +2406,7 @@ bool QDeclarativeBindingCompilerPrivate::parseConditional(QDeclarativeJS::AST::N
     if (!parseExpression(expression->ko, ko)) return false;
     if (ko.unknownType) return false;
 
-    // Release to allow reuse of reg
-    releaseReg(ko.reg);
+    // Do not release reg here, so that its ownership passes to the caller
     bytecode[skipIdx2].skip.count = bytecode.count() - skipIdx2 - 1;
 
     if (ok != ko)
diff --git a/src/declarative/qml/qdeclarativedata_p.h b/src/declarative/qml/qdeclarativedata_p.h
index 2a5eace..4f22b8f 100644
--- a/src/declarative/qml/qdeclarativedata_p.h
+++ b/src/declarative/qml/qdeclarativedata_p.h
@@ -55,10 +55,10 @@
 
 #include <QtScript/qscriptvalue.h>
 #include <private/qobject_p.h>
-#include "private/qdeclarativeguard_p.h"
 
 QT_BEGIN_NAMESPACE
 
+class QDeclarativeGuardImpl;
 class QDeclarativeCompiledData;
 class QDeclarativeAbstractBinding;
 class QDeclarativeContext;
@@ -134,7 +134,7 @@ public:
     quint32 objectDataRefCount;
     QDeclarativePropertyCache *propertyCache;
 
-    QDeclarativeGuard<QObject> *guards;
+    QDeclarativeGuardImpl *guards;
 
     static QDeclarativeData *get(const QObject *object, bool create = false) {
         QObjectPrivate *priv = QObjectPrivate::get(const_cast<QObject *>(object));
@@ -160,32 +160,6 @@ private:
     mutable QDeclarativeDataExtended *extendedData;
 };
 
-template<class T>
-void QDeclarativeGuard<T>::addGuard()
-{
-    Q_ASSERT(!prev);
-
-    if (QObjectPrivate::get(o)->wasDeleted) 
-        return;
-
-    QDeclarativeData *data = QDeclarativeData::get(o, true);
-    next = data->guards;
-    if (next) reinterpret_cast<QDeclarativeGuard<T> *>(next)->prev = &next;
-    data->guards = reinterpret_cast<QDeclarativeGuard<QObject> *>(this);
-    prev = &data->guards;
-}
-
-template<class T>
-void QDeclarativeGuard<T>::remGuard()
-{
-    Q_ASSERT(prev);
-
-    if (next) reinterpret_cast<QDeclarativeGuard<T> *>(next)->prev = prev;
-    *prev = next;
-    next = 0;
-    prev = 0;
-}
-
 QT_END_NAMESPACE
 
 #endif // QDECLARATIVEDATA_P_H
diff --git a/src/declarative/qml/qdeclarativeengine.cpp b/src/declarative/qml/qdeclarativeengine.cpp
index 8679445..34014f7 100644
--- a/src/declarative/qml/qdeclarativeengine.cpp
+++ b/src/declarative/qml/qdeclarativeengine.cpp
@@ -1154,7 +1154,7 @@ void QDeclarativeData::destroyed(QObject *object)
         context->destroy();
 
     while (guards) {
-        QDeclarativeGuard<QObject> *guard = guards;
+        QDeclarativeGuard<QObject> *guard = static_cast<QDeclarativeGuard<QObject> *>(guards);
         *guard = (QObject *)0;
         guard->objectDestroyed(object);
     }
diff --git a/src/declarative/qml/qdeclarativeguard_p.h b/src/declarative/qml/qdeclarativeguard_p.h
index a085258..4d84951 100644
--- a/src/declarative/qml/qdeclarativeguard_p.h
+++ b/src/declarative/qml/qdeclarativeguard_p.h
@@ -55,16 +55,30 @@
 
 #include <QtCore/qglobal.h>
 #include <QtCore/qvariant.h>
+#include <private/qdeclarativedata_p.h>
 
 QT_BEGIN_NAMESPACE
 
+class QDeclarativeGuardImpl 
+{
+public:
+    inline QDeclarativeGuardImpl();
+    inline QDeclarativeGuardImpl(QObject *);
+    inline QDeclarativeGuardImpl(const QDeclarativeGuardImpl &);
+    inline ~QDeclarativeGuardImpl();
+
+    QObject *o;
+    QDeclarativeGuardImpl  *next;
+    QDeclarativeGuardImpl **prev;
+
+    inline void addGuard();
+    inline void remGuard();
+};
+
 class QObject;
 template<class T>
-class QDeclarativeGuard
+class QDeclarativeGuard : private QDeclarativeGuardImpl
 {
-    QObject *o;
-    QDeclarativeGuard<QObject> *next;
-    QDeclarativeGuard<QObject> **prev;
     friend class QDeclarativeData;
 public:
     inline QDeclarativeGuard();
@@ -74,6 +88,9 @@ public:
 
     inline QDeclarativeGuard<T> &operator=(const QDeclarativeGuard<T> &o);
     inline QDeclarativeGuard<T> &operator=(T *);
+
+    inline T *object() const;
+    inline void setObject(T *g);
     
     inline bool isNull() const
         { return !o; }
@@ -89,69 +106,109 @@ public:
 
 protected:
     virtual void objectDestroyed(T *) {}
-
-private:
-    inline void addGuard();
-    inline void remGuard();
 };
 
-QT_END_NAMESPACE
+QDeclarativeGuardImpl::QDeclarativeGuardImpl()
+: o(0), next(0), prev(0)
+{
+}
 
-Q_DECLARE_METATYPE(QDeclarativeGuard<QObject>)
+QDeclarativeGuardImpl::QDeclarativeGuardImpl(QObject *g)
+: o(g), next(0), prev(0)
+{
+    if (o) addGuard();
+}
 
-#include "private/qdeclarativedata_p.h"
+QDeclarativeGuardImpl::QDeclarativeGuardImpl(const QDeclarativeGuardImpl &g)
+: o(g.o), next(0), prev(0)
+{
+    if (o) addGuard();
+}
 
-QT_BEGIN_NAMESPACE
+QDeclarativeGuardImpl::~QDeclarativeGuardImpl()
+{
+    if (prev) remGuard();
+    o = 0;
+}
+
+void QDeclarativeGuardImpl::addGuard()
+{
+    Q_ASSERT(!prev);
+
+    if (QObjectPrivate::get(o)->wasDeleted) 
+        return;
+
+    QDeclarativeData *data = QDeclarativeData::get(o, true);
+    next = data->guards;
+    if (next) next->prev = &next;
+    data->guards = this;
+    prev = &data->guards;
+}
+
+void QDeclarativeGuardImpl::remGuard()
+{
+    Q_ASSERT(prev);
+
+    if (next) next->prev = prev;
+    *prev = next;
+    next = 0;
+    prev = 0;
+}
 
 template<class T>
 QDeclarativeGuard<T>::QDeclarativeGuard()
-: o(0), next(0), prev(0)
 {
 }
 
 template<class T>
 QDeclarativeGuard<T>::QDeclarativeGuard(T *g)
-: o(g), next(0), prev(0)
+: QDeclarativeGuardImpl(g)
 {
-    if (o) addGuard();
 }
 
 template<class T>
 QDeclarativeGuard<T>::QDeclarativeGuard(const QDeclarativeGuard<T> &g)
-: o(g.o), next(0), prev(0)
+: QDeclarativeGuardImpl(g)
 {
-    if (o) addGuard();
 }
 
 template<class T>
 QDeclarativeGuard<T>::~QDeclarativeGuard()
 {
-    if (prev) remGuard();
-    o = 0;
 }
 
 template<class T>
 QDeclarativeGuard<T> &QDeclarativeGuard<T>::operator=(const QDeclarativeGuard<T> &g)
 {
-    if (g.o != o) {
-        if (prev) remGuard();
-        o = g.o;
-        if (o) addGuard();
-    }
+    setObject(g.object());
     return *this;
 }
 
 template<class T>
 QDeclarativeGuard<T> &QDeclarativeGuard<T>::operator=(T *g)
 {
+    setObject(g);
+    return *this;
+}
+
+template<class T>
+T *QDeclarativeGuard<T>::object() const 
+{ 
+    return static_cast<T *>(o); 
+};
+
+template<class T>
+void QDeclarativeGuard<T>::setObject(T *g) 
+{
     if (g != o) {
         if (prev) remGuard();
         o = g;
         if (o) addGuard();
     }
-    return *this;
 }
 
 QT_END_NAMESPACE
 
+Q_DECLARE_METATYPE(QDeclarativeGuard<QObject>)
+
 #endif // QDECLARATIVEGUARD_P_H
diff --git a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
index 53f702c..f6f593c 100644
--- a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
+++ b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
@@ -680,14 +680,30 @@ private:
 
     inline void cleanup();
 
-    char data[4 * sizeof(void *)];
+    union {
+        float floatValue;
+        double doubleValue;
+        quint32 intValue;
+        bool boolValue;
+        QObject *qobjectPtr;
+
+        char allocData[sizeof(QVariant)];
+    };
+
+    // Pointers to allocData
+    union {
+        QString *qstringPtr;
+        QVariant *qvariantPtr;
+        QList<QObject *> *qlistPtr;
+        QScriptValue *qscriptValuePtr;
+    };
+
     int type;
-    bool isObjectType;
 };
 }
 
 MetaCallArgument::MetaCallArgument()
-: type(QVariant::Invalid), isObjectType(false)
+: type(QVariant::Invalid)
 {
 }
 
@@ -699,22 +715,22 @@ MetaCallArgument::~MetaCallArgument()
 void MetaCallArgument::cleanup()
 {
     if (type == QMetaType::QString) {
-        ((QString *)&data)->~QString();
-    } else if (type == -1 || type == qMetaTypeId<QVariant>()) {
-        ((QVariant *)&data)->~QVariant();
+        qstringPtr->~QString();
+    } else if (type == -1 || type == QMetaType::QVariant) {
+        qvariantPtr->~QVariant();
     } else if (type == qMetaTypeId<QScriptValue>()) {
-        ((QScriptValue *)&data)->~QScriptValue();
+        qscriptValuePtr->~QScriptValue();
     } else if (type == qMetaTypeId<QList<QObject *> >()) {
-        ((QList<QObject *> *)&data)->~QList<QObject *>();
+        qlistPtr->~QList<QObject *>();
     }
 }
 
 void *MetaCallArgument::dataPtr()
 {
     if (type == -1)
-        return ((QVariant *)data)->data();
-    else
-        return (void *)&data;
+        return qvariantPtr->data();
+    else 
+        return (void *)&allocData;
 }
 
 void MetaCallArgument::initAsType(int callType, QDeclarativeEngine *e)
@@ -725,7 +741,7 @@ void MetaCallArgument::initAsType(int callType, QDeclarativeEngine *e)
     QScriptEngine *engine = QDeclarativeEnginePrivate::getScriptEngine(e);
 
     if (callType == qMetaTypeId<QScriptValue>()) {
-        new (&data) QScriptValue(engine->undefinedValue());
+        qscriptValuePtr = new (&allocData) QScriptValue(engine->undefinedValue());
         type = callType;
     } else if (callType == QMetaType::Int ||
                callType == QMetaType::UInt ||
@@ -734,20 +750,20 @@ void MetaCallArgument::initAsType(int callType, QDeclarativeEngine *e)
                callType == QMetaType::Float) {
         type = callType;
     } else if (callType == QMetaType::QObjectStar) {
-        *((QObject **)&data) = 0;
+        qobjectPtr = 0;
         type = callType;
     } else if (callType == QMetaType::QString) {
-        new (&data) QString();
+        qstringPtr = new (&allocData) QString();
         type = callType;
     } else if (callType == qMetaTypeId<QVariant>()) {
         type = callType;
-        new (&data) QVariant();
+        qvariantPtr = new (&allocData) QVariant();
     } else if (callType == qMetaTypeId<QList<QObject *> >()) {
         type = callType;
-        new (&data) QList<QObject *>();
+        qlistPtr = new (&allocData) QList<QObject *>();
     } else {
         type = -1;
-        new (&data) QVariant(callType, (void *)0);
+        qvariantPtr = new (&allocData) QVariant(callType, (void *)0);
     }
 }
 
@@ -756,59 +772,60 @@ void MetaCallArgument::fromScriptValue(int callType, QDeclarativeEngine *engine,
     if (type != 0) { cleanup(); type = 0; }
 
     if (callType == qMetaTypeId<QScriptValue>()) {
-        new (&data) QScriptValue(value);
+        qscriptValuePtr = new (&allocData) QScriptValue(value);
         type = qMetaTypeId<QScriptValue>();
     } else if (callType == QMetaType::Int) {
-        *((int *)&data) = int(value.toInt32());
+        intValue = quint32(value.toInt32());
         type = callType;
     } else if (callType == QMetaType::UInt) {
-        *((uint *)&data) = uint(value.toUInt32());
+        intValue = quint32(value.toUInt32());
         type = callType;
     } else if (callType == QMetaType::Bool) {
-        *((bool *)&data) = value.toBool();
+        boolValue = value.toBool();
         type = callType;
     } else if (callType == QMetaType::Double) {
-        *((double *)&data) = double(value.toNumber());
+        doubleValue = double(value.toNumber());
         type = callType;
     } else if (callType == QMetaType::Float) {
-        *((float *)&data) = float(value.toNumber());
+        floatValue = float(value.toNumber());
         type = callType;
     } else if (callType == QMetaType::QString) {
         if (value.isNull() || value.isUndefined())
-            new (&data) QString();
+            qstringPtr = new (&allocData) QString();
         else
-            new (&data) QString(value.toString());
+            qstringPtr = new (&allocData) QString(value.toString());
         type = callType;
     } else if (callType == QMetaType::QObjectStar) {
-        *((QObject **)&data) = value.toQObject();
+        qobjectPtr = value.toQObject();
         type = callType;
     } else if (callType == qMetaTypeId<QVariant>()) {
-        new (&data) QVariant(QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value));
+        QVariant other = QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value);
+        qvariantPtr = new (&allocData) QVariant(other);
         type = callType;
     } else if (callType == qMetaTypeId<QList<QObject*> >()) {
-        QList<QObject *> *list = new (&data) QList<QObject *>(); 
+        qlistPtr = new (&allocData) QList<QObject *>(); 
         if (value.isArray()) {
             int length = value.property(QLatin1String("length")).toInt32();
             for (int ii = 0; ii < length; ++ii) {
                 QScriptValue arrayItem = value.property(ii);
                 QObject *d = arrayItem.toQObject();
-                list->append(d);
+                qlistPtr->append(d);
             }
         } else if (QObject *d = value.toQObject()) {
-            list->append(d);
+            qlistPtr->append(d);
         }
         type = callType;
     } else {
-        new (&data) QVariant();
+        qvariantPtr = new (&allocData) QVariant();
         type = -1;
 
         QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(engine);
         QVariant v = priv->scriptValueToVariant(value);
         if (v.userType() == callType) {
-            *((QVariant *)&data) = v;
+            *qvariantPtr = v;
         } else if (v.canConvert((QVariant::Type)callType)) {
-            *((QVariant *)&data) = v;
-            ((QVariant *)&data)->convert((QVariant::Type)callType);
+            *qvariantPtr = v;
+            qvariantPtr->convert((QVariant::Type)callType);
         } else if (const QMetaObject *mo = priv->rawMetaObjectForType(callType)) {
             QObject *obj = priv->toQObject(v);
             
@@ -818,9 +835,9 @@ void MetaCallArgument::fromScriptValue(int callType, QDeclarativeEngine *engine,
                 if (!objMo) obj = 0;
             }
 
-            *((QVariant *)&data) = QVariant(callType, &obj);
+            *qvariantPtr = QVariant(callType, &obj);
         } else {
-            *((QVariant *)&data) = QVariant(callType, (void *)0);
+            *qvariantPtr = QVariant(callType, (void *)0);
         }
     }
 }
@@ -830,27 +847,26 @@ QScriptDeclarativeClass::Value MetaCallArgument::toValue(QDeclarativeEngine *e)
     QScriptEngine *engine = QDeclarativeEnginePrivate::getScriptEngine(e);
 
     if (type == qMetaTypeId<QScriptValue>()) {
-        return QScriptDeclarativeClass::Value(engine, *((QScriptValue *)&data));
+        return QScriptDeclarativeClass::Value(engine, *qscriptValuePtr);
     } else if (type == QMetaType::Int) {
-        return QScriptDeclarativeClass::Value(engine, *((int *)&data));
+        return QScriptDeclarativeClass::Value(engine, int(intValue));
     } else if (type == QMetaType::UInt) {
-        return QScriptDeclarativeClass::Value(engine, *((uint *)&data));
+        return QScriptDeclarativeClass::Value(engine, uint(intValue));
     } else if (type == QMetaType::Bool) {
-        return QScriptDeclarativeClass::Value(engine, *((bool *)&data));
+        return QScriptDeclarativeClass::Value(engine, boolValue);
     } else if (type == QMetaType::Double) {
-        return QScriptDeclarativeClass::Value(engine, *((double *)&data));
+        return QScriptDeclarativeClass::Value(engine, doubleValue);
     } else if (type == QMetaType::Float) {
-        return QScriptDeclarativeClass::Value(engine, *((float *)&data));
+        return QScriptDeclarativeClass::Value(engine, floatValue);
     } else if (type == QMetaType::QString) {
-        return QScriptDeclarativeClass::Value(engine, *((QString *)&data));
+        return QScriptDeclarativeClass::Value(engine, *qstringPtr);
     } else if (type == QMetaType::QObjectStar) {
-        QObject *object = *((QObject **)&data);
-        if (object)
-            QDeclarativeData::get(object, true)->setImplicitDestructible();
+        if (qobjectPtr)
+            QDeclarativeData::get(qobjectPtr, true)->setImplicitDestructible();
         QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
-        return QScriptDeclarativeClass::Value(engine, priv->objectClass->newQObject(object));
+        return QScriptDeclarativeClass::Value(engine, priv->objectClass->newQObject(qobjectPtr));
     } else if (type == qMetaTypeId<QList<QObject *> >()) {
-        QList<QObject *> &list = *(QList<QObject *>*)&data;
+        QList<QObject *> &list = *qlistPtr;
         QScriptValue rv = engine->newArray(list.count());
         QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
         for (int ii = 0; ii < list.count(); ++ii) {
@@ -861,7 +877,7 @@ QScriptDeclarativeClass::Value MetaCallArgument::toValue(QDeclarativeEngine *e)
         return QScriptDeclarativeClass::Value(engine, rv);
     } else if (type == -1 || type == qMetaTypeId<QVariant>()) {
         QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(e);
-        QScriptValue rv = ep->scriptValueFromVariant(*((QVariant *)&data));
+        QScriptValue rv = ep->scriptValueFromVariant(*qvariantPtr);
         if (rv.isQObject()) {
             QObject *object = rv.toQObject();
             if (object)
diff --git a/src/declarative/qml/qdeclarativevme.cpp b/src/declarative/qml/qdeclarativevme.cpp
index 06aed98..a23f89d 100644
--- a/src/declarative/qml/qdeclarativevme.cpp
+++ b/src/declarative/qml/qdeclarativevme.cpp
@@ -74,6 +74,27 @@
 
 QT_BEGIN_NAMESPACE
 
+// A simple stack wrapper around QVarLengthArray
+template<typename T>
+class QDeclarativeVMEStack : private QVarLengthArray<T, 128>
+{
+private:
+    typedef QVarLengthArray<T, 128> VLA; 
+    int _index;
+
+public:
+    inline QDeclarativeVMEStack();
+    inline bool isEmpty() const;
+    inline const T &top() const;
+    inline void push(const T &o);
+    inline T pop();
+    inline int count() const;
+    inline const T &at(int index) const;
+};
+
+// We do this so we can forward declare the type in the qdeclarativevme_p.h header
+class QDeclarativeVMEObjectStack : public QDeclarativeVMEStack<QObject *> {};
+
 QDeclarativeVME::QDeclarativeVME()
 {
 }
@@ -99,10 +120,12 @@ struct ListInstance
     QDeclarativeListProperty<void> qListProperty;
 };
 
+Q_DECLARE_TYPEINFO(ListInstance, Q_PRIMITIVE_TYPE  | Q_MOVABLE_TYPE);
+
 QObject *QDeclarativeVME::run(QDeclarativeContextData *ctxt, QDeclarativeCompiledData *comp, 
                               int start, int count, const QBitField &bindingSkipList)
 {
-    QDeclarativeVMEStack<QObject *> stack;
+    QDeclarativeVMEObjectStack stack;
 
     if (start == -1) start = 0;
     if (count == -1) count = comp->bytecode.count();
@@ -121,7 +144,7 @@ void QDeclarativeVME::runDeferred(QObject *object)
     QDeclarativeCompiledData *comp = data->deferredComponent;
     int start = data->deferredIdx + 1;
     int count = data->deferredComponent->bytecode.at(data->deferredIdx).defer.deferCount;
-    QDeclarativeVMEStack<QObject *> stack;
+    QDeclarativeVMEObjectStack stack;
     stack.push(object);
 
     run(stack, ctxt, comp, start, count, QBitField());
@@ -143,7 +166,7 @@ static void removeBindingOnProperty(QObject *o, int index)
 
 #define CLEAN_PROPERTY(o, index) if (fastHasBinding(o, index)) removeBindingOnProperty(o, index)
 
-QObject *QDeclarativeVME::run(QDeclarativeVMEStack<QObject *> &stack, 
+QObject *QDeclarativeVME::run(QDeclarativeVMEObjectStack &stack, 
                               QDeclarativeContextData *ctxt, 
                               QDeclarativeCompiledData *comp, 
                               int start, int count, 
@@ -1054,5 +1077,48 @@ QDeclarativeCompiledData::TypeReference::createInstance(QDeclarativeContextData
     } 
 }
 
+template<typename T>
+QDeclarativeVMEStack<T>::QDeclarativeVMEStack()
+: _index(-1)
+{
+}
+
+template<typename T>
+bool QDeclarativeVMEStack<T>::isEmpty() const {
+    return _index == -1;
+}
+
+template<typename T>
+const T &QDeclarativeVMEStack<T>::top() const {
+    return at(_index);
+}
+
+template<typename T>
+void QDeclarativeVMEStack<T>::push(const T &o) {
+    _index++;
+
+    Q_ASSERT(_index <= VLA::size());
+    if (_index == VLA::size())
+        VLA::append(o);
+    else
+        VLA::data()[_index] = o;
+}
+
+template<typename T>
+T QDeclarativeVMEStack<T>::pop() {
+    Q_ASSERT(_index >= 0);
+    --_index;
+    return VLA::data()[_index + 1];
+}
+
+template<typename T>
+int QDeclarativeVMEStack<T>::count() const {
+    return _index + 1;
+}
+
+template<typename T>
+const T &QDeclarativeVMEStack<T>::at(int index) const {
+    return VLA::data()[index];
+}
 
 QT_END_NAMESPACE
diff --git a/src/declarative/qml/qdeclarativevme_p.h b/src/declarative/qml/qdeclarativevme_p.h
index 6b7b93f..b7f110f 100644
--- a/src/declarative/qml/qdeclarativevme_p.h
+++ b/src/declarative/qml/qdeclarativevme_p.h
@@ -58,6 +58,7 @@
 
 #include <QtCore/QString>
 #include <QtCore/QStack>
+#include <QtCore/QVarLengthArray>
 
 QT_BEGIN_NAMESPACE
 
@@ -67,34 +68,7 @@ class QDeclarativeCompiledData;
 class QDeclarativeCompiledData;
 class QDeclarativeContextData;
 
-template<typename T, int N = 128>
-class QDeclarativeVMEStack {
-public:
-    QDeclarativeVMEStack() : index(-1), maxSize(N), data((T *)fixedData) {}
-    ~QDeclarativeVMEStack() { if (data != (T *)fixedData) qFree(data); }
-
-    bool isEmpty() const { return index == -1; }
-    const T &top() const { return data[index]; }
-    void push(const T &i) { ++index; if (index == maxSize) realloc(); data[index] = i; }
-    const T &pop() { --index; return data[index + 1]; }
-    int count() const { return index + 1; }
-    const T &at(int idx) { return data[idx]; }
-
-private:
-    void realloc() {
-        maxSize += N;
-        if (data != (T *)fixedData) {
-            data = (T*)qRealloc(data, maxSize * sizeof(T));
-        } else {
-            data = (T*)qMalloc(maxSize * sizeof(T));
-        }
-    }
-    int index;
-    int maxSize;
-    T *data;
-    char fixedData[N * sizeof(T)];
-};
-
+class QDeclarativeVMEObjectStack;
 class QDeclarativeVME
 {
 public:
@@ -109,7 +83,7 @@ public:
     QList<QDeclarativeError> errors() const;
 
 private:
-    QObject *run(QDeclarativeVMEStack<QObject *> &, 
+    QObject *run(QDeclarativeVMEObjectStack &, 
                  QDeclarativeContextData *, QDeclarativeCompiledData *, 
                  int start, int count, 
                  const QBitField &);