Add an external array type to support typed arrays.

runtime/vm/object.cc

 // Copyright (c) 2011, 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/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 379 matching lines @@
 
   cls = Class::New<TwoByteString>();
   object_store->set_two_byte_string_class(cls);
 
   cls = Class::New<FourByteString>();
   object_store->set_four_byte_string_class(cls);
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
 
+  cls = Class::New<ByteBuffer>();
+  object_store->set_byte_buffer_class(cls);
+
   cls = Class::New<UnhandledException>();
   object_store->set_unhandled_exception_class(cls);
 
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
   // Set the super type so that the 'toString' method is implemented.
   type = object_store->object_type();
   cls.set_super_type(type);
 
   cls = Class::New<JSRegExp>();
@@ skipping 110 matching lines @@
 
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadScript());
 
   name = String::NewSymbol("Object");
   cls = object_store->object_class();
   cls.set_name(name);
   cls.set_script(script);
   core_lib.AddClass(cls);
 
+  name = String::NewSymbol("ByteBuffer");
+  cls = object_store->byte_buffer_class();
+  cls.set_name(name);
+  cls.set_script(script);
+  core_lib.AddClass(cls);
+
   name = String::NewSymbol("Function");
   cls = Class::NewInterface(name, script);
   core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_interface(type);
 
   name = String::NewSymbol("num");
   cls = Class::NewInterface(name, script);
   core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
@@ skipping 78 matching lines @@
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   Array& empty_array = Array::Handle();
   empty_array = Array::New(0);
   object_store->set_empty_array(empty_array);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
 
+  cls = Class::New<ByteBuffer>();
+  object_store->set_byte_buffer_class(cls);
+
   cls = Class::New<Instance>();
   object_store->set_object_class(cls);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
 
   cls = Class::New<Double>();
@@ skipping 462 matching lines @@
       return object_store->four_byte_string_class();
     case kBool:
       ASSERT(object_store->bool_class() != Class::null());
       return object_store->bool_class();
     case kArray:
       ASSERT(object_store->array_class() != Class::null());
       return object_store->array_class();
     case kImmutableArray:
       ASSERT(object_store->immutable_array_class() != Class::null());
       return object_store->immutable_array_class();
+    case kByteBuffer:
+      ASSERT(object_store->byte_buffer_class() != Class::null());
+      return object_store->byte_buffer_class();
     case kStacktrace:
       ASSERT(object_store->stacktrace_class() != Class::null());
       return object_store->stacktrace_class();
     case kJSRegExp:
       ASSERT(object_store->jsregexp_class() != Class::null());
       return object_store->jsregexp_class();
     case kClosure:
       return Class::New<Closure>();
     case kInstance:
       return Class::New<Instance>();
@@ skipping 5510 matching lines @@
 RawArray* Array::Empty() {
   return Isolate::Current()->object_store()->empty_array();
 }
 
 
 const char* ImmutableArray::ToCString() const {
   return "ImmutableArray";
 }
 
 
+RawByteBuffer* ByteBuffer::New(uint8_t* data,
+                               intptr_t len,
+                               Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  const Class& byte_buffer_class =
+      Class::Handle(isolate->object_store()->byte_buffer_class());
+  ByteBuffer& result = ByteBuffer::Handle();
+  {
+    RawObject* raw = Object::Allocate(byte_buffer_class,
+                                      ByteBuffer::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.SetLength(len);
+    result.SetData(data);
+  }
+  return result.raw();
+}
+
+
+bool ByteBuffer::Equals(const Instance& other) const {
+  if (this->raw() == other.raw()) {
+    // Both handles point to the same raw instance.
+    return true;
+  }
+
+  if (!other.IsByteBuffer() || other.IsNull()) {
+    return false;
+  }
+
+  ByteBuffer& other_array = ByteBuffer::Handle();
+  other_array ^= other.raw();
+
+  intptr_t len = this->Length();
+  if (len != other_array.Length()) {
+    return false;
+  }
+
+  return !memcmp(this->Addr<uint8_t>(0), other_array.Addr<uint8_t>(0), len);
+}
+
+
+const char* ByteBuffer::ToCString() const {
+  return "ByteBuffer";
+}
+
+
 RawClosure* Closure::New(const Function& function,
                          const Context& context,
                          Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   ASSERT(context.isolate() == isolate);
 
   const Class& cls = Class::Handle(function.signature_class());
   Closure& result = Closure::Handle();
   {
     RawObject* raw = Object::Allocate(cls, Closure::InstanceSize(), space);
@@ skipping 289 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart