Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2709)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/vm/object.cc

Issue 10375007: Revert "Implement {Int,Uint}{8,16,32,64} and Float{32,64} typed arrays." (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 8 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/vm/object.h ('k') | runtime/vm/object_store.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/object.cc
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index f3528ce0a6a3792c3f07d1ffddf1d2f43b160231..ba9ff62999345c24a86aa0eff617002a00c73ad4 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -453,19 +453,6 @@ void Object::RegisterClass(const Class& cls,
}
-void Object::RegisterPrivateClass(const Class& cls,
- const char* public_class_name,
- const Script& script,
- const Library& lib) {
- String& str = String::Handle();
- str ^= String::NewSymbol(public_class_name);
- str ^= lib.PrivateName(str);
- cls.set_name(str);
- cls.set_script(script);
- lib.AddClass(cls);
-}
-
-
RawError* Object::Init(Isolate* isolate) {
TIMERSCOPE(time_bootstrap);
ObjectStore* object_store = isolate->object_store();
@@ -617,8 +604,8 @@ RawError* Object::Init(Isolate* isolate) {
// Initialize the base interfaces used by the core VM classes.
const Script& script = Script::Handle(Bootstrap::LoadScript());
- // Allocate and initialize the Object class and type. The Object
- // class and ByteArray subclasses are the only pre-allocated,
+ // Allocate and initialize the Object class and type.
+ // The Object and ExternalByteArray classes are the only pre-allocated
// non-interface classes in the core library.
cls = Class::New<Instance>();
object_store->set_object_class(cls);
@@ -630,85 +617,20 @@ RawError* Object::Init(Isolate* isolate) {
type = Type::NewNonParameterizedType(cls);
object_store->set_object_type(type);
- cls = Class::New<Int8Array>();
- object_store->set_int8_array_class(cls);
- RegisterPrivateClass(cls, "_Int8Array", script, core_lib);
-
- cls = Class::New<Uint8Array>();
- object_store->set_uint8_array_class(cls);
- RegisterPrivateClass(cls, "_Uint8Array", script, core_lib);
-
- cls = Class::New<Int16Array>();
- object_store->set_int16_array_class(cls);
- RegisterPrivateClass(cls, "_Int16Array", script, core_lib);
-
- cls = Class::New<Uint16Array>();
- object_store->set_uint16_array_class(cls);
- RegisterPrivateClass(cls, "_Uint16Array", script, core_lib);
-
- cls = Class::New<Int32Array>();
- object_store->set_int32_array_class(cls);
- RegisterPrivateClass(cls, "_Int32Array", script, core_lib);
-
- cls = Class::New<Uint32Array>();
- object_store->set_uint32_array_class(cls);
- RegisterPrivateClass(cls, "_Uint32Array", script, core_lib);
-
- cls = Class::New<Int64Array>();
- object_store->set_int64_array_class(cls);
- RegisterPrivateClass(cls, "_Int64Array", script, core_lib);
-
- cls = Class::New<Uint64Array>();
- object_store->set_uint64_array_class(cls);
- RegisterPrivateClass(cls, "_Uint64Array", script, core_lib);
-
- cls = Class::New<Float32Array>();
- object_store->set_float32_array_class(cls);
- RegisterPrivateClass(cls, "_Float32Array", script, core_lib);
-
- cls = Class::New<Float64Array>();
- object_store->set_float64_array_class(cls);
- RegisterPrivateClass(cls, "_Float64Array", script, core_lib);
-
- cls = Class::New<ExternalInt8Array>();
- object_store->set_external_int8_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalInt8Array", script, core_lib);
-
- cls = Class::New<ExternalUint8Array>();
- object_store->set_external_uint8_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalUint8Array", script, core_lib);
-
- cls = Class::New<ExternalInt16Array>();
- object_store->set_external_int16_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalInt16Array", script, core_lib);
-
- cls = Class::New<ExternalUint16Array>();
- object_store->set_external_uint16_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalUint16Array", script, core_lib);
-
- cls = Class::New<ExternalInt32Array>();
- object_store->set_external_int32_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalInt32Array", script, core_lib);
-
- cls = Class::New<ExternalUint32Array>();
- object_store->set_external_uint32_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalUint32Array", script, core_lib);
-
- cls = Class::New<ExternalInt64Array>();
- object_store->set_external_int64_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalInt64Array", script, core_lib);
-
- cls = Class::New<ExternalUint64Array>();
- object_store->set_external_uint64_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalUint64Array", script, core_lib);
-
- cls = Class::New<ExternalFloat32Array>();
- object_store->set_external_float32_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalFloat32Array", script, core_lib);
+ cls = Class::New<InternalByteArray>();
+ object_store->set_internal_byte_array_class(cls);
+ String& public_class_name = String::Handle();
+ public_class_name = String::New("_InternalByteArray");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
- cls = Class::New<ExternalFloat64Array>();
- object_store->set_external_float64_array_class(cls);
- RegisterPrivateClass(cls, "_ExternalFloat64Array", script, core_lib);
+ cls = Class::New<ExternalByteArray>();
+ object_store->set_external_byte_array_class(cls);
+ public_class_name = String::New("_ExternalByteArray");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
// Set the super type of class Stacktrace to Object type so that the
// 'toString' method is implemented.
@@ -849,65 +771,11 @@ void Object::InitFromSnapshot(Isolate* isolate) {
cls = Class::New<GrowableObjectArray>();
object_store->set_growable_object_array_class(cls);
- cls = Class::New<Int8Array>();
- object_store->set_int8_array_class(cls);
-
- cls = Class::New<Uint8Array>();
- object_store->set_uint8_array_class(cls);
-
- cls = Class::New<Int16Array>();
- object_store->set_int16_array_class(cls);
-
- cls = Class::New<Uint16Array>();
- object_store->set_uint16_array_class(cls);
-
- cls = Class::New<Int32Array>();
- object_store->set_int32_array_class(cls);
-
- cls = Class::New<Uint32Array>();
- object_store->set_uint32_array_class(cls);
-
- cls = Class::New<Int64Array>();
- object_store->set_int64_array_class(cls);
-
- cls = Class::New<Uint64Array>();
- object_store->set_uint64_array_class(cls);
-
- cls = Class::New<Float32Array>();
- object_store->set_float32_array_class(cls);
-
- cls = Class::New<Float64Array>();
- object_store->set_float64_array_class(cls);
-
- cls = Class::New<ExternalInt8Array>();
- object_store->set_external_int8_array_class(cls);
-
- cls = Class::New<ExternalUint8Array>();
- object_store->set_external_uint8_array_class(cls);
-
- cls = Class::New<ExternalInt16Array>();
- object_store->set_external_int16_array_class(cls);
+ cls = Class::New<InternalByteArray>();
+ object_store->set_internal_byte_array_class(cls);
- cls = Class::New<ExternalUint16Array>();
- object_store->set_external_uint16_array_class(cls);
-
- cls = Class::New<ExternalInt32Array>();
- object_store->set_external_int32_array_class(cls);
-
- cls = Class::New<ExternalUint32Array>();
- object_store->set_external_uint32_array_class(cls);
-
- cls = Class::New<ExternalInt64Array>();
- object_store->set_external_int64_array_class(cls);
-
- cls = Class::New<ExternalUint64Array>();
- object_store->set_external_uint64_array_class(cls);
-
- cls = Class::New<ExternalFloat32Array>();
- object_store->set_external_float32_array_class(cls);
-
- cls = Class::New<ExternalFloat64Array>();
- object_store->set_external_float64_array_class(cls);
+ cls = Class::New<ExternalByteArray>();
+ object_store->set_external_byte_array_class(cls);
cls = Class::New<Smi>();
object_store->set_smi_class(cls);
@@ -1095,19 +963,6 @@ void Class::InitEmptyFields() {
StorePointer(&raw_ptr()->fields_, empty_array.raw());
}
-
-bool Class::HasInstanceFields() const {
- const Array& field_array = Array::Handle(fields());
- Field& field = Field::Handle();
- for (intptr_t i = 0; i < field_array.Length(); ++i) {
- field ^= field_array.At(i);
- if (!field.is_static()) {
- return true;
- }
- }
- return false;
-}
-
void Class::SetFunctions(const Array& value) const {
ASSERT(!value.IsNull());
// Bind all the functions in the array to this class.
@@ -1538,66 +1393,12 @@ RawClass* Class::GetClass(ObjectKind kind) {
case kGrowableObjectArray:
ASSERT(object_store->growable_object_array_class() != Class::null());
return object_store->growable_object_array_class();
- case kInt8Array:
- ASSERT(object_store->int8_array_class() != Class::null());
- return object_store->int8_array_class();
- case kUint8Array:
- ASSERT(object_store->uint8_array_class() != Class::null());
- return object_store->uint8_array_class();
- case kInt16Array:
- ASSERT(object_store->int16_array_class() != Class::null());
- return object_store->int16_array_class();
- case kUint16Array:
- ASSERT(object_store->uint16_array_class() != Class::null());
- return object_store->uint16_array_class();
- case kInt32Array:
- ASSERT(object_store->int32_array_class() != Class::null());
- return object_store->int32_array_class();
- case kUint32Array:
- ASSERT(object_store->uint32_array_class() != Class::null());
- return object_store->uint32_array_class();
- case kInt64Array:
- ASSERT(object_store->int64_array_class() != Class::null());
- return object_store->int64_array_class();
- case kUint64Array:
- ASSERT(object_store->uint64_array_class() != Class::null());
- return object_store->uint64_array_class();
- case kFloat32Array:
- ASSERT(object_store->float32_array_class() != Class::null());
- return object_store->float32_array_class();
- case kFloat64Array:
- ASSERT(object_store->float64_array_class() != Class::null());
- return object_store->float64_array_class();
- case kExternalInt8Array:
- ASSERT(object_store->external_int8_array_class() != Class::null());
- return object_store->external_int8_array_class();
- case kExternalUint8Array:
- ASSERT(object_store->external_uint8_array_class() != Class::null());
- return object_store->external_uint8_array_class();
- case kExternalInt16Array:
- ASSERT(object_store->external_int16_array_class() != Class::null());
- return object_store->external_int16_array_class();
- case kExternalUint16Array:
- ASSERT(object_store->external_uint16_array_class() != Class::null());
- return object_store->external_uint16_array_class();
- case kExternalInt32Array:
- ASSERT(object_store->external_int32_array_class() != Class::null());
- return object_store->external_int32_array_class();
- case kExternalUint32Array:
- ASSERT(object_store->external_uint32_array_class() != Class::null());
- return object_store->external_uint32_array_class();
- case kExternalInt64Array:
- ASSERT(object_store->external_int64_array_class() != Class::null());
- return object_store->external_int64_array_class();
- case kExternalUint64Array:
- ASSERT(object_store->external_uint64_array_class() != Class::null());
- return object_store->external_uint64_array_class();
- case kExternalFloat32Array:
- ASSERT(object_store->external_float32_array_class() != Class::null());
- return object_store->external_float32_array_class();
- case kExternalFloat64Array:
- ASSERT(object_store->external_float64_array_class() != Class::null());
- return object_store->external_float64_array_class();
+ case kInternalByteArray:
+ ASSERT(object_store->internal_byte_array_class() != Class::null());
+ return object_store->internal_byte_array_class();
+ case kExternalByteArray:
+ ASSERT(object_store->external_byte_array_class() != Class::null());
+ return object_store->external_byte_array_class();
case kStacktrace:
ASSERT(object_store->stacktrace_class() != Class::null());
return object_store->stacktrace_class();
@@ -9113,11 +8914,18 @@ const char* GrowableObjectArray::ToCString() const {
}
-void ByteArray::Copy(void* dst,
+intptr_t ByteArray::Length() const {
+ // ByteArray is an abstract class.
+ UNREACHABLE();
+ return 0;
+}
+
+
+void ByteArray::Copy(uint8_t* dst,
const ByteArray& src,
intptr_t src_offset,
intptr_t length) {
- ASSERT(Utils::RangeCheck(src_offset, length, src.ByteLength()));
+ ASSERT(Utils::RangeCheck(src_offset, length, src.Length()));
{
NoGCScope no_gc;
if (length > 0) {
@@ -9129,9 +8937,9 @@ void ByteArray::Copy(void* dst,
void ByteArray::Copy(const ByteArray& dst,
intptr_t dst_offset,
- const void* src,
+ const uint8_t* src,
intptr_t length) {
- ASSERT(Utils::RangeCheck(dst_offset, length, dst.ByteLength()));
+ ASSERT(Utils::RangeCheck(dst_offset, length, dst.Length()));
{
NoGCScope no_gc;
if (length > 0) {
@@ -9146,8 +8954,8 @@ void ByteArray::Copy(const ByteArray& dst,
const ByteArray& src,
intptr_t src_offset,
intptr_t length) {
- ASSERT(Utils::RangeCheck(src_offset, length, src.ByteLength()));
- ASSERT(Utils::RangeCheck(dst_offset, length, dst.ByteLength()));
+ ASSERT(Utils::RangeCheck(src_offset, length, src.Length()));
+ ASSERT(Utils::RangeCheck(dst_offset, length, dst.Length()));
{
NoGCScope no_gc;
if (length > 0) {
@@ -9157,42 +8965,6 @@ void ByteArray::Copy(const ByteArray& dst,
}
-template<typename T>
-static void ExternalByteArrayFinalize(Dart_Handle handle, void* peer) {
- delete reinterpret_cast<ExternalByteArrayData<T>*>(peer);
- DeleteWeakPersistentHandle(handle);
-}
-
-
-template<typename HandleT, typename RawT, typename ElementT>
-RawT* ByteArray::NewExternalImpl(const Class& cls,
- ElementT* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- HandleT& result = HandleT::Handle();
- ExternalByteArrayData<ElementT>* external_data =
- new ExternalByteArrayData<ElementT>(data, peer, callback);
- {
- RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(), space);
- NoGCScope no_gc;
- result ^= raw;
- result.SetLength(len);
- result.SetExternalData(external_data);
- }
- AddFinalizer(result, external_data, ExternalByteArrayFinalize<ElementT>);
- return result.raw();
-}
-
-
-intptr_t ByteArray::ByteLength() const {
- // ByteArray is an abstract class.
- UNREACHABLE();
- return 0;
-}
-
-
uint8_t* ByteArray::ByteAddr(intptr_t byte_offset) const {
// ByteArray is an abstract class.
UNREACHABLE();
@@ -9207,452 +8979,83 @@ const char* ByteArray::ToCString() const {
}
-template<typename HandleT, typename RawT>
-RawT* ByteArray::NewImpl(const Class& cls, intptr_t len, Heap::Space space) {
- HandleT& result = HandleT::Handle();
+RawInternalByteArray* InternalByteArray::New(intptr_t len,
+ Heap::Space space) {
+ Isolate* isolate = Isolate::Current();
+ const Class& internal_byte_array_class =
+ Class::Handle(isolate->object_store()->internal_byte_array_class());
+ InternalByteArray& result = InternalByteArray::Handle();
{
- RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
+ RawObject* raw = Object::Allocate(internal_byte_array_class,
+ InternalByteArray::InstanceSize(len),
+ space);
NoGCScope no_gc;
result ^= raw;
result.SetLength(len);
if (len > 0) {
- memset(result.ByteAddr(0), 0, result.ByteLength());
+ memset(result.Addr<uint8_t>(0), 0, len);
}
}
return result.raw();
}
-template<typename HandleT, typename RawT, typename ElementT>
-RawT* ByteArray::NewImpl(const Class& cls,
- const ElementT* data,
- intptr_t len,
- Heap::Space space) {
- HandleT& result = HandleT::Handle();
+RawInternalByteArray* InternalByteArray::New(const uint8_t* data,
+ intptr_t len,
+ Heap::Space space) {
+ InternalByteArray& result =
+ InternalByteArray::Handle(InternalByteArray::New(len, space));
{
- RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
NoGCScope no_gc;
- result ^= raw;
- result.SetLength(len);
if (len > 0) {
- memmove(result.ByteAddr(0), data, result.ByteLength());
+ memmove(result.Addr<uint8_t>(0), data, len);
}
}
return result.raw();
}
-RawInt8Array* Int8Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int8_array_class());
- return NewImpl<Int8Array, RawInt8Array>(cls, len, space);
-}
-
-
-RawInt8Array* Int8Array::New(const int8_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int8_array_class());
- return NewImpl<Int8Array, RawInt8Array>(cls, data, len, space);
-}
-
-
-const char* Int8Array::ToCString() const {
- return "_Int8Array";
-}
-
-
-RawUint8Array* Uint8Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint8_array_class());
- return NewImpl<Uint8Array, RawUint8Array>(cls, len, space);
-}
-
-
-RawUint8Array* Uint8Array::New(const uint8_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint8_array_class());
- return NewImpl<Uint8Array, RawUint8Array>(cls, data, len, space);
-}
-
-
-const char* Uint8Array::ToCString() const {
- return "_Uint8Array";
-}
-
-
-RawInt16Array* Int16Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int16_array_class());
- return NewImpl<Int16Array, RawInt16Array>(cls, len, space);
-}
-
-
-RawInt16Array* Int16Array::New(const int16_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int16_array_class());
- return NewImpl<Int16Array, RawInt16Array>(cls, data, len, space);
-}
-
-
-const char* Int16Array::ToCString() const {
- return "_Int16Array";
-}
-
-
-RawUint16Array* Uint16Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint16_array_class());
- return NewImpl<Uint16Array, RawUint16Array>(cls, len, space);
+const char* InternalByteArray::ToCString() const {
+ return "_InternalByteArray";
}
-RawUint16Array* Uint16Array::New(const uint16_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint16_array_class());
- return NewImpl<Uint16Array, RawUint16Array>(cls, data, len, space);
-}
-
-
-const char* Uint16Array::ToCString() const {
- return "_Uint16Array";
-}
-
-
-RawInt32Array* Int32Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int32_array_class());
- return NewImpl<Int32Array, RawInt32Array>(cls, len, space);
-}
-
-
-RawInt32Array* Int32Array::New(const int32_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int32_array_class());
- return NewImpl<Int32Array, RawInt32Array>(cls, data, len, space);
-}
-
-
-const char* Int32Array::ToCString() const {
- return "_Int32Array";
-}
-
-
-RawUint32Array* Uint32Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint32_array_class());
- return NewImpl<Uint32Array, RawUint32Array>(cls, len, space);
-}
-
-
-RawUint32Array* Uint32Array::New(const uint32_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint32_array_class());
- return NewImpl<Uint32Array, RawUint32Array>(cls, data, len, space);
-}
-
-
-const char* Uint32Array::ToCString() const {
- return "_Uint32Array";
-}
-
-
-RawInt64Array* Int64Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int64_array_class());
- return NewImpl<Int64Array, RawInt64Array>(cls, len, space);
-}
-
-
-RawInt64Array* Int64Array::New(const int64_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->int64_array_class());
- return NewImpl<Int64Array, RawInt64Array>(cls, data, len, space);
-}
-
-
-const char* Int64Array::ToCString() const {
- return "_Int64Array";
-}
-
-
-RawUint64Array* Uint64Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint64_array_class());
- return NewImpl<Uint64Array, RawUint64Array>(cls, len, space);
-}
-
-
-RawUint64Array* Uint64Array::New(const uint64_t* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->uint64_array_class());
- return NewImpl<Uint64Array, RawUint64Array>(cls, data, len, space);
-}
-
-
-const char* Uint64Array::ToCString() const {
- return "_Uint64Array";
-}
-
-
-RawFloat32Array* Float32Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->float32_array_class());
- return NewImpl<Float32Array, RawFloat32Array>(cls, len, space);
-}
-
-
-RawFloat32Array* Float32Array::New(const float* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->float32_array_class());
- return NewImpl<Float32Array, RawFloat32Array>(cls, data, len, space);
-}
-
-
-const char* Float32Array::ToCString() const {
- return "_Float32Array";
-}
-
-
-RawFloat64Array* Float64Array::New(intptr_t len, Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->float64_array_class());
- return NewImpl<Float64Array, RawFloat64Array>(cls, len, space);
-}
-
-
-RawFloat64Array* Float64Array::New(const double* data,
- intptr_t len,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->float64_array_class());
- return NewImpl<Float64Array, RawFloat64Array>(cls, data, len, space);
-}
-
-
-const char* Float64Array::ToCString() const {
- return "_Float64Array";
+void ExternalByteArray::Finalize(Dart_Handle handle, void* peer) {
+ delete reinterpret_cast<ExternalByteArrayData*>(peer);
+ DeleteWeakPersistentHandle(handle);
}
-RawExternalInt8Array* ExternalInt8Array::New(int8_t* data,
+RawExternalByteArray* ExternalByteArray::New(uint8_t* data,
intptr_t len,
void* peer,
Dart_PeerFinalizer callback,
Heap::Space space) {
Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_int8_array_class());
- return NewExternalImpl<ExternalInt8Array, RawExternalInt8Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalInt8Array::ToCString() const {
- return "_ExternalInt8Array";
-}
-
-
-RawExternalUint8Array* ExternalUint8Array::New(uint8_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_uint8_array_class());
- return NewExternalImpl<ExternalUint8Array, RawExternalUint8Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalUint8Array::ToCString() const {
- return "_ExternalUint8Array";
-}
-
-
-RawExternalInt16Array* ExternalInt16Array::New(int16_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_int16_array_class());
- return NewExternalImpl<ExternalInt16Array, RawExternalInt16Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalInt16Array::ToCString() const {
- return "_ExternalInt16Array";
-}
-
-
-RawExternalUint16Array* ExternalUint16Array::New(uint16_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_uint16_array_class());
- return NewExternalImpl<ExternalUint16Array, RawExternalUint16Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalUint16Array::ToCString() const {
- return "_ExternalUint16Array";
-}
-
-
-RawExternalInt32Array* ExternalInt32Array::New(int32_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_int32_array_class());
- return NewExternalImpl<ExternalInt32Array, RawExternalInt32Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalInt32Array::ToCString() const {
- return "_ExternalInt32Array";
-}
-
-
-RawExternalUint32Array* ExternalUint32Array::New(uint32_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_uint32_array_class());
- return NewExternalImpl<ExternalUint32Array, RawExternalUint32Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalUint32Array::ToCString() const {
- return "_ExternalUint32Array";
-}
-
-
-RawExternalInt64Array* ExternalInt64Array::New(int64_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_int64_array_class());
- return NewExternalImpl<ExternalInt64Array, RawExternalInt64Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalInt64Array::ToCString() const {
- return "_ExternalInt64Array";
-}
-
-
-RawExternalUint64Array* ExternalUint64Array::New(uint64_t* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_uint64_array_class());
- return NewExternalImpl<ExternalUint64Array, RawExternalUint64Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalUint64Array::ToCString() const {
- return "_ExternalUint64Array";
-}
-
-
-RawExternalFloat32Array* ExternalFloat32Array::New(float* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_float32_array_class());
- return NewExternalImpl<ExternalFloat32Array, RawExternalFloat32Array>(
- cls, data, len, peer, callback, space);
-}
-
-
-const char* ExternalFloat32Array::ToCString() const {
- return "_ExternalFloat32Array";
-}
-
-
-RawExternalFloat64Array* ExternalFloat64Array::New(double* data,
- intptr_t len,
- void* peer,
- Dart_PeerFinalizer callback,
- Heap::Space space) {
- Isolate* isolate = Isolate::Current();
- const Class& cls =
- Class::Handle(isolate->object_store()->external_float64_array_class());
- return NewExternalImpl<ExternalFloat64Array, RawExternalFloat64Array>(
- cls, data, len, peer, callback, space);
+ const Class& external_byte_array_class =
+ Class::Handle(isolate->object_store()->external_byte_array_class());
+ ExternalByteArray& result = ExternalByteArray::Handle();
+ ExternalByteArrayData* external_data =
+ new ExternalByteArrayData(data, peer, callback);
+ {
+ RawObject* raw = Object::Allocate(external_byte_array_class,
+ ExternalByteArray::InstanceSize(),
+ space);
+ NoGCScope no_gc;
+ result ^= raw;
+ result.SetLength(len);
+ result.SetExternalData(external_data);
+ }
+ AddFinalizer(result, external_data, ExternalByteArray::Finalize);
+ return result.raw();
}
-const char* ExternalFloat64Array::ToCString() const {
- return "_ExternalFloat64Array";
+const char* ExternalByteArray::ToCString() const {
+ return "_ExternalByteArray";
}
-
RawClosure* Closure::New(const Function& function,
const Context& context,
Heap::Space space) {
« no previous file with comments | « runtime/vm/object.h ('k') | runtime/vm/object_store.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698