Add support for even more typed data on native ports

runtime/vm/dart_api_message.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 "vm/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
 
@@ skipping 107 matching lines @@
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(
           alloc_(NULL, 0, sizeof(Dart_CObject) + length + 1));
   ASSERT(value != NULL);
   value->value.as_string = reinterpret_cast<char*>(value) + sizeof(*value);
   value->type = Dart_CObject::kString;
   return value;
 }
 
 
-static int SizeInBytes(Dart_CObject::TypedDataType type) {
+static int GetTypedDataSizeInBytes(Dart_CObject::TypedDataType type) {
   switch (type) {
     case Dart_CObject::kInt8Array:
     case Dart_CObject::kUint8Array:
+    case Dart_CObject::kUint8ClampedArray:
       return 1;
     case Dart_CObject::kInt16Array:
     case Dart_CObject::kUint16Array:
       return 2;
+    case Dart_CObject::kInt32Array:
+    case Dart_CObject::kUint32Array:
+    case Dart_CObject::kFloat32Array:
+      return 4;
+    case Dart_CObject::kInt64Array:
+    case Dart_CObject::kUint64Array:
+    case Dart_CObject::kFloat64Array:
+      return 8;
     default:
       break;
   }
   UNREACHABLE();
   return -1;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectTypedData(
     Dart_CObject::TypedDataType type, intptr_t length) {
   // Allocate a Dart_CObject structure followed by an array of bytes
   // for the byte array content. The pointer to the byte array content
   // is set up to this area.
-  intptr_t length_in_bytes = SizeInBytes(type) * length;
+  intptr_t length_in_bytes = GetTypedDataSizeInBytes(type) * length;
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(
           alloc_(NULL, 0, sizeof(Dart_CObject) + length_in_bytes));
   ASSERT(value != NULL);
   value->type = Dart_CObject::kTypedData;
   value->value.as_typed_data.type = type;
   value->value.as_typed_data.length = length_in_bytes;
   if (length > 0) {
     value->value.as_typed_data.values =
         reinterpret_cast<uint8_t*>(value) + sizeof(*value);
@@ skipping 51 matching lines @@
 
 
 static Dart_CObject::TypedDataType GetTypedDataTypeFromView(
     Dart_CObject_Internal* object) {
   struct {
     const char* name;
     Dart_CObject::TypedDataType type;
   } view_class_names[] = {
     { "_Int8ArrayView", Dart_CObject::kInt8Array },
     { "_Uint8ArrayView", Dart_CObject::kUint8Array },
+    { "_Uint8ClampedArrayView", Dart_CObject::kUint8ClampedArray },
     { "_Int16ArrayView", Dart_CObject::kInt16Array },
     { "_Uint16ArrayView", Dart_CObject::kUint16Array },
+    { "_Int32ArrayView", Dart_CObject::kInt32Array },
+    { "_Uint32ArrayView", Dart_CObject::kUint32Array },
+    { "_Int64ArrayView", Dart_CObject::kInt64Array },
+    { "_Uint64ArrayView", Dart_CObject::kUint64Array },
+    { "_ByteDataView", Dart_CObject::kUint8Array },
+    { "_Float32ArrayView", Dart_CObject::kFloat32Array },
+    { "_Float64ArrayView", Dart_CObject::kFloat64Array },
     { NULL, Dart_CObject::kNumberOfTypedDataTypes },
   };
 
   char* library_url =
       object->cls->internal.as_class.library_url->value.as_string;
   char* class_name =
       object->cls->internal.as_class.class_name->value.as_string;
   if (strcmp("dart:typeddata", library_url) != 0) {
     return Dart_CObject::kNumberOfTypedDataTypes;
   }
   int i = 0;
   while (view_class_names[i].name != NULL) {
     if (strncmp(view_class_names[i].name,
                 class_name,
                 strlen(view_class_names[i].name)) == 0) {
       return view_class_names[i].type;
     }
     i++;
   }
   return Dart_CObject::kNumberOfTypedDataTypes;
 }
 
 
-static int GetTypedDataTypeElementSize(Dart_CObject::TypedDataType type) {
-  switch (type) {
-    case Dart_CObject::kInt8Array:
-    case Dart_CObject::kUint8Array:
-      return 1;
-    case Dart_CObject::kInt16Array:
-    case Dart_CObject::kUint16Array:
-      return 2;
-    default:
-      break;
-  }
-  UNREACHABLE();
-  return -1;
-}
-
-
 Dart_CObject* ApiMessageReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   intptr_t tags = ReadIntptrValue();
   USE(tags);
   intptr_t class_id;
 
   // There is limited support for reading regular dart instances. Only
   // typed data views are currently handled.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
@@ skipping 26 matching lines @@
       // The buffer is fully read now as typed data objects are
       // serialized in-line.
       Dart_CObject* buffer = object->internal.as_view.buffer;
       ASSERT(buffer->type == Dart_CObject::kTypedData);
 
       // Now turn the view into a byte array.
       object->type = Dart_CObject::kTypedData;
       object->value.as_typed_data.type = type;
       object->value.as_typed_data.length =
           object->internal.as_view.length *
-          GetTypedDataTypeElementSize(type);
+          GetTypedDataSizeInBytes(type);
       object->value.as_typed_data.values =
           buffer->value.as_typed_data.values +
           object->internal.as_view.offset_in_bytes;
     } else {
       // TODO(sgjesse): Handle other instances. Currently this will
       // skew the reading as the fields of the instance is not read.
     }
     return object;
   }
 
@@ skipping 275 matching lines @@
     }                                                                          \
 
     case kTypedDataInt8ArrayCid:
     case kExternalTypedDataInt8ArrayCid:
       READ_TYPED_DATA(Int8, int8_t);
 
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
       READ_TYPED_DATA(Uint8, uint8_t);
 
+    case kTypedDataUint8ClampedArrayCid:
+    case kExternalTypedDataUint8ClampedArrayCid:
+      READ_TYPED_DATA(Uint8Clamped, uint8_t);
+
     case kTypedDataInt16ArrayCid:
     case kExternalTypedDataInt16ArrayCid:
       READ_TYPED_DATA(Int16, int16_t);
 
     case kTypedDataUint16ArrayCid:
     case kExternalTypedDataUint16ArrayCid:
       READ_TYPED_DATA(Uint16, uint16_t);
 
+    case kTypedDataInt32ArrayCid:
+    case kExternalTypedDataInt32ArrayCid:
+      READ_TYPED_DATA(Int32, int32_t);
+
+    case kTypedDataUint32ArrayCid:
+    case kExternalTypedDataUint32ArrayCid:
+      READ_TYPED_DATA(Uint32, uint32_t);
+
+    case kTypedDataInt64ArrayCid:
+    case kExternalTypedDataInt64ArrayCid:
+      READ_TYPED_DATA(Int64, int64_t);
+
+    case kTypedDataUint64ArrayCid:
+    case kExternalTypedDataUint64ArrayCid:
+      READ_TYPED_DATA(Uint64, uint64_t);
+
+    case kTypedDataFloat32ArrayCid:
+    case kExternalTypedDataFloat32ArrayCid:
+      READ_TYPED_DATA(Float32, float);
+
+    case kTypedDataFloat64ArrayCid:
+    case kExternalTypedDataFloat64ArrayCid:
+      READ_TYPED_DATA(Float64, double);
+
     case kGrowableObjectArrayCid: {
       // A GrowableObjectArray is serialized as its length followed by
       // its backing store. The backing store is an array with a
       // length which might be longer than the length of the
       // GrowableObjectArray.
       intptr_t len = ReadSmiValue();
 
       Dart_CObject* value = GetBackRef(object_id);
       ASSERT(value == NULL);
       // Allocate an empty array for the GrowableObjectArray which
@@ skipping 461 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart