Changed RegExp to be garbage collected instead of reference counted

This makes a cache implementation much easier in the future.

Change-Id: I35ec5c416dc7455ea51dc58f889e2a4ee74d0ee8
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

7 files changed, 103 insertions, 14 deletions

diff --git a/src/v4/qv4engine.cpp b/src/v4/qv4engine.cpp
index 8917251ff9..85ca776f41 100644
--- a/src/v4/qv4engine.cpp
+++ b/src/v4/qv4engine.cpp
@@ -450,7 +450,7 @@ RegExpObject *ExecutionEngine::newRegExpObject(const QString &pattern, int flags
     return newRegExpObject(RegExp::create(this, pattern, ignoreCase, multiline), global);
 }
 
-RegExpObject *ExecutionEngine::newRegExpObject(PassRefPtr<RegExp> re, bool global)
+RegExpObject *ExecutionEngine::newRegExpObject(RegExp* re, bool global)
 {
     RegExpObject *object = new (memoryManager) RegExpObject(this, re, global);
     object->prototype = regExpPrototype;
diff --git a/src/v4/qv4engine.h b/src/v4/qv4engine.h
index e34db18ec2..cb4cf65994 100644
--- a/src/v4/qv4engine.h
+++ b/src/v4/qv4engine.h
@@ -48,7 +48,6 @@
 #include "qv4context.h"
 #include <setjmp.h>
 
-#include <wtf/PassRefPtr.h>
 #include <wtf/BumpPointerAllocator.h>
 
 QT_BEGIN_NAMESPACE
@@ -224,7 +223,7 @@ struct Q_V4_EXPORT ExecutionEngine
     Object *newDateObject(const Value &value);
 
     RegExpObject *newRegExpObject(const QString &pattern, int flags);
-    RegExpObject *newRegExpObject(PassRefPtr<RegExp> re, bool global);
+    RegExpObject *newRegExpObject(RegExp* re, bool global);
 
     Object *newErrorObject(const Value &value);
     Object *newSyntaxErrorObject(ExecutionContext *ctx, DiagnosticMessage *message);
diff --git a/src/v4/qv4managed.h b/src/v4/qv4managed.h
index bca91b4ce4..08f6f5b8f4 100644
--- a/src/v4/qv4managed.h
+++ b/src/v4/qv4managed.h
@@ -71,6 +71,7 @@ struct JSONObject;
 struct ForeachIteratorObject;
 struct Managed;
 struct Value;
+struct RegExp;
 
 struct ManagedVTable
 {
@@ -150,7 +151,8 @@ public:
         Type_ArgumentsObject,
         Type_JSONObject,
         Type_MathObject,
-        Type_ForeachIteratorObject
+        Type_ForeachIteratorObject,
+        Type_RegExp
     };
 
     String *asString() { return reinterpret_cast<String *>(this); }
@@ -166,6 +168,7 @@ public:
     ArgumentsObject *asArgumentsObject() { return type == Type_ArgumentsObject ? reinterpret_cast<ArgumentsObject *>(this) : 0; }
     JSONObject *asJSONObject() { return type == Type_JSONObject ? reinterpret_cast<JSONObject *>(this) : 0; }
     ForeachIteratorObject *asForeachIteratorObject() { return type == Type_ForeachIteratorObject ? reinterpret_cast<ForeachIteratorObject *>(this) : 0; }
+    RegExp *asRegExp() { return type == Type_RegExp ? reinterpret_cast<RegExp *>(this) : 0; }
 
     bool isArrayObject() const { return type == Type_ArrayObject; }
     bool isStringObject() const { return type == Type_StringObject; }
diff --git a/src/v4/qv4regexp.cpp b/src/v4/qv4regexp.cpp
index 8474d598a8..97477110ab 100644
--- a/src/v4/qv4regexp.cpp
+++ b/src/v4/qv4regexp.cpp
@@ -46,6 +46,8 @@
 namespace QQmlJS {
 namespace VM {
 
+DEFINE_MANAGED_VTABLE(RegExp);
+
 uint RegExp::match(const QString &string, int start, uint *matchOffsets)
 {
     if (!isValid())
@@ -54,12 +56,20 @@ uint RegExp::match(const QString &string, int start, uint *matchOffsets)
     return JSC::Yarr::interpret(m_byteCode.get(), WTF::String(string).characters16(), string.length(), start, matchOffsets);
 }
 
+RegExp* RegExp::create(ExecutionEngine* engine, const QString& pattern, bool ignoreCase, bool multiline)
+{
+    return new (engine->memoryManager) RegExp(engine, pattern, ignoreCase, multiline);
+}
+
 RegExp::RegExp(ExecutionEngine* engine, const QString &pattern, bool ignoreCase, bool multiline)
     : m_pattern(pattern)
     , m_subPatternCount(0)
     , m_ignoreCase(ignoreCase)
     , m_multiLine(multiline)
 {
+    vtbl = &static_vtbl;
+    type = Type_RegExpObject;
+
     if (!engine)
         return;
     const char* error = 0;
@@ -70,6 +80,58 @@ RegExp::RegExp(ExecutionEngine* engine, const QString &pattern, bool ignoreCase,
     m_byteCode = JSC::Yarr::byteCompile(yarrPattern, &engine->bumperPointerAllocator);
 }
 
+RegExp::~RegExp()
+{
+    _data = 0;
+}
+
+void RegExp::destroy(Managed *that)
+{
+    static_cast<RegExp*>(that)->~RegExp();
+}
+
+void RegExp::markObjects(Managed *that)
+{
+}
+
+Value RegExp::get(Managed *m, ExecutionContext *ctx, String *name, bool *hasProperty)
+{
+    return Value::undefinedValue();
+}
+
+Value RegExp::getIndexed(Managed *m, ExecutionContext *ctx, uint index, bool *hasProperty)
+{
+    return Value::undefinedValue();
+}
+
+void RegExp::put(Managed *m, ExecutionContext *ctx, String *name, const Value &value)
+{
+}
+
+void RegExp::putIndexed(Managed *m, ExecutionContext *ctx, uint index, const Value &value)
+{
+}
+
+PropertyFlags RegExp::query(Managed *m, ExecutionContext *ctx, String *name)
+{
+    return PropertyFlags(0);
+}
+
+PropertyFlags RegExp::queryIndexed(Managed *m, ExecutionContext *ctx, uint index)
+{
+    return PropertyFlags(0);
+}
+
+bool RegExp::deleteProperty(Managed *m, ExecutionContext *ctx, String *name)
+{
+    return false;
+}
+
+bool RegExp::deleteIndexedProperty(Managed *m, ExecutionContext *ctx, uint index)
+{
+    return false;
+}
+
 } // end of namespace VM
 } // end of namespace QQmlJS
 
diff --git a/src/v4/qv4regexp.h b/src/v4/qv4regexp.h
index f781417366..6ca962e4dc 100644
--- a/src/v4/qv4regexp.h
+++ b/src/v4/qv4regexp.h
@@ -44,7 +44,6 @@
 #include <QString>
 #include <QVector>
 
-#include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
 #include <wtf/FastAllocBase.h>
 #include <wtf/BumpPointerAllocator.h>
@@ -54,6 +53,8 @@
 #include <yarr/Yarr.h>
 #include <yarr/YarrInterpreter.h>
 
+#include "qv4managed.h"
+
 QT_BEGIN_NAMESPACE
 
 namespace QQmlJS {
@@ -61,11 +62,11 @@ namespace VM {
 
 struct ExecutionEngine;
 
-class RegExp : public RefCounted<RegExp>
+class RegExp : public Managed
 {
 public:
-    static PassRefPtr<RegExp> create(ExecutionEngine* engine, const QString& pattern, bool ignoreCase = false, bool multiline = false)
-    { return adoptRef(new RegExp(engine, pattern, ignoreCase, multiline)); }
+    static RegExp* create(ExecutionEngine* engine, const QString& pattern, bool ignoreCase = false, bool multiline = false);
+    ~RegExp();
 
     QString pattern() const { return m_pattern; }
 
@@ -77,6 +78,20 @@ public:
     bool multiLine() const { return m_multiLine; }
     int captureCount() const { return m_subPatternCount + 1; }
 
+protected:
+    static const ManagedVTable static_vtbl;
+    static void destroy(Managed *that);
+    static void markObjects(Managed *that);
+    static Value get(Managed *m, ExecutionContext *ctx, String *name, bool *hasProperty);
+    static Value getIndexed(Managed *m, ExecutionContext *ctx, uint index, bool *hasProperty);
+    static void put(Managed *m, ExecutionContext *ctx, String *name, const Value &value);
+    static void putIndexed(Managed *m, ExecutionContext *ctx, uint index, const Value &value);
+    static PropertyFlags query(Managed *m, ExecutionContext *ctx, String *name);
+    static PropertyFlags queryIndexed(Managed *m, ExecutionContext *ctx, uint index);
+    static bool deleteProperty(Managed *m, ExecutionContext *ctx, String *name);
+    static bool deleteIndexedProperty(Managed *m, ExecutionContext *ctx, uint index);
+
+
 private:
     Q_DISABLE_COPY(RegExp);
     RegExp(ExecutionEngine* engine, const QString& pattern, bool ignoreCase, bool multiline);
diff --git a/src/v4/qv4regexpobject.cpp b/src/v4/qv4regexpobject.cpp
index 926aca664b..19be8d9792 100644
--- a/src/v4/qv4regexpobject.cpp
+++ b/src/v4/qv4regexpobject.cpp
@@ -65,11 +65,12 @@ using namespace QQmlJS::VM;
 
 DEFINE_MANAGED_VTABLE(RegExpObject);
 
-RegExpObject::RegExpObject(ExecutionEngine *engine, PassRefPtr<RegExp> value, bool global)
+RegExpObject::RegExpObject(ExecutionEngine *engine, RegExp* value, bool global)
     : Object(engine)
     , value(value)
     , global(global)
 {
+    vtbl = &static_vtbl;
     type = Type_RegExpObject;
 
     PropertyDescriptor *lastIndexProperty = insertMember(engine->newIdentifier(QStringLiteral("lastIndex")));
@@ -78,7 +79,7 @@ RegExpObject::RegExpObject(ExecutionEngine *engine, PassRefPtr<RegExp> value, bo
     lastIndexProperty->enumerable = PropertyDescriptor::Disabled;
     lastIndexProperty->configurable = PropertyDescriptor::Disabled;
     lastIndexProperty->value = Value::fromInt32(0);
-    if (!this->value.get())
+    if (!this->value)
         return;
     defineReadonlyProperty(engine->newIdentifier(QStringLiteral("source")), Value::fromString(engine->newString(this->value->pattern())));
     defineReadonlyProperty(engine->newIdentifier(QStringLiteral("global")), Value::fromBoolean(global));
@@ -91,6 +92,14 @@ void RegExpObject::destroy(Managed *that)
     static_cast<RegExpObject *>(that)->~RegExpObject();
 }
 
+void RegExpObject::markObjects(Managed *that)
+{
+    RegExpObject *re = static_cast<RegExpObject*>(that);
+    if (re->value)
+        re->value->mark();
+    Object::markObjects(that);
+}
+
 PropertyDescriptor *RegExpObject::lastIndexProperty(ExecutionContext *ctx)
 {
     assert(0 == internalClass->find(ctx->engine->newIdentifier(QStringLiteral("lastIndex"))));
@@ -141,7 +150,7 @@ Value RegExpCtor::construct(Managed *, ExecutionContext *ctx, Value *argv, int a
         }
     }
 
-    RefPtr<RegExp> re = RegExp::create(ctx->engine, r.stringValue()->toQString(), ignoreCase, multiLine);
+    RegExp* re = RegExp::create(ctx->engine, r.stringValue()->toQString(), ignoreCase, multiLine);
     if (!re->isValid())
         ctx->throwSyntaxError(0);
 
diff --git a/src/v4/qv4regexpobject.h b/src/v4/qv4regexpobject.h
index b67aeb7398..d83e686243 100644
--- a/src/v4/qv4regexpobject.h
+++ b/src/v4/qv4regexpobject.h
@@ -65,15 +65,16 @@ namespace QQmlJS {
 namespace VM {
 
 struct RegExpObject: Object {
-    RefPtr<RegExp> value;
+    RegExp* value;
     PropertyDescriptor *lastIndexProperty(ExecutionContext *ctx);
     bool global;
-    RegExpObject(ExecutionEngine *engine, PassRefPtr<RegExp> value, bool global);
+    RegExpObject(ExecutionEngine *engine, RegExp* value, bool global);
     ~RegExpObject() {}
 
 protected:
     static const ManagedVTable static_vtbl;
     static void destroy(Managed *that);
+    static void markObjects(Managed *that);
 };
 
 
@@ -90,7 +91,7 @@ protected:
 
 struct RegExpPrototype: RegExpObject
 {
-    RegExpPrototype(ExecutionEngine* engine): RegExpObject(engine, RegExp::create(0, QString()), false) {}
+    RegExpPrototype(ExecutionEngine* engine): RegExpObject(engine, RegExp::create(engine, QString()), false) {}
     void init(ExecutionContext *ctx, const Value &ctor);
 
     static Value method_exec(ExecutionContext *ctx);