Remove support for 'dart:scalarlist' in the Dart VM.

runtime/vm/raw_object_snapshot.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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 2212 matching lines @@
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the mask values.
   writer->Write<uint32_t>(ptr()->value_[0]);
   writer->Write<uint32_t>(ptr()->value_[1]);
   writer->Write<uint32_t>(ptr()->value_[2]);
   writer->Write<uint32_t>(ptr()->value_[3]);
 }
 
 
-RawByteArray* ByteArray::ReadFrom(SnapshotReader* reader,
-                                  intptr_t object_id,
-                                  intptr_t tags,
-                                  Snapshot::Kind kind) {
-  UNREACHABLE();  // ByteArray is an abstract class.
-  return ByteArray::null();
-}
-
-
-template<typename HandleT, typename RawT, typename ElementT>
-RawT* ByteArray::ReadFromImpl(SnapshotReader* reader,
-                              intptr_t object_id,
-                              intptr_t tags,
-                              Snapshot::Kind kind) {
-  ASSERT(reader != NULL);
-
-  intptr_t len = reader->ReadSmiValue();
-  HandleT& result = HandleT::ZoneHandle(
-      reader->isolate(), HandleT::New(len, HEAP_SPACE(kind)));
-  reader->AddBackRef(object_id, &result, kIsDeserialized);
-
-  // Set the object tags.
-  result.set_tags(tags);
-
-  // Setup the array elements.
-  for (intptr_t i = 0; i < len; ++i) {
-    result.SetAt(i, reader->Read<ElementT>());
-  }
-  return result.raw();
-}
-
-
-#define BYTEARRAY_TYPE_LIST(V)                                                 \
-  V(Int8, int8, int8_t)                                                        \
-  V(Uint8, uint8, uint8_t)                                                     \
-  V(Uint8Clamped, uint8, uint8_t)                                              \
-  V(Int16, int16, int16_t)                                                     \
-  V(Uint16, uint16, uint16_t)                                                  \
-  V(Int32, int32, int32_t)                                                     \
-  V(Uint32, uint32, uint32_t)                                                  \
-  V(Int64, int64, int64_t)                                                     \
-  V(Uint64, uint64, uint64_t)                                                  \
-  V(Float32, float32, float)                                                   \
-  V(Float64, float64, double)                                                  \
-
-
-#define BYTEARRAY_READ_FROM(name, lname, type)                                 \
-Raw##name##Array* name##Array::ReadFrom(SnapshotReader* reader,                \
-                                          intptr_t object_id,                  \
-                                          intptr_t tags,                       \
-                                          Snapshot::Kind kind) {               \
-  return ReadFromImpl<name##Array, Raw##name##Array, type>(reader,             \
-                                                           object_id,          \
-                                                           tags,               \
-                                                           kind);              \
-}                                                                              \
-
-
-BYTEARRAY_TYPE_LIST(BYTEARRAY_READ_FROM)
-#undef BYTEARRAY_READ_FROM
-
-
-#define EXTERNALARRAY_READ_FROM(name, lname, type)                             \
-RawExternal##name##Array* External##name##Array::ReadFrom(                     \
-    SnapshotReader* reader,                                                    \
-    intptr_t object_id,                                                        \
-    intptr_t tags,                                                             \
-    Snapshot::Kind kind) {                                                     \
-  ASSERT(kind != Snapshot::kFull);                                             \
-  intptr_t length = reader->ReadSmiValue();                                    \
-  type* data = reinterpret_cast<type*>(reader->ReadIntptrValue());             \
-  const External##name##Array& obj = External##name##Array::Handle(            \
-      External##name##Array::New(data, length));                               \
-  void* peer = reinterpret_cast<void*>(reader->ReadIntptrValue());             \
-  Dart_WeakPersistentHandleFinalizer callback =                                \
-      reinterpret_cast<Dart_WeakPersistentHandleFinalizer>(                    \
-          reader->ReadIntptrValue());                                          \
-  obj.AddFinalizer(peer, callback);                                            \
-  return obj.raw();                                                            \
-}                                                                              \
-
-BYTEARRAY_TYPE_LIST(EXTERNALARRAY_READ_FROM)
-#undef EXTERNALARRAY_READ_FROM
-
-
-template<typename ElementT>
-static void ByteArrayWriteTo(SnapshotWriter* writer,
-                             intptr_t object_id,
-                             Snapshot::Kind kind,
-                             intptr_t byte_array_kind,
-                             intptr_t tags,
-                             RawSmi* length,
-                             ElementT* data) {
-  ASSERT(writer != NULL);
-  intptr_t len = Smi::Value(length);
-
-  // Write out the serialization header value for this object.
-  writer->WriteInlinedObjectHeader(object_id);
-
-  // Write out the class and tags information.
-  writer->WriteIndexedObject(byte_array_kind);
-  writer->WriteIntptrValue(tags);
-
-  // Write out the length field.
-  writer->Write<RawObject*>(length);
-
-  // Write out the array elements.
-  for (intptr_t i = 0; i < len; i++) {
-    writer->Write(data[i]);
-  }
-}
-
-
-void RawByteArray::WriteTo(SnapshotWriter* writer,
-                           intptr_t object_id,
-                           Snapshot::Kind kind) {
-  UNREACHABLE();  // ByteArray is an abstract class
-}
-
-
-#define BYTEARRAY_WRITE_TO(name, lname, type)                                  \
-void Raw##name##Array::WriteTo(SnapshotWriter* writer,                         \
-                               intptr_t object_id,                             \
-                               Snapshot::Kind kind) {                          \
-  ByteArrayWriteTo(writer,                                                     \
-                   object_id,                                                  \
-                   kind,                                                       \
-                   k##name##ArrayCid,                                          \
-                   writer->GetObjectTags(this),                                \
-                   ptr()->length_,                                             \
-                   ptr()->data_);                                              \
-}                                                                              \
-
-
-BYTEARRAY_TYPE_LIST(BYTEARRAY_WRITE_TO)
-#undef BYTEARRAY_WRITE_TO
-
-
-#define EXTERNALARRAY_WRITE_TO(name, lname, type)                              \
-void RawExternal##name##Array::WriteTo(SnapshotWriter* writer,                 \
-                                       intptr_t object_id,                     \
-                                       Snapshot::Kind kind) {                  \
-  ByteArrayWriteTo(writer,                                                     \
-                   object_id,                                                  \
-                   kind,                                                       \
-                   k##name##ArrayCid,                                          \
-                   writer->GetObjectTags(this),                                \
-                   ptr()->length_,                                             \
-                   ptr()->data_);                                              \
-}                                                                              \
-
-
-BYTEARRAY_TYPE_LIST(EXTERNALARRAY_WRITE_TO)
-#undef BYTEARRAY_WRITE_TO
-
-#undef BYTEARRAY_TYPE_LIST
-
-
 #define TYPED_DATA_READ(setter, type)                                          \
   for (intptr_t i = 0; i < lengthInBytes; i += element_size) {                 \
     result.Set##setter(i, reader->Read<type>());                               \
   }                                                                            \
 
+
 RawTypedData* TypedData::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
   intptr_t len = reader->ReadSmiValue();
   TypedData& result = TypedData::ZoneHandle(
       reader->isolate(), TypedData::New(cid, len, HEAP_SPACE(kind)));
@@ skipping 360 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->key_);
   writer->Write<RawObject*>(ptr()->value_);
 }
 
 }  // namespace dart