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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/vm/object.cc

Issue 9958046: 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: add view classes and their tests 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
« runtime/vm/object.h ('K') | « 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 9933c4e82a6d4760e965dc71d0c9d93195c84b3b..4737650c517e5eae32ec3d33c5783c286079a709 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -577,8 +577,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 and ExternalByteArray classes are the only pre-allocated
+ // Allocate and initialize the Object class and type. The Object
+ // class and ByteArray subclasses are the only pre-allocated,
// non-interface classes in the core library.
cls = Class::New<Instance>();
object_store->set_object_class(cls);
@@ -589,17 +589,143 @@ RawError* Object::Init(Isolate* isolate) {
type = Type::NewNonParameterizedType(cls);
object_store->set_object_type(type);
- cls = Class::New<InternalByteArray>();
- object_store->set_internal_byte_array_class(cls);
+ cls = Class::New<Int8Array>();
+ object_store->set_int8_array_class(cls);
String& public_class_name = String::Handle();
- public_class_name = String::New("_InternalByteArray");
+ public_class_name = String::New("_Int8Array");
Ivan Posva 2012/05/02 08:19:17 How about adding a RegisterPrivateClass similar to
cshapiro 2012/05/03 04:01:50 Sounds good. Done.
cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
cls.set_script(script);
core_lib.AddClass(cls);
- cls = Class::New<ExternalByteArray>();
- object_store->set_external_byte_array_class(cls);
- public_class_name = String::New("_ExternalByteArray");
+ cls = Class::New<Uint8Array>();
+ object_store->set_uint8_array_class(cls);
+ public_class_name = String::New("_Uint8Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Int16Array>();
+ object_store->set_int16_array_class(cls);
+ public_class_name = String::New("_Int16Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Uint16Array>();
+ object_store->set_uint16_array_class(cls);
+ public_class_name = String::New("_Uint16Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Int32Array>();
+ object_store->set_int32_array_class(cls);
+ public_class_name = String::New("_Int32Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Uint32Array>();
+ object_store->set_uint32_array_class(cls);
+ public_class_name = String::New("_Uint32Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Int64Array>();
+ object_store->set_int64_array_class(cls);
+ public_class_name = String::New("_Int64Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Uint64Array>();
+ object_store->set_uint64_array_class(cls);
+ public_class_name = String::New("_Uint64Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Float32Array>();
+ object_store->set_float32_array_class(cls);
+ public_class_name = String::New("_Float32Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<Float64Array>();
+ object_store->set_float64_array_class(cls);
+ public_class_name = String::New("_Float64Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalInt8Array>();
+ object_store->set_external_int8_array_class(cls);
+ public_class_name = String::New("_ExternalInt8Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalUint8Array>();
+ object_store->set_external_uint8_array_class(cls);
+ public_class_name = String::New("_ExternalUint8Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalInt16Array>();
+ object_store->set_external_int16_array_class(cls);
+ public_class_name = String::New("_ExternalInt16Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalUint16Array>();
+ object_store->set_external_uint16_array_class(cls);
+ public_class_name = String::New("_ExternalUint16Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalInt32Array>();
+ object_store->set_external_int32_array_class(cls);
+ public_class_name = String::New("_ExternalInt32Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalUint32Array>();
+ object_store->set_external_uint32_array_class(cls);
+ public_class_name = String::New("_ExternalUint32Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalInt64Array>();
+ object_store->set_external_int64_array_class(cls);
+ public_class_name = String::New("_ExternalInt64Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalUint64Array>();
+ object_store->set_external_uint64_array_class(cls);
+ public_class_name = String::New("_ExternalUint64Array");
+ cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
+ cls.set_script(script);
+ core_lib.AddClass(cls);
+
+ cls = Class::New<ExternalFloat32Array>();
+ object_store->set_external_float32_array_class(cls);
+ public_class_name = String::New("_ExternalFloat32Array");
+ 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);
+ public_class_name = String::New("_ExternalFloat64Array");
cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
cls.set_script(script);
core_lib.AddClass(cls);
@@ -743,11 +869,65 @@ void Object::InitFromSnapshot(Isolate* isolate) {
cls = Class::New<GrowableObjectArray>();
object_store->set_growable_object_array_class(cls);
- cls = Class::New<InternalByteArray>();
- object_store->set_internal_byte_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<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<ExternalByteArray>();
- object_store->set_external_byte_array_class(cls);
+ cls = Class::New<ExternalFloat64Array>();
+ object_store->set_external_float64_array_class(cls);
cls = Class::New<Instance>();
object_store->set_object_class(cls);
@@ -937,6 +1117,19 @@ 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.
@@ -1359,12 +1552,66 @@ RawClass* Class::GetClass(ObjectKind kind) {
case kGrowableObjectArray:
ASSERT(object_store->growable_object_array_class() != Class::null());
return object_store->growable_object_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 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 kStacktrace:
ASSERT(object_store->stacktrace_class() != Class::null());
return object_store->stacktrace_class();
@@ -8796,18 +9043,11 @@ const char* GrowableObjectArray::ToCString() const {
}
-intptr_t ByteArray::Length() const {
- // ByteArray is an abstract class.
- UNREACHABLE();
- return 0;
-}
-
-
-void ByteArray::Copy(uint8_t* dst,
+void ByteArray::Copy(void* dst,
const ByteArray& src,
intptr_t src_offset,
intptr_t length) {
- ASSERT(Utils::RangeCheck(src_offset, length, src.Length()));
+ ASSERT(Utils::RangeCheck(src_offset, length, src.ByteLength()));
{
NoGCScope no_gc;
if (length > 0) {
@@ -8819,9 +9059,9 @@ void ByteArray::Copy(uint8_t* dst,
void ByteArray::Copy(const ByteArray& dst,
intptr_t dst_offset,
- const uint8_t* src,
+ const void* src,
intptr_t length) {
- ASSERT(Utils::RangeCheck(dst_offset, length, dst.Length()));
+ ASSERT(Utils::RangeCheck(dst_offset, length, dst.ByteLength()));
{
NoGCScope no_gc;
if (length > 0) {
@@ -8836,8 +9076,8 @@ void ByteArray::Copy(const ByteArray& dst,
const ByteArray& src,
intptr_t src_offset,
intptr_t length) {
- ASSERT(Utils::RangeCheck(src_offset, length, src.Length()));
- ASSERT(Utils::RangeCheck(dst_offset, length, dst.Length()));
+ ASSERT(Utils::RangeCheck(src_offset, length, src.ByteLength()));
+ ASSERT(Utils::RangeCheck(dst_offset, length, dst.ByteLength()));
{
NoGCScope no_gc;
if (length > 0) {
@@ -8847,6 +9087,42 @@ 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();
@@ -8861,83 +9137,452 @@ const char* ByteArray::ToCString() const {
}
-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();
+template<typename HandleT, typename RawT>
+RawT* ByteArray::NewImpl(const Class& cls, intptr_t len, Heap::Space space) {
+ HandleT& result = HandleT::Handle();
{
- RawObject* raw = Object::Allocate(internal_byte_array_class,
- InternalByteArray::InstanceSize(len),
- space);
+ RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
NoGCScope no_gc;
result ^= raw;
result.SetLength(len);
if (len > 0) {
- memset(result.Addr<uint8_t>(0), 0, len);
+ memset(result.ByteAddr(0), 0, result.ByteLength());
}
}
return result.raw();
}
-RawInternalByteArray* InternalByteArray::New(const uint8_t* data,
- intptr_t len,
- Heap::Space space) {
- InternalByteArray& result =
- InternalByteArray::Handle(InternalByteArray::New(len, space));
+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();
{
+ RawObject* raw = Object::Allocate(cls, HandleT::InstanceSize(len), space);
NoGCScope no_gc;
+ result ^= raw;
+ result.SetLength(len);
if (len > 0) {
- memmove(result.Addr<uint8_t>(0), data, len);
+ memmove(result.ByteAddr(0), data, result.ByteLength());
}
}
return result.raw();
}
-const char* InternalByteArray::ToCString() const {
- return "_InternalByteArray";
+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);
}
-void ExternalByteArray::Finalize(Dart_Handle handle, void* peer) {
- delete reinterpret_cast<ExternalByteArrayData*>(peer);
- DeleteWeakPersistentHandle(handle);
+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";
}
-RawExternalByteArray* ExternalByteArray::New(uint8_t* data,
+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);
+}
+
+
+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";
+}
+
+
+RawExternalInt8Array* ExternalInt8Array::New(int8_t* data,
intptr_t len,
void* peer,
Dart_PeerFinalizer callback,
Heap::Space space) {
Isolate* isolate = Isolate::Current();
- 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 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* ExternalByteArray::ToCString() const {
- return "_ExternalByteArray";
+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 char* ExternalFloat64Array::ToCString() const {
+ return "_ExternalFloat64Array";
+}
+
+
+
RawClosure* Closure::New(const Function& function,
const Context& context,
Heap::Space space) {
« runtime/vm/object.h ('K') | « 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