}
-// TODO(rossberg): should replace these by proper uses of HasInstance,
-// once we figure out a good way to make the templates global.
-const char kArrayBufferMarkerPropName[] = "d8::_is_array_buffer_";
-const char kArrayMarkerPropName[] = "d8::_is_typed_array_";
-
-
-#define FOR_EACH_STRING(V) \
- V(ArrayBuffer, "ArrayBuffer") \
- V(ArrayBufferMarkerPropName, kArrayBufferMarkerPropName) \
- V(ArrayMarkerPropName, kArrayMarkerPropName) \
- V(buffer, "buffer") \
- V(byteLength, "byteLength") \
- V(byteOffset, "byteOffset") \
- V(BYTES_PER_ELEMENT, "BYTES_PER_ELEMENT") \
- V(length, "length")
-
class PerIsolateData {
public:
explicit PerIsolateData(Isolate* isolate) : isolate_(isolate), realms_(NULL) {
HandleScope scope(isolate);
-#define INIT_STRING(name, value) \
- name##_string_ = Persistent<String>::New(isolate, String::NewSymbol(value));
- FOR_EACH_STRING(INIT_STRING)
-#undef INIT_STRING
isolate->SetData(this);
}
~PerIsolateData() {
-#define DISPOSE_STRING(name, value) name##_string_.Dispose(isolate_);
- FOR_EACH_STRING(DISPOSE_STRING)
-#undef DISPOSE_STRING
isolate_->SetData(NULL); // Not really needed, just to be sure...
}
return reinterpret_cast<PerIsolateData*>(isolate->GetData());
}
-#define DEFINE_STRING_GETTER(name, value) \
- static Handle<String> name##_string(Isolate* isolate) { \
- return Handle<String>(*Get(isolate)->name##_string_); \
- }
- FOR_EACH_STRING(DEFINE_STRING_GETTER)
-#undef DEFINE_STRING_GETTER
-
class RealmScope {
public:
explicit RealmScope(PerIsolateData* data);
Persistent<Context>* realms_;
Persistent<Value> realm_shared_;
-#define DEFINE_MEMBER(name, value) Persistent<String> name##_string_;
- FOR_EACH_STRING(DEFINE_MEMBER)
-#undef DEFINE_MEMBER
-
int RealmFind(Handle<Context> context);
};
return Undefined(args.GetIsolate());
}
-static int32_t convertToInt(Local<Value> value_in, TryCatch* try_catch) {
- if (value_in->IsInt32()) {
- return value_in->Int32Value();
- }
-
- Local<Value> number = value_in->ToNumber();
- if (try_catch->HasCaught()) return 0;
-
- ASSERT(number->IsNumber());
- Local<Int32> int32 = number->ToInt32();
- if (try_catch->HasCaught() || int32.IsEmpty()) return 0;
-
- int32_t value = int32->Int32Value();
- if (try_catch->HasCaught()) return 0;
-
- return value;
-}
-
-
-static int32_t convertToUint(Local<Value> value_in, TryCatch* try_catch) {
- int32_t raw_value = convertToInt(value_in, try_catch);
- if (try_catch->HasCaught()) return 0;
-
- if (raw_value < 0) {
- Throw("Array length must not be negative.");
- return 0;
- }
-
- static const int kMaxLength = 0x3fffffff;
-#ifndef V8_SHARED
- ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
-#endif // V8_SHARED
- if (raw_value > static_cast<int32_t>(kMaxLength)) {
- Throw("Array length exceeds maximum length.");
- }
- return raw_value;
-}
-
-
-Handle<Value> Shell::CreateExternalArrayBuffer(Isolate* isolate,
- Handle<Object> buffer,
- int32_t length) {
- static const int32_t kMaxSize = 0x7fffffff;
- // Make sure the total size fits into a (signed) int.
- if (length < 0 || length > kMaxSize) {
- return Throw("ArrayBuffer exceeds maximum size (2G)");
- }
- uint8_t* data = new uint8_t[length];
- if (data == NULL) {
- return Throw("Memory allocation failed");
- }
- memset(data, 0, length);
-
- buffer->SetHiddenValue(
- PerIsolateData::ArrayBufferMarkerPropName_string(isolate), True());
- Persistent<Object> persistent_array =
- Persistent<Object>::New(isolate, buffer);
- persistent_array.MakeWeak(isolate, data, ExternalArrayWeakCallback);
- persistent_array.MarkIndependent(isolate);
- isolate->AdjustAmountOfExternalAllocatedMemory(length);
-
- buffer->SetIndexedPropertiesToExternalArrayData(
- data, v8::kExternalByteArray, length);
- buffer->Set(PerIsolateData::byteLength_string(isolate),
- Int32::New(length, isolate),
- ReadOnly);
-
- return buffer;
-}
-
-
-Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
- if (!args.IsConstructCall()) {
- Handle<Value>* rec_args = new Handle<Value>[args.Length()];
- for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i];
- Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args);
- delete[] rec_args;
- return result;
- }
-
- if (args.Length() == 0) {
- return Throw("ArrayBuffer constructor must have one argument");
- }
- TryCatch try_catch;
- int32_t length = convertToUint(args[0], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- return CreateExternalArrayBuffer(args.GetIsolate(), args.This(), length);
-}
-
-
-Handle<Object> Shell::CreateExternalArray(Isolate* isolate,
- Handle<Object> array,
- Handle<Object> buffer,
- ExternalArrayType type,
- int32_t length,
- int32_t byteLength,
- int32_t byteOffset,
- int32_t element_size) {
- ASSERT(element_size == 1 || element_size == 2 ||
- element_size == 4 || element_size == 8);
- ASSERT(byteLength == length * element_size);
-
- void* data = buffer->GetIndexedPropertiesExternalArrayData();
- ASSERT(data != NULL);
-
- array->SetIndexedPropertiesToExternalArrayData(
- static_cast<uint8_t*>(data) + byteOffset, type, length);
- array->SetHiddenValue(PerIsolateData::ArrayMarkerPropName_string(isolate),
- Int32::New(type, isolate));
- array->Set(PerIsolateData::byteLength_string(isolate),
- Int32::New(byteLength, isolate),
- ReadOnly);
- array->Set(PerIsolateData::byteOffset_string(isolate),
- Int32::New(byteOffset, isolate),
- ReadOnly);
- array->Set(PerIsolateData::length_string(isolate),
- Int32::New(length, isolate),
- ReadOnly);
- array->Set(PerIsolateData::BYTES_PER_ELEMENT_string(isolate),
- Int32::New(element_size, isolate));
- array->Set(PerIsolateData::buffer_string(isolate),
- buffer,
- ReadOnly);
-
- return array;
-}
-
-
-Handle<Value> Shell::CreateExternalArray(const Arguments& args,
- ExternalArrayType type,
- int32_t element_size) {
- Isolate* isolate = args.GetIsolate();
- if (!args.IsConstructCall()) {
- Handle<Value>* rec_args = new Handle<Value>[args.Length()];
- for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i];
- Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args);
- delete[] rec_args;
- return result;
- }
-
- TryCatch try_catch;
- ASSERT(element_size == 1 || element_size == 2 ||
- element_size == 4 || element_size == 8);
-
- // All of the following constructors are supported:
- // TypedArray(unsigned long length)
- // TypedArray(type[] array)
- // TypedArray(TypedArray array)
- // TypedArray(ArrayBuffer buffer,
- // optional unsigned long byteOffset,
- // optional unsigned long length)
- Handle<Object> buffer;
- int32_t length;
- int32_t byteLength;
- int32_t byteOffset;
- bool init_from_array = false;
- if (args.Length() == 0) {
- return Throw("Array constructor must have at least one argument");
- }
- if (args[0]->IsObject() &&
- !args[0]->ToObject()->GetHiddenValue(
- PerIsolateData::ArrayBufferMarkerPropName_string(isolate)).IsEmpty()) {
- // Construct from ArrayBuffer.
- buffer = args[0]->ToObject();
- int32_t bufferLength = convertToUint(
- buffer->Get(PerIsolateData::byteLength_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- if (args.Length() < 2 || args[1]->IsUndefined()) {
- byteOffset = 0;
- } else {
- byteOffset = convertToUint(args[1], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- if (byteOffset > bufferLength) {
- return Throw("byteOffset out of bounds");
- }
- if (byteOffset % element_size != 0) {
- return Throw("byteOffset must be multiple of element size");
- }
- }
-
- if (args.Length() < 3 || args[2]->IsUndefined()) {
- byteLength = bufferLength - byteOffset;
- length = byteLength / element_size;
- if (byteLength % element_size != 0) {
- return Throw("buffer size must be multiple of element size");
- }
- } else {
- length = convertToUint(args[2], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- byteLength = length * element_size;
- if (byteOffset + byteLength > bufferLength) {
- return Throw("length out of bounds");
- }
- }
- } else {
- if (args[0]->IsObject() &&
- args[0]->ToObject()->Has(PerIsolateData::length_string(isolate))) {
- // Construct from array.
- Local<Value> value =
- args[0]->ToObject()->Get(PerIsolateData::length_string(isolate));
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- length = convertToUint(value, &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- init_from_array = true;
- } else {
- // Construct from size.
- length = convertToUint(args[0], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- }
- byteLength = length * element_size;
- byteOffset = 0;
-
- Handle<Object> global = Context::GetCurrent()->Global();
- Handle<Value> array_buffer =
- global->Get(PerIsolateData::ArrayBuffer_string(isolate));
- ASSERT(!try_catch.HasCaught() && array_buffer->IsFunction());
- Handle<Value> buffer_args[] = { Uint32::New(byteLength, isolate) };
- Handle<Value> result = Handle<Function>::Cast(array_buffer)->NewInstance(
- 1, buffer_args);
- if (try_catch.HasCaught()) return result;
- buffer = result->ToObject();
- }
-
- Handle<Object> array =
- CreateExternalArray(isolate, args.This(), buffer, type, length,
- byteLength, byteOffset, element_size);
-
- if (init_from_array) {
- Handle<Object> init = args[0]->ToObject();
- for (int i = 0; i < length; ++i) {
- Local<Value> value = init->Get(i);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- array->Set(i, value);
- }
- }
-
- return array;
-}
-
-
-Handle<Value> Shell::ArrayBufferSlice(const Arguments& args) {
- TryCatch try_catch;
-
- if (!args.This()->IsObject()) {
- return Throw("'slice' invoked on non-object receiver");
- }
-
- Isolate* isolate = args.GetIsolate();
- Local<Object> self = args.This();
- Local<Value> marker = self->GetHiddenValue(
- PerIsolateData::ArrayBufferMarkerPropName_string(isolate));
- if (marker.IsEmpty()) {
- return Throw("'slice' invoked on wrong receiver type");
- }
-
- int32_t length = convertToUint(
- self->Get(PerIsolateData::byteLength_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- if (args.Length() == 0) {
- return Throw("'slice' must have at least one argument");
- }
- int32_t begin = convertToInt(args[0], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- if (begin < 0) begin += length;
- if (begin < 0) begin = 0;
- if (begin > length) begin = length;
-
- int32_t end;
- if (args.Length() < 2 || args[1]->IsUndefined()) {
- end = length;
- } else {
- end = convertToInt(args[1], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- if (end < 0) end += length;
- if (end < 0) end = 0;
- if (end > length) end = length;
- if (end < begin) end = begin;
- }
-
- Local<Function> constructor = Local<Function>::Cast(self->GetConstructor());
- Handle<Value> new_args[] = { Uint32::New(end - begin, isolate) };
- Handle<Value> result = constructor->NewInstance(1, new_args);
- if (try_catch.HasCaught()) return result;
- Handle<Object> buffer = result->ToObject();
- uint8_t* dest =
- static_cast<uint8_t*>(buffer->GetIndexedPropertiesExternalArrayData());
- uint8_t* src = begin + static_cast<uint8_t*>(
- self->GetIndexedPropertiesExternalArrayData());
- memcpy(dest, src, end - begin);
-
- return buffer;
-}
-
-
-Handle<Value> Shell::ArraySubArray(const Arguments& args) {
- TryCatch try_catch;
-
- if (!args.This()->IsObject()) {
- return Throw("'subarray' invoked on non-object receiver");
- }
-
- Isolate* isolate = args.GetIsolate();
- Local<Object> self = args.This();
- Local<Value> marker =
- self->GetHiddenValue(PerIsolateData::ArrayMarkerPropName_string(isolate));
- if (marker.IsEmpty()) {
- return Throw("'subarray' invoked on wrong receiver type");
- }
-
- Handle<Object> buffer =
- self->Get(PerIsolateData::buffer_string(isolate))->ToObject();
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- int32_t length = convertToUint(
- self->Get(PerIsolateData::length_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- int32_t byteOffset = convertToUint(
- self->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- int32_t element_size = convertToUint(
- self->Get(PerIsolateData::BYTES_PER_ELEMENT_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- if (args.Length() == 0) {
- return Throw("'subarray' must have at least one argument");
- }
- int32_t begin = convertToInt(args[0], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- if (begin < 0) begin += length;
- if (begin < 0) begin = 0;
- if (begin > length) begin = length;
-
- int32_t end;
- if (args.Length() < 2 || args[1]->IsUndefined()) {
- end = length;
- } else {
- end = convertToInt(args[1], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- if (end < 0) end += length;
- if (end < 0) end = 0;
- if (end > length) end = length;
- if (end < begin) end = begin;
- }
-
- length = end - begin;
- byteOffset += begin * element_size;
-
- Local<Function> constructor = Local<Function>::Cast(self->GetConstructor());
- Handle<Value> construct_args[] = {
- buffer, Uint32::New(byteOffset, isolate), Uint32::New(length, isolate)
- };
- return constructor->NewInstance(3, construct_args);
-}
-
-
-Handle<Value> Shell::ArraySet(const Arguments& args) {
- TryCatch try_catch;
-
- if (!args.This()->IsObject()) {
- return Throw("'set' invoked on non-object receiver");
- }
-
- Isolate* isolate = args.GetIsolate();
- Local<Object> self = args.This();
- Local<Value> marker =
- self->GetHiddenValue(PerIsolateData::ArrayMarkerPropName_string(isolate));
- if (marker.IsEmpty()) {
- return Throw("'set' invoked on wrong receiver type");
- }
- int32_t length = convertToUint(
- self->Get(PerIsolateData::length_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- int32_t element_size = convertToUint(
- self->Get(PerIsolateData::BYTES_PER_ELEMENT_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- if (args.Length() == 0) {
- return Throw("'set' must have at least one argument");
- }
- if (!args[0]->IsObject() ||
- !args[0]->ToObject()->Has(PerIsolateData::length_string(isolate))) {
- return Throw("'set' invoked with non-array argument");
- }
- Handle<Object> source = args[0]->ToObject();
- int32_t source_length = convertToUint(
- source->Get(PerIsolateData::length_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- int32_t offset;
- if (args.Length() < 2 || args[1]->IsUndefined()) {
- offset = 0;
- } else {
- offset = convertToUint(args[1], &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- }
- if (offset + source_length > length) {
- return Throw("offset or source length out of bounds");
- }
-
- int32_t source_element_size;
- if (source->GetHiddenValue(
- PerIsolateData::ArrayMarkerPropName_string(isolate)).IsEmpty()) {
- source_element_size = 0;
- } else {
- source_element_size = convertToUint(
- source->Get(PerIsolateData::BYTES_PER_ELEMENT_string(isolate)),
- &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- }
-
- if (element_size == source_element_size &&
- self->GetConstructor()->StrictEquals(source->GetConstructor())) {
- // Use memmove on the array buffers.
- Handle<Object> buffer =
- self->Get(PerIsolateData::buffer_string(isolate))->ToObject();
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- Handle<Object> source_buffer =
- source->Get(PerIsolateData::buffer_string(isolate))->ToObject();
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- int32_t byteOffset = convertToUint(
- self->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- int32_t source_byteOffset = convertToUint(
- source->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- uint8_t* dest = byteOffset + offset * element_size + static_cast<uint8_t*>(
- buffer->GetIndexedPropertiesExternalArrayData());
- uint8_t* src = source_byteOffset + static_cast<uint8_t*>(
- source_buffer->GetIndexedPropertiesExternalArrayData());
- memmove(dest, src, source_length * element_size);
- } else if (source_element_size == 0) {
- // Source is not a typed array, copy element-wise sequentially.
- for (int i = 0; i < source_length; ++i) {
- self->Set(offset + i, source->Get(i));
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- }
- } else {
- // Need to copy element-wise to make the right conversions.
- Handle<Object> buffer =
- self->Get(PerIsolateData::buffer_string(isolate))->ToObject();
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- Handle<Object> source_buffer =
- source->Get(PerIsolateData::buffer_string(isolate))->ToObject();
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- if (buffer->StrictEquals(source_buffer)) {
- // Same backing store, need to handle overlap correctly.
- // This gets a bit tricky in the case of different element sizes
- // (which, of course, is extremely unlikely to ever occur in practice).
- int32_t byteOffset = convertToUint(
- self->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
- int32_t source_byteOffset = convertToUint(
- source->Get(PerIsolateData::byteOffset_string(isolate)), &try_catch);
- if (try_catch.HasCaught()) return try_catch.ReThrow();
-
- // Copy as much as we can from left to right.
- int i = 0;
- int32_t next_dest_offset = byteOffset + (offset + 1) * element_size;
- int32_t next_src_offset = source_byteOffset + source_element_size;
- while (i < length && next_dest_offset <= next_src_offset) {
- self->Set(offset + i, source->Get(i));
- ++i;
- next_dest_offset += element_size;
- next_src_offset += source_element_size;
- }
- // Of what's left, copy as much as we can from right to left.
- int j = length - 1;
- int32_t dest_offset = byteOffset + (offset + j) * element_size;
- int32_t src_offset = source_byteOffset + j * source_element_size;
- while (j >= i && dest_offset >= src_offset) {
- self->Set(offset + j, source->Get(j));
- --j;
- dest_offset -= element_size;
- src_offset -= source_element_size;
- }
- // There can be at most 8 entries left in the middle that need buffering
- // (because the largest element_size is 8 times the smallest).
- ASSERT(j+1 - i <= 8);
- Handle<Value> temp[8];
- for (int k = i; k <= j; ++k) {
- temp[k - i] = source->Get(k);
- }
- for (int k = i; k <= j; ++k) {
- self->Set(offset + k, temp[k - i]);
- }
- } else {
- // Different backing stores, safe to copy element-wise sequentially.
- for (int i = 0; i < source_length; ++i)
- self->Set(offset + i, source->Get(i));
- }
- }
-
- return Undefined(args.GetIsolate());
-}
-
-
-void Shell::ExternalArrayWeakCallback(v8::Isolate* isolate,
- Persistent<Object>* object,
- uint8_t* data) {
- HandleScope scope(isolate);
- int32_t length = (*object)->Get(
- PerIsolateData::byteLength_string(isolate))->Uint32Value();
- isolate->AdjustAmountOfExternalAllocatedMemory(-length);
- delete[] data;
- object->Dispose(isolate);
-}
-
-
-Handle<Value> Shell::Int8Array(const Arguments& args) {
- return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t));
-}
-
-
-Handle<Value> Shell::Uint8Array(const Arguments& args) {
- return CreateExternalArray(args, kExternalUnsignedByteArray, sizeof(uint8_t));
-}
-
-
-Handle<Value> Shell::Int16Array(const Arguments& args) {
- return CreateExternalArray(args, kExternalShortArray, sizeof(int16_t));
-}
-
-
-Handle<Value> Shell::Uint16Array(const Arguments& args) {
- return CreateExternalArray(
- args, kExternalUnsignedShortArray, sizeof(uint16_t));
-}
-
-
-Handle<Value> Shell::Int32Array(const Arguments& args) {
- return CreateExternalArray(args, kExternalIntArray, sizeof(int32_t));
-}
-
-
-Handle<Value> Shell::Uint32Array(const Arguments& args) {
- return CreateExternalArray(args, kExternalUnsignedIntArray, sizeof(uint32_t));
-}
-
-
-Handle<Value> Shell::Float32Array(const Arguments& args) {
- return CreateExternalArray(
- args, kExternalFloatArray, sizeof(float)); // NOLINT
-}
-
-
-Handle<Value> Shell::Float64Array(const Arguments& args) {
- return CreateExternalArray(
- args, kExternalDoubleArray, sizeof(double)); // NOLINT
-}
-
-
-Handle<Value> Shell::Uint8ClampedArray(const Arguments& args) {
- return CreateExternalArray(args, kExternalPixelArray, sizeof(uint8_t));
-}
-
Handle<Value> Shell::Quit(const Arguments& args) {
int exit_code = args[0]->Int32Value();
#endif
-Handle<FunctionTemplate> Shell::CreateArrayBufferTemplate(
- InvocationCallback fun) {
- Handle<FunctionTemplate> buffer_template = FunctionTemplate::New(fun);
- Local<Template> proto_template = buffer_template->PrototypeTemplate();
- proto_template->Set(String::New("slice"),
- FunctionTemplate::New(ArrayBufferSlice));
- return buffer_template;
-}
-
-
-Handle<FunctionTemplate> Shell::CreateArrayTemplate(InvocationCallback fun) {
- Handle<FunctionTemplate> array_template = FunctionTemplate::New(fun);
- Local<Template> proto_template = array_template->PrototypeTemplate();
- proto_template->Set(String::New("set"), FunctionTemplate::New(ArraySet));
- proto_template->Set(String::New("subarray"),
- FunctionTemplate::New(ArraySubArray));
- return array_template;
-}
-
-
Handle<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
Handle<ObjectTemplate> global_template = ObjectTemplate::New();
global_template->Set(String::New("print"), FunctionTemplate::New(Print));
RealmSharedGet, RealmSharedSet);
global_template->Set(String::New("Realm"), realm_template);
- // Bind the handlers for external arrays.
-#ifndef V8_SHARED
- if (!i::FLAG_harmony_typed_arrays) {
-#endif // V8_SHARED
- PropertyAttribute attr =
- static_cast<PropertyAttribute>(ReadOnly | DontDelete);
- global_template->Set(PerIsolateData::ArrayBuffer_string(isolate),
- CreateArrayBufferTemplate(ArrayBuffer), attr);
- global_template->Set(String::New("Int8Array"),
- CreateArrayTemplate(Int8Array), attr);
- global_template->Set(String::New("Uint8Array"),
- CreateArrayTemplate(Uint8Array), attr);
- global_template->Set(String::New("Int16Array"),
- CreateArrayTemplate(Int16Array), attr);
- global_template->Set(String::New("Uint16Array"),
- CreateArrayTemplate(Uint16Array), attr);
- global_template->Set(String::New("Int32Array"),
- CreateArrayTemplate(Int32Array), attr);
- global_template->Set(String::New("Uint32Array"),
- CreateArrayTemplate(Uint32Array), attr);
- global_template->Set(String::New("Float32Array"),
- CreateArrayTemplate(Float32Array), attr);
- global_template->Set(String::New("Float64Array"),
- CreateArrayTemplate(Float64Array), attr);
- global_template->Set(String::New("Uint8ClampedArray"),
- CreateArrayTemplate(Uint8ClampedArray), attr);
-#ifndef V8_SHARED
- }
-#endif // V8_SHARED
-
#if !defined(V8_SHARED) && !defined(_WIN32) && !defined(_WIN64)
Handle<ObjectTemplate> os_templ = ObjectTemplate::New();
AddOSMethods(os_templ);
if (data == NULL) {
return Throw("Error reading file");
}
- Isolate* isolate = args.GetIsolate();
- Handle<Object> buffer = Object::New();
- buffer->SetHiddenValue(
- PerIsolateData::ArrayBufferMarkerPropName_string(isolate), True());
- Persistent<Object> persistent_buffer =
- Persistent<Object>::New(isolate, buffer);
- persistent_buffer.MakeWeak(isolate, data, ExternalArrayWeakCallback);
- persistent_buffer.MarkIndependent(isolate);
- isolate->AdjustAmountOfExternalAllocatedMemory(length);
-
- buffer->SetIndexedPropertiesToExternalArrayData(
- data, kExternalUnsignedByteArray, length);
- buffer->Set(PerIsolateData::byteLength_string(isolate),
- Int32::New(static_cast<int32_t>(length), isolate), ReadOnly);
+ Handle<v8::ArrayBuffer> buffer = ArrayBuffer::New(length);
+ memcpy(buffer->Data(), data, length);
+ delete[] data;
return buffer;
}
projects / platform / upstream / v8.git / commitdiff