v8 typed arrays: add DataView type

src/api.cc

Index: src/api.cc
diff --git a/src/api.cc b/src/api.cc
index c2c7930f48ca5b3ee49696481f8c402fef43287e..2d25762720f59cb441dc0b474f00479a119512ba 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -2571,6 +2571,13 @@ bool Value::IsArrayBuffer() const {
 }
 
 
+bool Value::IsDataView() const {
+  if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsDataView()"))
+    return false;
+  return Utils::OpenHandle(this)->IsJSDataView();
+}
+
+
 bool Value::IsTypedArray() const {
   if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsArrayBuffer()"))
     return false;
@@ -2950,6 +2957,15 @@ void v8::ArrayBuffer::CheckCast(Value* that) {
 }
 
 
+void v8::DataView::CheckCast(Value* that) {
+  if (IsDeadCheck(i::Isolate::Current(), "v8::DataView::Cast()")) return;
+  i::Handle<i::Object> obj = Utils::OpenHandle(that);
+  ApiCheck(obj->IsJSDataView(),
+           "v8::DataView::Cast()",
+           "Could not convert to DataView");
+}
+
+
 void v8::TypedArray::CheckCast(Value* that) {
   if (IsDeadCheck(i::Isolate::Current(), "v8::TypedArray::Cast()")) return;
   i::Handle<i::Object> obj = Utils::OpenHandle(that);
@@ -6064,6 +6080,214 @@ Local<ArrayBuffer> v8::ArrayBuffer::New(void* data, size_t byte_length) {
 }
 
 
+Local<DataView> v8::DataView::New(Handle<ArrayBuffer> array_buffer,
+                                  size_t byte_offset,
+                                  size_t byte_length) {
+  i::Isolate* isolate = i::Isolate::Current();
+  i::Handle<i::JSDataView> obj =
+      isolate->factory()->NewJSDataView();
+  i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer);
+  ASSERT(byte_offset + byte_length <=
+      static_cast<size_t>(buffer->byte_length()->Number()));
+  obj->set_buffer(*buffer);
+  i::Handle<i::Object> byte_offset_object = isolate->factory()->NewNumber(
+      static_cast<double>(byte_offset));
+  obj->set_byte_offset(*byte_offset_object);
+  i::Handle<i::Object> byte_length_object = isolate->factory()->NewNumber(
+      static_cast<double>(byte_length));
+  obj->set_byte_length(*byte_length_object);
+  i::Handle<i::ExternalArray> elements =

[Dmitry Lomov (no reviews), 2013/06/03 13:09:04]

DataView is not a external array, so everything here is not needed.

[bnoordhuis, 2013/06/03 13:48:12]

Sorry, that's a left-over from my initial attempt.  The DataView we have in
node.js is indexable for convenience reasons. I thought I'd removed it from the
V8 patch but I probably botched a rebase.

+      isolate->factory()->NewExternalArray(
+          static_cast<int>(byte_length),
+          kExternalUnsignedByteArray,
+          static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
+  i::Handle<i::Map> map =
+      isolate->factory()->GetElementsTransitionMap(
+          obj, i::EXTERNAL_UNSIGNED_BYTE_ELEMENTS);
+  obj->set_map(*map);
+  obj->set_elements(*elements);
+  return Utils::ToLocal(obj);
+}
+
+
+Local<ArrayBuffer> v8::DataView::Buffer() {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::Buffer()"))
+    return Local<ArrayBuffer>();
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  ASSERT(obj->buffer()->IsJSArrayBuffer());
+  i::Handle<i::JSArrayBuffer> buffer(i::JSArrayBuffer::cast(obj->buffer()));
+  return Utils::ToLocal(buffer);
+}
+
+
+size_t v8::DataView::ByteOffset() const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::ByteOffset()")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return static_cast<size_t>(obj->byte_offset()->Number());
+}
+
+
+size_t v8::DataView::ByteLength() const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::ByteLength()")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return static_cast<size_t>(obj->byte_length()->Number());
+}
+
+
+void* v8::DataView::Data() const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::BaseAddress()")) return NULL;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  i::Handle<i::JSArrayBuffer> buffer(i::JSArrayBuffer::cast(obj->buffer()));
+  void* buffer_data = buffer->backing_store();
+  size_t byte_offset = static_cast<size_t>(obj->byte_offset()->Number());
+  return static_cast<uint8_t*>(buffer_data) + byte_offset;
+}
+
+
+int8_t v8::DataView::GetInt8(size_t byte_offset) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetInt8")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<int8_t>(byte_offset);
+}
+
+
+uint8_t v8::DataView::GetUint8(size_t byte_offset) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetUint8")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<uint8_t>(byte_offset);
+}
+
+
+int16_t v8::DataView::GetInt16(size_t byte_offset, bool little_endian) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetInt16")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<int16_t>(byte_offset, little_endian);
+}
+
+
+uint16_t v8::DataView::GetUint16(size_t byte_offset, bool little_endian) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetUint16")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<uint16_t>(byte_offset, little_endian);
+}
+
+
+int32_t v8::DataView::GetInt32(size_t byte_offset, bool little_endian) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetInt32")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<int32_t>(byte_offset, little_endian);
+}
+
+
+uint32_t v8::DataView::GetUint32(size_t byte_offset, bool little_endian) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetUint32")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<uint32_t>(byte_offset, little_endian);
+}
+
+
+float v8::DataView::GetFloat32(size_t byte_offset, bool little_endian) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetFloat32")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<float>(byte_offset, little_endian);
+}
+
+
+double v8::DataView::GetFloat64(size_t byte_offset, bool little_endian) const {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::GetFloat64")) return 0;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  return obj->Get<double>(byte_offset, little_endian);
+}
+
+
+void v8::DataView::SetInt8(size_t byte_offset, int8_t value) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetInt8")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value);
+}
+
+
+void v8::DataView::SetUint8(size_t byte_offset, uint8_t value) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetUint8")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value);
+}
+
+
+void v8::DataView::SetInt16(size_t byte_offset,
+                            int16_t value,
+                            bool little_endian) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetInt16")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value, little_endian);
+}
+
+
+void v8::DataView::SetUint16(size_t byte_offset,
+                             uint16_t value,
+                             bool little_endian) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetUint16")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value, little_endian);
+}
+
+
+void v8::DataView::SetInt32(size_t byte_offset,
+                            int32_t value,
+                            bool little_endian) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetInt32")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value, little_endian);
+}
+
+
+void v8::DataView::SetUint32(size_t byte_offset,
+                             uint32_t value,
+                             bool little_endian) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetUint32")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value, little_endian);
+}
+
+
+void v8::DataView::SetFloat32(size_t byte_offset,
+                              float value,
+                              bool little_endian) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetFloat32")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value, little_endian);
+}
+
+
+void v8::DataView::SetFloat64(size_t byte_offset,
+                              double value,
+                              bool little_endian) {
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::DataView::SetFloat64")) return;
+  i::Handle<i::JSDataView> obj = Utils::OpenHandle(this);
+  obj->Set(byte_offset, value, little_endian);
+}
+
+
 Local<ArrayBuffer> v8::TypedArray::Buffer() {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   if (IsDeadCheck(isolate, "v8::TypedArray::Buffer()"))