1 files changed, 43 insertions, 30 deletions

diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index 71e2bd1a06..4022d98c3f 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -69,8 +69,9 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(RegExpObject);
 
-Heap::RegExpObject::RegExpObject()
+void Heap::RegExpObject::init()
 {
+    Object::init();
     Scope scope(internalClass->engine);
     Scoped<QV4::RegExpObject> o(scope, this);
     o->d()->value = QV4::RegExp::create(scope.engine, QString(), false, false);
@@ -78,10 +79,11 @@ Heap::RegExpObject::RegExpObject()
     o->initProperties();
 }
 
-Heap::RegExpObject::RegExpObject(QV4::RegExp *value, bool global)
-    : value(value->d())
-    , global(global)
+void Heap::RegExpObject::init(QV4::RegExp *value, bool global)
 {
+    Object::init();
+    this->global = global;
+    this->value = value->d();
     Scope scope(internalClass->engine);
     Scoped<QV4::RegExpObject> o(scope, this);
     o->initProperties();
@@ -90,8 +92,9 @@ Heap::RegExpObject::RegExpObject(QV4::RegExp *value, bool global)
 // Converts a QRegExp to a JS RegExp.
 // The conversion is not 100% exact since ECMA regexp and QRegExp
 // have different semantics/flags, but we try to do our best.
-Heap::RegExpObject::RegExpObject(const QRegExp &re)
+void Heap::RegExpObject::init(const QRegExp &re)
 {
+    Object::init();
     global = false;
 
     // Convert the pattern to a ECMAScript pattern.
@@ -145,7 +148,7 @@ void RegExpObject::initProperties()
 
     Q_ASSERT(value());
 
-    QString p = value()->pattern;
+    QString p = *value()->pattern;
     if (p.isEmpty()) {
         p = QStringLiteral("(?:)");
     } else {
@@ -180,13 +183,12 @@ Value *RegExpObject::lastIndexProperty()
 QRegExp RegExpObject::toQRegExp() const
 {
     Qt::CaseSensitivity caseSensitivity = value()->ignoreCase ? Qt::CaseInsensitive : Qt::CaseSensitive;
-    return QRegExp(value()->pattern, caseSensitivity, QRegExp::RegExp2);
+    return QRegExp(*value()->pattern, caseSensitivity, QRegExp::RegExp2);
 }
 
 QString RegExpObject::toString() const
 {
-    QString result = QLatin1Char('/') + source();
-    result += QLatin1Char('/');
+    QString result = QLatin1Char('/') + source() + QLatin1Char('/');
     if (global())
         result += QLatin1Char('g');
     if (value()->ignoreCase)
@@ -218,9 +220,9 @@ uint RegExpObject::flags() const
 
 DEFINE_OBJECT_VTABLE(RegExpCtor);
 
-Heap::RegExpCtor::RegExpCtor(QV4::ExecutionContext *scope)
-    : Heap::FunctionObject(scope, QStringLiteral("RegExp"))
+void Heap::RegExpCtor::init(QV4::ExecutionContext *scope)
 {
+    Heap::FunctionObject::init(scope, QStringLiteral("RegExp"));
     clearLastMatch();
 }
 
@@ -232,34 +234,39 @@ void Heap::RegExpCtor::clearLastMatch()
     lastMatchEnd = 0;
 }
 
-ReturnedValue RegExpCtor::construct(const Managed *m, CallData *callData)
+void RegExpCtor::construct(const Managed *, Scope &scope, CallData *callData)
 {
-    Scope scope(static_cast<const Object *>(m)->engine());
-
     ScopedValue r(scope, callData->argument(0));
     ScopedValue f(scope, callData->argument(1));
     Scoped<RegExpObject> re(scope, r);
     if (re) {
-        if (!f->isUndefined())
-            return scope.engine->throwTypeError();
+        if (!f->isUndefined()) {
+            scope.result = scope.engine->throwTypeError();
+            return;
+        }
 
         Scoped<RegExp> regexp(scope, re->value());
-        return Encode(scope.engine->newRegExpObject(regexp, re->global()));
+        scope.result = Encode(scope.engine->newRegExpObject(regexp, re->global()));
+        return;
     }
 
     QString pattern;
     if (!r->isUndefined())
         pattern = r->toQString();
-    if (scope.hasException())
-        return Encode::undefined();
+    if (scope.hasException()) {
+        scope.result = Encode::undefined();
+        return;
+    }
 
     bool global = false;
     bool ignoreCase = false;
     bool multiLine = false;
     if (!f->isUndefined()) {
         f = RuntimeHelpers::toString(scope.engine, f);
-        if (scope.hasException())
-            return Encode::undefined();
+        if (scope.hasException()) {
+            scope.result = Encode::undefined();
+            return;
+        }
         QString str = f->stringValue()->toQString();
         for (int i = 0; i < str.length(); ++i) {
             if (str.at(i) == QLatin1Char('g') && !global) {
@@ -269,26 +276,31 @@ ReturnedValue RegExpCtor::construct(const Managed *m, CallData *callData)
             } else if (str.at(i) == QLatin1Char('m') && !multiLine) {
                 multiLine = true;
             } else {
-                return scope.engine->throwSyntaxError(QStringLiteral("Invalid flags supplied to RegExp constructor"));
+                scope.result = scope.engine->throwSyntaxError(QStringLiteral("Invalid flags supplied to RegExp constructor"));
+                return;
             }
         }
     }
 
     Scoped<RegExp> regexp(scope, RegExp::create(scope.engine, pattern, ignoreCase, multiLine));
-    if (!regexp->isValid())
-        return scope.engine->throwSyntaxError(QStringLiteral("Invalid regular expression"));
+    if (!regexp->isValid()) {
+        scope.result = scope.engine->throwSyntaxError(QStringLiteral("Invalid regular expression"));
+        return;
+    }
 
-    return Encode(scope.engine->newRegExpObject(regexp, global));
+    scope.result = Encode(scope.engine->newRegExpObject(regexp, global));
 }
 
-ReturnedValue RegExpCtor::call(const Managed *that, CallData *callData)
+void RegExpCtor::call(const Managed *that, Scope &scope, CallData *callData)
 {
     if (callData->argc > 0 && callData->args[0].as<RegExpObject>()) {
-        if (callData->argc == 1 || callData->args[1].isUndefined())
-            return callData->args[0].asReturnedValue();
+        if (callData->argc == 1 || callData->args[1].isUndefined()) {
+            scope.result = callData->args[0];
+            return;
+        }
     }
 
-    return construct(that, callData);
+    construct(that, scope, callData);
 }
 
 void RegExpCtor::markObjects(Heap::Base *that, ExecutionEngine *e)
@@ -420,7 +432,8 @@ ReturnedValue RegExpPrototype::method_compile(CallContext *ctx)
     ScopedCallData callData(scope, ctx->argc());
     memcpy(callData->args, ctx->args(), ctx->argc()*sizeof(Value));
 
-    Scoped<RegExpObject> re(scope, ctx->d()->engine->regExpCtor()->as<FunctionObject>()->construct(callData));
+    ctx->d()->engine->regExpCtor()->as<FunctionObject>()->construct(scope, callData);
+    Scoped<RegExpObject> re(scope, scope.result.asReturnedValue());
 
     r->d()->value = re->value();
     r->d()->global = re->global();