Implement {Int,Uint}{8,16,32,64} and Float{32,64} typed arrays.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 1635 matching lines @@
   type& array = type::Handle(isolate);                                         \
   array ^= obj.raw();                                                          \
   *len = array.Length();                                                       \
   return Api::Success(isolate);                                                \
 
 
 DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
-  if (obj.IsByteArray()) {

[Ivan Posva, 2012/05/02 08:19:17]

You should preserve support for fast handling of byte arrays. This is essential
for dart:io.

[cshapiro, 2012/05/03 04:01:50]

Done.  Restored.  I think this case is easy to keep.  The ones below are not as
straight forward.

-    GET_LIST_LENGTH(isolate, ByteArray, obj, len);
-  }
   if (obj.IsArray()) {
     GET_LIST_LENGTH(isolate, Array, obj, len);
   }
   if (obj.IsGrowableObjectArray()) {
     GET_LIST_LENGTH(isolate, GrowableObjectArray, obj, len);
   }
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance =
       Instance::Handle(isolate, GetListInstance(isolate, obj));
   if (instance.IsNull()) {
@@ skipping 151 matching lines @@
   return Api::NewError("Invalid length passed in to access array elements");   \
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
-  if (obj.IsByteArray()) {

[Ivan Posva, 2012/05/02 08:19:17]

ditto.

[cshapiro, 2012/05/03 04:01:50]

I will make this work for the Uint8Array types.  I am not sure any other types
make sense.

The semantics of this function and its setter variant are not obvious.  While
they were the only way to transmit data back when, now we have something better.
 Once this change is complete, we ought to replace these (rather slow) methods
with something specific to byte arrays.

-    ByteArray& byte_array = ByteArray::Handle(isolate);
-    byte_array ^= obj.raw();
-    if (Utils::RangeCheck(offset, length, byte_array.Length())) {
-      ByteArray::Copy(native_array, byte_array, offset, length);
-      return Api::Success(isolate);
-    }
-    return Api::NewError("Invalid length passed in to access list elements");
-  }
   if (obj.IsArray()) {
     GET_LIST_ELEMENT_AS_BYTES(isolate,
                               Array,
                               obj,
                               native_array,
                               offset,
                               length);  }
   if (obj.IsGrowableObjectArray()) {
     GET_LIST_ELEMENT_AS_BYTES(isolate,
                               GrowableObjectArray,
@@ skipping 55 matching lines @@
   return Api::NewError("Invalid length passed in to set array elements");      \
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
-  if (obj.IsByteArray()) {

[Ivan Posva, 2012/05/02 08:19:17]

ditto.

[cshapiro, 2012/05/03 04:01:50]

Sure, with the same limitations as above.

-    ByteArray& byte_array = ByteArray::Handle(isolate);
-    byte_array ^= obj.raw();
-    if (Utils::RangeCheck(offset, length, byte_array.Length())) {
-      ByteArray::Copy(byte_array, offset, native_array, length);
-      return Api::Success(isolate);
-    }
-    return Api::NewError("Invalid length passed in to set list elements");
-  }
   if (obj.IsArray()) {
     if (obj.IsImmutableArray()) {
       return Api::NewError("Cannot modify immutable array");
     }
     SET_LIST_ELEMENT_AS_BYTES(isolate,
                               Array,
                               obj,
                               native_array,
                               offset,
                               length);
@@ skipping 46 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsByteArray();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewByteArray(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  return Api::NewHandle(isolate, InternalByteArray::New(length));
+  return Api::NewHandle(isolate, Uint8Array::New(length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalByteArray(uint8_t* data,
                                                   intptr_t length,
                                                   void* peer,
                                                   Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
     return Api::NewError("%s expects argument 'data' to be non-null.",
                          CURRENT_FUNC);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
   return Api::NewHandle(
-      isolate, ExternalByteArray::New(data, length, peer, callback));
+      isolate, ExternalUint8Array::New(data, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ExternalByteArrayGetPeer(Dart_Handle object,
                                                       void** peer) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const ExternalByteArray& array =
-      Api::UnwrapExternalByteArrayHandle(isolate, object);
+  const ExternalUint8Array& array =
+      Api::UnwrapExternalUint8ArrayHandle(isolate, object);
   if (array.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, object, ExternalByteArray);
+    RETURN_TYPE_ERROR(isolate, object, ExternalUint8Array);
   }
   if (peer == NULL) {
     return Api::NewError("%s expects argument 'peer' to be non-null.",
                          CURRENT_FUNC);
   }
   *peer = array.GetPeer();
   return Api::Success(isolate);
 }
 
 
 template<typename T>
 Dart_Handle ByteArrayGetAt(T* value, Dart_Handle array, intptr_t offset) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   const ByteArray& array_obj = Api::UnwrapByteArrayHandle(isolate, array);
   if (array_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, array, ByteArray);
   }
   intptr_t length = sizeof(T);
-  if (!Utils::RangeCheck(offset, length, array_obj.Length())) {
+  if (!Utils::RangeCheck(offset, length, array_obj.ByteLength())) {
     return Api::NewError("Invalid index passed in to get byte array element");
   }
   uint8_t* dst = reinterpret_cast<uint8_t*>(value);
   ByteArray::Copy(dst, array_obj, offset, length);
   return Api::Success(isolate);
 }
 
 
 template<typename T>
 Dart_Handle ByteArraySetAt(Dart_Handle array, intptr_t offset, T value) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   const ByteArray& array_obj = Api::UnwrapByteArrayHandle(isolate, array);
   if (array_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, array, ByteArray);
   }
   intptr_t length = sizeof(T);
-  if (!Utils::RangeCheck(offset, length, array_obj.Length())) {
+  if (!Utils::RangeCheck(offset, length, array_obj.ByteLength())) {
     return Api::NewError("Invalid index passed in to get byte array element");
   }
   const uint8_t* src = reinterpret_cast<uint8_t*>(&value);
   ByteArray::Copy(array_obj, offset, src, length);
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetInt8At(Dart_Handle array,
-                                                intptr_t offset,
+                                                intptr_t byte_offset,
                                                 int8_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetInt8At(Dart_Handle array,
-                                                intptr_t offset,
+                                                intptr_t byte_offset,
                                                 int8_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetUint8At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  uint8_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetUint8At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  uint8_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetInt16At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  int16_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetInt16At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  int16_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetUint16At(Dart_Handle array,
-                                                  intptr_t offset,
+                                                  intptr_t byte_offset,
                                                   uint16_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetUint16At(Dart_Handle array,
-                                                  intptr_t offset,
+                                                  intptr_t byte_offset,
                                                   uint16_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetInt32At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  int32_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetInt32At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  int32_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetUint32At(Dart_Handle array,
-                                                  intptr_t offset,
+                                                  intptr_t byte_offset,
                                                   uint32_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetUint32At(Dart_Handle array,
-                                                  intptr_t offset,
+                                                  intptr_t byte_offset,
                                                   uint32_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetInt64At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  int64_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetInt64At(Dart_Handle array,
-                                                 intptr_t offset,
+                                                 intptr_t byte_offset,
                                                  int64_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetUint64At(Dart_Handle array,
-                                                  intptr_t offset,
+                                                  intptr_t byte_offset,
                                                   uint64_t* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetUint64At(Dart_Handle array,
-                                                  intptr_t offset,
+                                                  intptr_t byte_offset,
                                                   uint64_t value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetFloat32At(Dart_Handle array,
-                                                   intptr_t offset,
+                                                   intptr_t byte_offset,
                                                    float* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetFloat32At(Dart_Handle array,
-                                                   intptr_t offset,
+                                                   intptr_t byte_offset,
                                                    float value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArrayGetFloat64At(Dart_Handle array,
-                                                   intptr_t offset,
+                                                   intptr_t byte_offset,
                                                    double* value) {
-  return ByteArrayGetAt(value, array, offset);
+  return ByteArrayGetAt(value, array, byte_offset);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ByteArraySetFloat64At(Dart_Handle array,
-                                                   intptr_t offset,
+                                                   intptr_t byte_offset,
                                                    double value) {
-  return ByteArraySetAt(array, offset, value);
+  return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 // --- Closures ---
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
@@ skipping 1073 matching lines @@
       *buffer = NULL;
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 }  // namespace dart