Provide implementations for

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 2320 matching lines @@
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ScalarListAcquireData(Dart_Handle array,
                                                    Dart_Scalar_Type* type,
                                                    void** data,
                                                    intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  if (!RawObject::IsByteArrayClassId(Api::ClassId(array))) {
+  intptr_t class_id = Api::ClassId(array);
+  if (!RawObject::IsByteArrayClassId(class_id)) {
     RETURN_TYPE_ERROR(isolate, array, 'scalar list');
   }
   if (type == NULL) {
     RETURN_NULL_ERROR(type);
   }
   if (data == NULL) {
     RETURN_NULL_ERROR(data);
   }
   if (len == NULL) {
     RETURN_NULL_ERROR(len);
   }
-  isolate->IncrementNoGCScopeDepth();
-  START_NO_CALLBACK_SCOPE(isolate);
-
-  UNIMPLEMENTED();
+  // Get the type of typed array.
+  switch (class_id) {
+    case kByteArrayCid :
+      *type = kByteArray;
+      break;
+    case kInt8ArrayCid :
+    case kExternalInt8ArrayCid :
+      *type = kInt8;
+      break;
+    case kUint8ArrayCid :
+    case kExternalUint8ArrayCid :
+      *type = kUint8;
+      break;
+    case kUint8ClampedArrayCid :
+    case kExternalUint8ClampedArrayCid :
+      *type = kUint8Clamped;
+      break;
+    case kInt16ArrayCid :
+    case kExternalInt16ArrayCid :
+      *type = kInt16;
+      break;
+    case kUint16ArrayCid :
+    case kExternalUint16ArrayCid :
+      *type = kUint16;
+      break;
+    case kInt32ArrayCid :
+    case kExternalInt32ArrayCid :
+      *type = kInt32;
+      break;
+    case kUint32ArrayCid :
+    case kExternalUint32ArrayCid :
+      *type = kUint32;
+      break;
+    case kInt64ArrayCid :
+    case kExternalInt64ArrayCid :
+      *type = kInt64;
+      break;
+    case kUint64ArrayCid :
+    case kExternalUint64ArrayCid :
+      *type = kUint64;
+      break;
+    case kFloat32ArrayCid :
+    case kExternalFloat32ArrayCid :
+      *type = kFloat32;
+      break;
+    case kFloat64ArrayCid :
+    case kExternalFloat64ArrayCid :
+      *type = kFloat64;
+      break;
+  }
+  const ByteArray& obj = Api::UnwrapByteArrayHandle(isolate, array);
+  ASSERT(!obj.IsNull());
+  *len = obj.Length();
+  // If it is an external typed array object just return the data field.
+  if (RawObject::IsExternalByteArrayClassId(class_id)) {
+    *data = reinterpret_cast<void*>(obj.ByteAddr(0));
+  } else {
+    // Regular typed array object, set up some GC and API callback guards.
+    isolate->IncrementNoGCScopeDepth();
+    START_NO_CALLBACK_SCOPE(isolate);
+    *data = reinterpret_cast<void*>(obj.ByteAddr(0));
+  }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ScalarListReleaseData(Dart_Handle array) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  if (!RawObject::IsByteArrayClassId(Api::ClassId(array))) {
+  intptr_t class_id = Api::ClassId(array);
+  if (!RawObject::IsByteArrayClassId(class_id)) {
     RETURN_TYPE_ERROR(isolate, array, 'scalar list');
   }
-
-  UNIMPLEMENTED();
-  isolate->DecrementNoGCScopeDepth();
-  END_NO_CALLBACK_SCOPE(isolate);
+  if (!RawObject::IsExternalByteArrayClassId(class_id)) {
+    isolate->DecrementNoGCScopeDepth();
+    END_NO_CALLBACK_SCOPE(isolate);
+  }
   return Api::Success(isolate);
 }
 
 
 // --- Closures ---
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
   // We can't use a fast class index check here because there are many
   // different signature classes for closures.
@@ skipping 2069 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart