#define ValuePtr(obj) reinterpret_cast<QQmlJS::VM::Value*>(obj)
#define ConstValuePtr(obj) reinterpret_cast<const QQmlJS::VM::Value*>(obj)
-void gcProtect(void *handle)
+void *gcProtect(void *handle)
{
Q_D(handle);
- if (VM::Managed *m = d->asManaged())
+ if (VM::Managed *m = d->asManaged()) {
currentEngine()->memoryManager->protect(m);
+ return currentEngine()->memoryManager;
+ }
+}
+
+void gcProtect(void *memoryManager, void *handle)
+{
+ Q_D(handle);
+ if (VM::Managed *m = d->asManaged())
+ if (memoryManager)
+ static_cast<VM::MemoryManager *>(memoryManager)->protect(m);
}
-void gcUnprotect(void *handle)
+void gcUnprotect(void *memoryManager, void *handle)
{
Q_D(handle);
if (VM::Managed *m = d->asManaged())
- currentEngine()->memoryManager->unprotect(m);
+ if (memoryManager)
+ static_cast<VM::MemoryManager *>(memoryManager)->unprotect(m);
}
struct V8AccessorGetter: FunctionObject {
s->m_script = source->ToString()->asQString();
if (origin)
s->m_origin = *origin;
+ qDebug() << "script" << s << (flags & QmlMode) << source->asQString();
s->m_flags = flags;
s->m_context = Handle<Context>();
return Local<Script>::New(Handle<Script>(s));
s->m_script = source->ToString()->asQString();
if (origin)
s->m_origin = *origin;
+ qDebug() << "script" << s << (flags & QmlMode) << source->asQString();
s->m_flags = flags;
s->m_context = Context::GetCurrent();
return Local<Script>::New(Handle<Script>(s));
Local<Value> Script::Run()
{
+ qDebug() << "run" << this;
Handle<Context> context = m_context;
if (context.IsEmpty())
context = Context::GetCurrent();
Local<Value> Script::Run(Handle<Object> qml)
{
+ qDebug() << "runQml" << this;
Handle<Context> context = m_context;
if (context.IsEmpty())
context = Context::GetCurrent();
class Isolate;
class TryCatch;
-void V8EXPORT gcProtect(void *handle);
-void V8EXPORT gcUnprotect(void *handle);
+V8EXPORT void *gcProtect(void *handle);
+V8EXPORT void gcProtect(void *memoryManager, void *handle);
+V8EXPORT void gcUnprotect(void *memoryManager, void *handle);
// --- Weak Handles ---
{
}
- static void protect(Handle<T> *handle)
+ static void *protect(Handle<T> *handle)
{
- gcProtect(handle);
+ return gcProtect(handle);
}
- static void unProtect(Handle<T> *handle)
+ static void protect(void *memoryManager, Handle<T> *handle)
{
- gcUnprotect(handle);
+ gcProtect(memoryManager, handle);
+ }
+
+ static void unProtect(void *memoryManager, Handle<T> *handle)
+ {
+ gcUnprotect(memoryManager, handle);
}
static bool isEmpty(const Handle<T> *handle)
handle->object = 0; \
} \
} \
- static void protect(Handle<Type> *) {} \
- static void unProtect(Handle<Type> *) {} \
+ static void *protect(Handle<Type> *) { return 0; } \
+ static void protect(void *, Handle<Type> *) {} \
+ static void unProtect(void *, Handle<Type> *) {} \
static bool isEmpty(const Handle<Type> *handle) \
{ \
return handle->object == 0; \
*/
Persistent() {}
~Persistent() {
- HandleOperations<T>::unProtect(this);
+ HandleOperations<T>::unProtect(m_memoryManager, this);
+ }
+
+ Persistent(const Persistent &other)
+ : Handle<T>(other)
+ , m_memoryManager(other.m_memoryManager)
+ {
+ HandleOperations<T>::protect(m_memoryManager, this);
+ }
+
+ Persistent &operator =(const Persistent &other)
+ {
+ if (&other == this)
+ return *this;
+ HandleOperations<T>::unProtect(m_memoryManager, this);
+ Handle<T>::operator =(other);
+ m_memoryManager = other.m_memoryManager;
+ HandleOperations<T>::protect(m_memoryManager, this);
}
/**
*/
template <class S> Persistent(Persistent<S> that)
: Handle<T>(Handle<T>::Cast(that)) {
- HandleOperations<T>::protect(this);
+ m_memoryManager = that.m_memoryManager;
+ HandleOperations<T>::protect(m_memoryManager, this);
}
template <class S> Persistent(S* that) : Handle<T>(that)
{
- HandleOperations<T>::protect(this);
+ m_memoryManager = HandleOperations<T>::protect(this);
}
/**
template <class S> explicit Persistent(Handle<S> that)
: Handle<T>(*that)
{
- HandleOperations<T>::protect(this);
+ m_memoryManager = HandleOperations<T>::protect(this);
}
template <class S> static Persistent<T> Cast(Persistent<S> that) {
{
Persistent<T> result;
result.Handle<T>::operator =(that);
- HandleOperations<T>::protect(&result);
+ result.m_memoryManager = HandleOperations<T>::protect(&result);
return result;
}
* cell remain and IsEmpty will still return false.
*/
void Dispose() {
- HandleOperations<T>::unProtect(this);
+ HandleOperations<T>::unProtect(m_memoryManager, this);
+ m_memoryManager = 0;
HandleOperations<T>::deref(this);
HandleOperations<T>::init(this);
}
* it the object reference and the given parameters.
*/
void MakeWeak(void* parameters, WeakReferenceCallback callback);
+public:
+ void *m_memoryManager;
};