Add stubs for all the methods in the v8 API

Qt Qml and Qt Quick now link against V4 :)

Change-Id: I8320875bdeab91d800fbf530b0d57a67dc872188
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

diff --git a/src/v4/qcalculatehash_p.h b/src/v4/qcalculatehash_p.h
index 9eedbfc..36c5a68 100644 (file)
--- a/src/v4/qcalculatehash_p.h
+++ b/src/v4/qcalculatehash_p.h
@@ -55,11 +55,18 @@
 
 #include <QtCore/qglobal.h>
 #include <QtCore/qstring.h>
-
+#include "qv4v8.h"
 QT_BEGIN_NAMESPACE
 
-uint32_t calculateHash(const quint8* chars, int length);
-uint32_t calculateHash(const quint16* chars, int length);
+inline uint32_t calculateHash(const quint8* chars, int length)
+{
+    return v8::String::ComputeHash((char *)chars, length);
+}
+
+inline uint32_t calculateHash(const quint16* chars, int length)
+{
+    return v8::String::ComputeHash((uint16_t *)chars, length);
+}
 
 QT_END_NAMESPACE
 

diff --git a/src/v4/qv4v8.cpp b/src/v4/qv4v8.cpp
index 05c9618..bba1ca6 100644 (file)
--- a/src/v4/qv4v8.cpp
+++ b/src/v4/qv4v8.cpp
@@ -61,6 +61,9 @@ namespace v8 {
 
 #define Q_D(obj) QQmlJS::VM::Value *d = reinterpret_cast<QQmlJS::VM::Value*>(obj)
 
+#define ValuePtr(obj) reinterpret_cast<QQmlJS::VM::Value*>(obj)
+#define ConstValuePtr(obj) reinterpret_cast<const QQmlJS::VM::Value*>(obj)
+
 void gcProtect(void *handle)
 {
     Q_D(handle);
@@ -75,383 +78,1037 @@ void gcUnprotect(void *handle)
         currentEngine()->memoryManager->unprotect(m);
 }
 
-#define ValuePtr(obj) reinterpret_cast<QQmlJS::VM::Value*>(obj)
-#define ConstValuePtr(obj) reinterpret_cast<const QQmlJS::VM::Value*>(obj)
 
-bool Value::IsUndefined() const { return ConstValuePtr(this)->isUndefined(); }
-bool Value::IsNull() const { return ConstValuePtr(this)->isNull(); }
+ScriptOrigin::ScriptOrigin(Handle<Value> resource_name, Handle<Integer> resource_line_offset, Handle<Integer> resource_column_offset)
+{
+    m_fileName = resource_name->ToString()->asQString();
+    m_lineNumber = resource_line_offset->ToInt32()->Value();
+    m_columnNumber = resource_column_offset->ToInt32()->Value();
+}
 
-bool Value::IsTrue() const
+Handle<Value> ScriptOrigin::ResourceName() const
 {
-    return ConstValuePtr(this)->isBoolean() && ConstValuePtr(this)->booleanValue();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::IsFalse() const
+Handle<Integer> ScriptOrigin::ResourceLineOffset() const
 {
-    return !IsTrue();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::IsString() const
+Handle<Integer> ScriptOrigin::ResourceColumnOffset() const
 {
-    return ConstValuePtr(this)->isString();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::IsFunction() const
+
+Local<Script> Script::New(Handle<String> source,
+                         ScriptOrigin* origin,
+                         ScriptData* pre_data,
+                         Handle<String> script_data,
+                         CompileFlags flags)
 {
-    return ConstValuePtr(this)->asFunctionObject();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::IsArray() const
+
+Local<Script> Script::New(Handle<String> source,
+                         Handle<Value> file_name,
+                         CompileFlags flags)
 {
-    return ConstValuePtr(this)->asArrayObject();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::StrictEquals(Handle<Value> that) const
+Local<Script> Script::Compile(Handle<String> source, ScriptOrigin *origin, ScriptData *pre_data, Handle<String> script_data, Script::CompileFlags flags)
 {
-    return __qmljs_strict_equal(*ConstValuePtr(this), *ConstValuePtr(&that));
+    Script *s = new Script;
+    s->m_script = source->ToString()->asQString();
+    if (origin)
+        s->m_origin = *origin;
+    s->m_flags = flags;
+    s->m_context = Context::GetCurrent();
+    return Local<Script>::New(Handle<Script>(s));
 }
 
-VM::Value Value::vmValue() const
+Local<Script> Script::Compile(Handle<String> source,
+                             Handle<Value> file_name,
+                             Handle<String> script_data,
+                             CompileFlags flags)
 {
-    return *ConstValuePtr(this);
+    ScriptOrigin origin(file_name);
+    return Compile(source, &origin, 0, script_data, flags);
 }
 
-Handle<Value> Value::fromVmValue(const VM::Value &vmValue)
+Local<Value> Script::Run()
 {
-    Handle<Value> res;
-    res.val = vmValue.val;
-    return res;
+    Handle<Context> context = m_context;
+    if (!context.IsEmpty())
+        context = Context::GetCurrent();
+    QQmlJS::VM::Function *f = QQmlJS::VM::EvalFunction::parseSource(context->GetEngine()->rootContext, m_origin.m_fileName, m_script, QQmlJS::Codegen::EvalCode,
+                                                                    /*strictMode =*/ false, /*inheritContext =*/ false);
+    if (!f)
+        return Local<Value>();
+
+    QQmlJS::VM::Value result = context->GetEngine()->run(f);
+    return Local<Value>::New(Value::NewFromInternalValue(result.val));
 }
 
-Local<Boolean> Value::ToBoolean() const
+Local<Value> Script::Run(Handle<Object> qml)
 {
-    return Local<Boolean>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromBoolean(ConstValuePtr(this)->toBoolean()).val));
+    Q_UNIMPLEMENTED();
 }
 
-Local<Number> Value::ToNumber() const
+Local<Value> Script::Id()
 {
-    return Local<Number>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromDouble(ConstValuePtr(this)->toNumber(currentEngine()->current)).val));
+    Q_UNIMPLEMENTED();
 }
 
-Local<String> Value::ToString() const
+void Script::SetData(Handle<String> data)
 {
-    return Local<String>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromString(ConstValuePtr(this)->toString(currentEngine()->current)).val));
+    Q_UNIMPLEMENTED();
 }
 
-Local<Integer> Value::ToInteger() const
+
+Local<String> Message::Get() const
 {
-    return Local<Integer>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromDouble(ConstValuePtr(this)->toInteger(currentEngine()->current)).val));
+    Q_UNIMPLEMENTED();
 }
 
-Local<Uint32> Value::ToUint32() const
+Handle<Value> Message::GetScriptResourceName() const
 {
-    return Local<Uint32>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromUInt32(ConstValuePtr(this)->toUInt32(currentEngine()->current)).val));
+    Q_UNIMPLEMENTED();
 }
 
-Local<Int32> Value::ToInt32() const
+int Message::GetLineNumber() const
 {
-    return Local<Int32>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromInt32(ConstValuePtr(this)->toInt32(currentEngine()->current)).val));
+    Q_UNIMPLEMENTED();
 }
 
-Local<Object> Value::ToObject() const
+
+Local<StackFrame> StackTrace::GetFrame(uint32_t index) const
 {
-    return Local<Object>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromObject(ConstValuePtr(this)->toObject(currentEngine()->current)).val));
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::IsObject() const
+int StackTrace::GetFrameCount() const
 {
-    return ConstValuePtr(this)->isObject();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::IsBoolean() const
+Local<Array> StackTrace::AsArray()
 {
-    return ConstValuePtr(this)->isBoolean();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::IsNumber() const
+Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit, StackTrace::StackTraceOptions options)
 {
-    return ConstValuePtr(this)->isNumber();
+    Q_UNIMPLEMENTED();
 }
 
-bool Value::BooleanValue() const
+
+int StackFrame::GetLineNumber() const
 {
-    return ConstValuePtr(this)->toBoolean();
+    Q_UNIMPLEMENTED();
 }
 
-String::CompleteHashData String::CompleteHash() const
+int StackFrame::GetColumn() const
 {
-    CompleteHashData data;
-    data.hash = asVMString()->hashValue();
-    data.length = asQString().length();
-    data.symbol_id = 0; // ###
-    return data;
+    Q_UNIMPLEMENTED();
 }
 
-bool String::Equals(uint16_t *str, int length)
+Local<String> StackFrame::GetScriptName() const
 {
-    return asQString() == QString(reinterpret_cast<QChar*>(str), length);
+    Q_UNIMPLEMENTED();
 }
 
-bool String::Equals(char *str, int length)
+Local<String> StackFrame::GetScriptNameOrSourceURL() const
 {
-    return asQString() == QString::fromLatin1(str, length);
+    Q_UNIMPLEMENTED();
 }
 
-Local<String> String::New(const char *data, int length)
+Local<String> StackFrame::GetFunctionName() const
 {
-    QQmlJS::VM::Value v = QQmlJS::VM::Value::fromString(currentEngine()->current, QString::fromLatin1(data, length));
-    return Local<String>::New(v8::Value::NewFromInternalValue(v.val));
+    Q_UNIMPLEMENTED();
 }
 
-QString String::asQString() const
+
+bool Value::IsUndefined() const
 {
-    return asVMString()->toQString();
+    return ConstValuePtr(this)->isUndefined();
 }
 
-VM::String *String::asVMString() const
+bool Value::IsNull() const {
+    return ConstValuePtr(this)->isNull();
+}
+
+bool Value::IsTrue() const
 {
-    const VM::Value *v = ConstValuePtr(this);
-    ASSERT(v->isString());
-    return v->stringValue();
+    return ConstValuePtr(this)->isBoolean() && ConstValuePtr(this)->booleanValue();
 }
 
-double Number::Value() const
+bool Value::IsFalse() const
 {
-    const VM::Value *v = ConstValuePtr(this);
-    assert(v->isNumber());
-    return v->asDouble();
+    return !IsTrue();
 }
 
-int64_t Integer::Value() const
+bool Value::IsString() const
 {
-    const VM::Value *v = ConstValuePtr(this);
-    assert(v->isNumber());
-    return (int64_t)v->asDouble();
+    return ConstValuePtr(this)->isString();
 }
 
-int32_t Int32::Value() const
+bool Value::IsFunction() const
 {
-    const VM::Value *v = ConstValuePtr(this);
-    assert(v->isInteger());
-    return v->int_32;
+    return ConstValuePtr(this)->asFunctionObject();
 }
 
-uint32_t Uint32::Value() const
+bool Value::IsArray() const
 {
-    const VM::Value *v = ConstValuePtr(this);
-    assert(v->isNumber());
-    return v->toUInt32(currentEngine()->current);
+    return ConstValuePtr(this)->asArrayObject();
 }
 
-struct Context::Private
+bool Value::IsObject() const
 {
-    Private()
-    {
-        engine.reset(new QQmlJS::VM::ExecutionEngine);
-    }
+    return ConstValuePtr(this)->isObject();
+}
 
-    QScopedPointer<QQmlJS::VM::ExecutionEngine> engine;
-};
+bool Value::IsBoolean() const
+{
+    return ConstValuePtr(this)->isBoolean();
+}
 
-Context::Context()
-    : m_lastContext(0)
-    , d(new Private)
+bool Value::IsNumber() const
 {
+    return ConstValuePtr(this)->isNumber();
 }
 
-Context::~Context()
+bool Value::IsExternal() const
 {
-    delete d;
+    Q_UNIMPLEMENTED();
 }
 
-Persistent<Context> Context::New(ExtensionConfiguration *extensions, Handle<ObjectTemplate> global_template, Handle<Value> global_object)
+bool Value::IsInt32() const
 {
-    Context *result = new Context;
-    return Persistent<Context>::New(Handle<Context>(result));
+    return ConstValuePtr(this)->isInteger();
 }
 
-Local<Object> Context::Global()
+bool Value::IsUint32() const
 {
-    return Local<Object>::New(Value::NewFromInternalValue(d->engine->globalObject.val));
+    Q_UNIMPLEMENTED();
 }
 
-void Context::Enter()
+bool Value::IsDate() const
 {
-    Isolate* iso = Isolate::GetCurrent();
-    m_lastContext = iso->m_currentContext;
-    iso->m_currentContext = this;
+    return ConstValuePtr(this)->asDateObject();
 }
 
-void Context::Exit()
+bool Value::IsBooleanObject() const
 {
-    Isolate::GetCurrent()->m_currentContext = m_lastContext;
+    return ConstValuePtr(this)->asBooleanObject();
 }
 
-Local<Context> Context::GetCurrent()
+bool Value::IsNumberObject() const
 {
-    return Context::Adopt(Isolate::GetCurrent()->m_currentContext);
+    return ConstValuePtr(this)->asNumberObject();
 }
 
-QQmlJS::VM::ExecutionEngine *Context::GetEngine()
+bool Value::IsStringObject() const
 {
-    return d->engine.data();
+    return ConstValuePtr(this)->asStringObject();
 }
 
-static QThreadStorage<Isolate*> currentIsolate;
+bool Value::IsRegExp() const
+{
+    return ConstValuePtr(this)->asRegExpObject();
+}
 
-Isolate::Isolate()
-    : m_lastIsolate(0)
+bool Value::IsError() const
 {
+    return ConstValuePtr(this)->asErrorObject();
 }
 
-Isolate::~Isolate()
+Local<Boolean> Value::ToBoolean() const
 {
+    return Local<Boolean>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromBoolean(ConstValuePtr(this)->toBoolean()).val));
 }
 
-void Isolate::Enter()
+Local<Number> Value::ToNumber() const
 {
-    m_lastIsolate = currentIsolate.localData();
-    currentIsolate.localData() = this;
+    return Local<Number>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromDouble(ConstValuePtr(this)->toNumber(currentEngine()->current)).val));
 }
 
-void Isolate::Exit()
+Local<String> Value::ToString() const
 {
-    currentIsolate.localData() = m_lastIsolate;
-    m_lastIsolate = 0;
+    return Local<String>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromString(ConstValuePtr(this)->toString(currentEngine()->current)).val));
 }
 
-Isolate *Isolate::GetCurrent()
+Local<Object> Value::ToObject() const
 {
-    if (!currentIsolate.hasLocalData())
-        currentIsolate.setLocalData(new Isolate);
-    return currentIsolate.localData();
+    return Local<Object>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromObject(ConstValuePtr(this)->toObject(currentEngine()->current)).val));
 }
 
-Local<Value> Object::Get(Handle<Value> key)
+Local<Integer> Value::ToInteger() const
 {
-    Local<Value> result;
-    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
-    if (!o)
-        return result;
-    QQmlJS::VM::ExecutionContext *ctx = currentEngine()->current;
-    QQmlJS::VM::Value prop = o->__get__(ctx, ValuePtr(&key)->toString(ctx));
-    return Local<Value>::New(Value::NewFromInternalValue(prop.val));
+    return Local<Integer>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromDouble(ConstValuePtr(this)->toInteger(currentEngine()->current)).val));
 }
 
-Local<Value> Object::Get(uint32_t key)
+Local<Uint32> Value::ToUint32() const
 {
-    Local<Value> result;
-    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
-    if (!o)
-        return result;
-    QQmlJS::VM::ExecutionContext *ctx = currentEngine()->current;
-    QQmlJS::VM::Value prop = o->__get__(ctx, key);
-    return Local<Value>::New(Value::NewFromInternalValue(prop.val));
+    return Local<Uint32>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromUInt32(ConstValuePtr(this)->toUInt32(currentEngine()->current)).val));
 }
 
-Local<Value> Object::GetPrototype()
+Local<Int32> Value::ToInt32() const
 {
-    Local<Value> result;
-    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
-    if (!o)
-        return result;
-    return Local<Value>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromObject(o->prototype).val));
+    return Local<Int32>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromInt32(ConstValuePtr(this)->toInt32(currentEngine()->current)).val));
 }
 
-bool Object::Has(Handle<String> key)
+Local<Uint32> Value::ToArrayIndex() const
 {
-    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
-    if (!o)
-        return false;
-    return o->__hasProperty__(currentEngine()->current, ValuePtr(&key)->asString());
+    Q_UNIMPLEMENTED();
 }
 
-Local<Value> Function::Call(Handle<Object> thisObj, int argc, Handle<Value> argv[])
+bool Value::BooleanValue() const
 {
-    QQmlJS::VM::FunctionObject *f = ConstValuePtr(this)->asFunctionObject();
-    if (!f)
-        return Local<Value>();
-    QQmlJS::VM::Value result = f->call(currentEngine()->current,
-                                       *ConstValuePtr(&thisObj),
-                                       reinterpret_cast<QQmlJS::VM::Value*>(argv),
-                                       argc);
-    return Local<Value>::New(Value::NewFromInternalValue(result.val));
+    return ConstValuePtr(this)->toBoolean();
 }
 
-struct ExternalResourceWrapper : public QQmlJS::VM::Object::ExternalResource
+double Value::NumberValue() const
 {
-    ExternalResourceWrapper(v8::Object::ExternalResource *wrapped)
-    {
-        this->wrapped = wrapped;
-    }
+    return ConstValuePtr(this)->asDouble();
+}
 
-    virtual ~ExternalResourceWrapper()
-    {
-        wrapped->Dispose();
-    }
+int64_t Value::IntegerValue() const
+{
+    Q_UNIMPLEMENTED();
+}
 
-    v8::Object::ExternalResource *wrapped;
-};
+uint32_t Value::Uint32Value() const
+{
+    Q_UNIMPLEMENTED();
+}
 
-void Object::SetExternalResource(Object::ExternalResource *resource)
+int32_t Value::Int32Value() const
 {
-    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
-    if (!o)
-        return;
-    o->externalResource = new ExternalResourceWrapper(resource);
+    Q_UNIMPLEMENTED();
 }
 
-Object::ExternalResource *Object::GetExternalResource()
+bool Value::Equals(Handle<Value> that) const
 {
-    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
-    if (!o || !o->externalResource)
-        return 0;
-    return static_cast<ExternalResourceWrapper*>(o->externalResource)->wrapped;
+    return __qmljs_equal(*ConstValuePtr(this), *ConstValuePtr(&that), currentEngine()->current);
 }
 
-Local<Script> Script::Compile(Handle<String> source, ScriptOrigin *origin, ScriptData *pre_data, Handle<String> script_data, Script::CompileFlags flags)
+bool Value::StrictEquals(Handle<Value> that) const
 {
-    Script *s = new Script;
-    s->m_script = source->ToString()->asQString();
-    if (origin)
-        s->m_origin = *origin;
-    s->m_flags = flags;
-    s->m_context = Context::GetCurrent();
-    return Local<Script>::New(Handle<Script>(s));
+    return __qmljs_strict_equal(*ConstValuePtr(this), *ConstValuePtr(&that));
+}
+
+VM::Value Value::vmValue() const
+{
+    return *ConstValuePtr(this);
+}
+
+Handle<Value> Value::fromVmValue(const VM::Value &vmValue)
+{
+    Handle<Value> res;
+    res.val = vmValue.val;
+    return res;
+}
+
+
+bool Boolean::Value() const
+{
+    return BooleanValue();
+}
+
+Handle<Boolean> Boolean::New(bool value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+int String::Length() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+uint32_t String::Hash() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+String::CompleteHashData String::CompleteHash() const
+{
+    CompleteHashData data;
+    data.hash = asVMString()->hashValue();
+    data.length = asQString().length();
+    data.symbol_id = 0; // ###
+    return data;
+}
+
+uint32_t String::ComputeHash(uint16_t *string, int length)
+{
+    Q_UNIMPLEMENTED();
+}
+
+uint32_t String::ComputeHash(char *string, int length)
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool String::Equals(uint16_t *str, int length)
+{
+    return asQString() == QString(reinterpret_cast<QChar*>(str), length);
+}
+
+bool String::Equals(char *str, int length)
+{
+    return asQString() == QString::fromLatin1(str, length);
+}
+
+uint16_t String::GetCharacter(int index)
+{
+    return asQString().at(index).unicode();
+}
+
+int String::Write(uint16_t *buffer, int start, int length, int options) const
+{
+    Q_UNIMPLEMENTED();
+}
+
+v8::Local<String> String::Empty()
+{
+    return Local<String>::New(v8::Value::fromVmValue(VM::Value::fromString(currentEngine()->current, QString())));
+}
+
+bool String::IsExternal() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+String::ExternalStringResource *String::GetExternalStringResource() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+String *String::Cast(v8::Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+Local<String> String::New(const char *data, int length)
+{
+    QQmlJS::VM::Value v = QQmlJS::VM::Value::fromString(currentEngine()->current, QString::fromLatin1(data, length));
+    return Local<String>::New(v8::Value::NewFromInternalValue(v.val));
+}
+
+Local<String> String::New(const uint16_t *data, int length)
+{
+    QQmlJS::VM::Value v = QQmlJS::VM::Value::fromString(currentEngine()->current, QString((const QChar *)data, length));
+    return Local<String>::New(v8::Value::NewFromInternalValue(v.val));
+}
+
+Local<String> String::NewSymbol(const char *data, int length)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<String> String::NewExternal(String::ExternalStringResource *resource)
+{
+    Q_UNIMPLEMENTED();
+}
+
+QString String::asQString() const
+{
+    return asVMString()->toQString();
+}
+
+VM::String *String::asVMString() const
+{
+    const VM::Value *v = ConstValuePtr(this);
+    ASSERT(v->isString());
+    return v->stringValue();
+}
+
+String::AsciiValue::AsciiValue(Handle<v8::Value> obj)
+{
+    str = obj->ToString()->asQString().toLatin1();
+}
+
+String::Value::Value(Handle<v8::Value> obj)
+{
+    str = obj->ToString()->asQString();
+}
+
+
+double Number::Value() const
+{
+    const VM::Value *v = ConstValuePtr(this);
+    assert(v->isNumber());
+    return v->asDouble();
+}
+
+Local<Number> Number::New(double value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Number *Number::Cast(v8::Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Integer> Integer::New(int32_t value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Integer> Integer::NewFromUnsigned(uint32_t value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Integer> Integer::New(int32_t value, Isolate *)
+{
+    return New(value);
+}
+
+Local<Integer> Integer::NewFromUnsigned(uint32_t value, Isolate *)
+{
+    return NewFromUnsigned(value);
+}
+
+int64_t Integer::Value() const
+{
+    const VM::Value *v = ConstValuePtr(this);
+    assert(v->isNumber());
+    return (int64_t)v->asDouble();
+}
+
+Integer *Integer::Cast(v8::Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+int32_t Int32::Value() const
+{
+    const VM::Value *v = ConstValuePtr(this);
+    assert(v->isInteger());
+    return v->int_32;
+}
+
+uint32_t Uint32::Value() const
+{
+    const VM::Value *v = ConstValuePtr(this);
+    assert(v->isNumber());
+    return v->toUInt32(currentEngine()->current);
+}
+
+
+struct ExternalResourceWrapper : public QQmlJS::VM::Object::ExternalResource
+{
+    ExternalResourceWrapper(v8::Object::ExternalResource *wrapped)
+    {
+        this->wrapped = wrapped;
+    }
+
+    virtual ~ExternalResourceWrapper()
+    {
+        wrapped->Dispose();
+    }
+
+    v8::Object::ExternalResource *wrapped;
+};
+
+
+bool Object::Set(Handle<Value> key, Handle<Value> value, PropertyAttribute attribs)
+{
+}
+
+bool Object::Set(uint32_t index, Handle<Value> value)
+{
+}
+
+Local<Value> Object::Get(Handle<Value> key)
+{
+    Local<Value> result;
+    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
+    if (!o)
+        return result;
+    QQmlJS::VM::ExecutionContext *ctx = currentEngine()->current;
+    QQmlJS::VM::Value prop = o->__get__(ctx, ValuePtr(&key)->toString(ctx));
+    return Local<Value>::New(Value::NewFromInternalValue(prop.val));
+}
+
+Local<Value> Object::Get(uint32_t key)
+{
+    Local<Value> result;
+    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
+    if (!o)
+        return result;
+    QQmlJS::VM::ExecutionContext *ctx = currentEngine()->current;
+    QQmlJS::VM::Value prop = o->__get__(ctx, key);
+    return Local<Value>::New(Value::NewFromInternalValue(prop.val));
+}
+
+bool Object::Has(Handle<String> key)
+{
+    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
+    if (!o)
+        return false;
+    return o->__hasProperty__(currentEngine()->current, ValuePtr(&key)->asString());
+}
+
+bool Object::Delete(Handle<String> key)
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool Object::Has(uint32_t index)
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool Object::Delete(uint32_t index)
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool Object::SetAccessor(Handle<String> name, AccessorGetter getter, AccessorSetter setter, Handle<Value> data, AccessControl settings, PropertyAttribute attribute)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Array> Object::GetPropertyNames()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Array> Object::GetOwnPropertyNames()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Object::GetPrototype()
+{
+    Local<Value> result;
+    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
+    if (!o)
+        return result;
+    return Local<Value>::New(Value::NewFromInternalValue(QQmlJS::VM::Value::fromObject(o->prototype).val));
+}
+
+bool Object::SetPrototype(Handle<Value> prototype)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<String> Object::GetConstructorName()
+{
+    Q_UNIMPLEMENTED();
+}
+
+int Object::InternalFieldCount()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Object::GetInternalField(int index)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void Object::SetInternalField(int index, Handle<Value> value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void Object::SetExternalResource(Object::ExternalResource *resource)
+{
+    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
+    if (!o)
+        return;
+    o->externalResource = new ExternalResourceWrapper(resource);
+}
+
+Object::ExternalResource *Object::GetExternalResource()
+{
+    QQmlJS::VM::Object *o = ConstValuePtr(this)->asObject();
+    if (!o || !o->externalResource)
+        return 0;
+    return static_cast<ExternalResourceWrapper*>(o->externalResource)->wrapped;
+}
+
+bool Object::HasOwnProperty(Handle<String> key)
+{
+    Q_UNIMPLEMENTED();
+}
+
+int Object::GetIdentityHash()
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool Object::SetHiddenValue(Handle<String> key, Handle<Value> value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Object::GetHiddenValue(Handle<String> key)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> Object::Clone()
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool Object::IsCallable()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Object::CallAsFunction(Handle<Object> recv, int argc, Handle<Value> argv[])
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Object::CallAsConstructor(int argc, Handle<Value> argv[])
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> Object::New()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Object *Object::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+uint32_t Array::Length() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Array> Array::New(int length)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Array *Array::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+Local<Object> Function::NewInstance() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> Function::NewInstance(int argc, Handle<Value> argv[]) const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Function::Call(Handle<Object> thisObj, int argc, Handle<Value> argv[])
+{
+    QQmlJS::VM::FunctionObject *f = ConstValuePtr(this)->asFunctionObject();
+    if (!f)
+        return Local<Value>();
+    QQmlJS::VM::Value result = f->call(currentEngine()->current,
+                                       *ConstValuePtr(&thisObj),
+                                       reinterpret_cast<QQmlJS::VM::Value*>(argv),
+                                       argc);
+    return Local<Value>::New(Value::NewFromInternalValue(result.val));
+}
+
+Handle<Value> Function::GetName() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+ScriptOrigin Function::GetScriptOrigin() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Function *Function::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+Local<Value> Date::New(double time)
+{
+    Q_UNIMPLEMENTED();
+}
+
+double Date::NumberValue() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Date *Date::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void Date::DateTimeConfigurationChangeNotification()
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+Local<Value> NumberObject::New(double value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+double NumberObject::NumberValue() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+NumberObject *NumberObject::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> BooleanObject::New(bool value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool BooleanObject::BooleanValue() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+BooleanObject *BooleanObject::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> StringObject::New(Handle<String> value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<String> StringObject::StringValue() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+StringObject *StringObject::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<RegExp> RegExp::New(Handle<String> pattern, RegExp::Flags flags)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<String> RegExp::GetSource() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+RegExp::Flags RegExp::GetFlags() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+RegExp *RegExp::Cast(Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> External::Wrap(void *data)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void *External::Unwrap(Handle<v8::Value> obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<External> External::New(void *value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+External *External::Cast(v8::Value *obj)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void *External::Value() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+void Template::Set(Handle<String> name, Handle<Data> value, PropertyAttribute attributes)
+{
+    Q_UNIMPLEMENTED();
 }
 
-Local<Value> Script::Run()
+void Template::Set(const char *name, Handle<Data> value)
 {
-    Handle<Context> context = m_context;
-    if (!context.IsEmpty())
-        context = Context::GetCurrent();
-    QQmlJS::VM::Function *f = QQmlJS::VM::EvalFunction::parseSource(context->GetEngine()->rootContext, m_origin.m_fileName, m_script, QQmlJS::Codegen::EvalCode,
-                                                                    /*strictMode =*/ false, /*inheritContext =*/ false);
-    if (!f)
-        return Local<Value>();
+    Q_UNIMPLEMENTED();
+}
 
-    QQmlJS::VM::Value result = context->GetEngine()->run(f);
-    return Local<Value>::New(Value::NewFromInternalValue(result.val));
+
+int Arguments::Length() const
+{
+    Q_UNIMPLEMENTED();
 }
 
-ScriptOrigin::ScriptOrigin(Handle<Value> resource_name, Handle<Integer> resource_line_offset, Handle<Integer> resource_column_offset)
+Local<Value> Arguments::operator [](int i) const
 {
-    m_fileName = resource_name->ToString()->asQString();
-    m_lineNumber = resource_line_offset->ToInt32()->Value();
-    m_columnNumber = resource_column_offset->ToInt32()->Value();
+    Q_UNIMPLEMENTED();
 }
 
-String::AsciiValue::AsciiValue(Handle<v8::Value> obj)
+Local<Function> Arguments::Callee() const
 {
-    str = obj->ToString()->asQString().toLatin1();
+    Q_UNIMPLEMENTED();
 }
 
-String::Value::Value(Handle<v8::Value> obj)
+Local<Object> Arguments::This() const
 {
-    str = obj->ToString()->asQString();
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> Arguments::Holder() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool Arguments::IsConstructCall() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Arguments::Data() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Isolate *Arguments::GetIsolate() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+AccessorInfo::AccessorInfo(internal::Object **args)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Isolate *AccessorInfo::GetIsolate() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> AccessorInfo::Data() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> AccessorInfo::This() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> AccessorInfo::Holder() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+Local<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback, Handle<Value> data)
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Function> FunctionTemplate::GetFunction()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<ObjectTemplate> FunctionTemplate::InstanceTemplate()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate()
+{
+    Q_UNIMPLEMENTED();
 }
 
 
+Local<ObjectTemplate> ObjectTemplate::New()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> ObjectTemplate::NewInstance()
+{
+    Q_UNIMPLEMENTED();
+}
+
+void ObjectTemplate::SetAccessor(Handle<String> name, AccessorGetter getter, AccessorSetter setter, Handle<Value> data, AccessControl settings, PropertyAttribute attribute)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void ObjectTemplate::SetNamedPropertyHandler(NamedPropertyGetter getter, NamedPropertySetter setter, NamedPropertyQuery query, NamedPropertyDeleter deleter, NamedPropertyEnumerator enumerator, Handle<Value> data)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void ObjectTemplate::SetFallbackPropertyHandler(NamedPropertyGetter getter, NamedPropertySetter setter, NamedPropertyQuery query, NamedPropertyDeleter deleter, NamedPropertyEnumerator enumerator, Handle<Value> data)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void ObjectTemplate::SetIndexedPropertyHandler(IndexedPropertyGetter getter, IndexedPropertySetter setter, IndexedPropertyQuery query, IndexedPropertyDeleter deleter, IndexedPropertyEnumerator enumerator, Handle<Value> data)
+{
+    Q_UNIMPLEMENTED();
+}
+
+int ObjectTemplate::InternalFieldCount()
+{
+    Q_UNIMPLEMENTED();
+}
+
+void ObjectTemplate::SetInternalFieldCount(int value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool ObjectTemplate::HasExternalResource()
+{
+    Q_UNIMPLEMENTED();
+}
+
+void ObjectTemplate::SetHasExternalResource(bool value)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void ObjectTemplate::MarkAsUseUserObjectComparison()
+{
+    Q_UNIMPLEMENTED();
+}
 
 
 Handle<Primitive> Undefined()
@@ -482,6 +1139,7 @@ Handle<Boolean> False()
     return val;
 }
 
+
 Handle<Value> ThrowException(Handle<Value> exception)
 {
     __qmljs_throw(currentEngine()->current, exception->vmValue());
@@ -517,4 +1175,209 @@ Local<Value> Exception::Error(Handle<String> message)
     return Local<Value>::New(Value::fromVmValue(VM::Value::fromObject(o)));
 }
 
+
+static QThreadStorage<Isolate*> currentIsolate;
+
+Isolate::Isolate()
+    : m_lastIsolate(0)
+{
+}
+
+Isolate::~Isolate()
+{
+}
+
+Isolate *Isolate::New()
+{
+    Q_UNIMPLEMENTED();
+}
+
+void Isolate::Enter()
+{
+    m_lastIsolate = currentIsolate.localData();
+    currentIsolate.localData() = this;
+}
+
+void Isolate::Exit()
+{
+    currentIsolate.localData() = m_lastIsolate;
+    m_lastIsolate = 0;
+}
+
+void Isolate::Dispose()
+{
+    Q_UNIMPLEMENTED();
+}
+
+void Isolate::SetData(void *data)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void *Isolate::GetData()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Isolate *Isolate::GetCurrent()
+{
+    if (!currentIsolate.hasLocalData())
+        currentIsolate.setLocalData(new Isolate);
+    return currentIsolate.localData();
+}
+
+
+void V8::SetFlagsFromString(const char *str, int length)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void V8::SetUserObjectComparisonCallbackFunction(UserObjectComparisonCallback)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void V8::AddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type_filter)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void V8::RemoveGCPrologueCallback(GCPrologueCallback callback)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void V8::AddImplicitReferences(Persistent<Object> parent, Persistent<Value> *children, size_t length)
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool V8::Initialize()
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool V8::Dispose()
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool V8::IdleNotification(int hint)
+{
+    Q_UNIMPLEMENTED();
+}
+
+void V8::LowMemoryNotification()
+{
+    Q_UNIMPLEMENTED();
+}
+
+TryCatch::TryCatch()
+{
+    Q_UNIMPLEMENTED();
+}
+
+TryCatch::~TryCatch()
+{
+    Q_UNIMPLEMENTED();
+}
+
+bool TryCatch::HasCaught() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Handle<Value> TryCatch::ReThrow()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> TryCatch::Exception() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Message> TryCatch::Message() const
+{
+    Q_UNIMPLEMENTED();
+}
+
+void TryCatch::Reset()
+{
+    Q_UNIMPLEMENTED();
+}
+
+
+
+struct Context::Private
+{
+    Private()
+    {
+        engine.reset(new QQmlJS::VM::ExecutionEngine);
+    }
+
+    QScopedPointer<QQmlJS::VM::ExecutionEngine> engine;
+};
+
+Context::Context()
+    : m_lastContext(0)
+    , d(new Private)
+{
+}
+
+Context::~Context()
+{
+    delete d;
+}
+
+Persistent<Context> Context::New(ExtensionConfiguration *extensions, Handle<ObjectTemplate> global_template, Handle<Value> global_object)
+{
+    Context *result = new Context;
+    return Persistent<Context>::New(Handle<Context>(result));
+}
+
+Local<Object> Context::Global()
+{
+    return Local<Object>::New(Value::NewFromInternalValue(d->engine->globalObject.val));
+}
+
+Local<Context> Context::GetCurrent()
+{
+    return Context::Adopt(Isolate::GetCurrent()->m_currentContext);
+}
+
+Local<Context> Context::GetCalling()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Object> Context::GetCallingQmlGlobal()
+{
+    Q_UNIMPLEMENTED();
+}
+
+Local<Value> Context::GetCallingScriptData()
+{
+    Q_UNIMPLEMENTED();
+}
+
+void Context::Enter()
+{
+    Isolate* iso = Isolate::GetCurrent();
+    m_lastContext = iso->m_currentContext;
+    iso->m_currentContext = this;
+}
+
+void Context::Exit()
+{
+    Isolate::GetCurrent()->m_currentContext = m_lastContext;
+}
+
+
+QQmlJS::VM::ExecutionEngine *Context::GetEngine()
+{
+    return d->engine.data();
+}
+
+
 }

diff --git a/src/v4/qv4v8.h b/src/v4/qv4v8.h
index 4c38c8b..1ee683f 100644 (file)
--- a/src/v4/qv4v8.h
+++ b/src/v4/qv4v8.h
@@ -142,8 +142,8 @@ class HeapObject;
 class Isolate;
 }
 
-void gcProtect(void *handle);
-void gcUnprotect(void *handle);
+void V8EXPORT gcProtect(void *handle);
+void V8EXPORT gcUnprotect(void *handle);
 
 // --- Weak Handles ---
 
@@ -462,7 +462,7 @@ template <class T> class Persistent : public Handle<T> {
    * Creates an empty persistent handle that doesn't point to any
    * storage cell.
    */
-  Persistent();
+  Persistent() {}
 
   /**
    * Creates a persistent handle for the same storage cell as the
@@ -522,7 +522,9 @@ template <class T> class Persistent : public Handle<T> {
        HandleOperations<T>::unProtect(this);
   }
 
-  void Dispose(Isolate* isolate);
+  void Dispose(Isolate*) {
+      Dispose();
+  }
 
   /**
    * Make the reference to this object weak.  When only weak handles
@@ -559,12 +561,7 @@ class V8EXPORT HandleScope {
    * Closes the handle scope and returns the value as a handle in the
    * previous scope, which is the new current scope after the call.
    */
-  template <class T> Local<T> Close(Handle<T> value);
-
-  /**
-   * Counts the number of allocated handles.
-   */
-  static int NumberOfHandles();
+  template <class T> Local<T> Close(Handle<T> value) { return Local<T>::New(value); }
 };
 
 
@@ -581,9 +578,10 @@ class V8EXPORT Data {
 /**
  * The origin, within a file, of a script.
  */
-class ScriptOrigin {
- public:
-    ScriptOrigin() : m_lineNumber(0), m_columnNumber(0) {}
+class V8EXPORT ScriptOrigin {
+public:
+  ScriptOrigin() : m_lineNumber(0), m_columnNumber(0) {}
+
   ScriptOrigin(
       Handle<Value> resource_name,
       Handle<Integer> resource_line_offset = Handle<Integer>(),
@@ -975,14 +973,14 @@ class V8EXPORT Value : public Data {
 /**
  * The superclass of primitive values.  See ECMA-262 4.3.2.
  */
-class Primitive : public Value { };
+class V8EXPORT Primitive : public Value { };
 
 
 /**
  * A primitive boolean value (ECMA-262, 4.3.14).  Either the true
  * or false value.
  */
-class Boolean : public Primitive {
+class V8EXPORT Boolean : public Primitive {
  public:
   V8EXPORT bool Value() const;
   static Handle<Boolean> New(bool value);
@@ -992,7 +990,7 @@ class Boolean : public Primitive {
 /**
  * A JavaScript string value (ECMA-262, 4.3.17).
  */
-class String : public Primitive {
+class V8EXPORT String : public Primitive {
  public:
   /**
    * Returns the number of characters in this string.
@@ -1208,7 +1206,7 @@ class String : public Primitive {
   class V8EXPORT Value {
    public:
     explicit Value(Handle<v8::Value> obj);
-    ~Value();
+    ~Value() {}
     uint16_t* operator*() { return (uint16_t *)str.data(); }
     const uint16_t* operator*() const { return str.utf16(); }
     int length() const { return str.length(); }
@@ -1228,7 +1226,7 @@ class String : public Primitive {
 /**
  * A JavaScript number value (ECMA-262, 4.3.20)
  */
-class Number : public Primitive {
+class V8EXPORT Number : public Primitive {
  public:
   V8EXPORT double Value() const;
   V8EXPORT static Local<Number> New(double value);
@@ -1239,7 +1237,7 @@ class Number : public Primitive {
 /**
  * A JavaScript value representing a signed integer.
  */
-class Integer : public Number {
+class V8EXPORT Integer : public Number {
  public:
   V8EXPORT static Local<Integer> New(int32_t value);
   V8EXPORT static Local<Integer> NewFromUnsigned(uint32_t value);
@@ -1253,7 +1251,7 @@ class Integer : public Number {
 /**
  * A JavaScript value representing a 32-bit signed integer.
  */
-class Int32 : public Integer {
+class V8EXPORT Int32 : public Integer {
  public:
   V8EXPORT int32_t Value() const;
  private:
@@ -1264,7 +1262,7 @@ class Int32 : public Integer {
 /**
  * A JavaScript value representing a 32-bit unsigned integer.
  */
-class Uint32 : public Integer {
+class V8EXPORT Uint32 : public Integer {
  public:
   V8EXPORT uint32_t Value() const;
  private:
@@ -1317,7 +1315,7 @@ enum AccessControl {
 /**
  * A JavaScript object (ECMA-262, 4.3.3)
  */
-class Object : public Value {
+class V8EXPORT Object : public Value {
  public:
   V8EXPORT bool Set(Handle<Value> key,
                     Handle<Value> value,
@@ -1464,7 +1462,7 @@ class Object : public Value {
 /**
  * An instance of the built-in array constructor (ECMA-262, 15.4.2).
  */
-class Array : public Object {
+class V8EXPORT Array : public Object {
  public:
   V8EXPORT uint32_t Length() const;
 
@@ -1481,7 +1479,7 @@ class Array : public Object {
 /**
  * A JavaScript function object (ECMA-262, 15.3).
  */
-class Function : public Object {
+class V8EXPORT Function : public Object {
  public:
   V8EXPORT Local<Object> NewInstance() const;
   V8EXPORT Local<Object> NewInstance(int argc, Handle<Value> argv[]) const;
@@ -1498,7 +1496,7 @@ class Function : public Object {
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
-class Date : public Object {
+class V8EXPORT Date : public Object {
  public:
   V8EXPORT static Local<Value> New(double time);
 
@@ -1530,7 +1528,7 @@ class Date : public Object {
 /**
  * A Number object (ECMA-262, 4.3.21).
  */
-class NumberObject : public Object {
+class V8EXPORT NumberObject : public Object {
  public:
   V8EXPORT static Local<Value> New(double value);
 
@@ -1547,7 +1545,7 @@ class NumberObject : public Object {
 /**
  * A Boolean object (ECMA-262, 4.3.15).
  */
-class BooleanObject : public Object {
+class V8EXPORT BooleanObject : public Object {
  public:
   V8EXPORT static Local<Value> New(bool value);
 
@@ -1564,7 +1562,7 @@ class BooleanObject : public Object {
 /**
  * A String object (ECMA-262, 4.3.18).
  */
-class StringObject : public Object {
+class V8EXPORT StringObject : public Object {
  public:
   V8EXPORT static Local<Value> New(Handle<String> value);
 
@@ -1581,7 +1579,7 @@ class StringObject : public Object {
 /**
  * An instance of the built-in RegExp constructor (ECMA-262, 15.10).
  */
-class RegExp : public Object {
+class V8EXPORT RegExp : public Object {
  public:
   /**
    * Regular expression flag bits. They can be or'ed to enable a set
@@ -1634,7 +1632,7 @@ class RegExp : public Object {
  * value Unwrap should be used, all other operations on that object will lead
  * to unpredictable results.
  */
-class External : public Value {
+class V8EXPORT External : public Value {
  public:
   V8EXPORT static Local<Value> Wrap(void* data);
   static void* Unwrap(Handle<Value> obj);
@@ -1666,7 +1664,7 @@ class V8EXPORT Template : public Data {
  * including the receiver, the number and values of arguments, and
  * the holder of the function.
  */
-class Arguments {
+class V8EXPORT Arguments {
  public:
   int Length() const;
   Local<Value> operator[](int i) const;
@@ -2027,10 +2025,10 @@ Handle<Primitive> V8EXPORT Null();
 Handle<Boolean> V8EXPORT True();
 Handle<Boolean> V8EXPORT False();
 
-Handle<Primitive> Undefined(Isolate*) { return Undefined(); }
-Handle<Primitive> Null(Isolate*) { return Null(); }
-Handle<Boolean> True(Isolate*) { return True(); }
-Handle<Boolean> False(Isolate*) { return False(); }
+inline Handle<Primitive> Undefined(Isolate*) { return Undefined(); }
+inline Handle<Primitive> Null(Isolate*) { return Null(); }
+inline Handle<Boolean> True(Isolate*) { return True(); }
+inline Handle<Boolean> False(Isolate*) { return False(); }
 
 
 
@@ -2448,6 +2446,13 @@ private:
 
 DEFINE_REFCOUNTED_HANDLE_OPERATIONS(Context)
 
+template<typename T>
+void Persistent<T>::MakeWeak(void* parameters, WeakReferenceCallback callback)
+{
+    Q_UNIMPLEMENTED();
+}
+
+
 
 }  // namespace v8