Revision: 18068
Author: [email protected]
Date: Tue Nov 26 09:45:17 2013 UTC
Log: Add Isolate* parameter to static API methods that don't take one.
We cannot yet deprecate the versions that don't take one, because
there's too much test code in v8 using them. To keep this CL small and
managable, I'll first introduce the new APIs.
BUG=none
[email protected], [email protected]
LOG=n
Review URL: https://codereview.chromium.org/84833006
http://code.google.com/p/v8/source/detail?r=18068
Modified:
/branches/bleeding_edge/include/v8.h
/branches/bleeding_edge/src/api.cc
/branches/bleeding_edge/src/full-codegen.cc
=======================================
--- /branches/bleeding_edge/include/v8.h Mon Nov 25 14:30:59 2013 UTC
+++ /branches/bleeding_edge/include/v8.h Tue Nov 26 09:45:17 2013 UTC
@@ -1137,6 +1137,8 @@
bool IsSharedCrossOrigin() const;
// TODO(1245381): Print to a string instead of on a FILE.
+ static void PrintCurrentStackTrace(Isolate* isolate, FILE* out);
+ // Will be deprecated soon.
static void PrintCurrentStackTrace(FILE* out);
static const int kNoLineNumberInfo = 0;
@@ -1192,8 +1194,13 @@
* StackFrame.
*/
static Local<StackTrace> CurrentStackTrace(
+ Isolate* isolate,
int frame_limit,
StackTraceOptions options = kOverview);
+ // Will be deprecated soon.
+ static Local<StackTrace> CurrentStackTrace(
+ int frame_limit,
+ StackTraceOptions options = kOverview);
};
@@ -1794,6 +1801,9 @@
* should the underlying buffer be deallocated or modified except
through the
* destructor of the external string resource.
*/
+ static Local<String> NewExternal(Isolate* isolate,
+ ExternalStringResource* resource);
+ // Will be deprecated soon.
static Local<String> NewExternal(ExternalStringResource* resource);
/**
@@ -1815,6 +1825,9 @@
* should the underlying buffer be deallocated or modified except
through the
* destructor of the external string resource.
*/
+ static Local<String> NewExternal(Isolate* isolate,
+ ExternalAsciiStringResource* resource);
+ // Will be deprecated soon.
static Local<String> NewExternal(ExternalAsciiStringResource* resource);
/**
@@ -1968,8 +1981,9 @@
class V8_EXPORT Number : public Primitive {
public:
double Value() const;
+ static Local<Number> New(Isolate* isolate, double value);
+ // Will be deprecated soon.
static Local<Number> New(double value);
- static Local<Number> New(Isolate* isolate, double value);
V8_INLINE static Number* Cast(v8::Value* obj);
private:
Number();
@@ -1982,10 +1996,13 @@
*/
class V8_EXPORT Integer : public Number {
public:
- static Local<Integer> New(int32_t value);
- static Local<Integer> NewFromUnsigned(uint32_t value);
+ static Local<Integer> New(Isolate* isolate, int32_t value);
+ static Local<Integer> NewFromUnsigned(Isolate* isolate, uint32_t value);
+ // Will be deprecated soon.
static Local<Integer> New(int32_t value, Isolate*);
static Local<Integer> NewFromUnsigned(uint32_t value, Isolate*);
+ static Local<Integer> New(int32_t value);
+ static Local<Integer> NewFromUnsigned(uint32_t value);
int64_t Value() const;
V8_INLINE static Integer* Cast(v8::Value* obj);
private:
@@ -2338,6 +2355,8 @@
*/
Local<Value> CallAsConstructor(int argc, Handle<Value> argv[]);
+ static Local<Object> New(Isolate* isolate);
+ // Will be deprecated soon.
static Local<Object> New();
V8_INLINE static Object* Cast(Value* obj);
@@ -2366,6 +2385,8 @@
* Creates a JavaScript array with the given length. If the length
* is negative the returned array will have length 0.
*/
+ static Local<Array> New(Isolate* isolate, int length = 0);
+ // Will be deprecated soon.
static Local<Array> New(int length = 0);
V8_INLINE static Array* Cast(Value* obj);
@@ -2629,6 +2650,8 @@
* will be deallocated when it is garbage-collected,
* unless the object is externalized.
*/
+ static Local<ArrayBuffer> New(Isolate* isolate, size_t byte_length);
+ // Will be deprecated soon.
static Local<ArrayBuffer> New(size_t byte_length);
/**
@@ -2637,6 +2660,9 @@
* The memory block will not be reclaimed when a created ArrayBuffer
* is garbage-collected.
*/
+ static Local<ArrayBuffer> New(Isolate* isolate, void* data,
+ size_t byte_length);
+ // Will be deprecated soon.
static Local<ArrayBuffer> New(void* data, size_t byte_length);
/**
@@ -2897,6 +2923,8 @@
*/
class V8_EXPORT Date : public Object {
public:
+ static Local<Value> New(Isolate* isolate, double time);
+ // Will be deprecated soon.
static Local<Value> New(double time);
V8_DEPRECATED(
@@ -2923,6 +2951,8 @@
* This API should not be called more than needed as it will
* negatively impact the performance of date operations.
*/
+ static void DateTimeConfigurationChangeNotification(Isolate* isolate);
+ // Will be deprecated soon.
static void DateTimeConfigurationChangeNotification();
private:
@@ -2935,6 +2965,8 @@
*/
class V8_EXPORT NumberObject : public Object {
public:
+ static Local<Value> New(Isolate* isolate, double value);
+ // Will be deprecated soon.
static Local<Value> New(double value);
V8_DEPRECATED(
@@ -3381,10 +3413,17 @@
public:
/** Creates a function template.*/
static Local<FunctionTemplate> New(
+ Isolate* isolate,
FunctionCallback callback = 0,
Handle<Value> data = Handle<Value>(),
Handle<Signature> signature = Handle<Signature>(),
int length = 0);
+ // Will be deprecated soon.
+ static Local<FunctionTemplate> New(
+ FunctionCallback callback = 0,
+ Handle<Value> data = Handle<Value>(),
+ Handle<Signature> signature = Handle<Signature>(),
+ int length = 0);
/** Returns the unique function instance in the current execution
context.*/
Local<Function> GetFunction();
@@ -3467,6 +3506,8 @@
class V8_EXPORT ObjectTemplate : public Template {
public:
/** Creates an ObjectTemplate. */
+ static Local<ObjectTemplate> New(Isolate* isolate);
+ // Will be deprecated soon.
static Local<ObjectTemplate> New();
/** Creates a new instance of this template.*/
@@ -3608,7 +3649,8 @@
private:
ObjectTemplate();
- static Local<ObjectTemplate> New(Handle<FunctionTemplate> constructor);
+ static Local<ObjectTemplate> New(internal::Isolate* isolate,
+ Handle<FunctionTemplate> constructor);
friend class FunctionTemplate;
};
@@ -3619,6 +3661,12 @@
*/
class V8_EXPORT Signature : public Data {
public:
+ static Local<Signature> New(Isolate* isolate,
+ Handle<FunctionTemplate> receiver =
+ Handle<FunctionTemplate>(),
+ int argc = 0,
+ Handle<FunctionTemplate> argv[] = 0);
+ // Will be deprecated soon.
static Local<Signature> New(Handle<FunctionTemplate> receiver =
Handle<FunctionTemplate>(),
int argc = 0,
@@ -3634,8 +3682,13 @@
*/
class V8_EXPORT AccessorSignature : public Data {
public:
+ static Local<AccessorSignature> New(Isolate* isolate,
+ Handle<FunctionTemplate> receiver =
+ Handle<FunctionTemplate>());
+ // Will be deprecated soon.
static Local<AccessorSignature> New(Handle<FunctionTemplate> receiver =
Handle<FunctionTemplate>());
+
private:
AccessorSignature();
};
@@ -3739,6 +3792,11 @@
const char** deps = 0,
int source_length = -1);
virtual ~Extension() { }
+ virtual v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
+ v8::Isolate* isolate, v8::Handle<v8::String> name) {
+ return GetNativeFunction(name);
+ }
+ // Will be deprecated soon.
virtual v8::Handle<v8::FunctionTemplate>
GetNativeFunction(v8::Handle<v8::String> name) {
return v8::Handle<v8::FunctionTemplate>();
@@ -3783,17 +3841,17 @@
// --- Statics ---
+V8_INLINE Handle<Primitive> Undefined(Isolate* isolate);
+V8_INLINE Handle<Primitive> Null(Isolate* isolate);
+V8_INLINE Handle<Boolean> True(Isolate* isolate);
+V8_INLINE Handle<Boolean> False(Isolate* isolate);
+// Will be removed soon.
Handle<Primitive> V8_EXPORT Undefined();
Handle<Primitive> V8_EXPORT Null();
Handle<Boolean> V8_EXPORT True();
Handle<Boolean> V8_EXPORT False();
-V8_INLINE Handle<Primitive> Undefined(Isolate* isolate);
-V8_INLINE Handle<Primitive> Null(Isolate* isolate);
-V8_INLINE Handle<Boolean> True(Isolate* isolate);
-V8_INLINE Handle<Boolean> False(Isolate* isolate);
-
/**
* A set of constraints that specifies the limits of the runtime's memory
use.
=======================================
--- /branches/bleeding_edge/src/api.cc Fri Nov 22 12:28:58 2013 UTC
+++ /branches/bleeding_edge/src/api.cc Tue Nov 26 09:45:17 2013 UTC
@@ -1078,32 +1078,42 @@
}
Local<FunctionTemplate> FunctionTemplate::New(
+ Isolate* isolate,
FunctionCallback callback,
v8::Handle<Value> data,
v8::Handle<Signature> signature,
int length) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::FunctionTemplate::New()");
- LOG_API(isolate, "FunctionTemplate::New");
- ENTER_V8(isolate);
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::FunctionTemplate::New()");
+ LOG_API(i_isolate, "FunctionTemplate::New");
+ ENTER_V8(i_isolate);
return FunctionTemplateNew(
- isolate, callback, data, signature, length, false);
+ i_isolate, callback, data, signature, length, false);
}
-Local<Signature> Signature::New(Handle<FunctionTemplate> receiver,
- int argc, Handle<FunctionTemplate> argv[]) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::Signature::New()");
- LOG_API(isolate, "Signature::New");
- ENTER_V8(isolate);
+Local<FunctionTemplate> FunctionTemplate::New(
+ FunctionCallback callback,
+ v8::Handle<Value> data,
+ v8::Handle<Signature> signature,
+ int length) {
+ return New(Isolate::GetCurrent(), callback, data, signature, length);
+}
+
+Local<Signature> Signature::New(Isolate* isolate,
+ Handle<FunctionTemplate> receiver, int
argc,
+ Handle<FunctionTemplate> argv[]) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::Signature::New()");
+ LOG_API(i_isolate, "Signature::New");
+ ENTER_V8(i_isolate);
i::Handle<i::Struct> struct_obj =
- isolate->factory()->NewStruct(i::SIGNATURE_INFO_TYPE);
+ i_isolate->factory()->NewStruct(i::SIGNATURE_INFO_TYPE);
i::Handle<i::SignatureInfo> obj =
i::Handle<i::SignatureInfo>::cast(struct_obj);
if (!receiver.IsEmpty())
obj->set_receiver(*Utils::OpenHandle(*receiver));
if (argc > 0) {
- i::Handle<i::FixedArray> args =
isolate->factory()->NewFixedArray(argc);
+ i::Handle<i::FixedArray> args =
i_isolate->factory()->NewFixedArray(argc);
for (int i = 0; i < argc; i++) {
if (!argv[i].IsEmpty())
args->set(i, *Utils::OpenHandle(*argv[i]));
@@ -1112,12 +1122,26 @@
}
return Utils::ToLocal(obj);
}
+
+
+Local<Signature> Signature::New(Handle<FunctionTemplate> receiver,
+ int argc, Handle<FunctionTemplate> argv[]) {
+ return New(Isolate::GetCurrent(), receiver, argc, argv);
+}
Local<AccessorSignature> AccessorSignature::New(
+ Isolate* isolate,
Handle<FunctionTemplate> receiver) {
return Utils::AccessorSignatureToLocal(Utils::OpenHandle(*receiver));
}
+
+
+// While this is just a cast, it's lame not to use an Isolate parameter.
+Local<AccessorSignature> AccessorSignature::New(
+ Handle<FunctionTemplate> receiver) {
+ return Utils::AccessorSignatureToLocal(Utils::OpenHandle(*receiver));
+}
template<typename Operation>
@@ -1363,7 +1387,7 @@
i::Handle<i::FunctionTemplateInfo> handle = Utils::OpenHandle(this);
if (handle->instance_template()->IsUndefined()) {
Local<ObjectTemplate> templ =
- ObjectTemplate::New(ToApiHandle<FunctionTemplate>(handle));
+ ObjectTemplate::New(isolate,
ToApiHandle<FunctionTemplate>(handle));
handle->set_instance_template(*Utils::OpenHandle(*templ));
}
i::Handle<i::ObjectTemplateInfo> result(
@@ -1410,14 +1434,19 @@
// --- O b j e c t T e m p l a t e ---
+Local<ObjectTemplate> ObjectTemplate::New(Isolate* isolate) {
+ return New(reinterpret_cast<i::Isolate*>(isolate),
Local<FunctionTemplate>());
+}
+
+
Local<ObjectTemplate> ObjectTemplate::New() {
- return New(Local<FunctionTemplate>());
+ return New(i::Isolate::Current(), Local<FunctionTemplate>());
}
Local<ObjectTemplate> ObjectTemplate::New(
+ i::Isolate* isolate,
v8::Handle<FunctionTemplate> constructor) {
- i::Isolate* isolate = i::Isolate::Current();
EnsureInitializedForIsolate(isolate, "v8::ObjectTemplate::New()");
LOG_API(isolate, "ObjectTemplate::New");
ENTER_V8(isolate);
@@ -2283,12 +2312,17 @@
return Local<String>();
}
}
+
+
+void Message::PrintCurrentStackTrace(Isolate* isolate, FILE* out) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ ENTER_V8(i_isolate);
+ i_isolate->PrintCurrentStackTrace(out);
+}
void Message::PrintCurrentStackTrace(FILE* out) {
- i::Isolate* isolate = i::Isolate::Current();
- ENTER_V8(isolate);
- isolate->PrintCurrentStackTrace(out);
+ PrintCurrentStackTrace(Isolate::GetCurrent(), out);
}
@@ -2319,14 +2353,22 @@
}
-Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit,
+Local<StackTrace> StackTrace::CurrentStackTrace(
+ Isolate* isolate,
+ int frame_limit,
StackTraceOptions options) {
- i::Isolate* isolate = i::Isolate::Current();
- ENTER_V8(isolate);
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ ENTER_V8(i_isolate);
i::Handle<i::JSArray> stackTrace =
- isolate->CaptureCurrentStackTrace(frame_limit, options);
+ i_isolate->CaptureCurrentStackTrace(frame_limit, options);
return Utils::StackTraceToLocal(stackTrace);
}
+
+
+Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit,
+ StackTraceOptions options) {
+ return CurrentStackTrace(Isolate::GetCurrent(), frame_limit, options);
+}
// --- S t a c k F r a m e ---
@@ -5646,16 +5688,23 @@
Local<String> v8::String::NewExternal(
+ Isolate* isolate,
v8::String::ExternalStringResource* resource) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::String::NewExternal()");
- LOG_API(isolate, "String::NewExternal");
- ENTER_V8(isolate);
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::String::NewExternal()");
+ LOG_API(i_isolate, "String::NewExternal");
+ ENTER_V8(i_isolate);
CHECK(resource && resource->data());
- i::Handle<i::String> result = NewExternalStringHandle(isolate, resource);
- isolate->heap()->external_string_table()->AddString(*result);
+ i::Handle<i::String> result = NewExternalStringHandle(i_isolate,
resource);
+ i_isolate->heap()->external_string_table()->AddString(*result);
return Utils::ToLocal(result);
}
+
+
+Local<String> v8::String::NewExternal(
+ v8::String::ExternalStringResource* resource) {
+ return NewExternal(Isolate::GetCurrent(), resource);
+}
bool v8::String::MakeExternal(v8::String::ExternalStringResource*
resource) {
@@ -5695,16 +5744,24 @@
Local<String> v8::String::NewExternal(
+ Isolate* isolate,
v8::String::ExternalAsciiStringResource* resource) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::String::NewExternal()");
- LOG_API(isolate, "String::NewExternal");
- ENTER_V8(isolate);
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::String::NewExternal()");
+ LOG_API(i_isolate, "String::NewExternal");
+ ENTER_V8(i_isolate);
CHECK(resource && resource->data());
- i::Handle<i::String> result = NewExternalAsciiStringHandle(isolate,
resource);
- isolate->heap()->external_string_table()->AddString(*result);
+ i::Handle<i::String> result =
+ NewExternalAsciiStringHandle(i_isolate, resource);
+ i_isolate->heap()->external_string_table()->AddString(*result);
return Utils::ToLocal(result);
}
+
+
+Local<String> v8::String::NewExternal(
+ v8::String::ExternalAsciiStringResource* resource) {
+ return NewExternal(Isolate::GetCurrent(), resource);
+}
bool v8::String::MakeExternal(
@@ -5760,27 +5817,37 @@
i::StringShape shape(*obj);
return !shape.IsExternal();
}
+
+
+Local<v8::Object> v8::Object::New(Isolate* isolate) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::Object::New()");
+ LOG_API(i_isolate, "Object::New");
+ ENTER_V8(i_isolate);
+ i::Handle<i::JSObject> obj =
+ i_isolate->factory()->NewJSObject(i_isolate->object_function());
+ return Utils::ToLocal(obj);
+}
Local<v8::Object> v8::Object::New() {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::Object::New()");
- LOG_API(isolate, "Object::New");
- ENTER_V8(isolate);
- i::Handle<i::JSObject> obj =
- isolate->factory()->NewJSObject(isolate->object_function());
+ return New(Isolate::GetCurrent());
+}
+
+
+Local<v8::Value> v8::NumberObject::New(Isolate* isolate, double value) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::NumberObject::New()");
+ LOG_API(i_isolate, "NumberObject::New");
+ ENTER_V8(i_isolate);
+ i::Handle<i::Object> number = i_isolate->factory()->NewNumber(value);
+ i::Handle<i::Object> obj = i_isolate->factory()->ToObject(number);
return Utils::ToLocal(obj);
}
Local<v8::Value> v8::NumberObject::New(double value) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::NumberObject::New()");
- LOG_API(isolate, "NumberObject::New");
- ENTER_V8(isolate);
- i::Handle<i::Object> number = isolate->factory()->NewNumber(value);
- i::Handle<i::Object> obj = isolate->factory()->ToObject(number);
- return Utils::ToLocal(obj);
+ return New(Isolate::GetCurrent(), value);
}
@@ -5858,21 +5925,26 @@
}
-Local<v8::Value> v8::Date::New(double time) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::Date::New()");
- LOG_API(isolate, "Date::New");
+Local<v8::Value> v8::Date::New(Isolate* isolate, double time) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::Date::New()");
+ LOG_API(i_isolate, "Date::New");
if (std::isnan(time)) {
// Introduce only canonical NaN value into the VM, to avoid signaling
NaNs.
time = i::OS::nan_value();
}
- ENTER_V8(isolate);
- EXCEPTION_PREAMBLE(isolate);
+ ENTER_V8(i_isolate);
+ EXCEPTION_PREAMBLE(i_isolate);
i::Handle<i::Object> obj =
- i::Execution::NewDate(isolate, time, &has_pending_exception);
- EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Value>());
+ i::Execution::NewDate(i_isolate, time, &has_pending_exception);
+ EXCEPTION_BAILOUT_CHECK(i_isolate, Local<v8::Value>());
return Utils::ToLocal(obj);
}
+
+
+Local<v8::Value> v8::Date::New(double time) {
+ return New(Isolate::GetCurrent(), time);
+}
double v8::Date::ValueOf() const {
@@ -5884,22 +5956,22 @@
}
-void v8::Date::DateTimeConfigurationChangeNotification() {
- i::Isolate* isolate = i::Isolate::Current();
-
ON_BAILOUT(isolate, "v8::Date::DateTimeConfigurationChangeNotification()",
+void v8::Date::DateTimeConfigurationChangeNotification(Isolate* isolate) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+
ON_BAILOUT(i_isolate, "v8::Date::DateTimeConfigurationChangeNotification()",
return);
- LOG_API(isolate, "Date::DateTimeConfigurationChangeNotification");
- ENTER_V8(isolate);
+ LOG_API(i_isolate, "Date::DateTimeConfigurationChangeNotification");
+ ENTER_V8(i_isolate);
- isolate->date_cache()->ResetDateCache();
+ i_isolate->date_cache()->ResetDateCache();
- i::HandleScope scope(isolate);
+ i::HandleScope scope(i_isolate);
// Get the function ResetDateCache (defined in date.js).
i::Handle<i::String> func_name_str =
- isolate->factory()->InternalizeOneByteString(
+ i_isolate->factory()->InternalizeOneByteString(
STATIC_ASCII_VECTOR("ResetDateCache"));
i::MaybeObject* result =
- isolate->js_builtins_object()->GetProperty(*func_name_str);
+ i_isolate->js_builtins_object()->GetProperty(*func_name_str);
i::Object* object_func;
if (!result->ToObject(&object_func)) {
return;
@@ -5912,12 +5984,17 @@
// Call ResetDateCache(0 but expect no exceptions:
bool caught_exception = false;
i::Execution::TryCall(func,
- isolate->js_builtins_object(),
+ i_isolate->js_builtins_object(),
0,
NULL,
&caught_exception);
}
}
+
+
+void v8::Date::DateTimeConfigurationChangeNotification() {
+ DateTimeConfigurationChangeNotification(Isolate::GetCurrent());
+}
static i::Handle<i::String> RegExpFlagsToString(RegExp::Flags flags) {
@@ -5971,18 +6048,23 @@
}
-Local<v8::Array> v8::Array::New(int length) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::Array::New()");
- LOG_API(isolate, "Array::New");
- ENTER_V8(isolate);
+Local<v8::Array> v8::Array::New(Isolate* isolate, int length) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::Array::New()");
+ LOG_API(i_isolate, "Array::New");
+ ENTER_V8(i_isolate);
int real_length = length > 0 ? length : 0;
- i::Handle<i::JSArray> obj = isolate->factory()->NewJSArray(real_length);
+ i::Handle<i::JSArray> obj =
i_isolate->factory()->NewJSArray(real_length);
i::Handle<i::Object> length_obj =
- isolate->factory()->NewNumberFromInt(real_length);
+ i_isolate->factory()->NewNumberFromInt(real_length);
obj->set_length(*length_obj);
return Utils::ToLocal(obj);
}
+
+
+Local<v8::Array> v8::Array::New(int length) {
+ return New(Isolate::GetCurrent(), length);
+}
uint32_t v8::Array::Length() const {
@@ -6068,28 +6150,39 @@
}
-Local<ArrayBuffer> v8::ArrayBuffer::New(size_t byte_length) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::ArrayBuffer::New(size_t)");
- LOG_API(isolate, "v8::ArrayBuffer::New(size_t)");
- ENTER_V8(isolate);
+Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, size_t
byte_length) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::ArrayBuffer::New(size_t)");
+ LOG_API(i_isolate, "v8::ArrayBuffer::New(size_t)");
+ ENTER_V8(i_isolate);
i::Handle<i::JSArrayBuffer> obj =
- isolate->factory()->NewJSArrayBuffer();
- i::Runtime::SetupArrayBufferAllocatingData(isolate, obj, byte_length);
+ i_isolate->factory()->NewJSArrayBuffer();
+ i::Runtime::SetupArrayBufferAllocatingData(i_isolate, obj, byte_length);
return Utils::ToLocal(obj);
}
-Local<ArrayBuffer> v8::ArrayBuffer::New(void* data, size_t byte_length) {
- i::Isolate* isolate = i::Isolate::Current();
- EnsureInitializedForIsolate(isolate, "v8::ArrayBuffer::New(void*,
size_t)");
- LOG_API(isolate, "v8::ArrayBuffer::New(void*, size_t)");
- ENTER_V8(isolate);
+Local<ArrayBuffer> v8::ArrayBuffer::New(size_t byte_length) {
+ return New(Isolate::GetCurrent(), byte_length);
+}
+
+
+Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, void* data,
+ size_t byte_length) {
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ EnsureInitializedForIsolate(i_isolate, "v8::ArrayBuffer::New(void*,
size_t)");
+ LOG_API(i_isolate, "v8::ArrayBuffer::New(void*, size_t)");
+ ENTER_V8(i_isolate);
i::Handle<i::JSArrayBuffer> obj =
- isolate->factory()->NewJSArrayBuffer();
- i::Runtime::SetupArrayBuffer(isolate, obj, true, data, byte_length);
+ i_isolate->factory()->NewJSArrayBuffer();
+ i::Runtime::SetupArrayBuffer(i_isolate, obj, true, data, byte_length);
return Utils::ToLocal(obj);
}
+
+
+Local<ArrayBuffer> v8::ArrayBuffer::New(void* data, size_t byte_length) {
+ return New(Isolate::GetCurrent(), data, byte_length);
+}
Local<ArrayBuffer> v8::ArrayBufferView::Buffer() {
@@ -6280,18 +6373,28 @@
Local<Integer> v8::Integer::New(int32_t value) {
i::Isolate* isolate = i::Isolate::UncheckedCurrent();
EnsureInitializedForIsolate(isolate, "v8::Integer::New()");
- return v8::Integer::New(value, reinterpret_cast<Isolate*>(isolate));
+ return v8::Integer::New(reinterpret_cast<Isolate*>(isolate), value);
}
Local<Integer> Integer::NewFromUnsigned(uint32_t value) {
i::Isolate* isolate = i::Isolate::Current();
EnsureInitializedForIsolate(isolate, "v8::Integer::NewFromUnsigned()");
- return Integer::NewFromUnsigned(value,
reinterpret_cast<Isolate*>(isolate));
+ return Integer::NewFromUnsigned(reinterpret_cast<Isolate*>(isolate),
value);
}
Local<Integer> v8::Integer::New(int32_t value, Isolate* isolate) {
+ return Integer::New(isolate, value);
+}
+
+
+Local<Integer> v8::Integer::NewFromUnsigned(uint32_t value, Isolate*
isolate) {
+ return Integer::NewFromUnsigned(isolate, value);
+}
+
+
+Local<Integer> v8::Integer::New(Isolate* isolate, int32_t value) {
i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
ASSERT(internal_isolate->IsInitialized());
if (i::Smi::IsValid(value)) {
@@ -6304,7 +6407,7 @@
}
-Local<Integer> v8::Integer::NewFromUnsigned(uint32_t value, Isolate*
isolate) {
+Local<Integer> v8::Integer::NewFromUnsigned(Isolate* isolate, uint32_t
value) {
i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
ASSERT(internal_isolate->IsInitialized());
bool fits_into_int32_t = (value & (1 << 31)) == 0;
=======================================
--- /branches/bleeding_edge/src/full-codegen.cc Wed Oct 23 13:48:04 2013 UTC
+++ /branches/bleeding_edge/src/full-codegen.cc Tue Nov 26 09:45:17 2013 UTC
@@ -1579,7 +1579,8 @@
// Compute the function template for the native function.
Handle<String> name = expr->name();
v8::Handle<v8::FunctionTemplate> fun_template =
- expr->extension()->GetNativeFunction(v8::Utils::ToLocal(name));
+ expr->extension()->GetNativeFunctionTemplate(
+ reinterpret_cast<v8::Isolate*>(isolate()),
v8::Utils::ToLocal(name));
ASSERT(!fun_template.IsEmpty());
// Instantiate the function and create a shared function info from it.
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
