Introduce a VM-only dart:scalarlist library for byte arrays.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 536 matching lines @@
   const GrowableObjectArray& libraries =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   object_store->set_libraries(libraries);
 
   // Basic infrastructure has been setup, initialize the class dictionary.
   Library::InitCoreLibrary(isolate);
   Library& core_lib = Library::Handle(Library::CoreLibrary());
   ASSERT(!core_lib.IsNull());
   Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   ASSERT(!core_impl_lib.IsNull());
+  Library::InitScalarlistLibrary(isolate);

[Ivan Posva, 2012/09/20 06:42:26]

Can you explain why this has to be done so early?

[Mads Ager (google), 2012/09/20 06:49:43]

The code below adds the classes to the library, so we need the library here for
the same reason as we need it for core and coreimpl since classes are added
explicitly below.

+  Library& scalarlist_lib = Library::Handle(Library::ScalarlistLibrary());
 
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   object_store->set_pending_classes(pending_classes);
 
   Context& context = Context::Handle(Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
@@ skipping 112 matching lines @@
   name = Symbols::Bigint();
   RegisterPrivateClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
   name = Symbols::Double();
   RegisterPrivateClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
-  cls = Class::New<Int8Array>();
-  object_store->set_int8_array_class(cls);
-  name = Symbols::_Int8Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Uint8Array>();
-  object_store->set_uint8_array_class(cls);
-  name = Symbols::_Uint8Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Int16Array>();
-  object_store->set_int16_array_class(cls);
-  name = Symbols::_Int16Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Uint16Array>();
-  object_store->set_uint16_array_class(cls);
-  name = Symbols::_Uint16Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Int32Array>();
-  object_store->set_int32_array_class(cls);
-  name = Symbols::_Int32Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Uint32Array>();
-  object_store->set_uint32_array_class(cls);
-  name = Symbols::_Uint32Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Int64Array>();
-  object_store->set_int64_array_class(cls);
-  name = Symbols::_Int64Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Uint64Array>();
-  object_store->set_uint64_array_class(cls);
-  name = Symbols::_Uint64Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Float32Array>();
-  object_store->set_float32_array_class(cls);
-  name = Symbols::_Float32Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<Float64Array>();
-  object_store->set_float64_array_class(cls);
-  name = Symbols::_Float64Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalInt8Array>();
-  object_store->set_external_int8_array_class(cls);
-  name = Symbols::_ExternalInt8Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalUint8Array>();
-  object_store->set_external_uint8_array_class(cls);
-  name = Symbols::_ExternalUint8Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalInt16Array>();
-  object_store->set_external_int16_array_class(cls);
-  name = Symbols::_ExternalInt16Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalUint16Array>();
-  object_store->set_external_uint16_array_class(cls);
-  name = Symbols::_ExternalUint16Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalInt32Array>();
-  object_store->set_external_int32_array_class(cls);
-  name = Symbols::_ExternalInt32Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalUint32Array>();
-  object_store->set_external_uint32_array_class(cls);
-  name = Symbols::_ExternalUint32Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalInt64Array>();
-  object_store->set_external_int64_array_class(cls);
-  name = Symbols::_ExternalInt64Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalUint64Array>();
-  object_store->set_external_uint64_array_class(cls);
-  name = Symbols::_ExternalUint64Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalFloat32Array>();
-  object_store->set_external_float32_array_class(cls);
-  name = Symbols::_ExternalFloat32Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
-  cls = Class::New<ExternalFloat64Array>();
-  object_store->set_external_float64_array_class(cls);
-  name = Symbols::_ExternalFloat64Array();
-  RegisterPrivateClass(cls, name, core_lib);
-
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   name = Symbols::_WeakProperty();
   RegisterPrivateClass(cls, name, core_lib);
 
+  cls = Class::New<Int8Array>();
+  object_store->set_int8_array_class(cls);
+  name = Symbols::_Int8Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Uint8Array>();
+  object_store->set_uint8_array_class(cls);
+  name = Symbols::_Uint8Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Int16Array>();
+  object_store->set_int16_array_class(cls);
+  name = Symbols::_Int16Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Uint16Array>();
+  object_store->set_uint16_array_class(cls);
+  name = Symbols::_Uint16Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Int32Array>();
+  object_store->set_int32_array_class(cls);
+  name = Symbols::_Int32Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Uint32Array>();
+  object_store->set_uint32_array_class(cls);
+  name = Symbols::_Uint32Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Int64Array>();
+  object_store->set_int64_array_class(cls);
+  name = Symbols::_Int64Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Uint64Array>();
+  object_store->set_uint64_array_class(cls);
+  name = Symbols::_Uint64Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Float32Array>();
+  object_store->set_float32_array_class(cls);
+  name = Symbols::_Float32Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<Float64Array>();
+  object_store->set_float64_array_class(cls);
+  name = Symbols::_Float64Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalInt8Array>();
+  object_store->set_external_int8_array_class(cls);
+  name = Symbols::_ExternalInt8Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalUint8Array>();
+  object_store->set_external_uint8_array_class(cls);
+  name = Symbols::_ExternalUint8Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalInt16Array>();
+  object_store->set_external_int16_array_class(cls);
+  name = Symbols::_ExternalInt16Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalUint16Array>();
+  object_store->set_external_uint16_array_class(cls);
+  name = Symbols::_ExternalUint16Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalInt32Array>();
+  object_store->set_external_int32_array_class(cls);
+  name = Symbols::_ExternalInt32Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalUint32Array>();
+  object_store->set_external_uint32_array_class(cls);
+  name = Symbols::_ExternalUint32Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalInt64Array>();
+  object_store->set_external_int64_array_class(cls);
+  name = Symbols::_ExternalInt64Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalUint64Array>();
+  object_store->set_external_uint64_array_class(cls);
+  name = Symbols::_ExternalUint64Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalFloat32Array>();
+  object_store->set_external_float32_array_class(cls);
+  name = Symbols::_ExternalFloat32Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
+  cls = Class::New<ExternalFloat64Array>();
+  object_store->set_external_float64_array_class(cls);
+  name = Symbols::_ExternalFloat64Array();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   cls.set_super_type(type);
 
   // Note: The abstract class Function is represented by VM class
   // DartFunction, not VM class Function.
   name = Symbols::Function();
   cls = Class::New<DartFunction>();
   RegisterClass(cls, name, core_lib);
@@ skipping 135 matching lines @@
   ASSERT(!mirrors_lib.IsNull());
   error = Bootstrap::Compile(mirrors_lib, mirrors_script);
   if (!error.IsNull()) {
     return error.raw();
   }
   patch_script = Bootstrap::LoadMirrorsScript(true);
   error = mirrors_lib.Patch(patch_script);
   if (!error.IsNull()) {
     return error.raw();
   }
+  const Script& scalarlist_script = Script::Handle(
+      Bootstrap::LoadScalarlistScript(false));
+  ASSERT(!scalarlist_lib.IsNull());
+  error = Bootstrap::Compile(scalarlist_lib, scalarlist_script);
+  if (!error.IsNull()) {
+    return error.raw();
+  }
+  patch_script = Bootstrap::LoadScalarlistScript(true);
+  error = scalarlist_lib.Patch(patch_script);
+  if (!error.IsNull()) {
+    return error.raw();
+  }
   Bootstrap::SetupNativeResolver();
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
   cls.set_super_type(Type::Handle());
 
   ClassFinalizer::VerifyBootstrapClasses();
   return Error::null();
 }
@@ skipping 5663 matching lines @@
   lib.Register();
   const Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
   lib.AddImport(isolate_lib);
   const Library& wrappers_lib =
       Library::Handle(Library::NativeWrappersLibrary());
   lib.AddImport(wrappers_lib);
   isolate->object_store()->set_mirrors_library(lib);
 }
 
 
+void Library::InitScalarlistLibrary(Isolate* isolate) {
+  const String& url = String::Handle(Symbols::New("dart:scalarlist"));
+  const Library& lib = Library::Handle(Library::New(url));
+  lib.Register();
+  const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
+  lib.AddImport(core_impl_lib);
+  isolate->object_store()->set_scalarlist_library(lib);
+}
+
+
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
   static const int kNumNativeWrappersClasses = 4;
   ASSERT(kNumNativeWrappersClasses > 0 && kNumNativeWrappersClasses < 10);
   const String& native_flds_lib_url = String::Handle(
       Symbols::New("dart:nativewrappers"));
   const Library& native_flds_lib = Library::Handle(
       Library::NewLibraryHelper(native_flds_lib_url, false));
   native_flds_lib.Register();
   isolate->object_store()->set_native_wrappers_library(native_flds_lib);
   static const char* const kNativeWrappersClass = "NativeFieldWrapperClass";
@@ skipping 108 matching lines @@
 RawLibrary* Library::IsolateLibrary() {
   return Isolate::Current()->object_store()->isolate_library();
 }
 
 
 RawLibrary* Library::MirrorsLibrary() {
   return Isolate::Current()->object_store()->mirrors_library();
 }
 
 
+RawLibrary* Library::ScalarlistLibrary() {
+  return Isolate::Current()->object_store()->scalarlist_library();
+}
+
+
 RawLibrary* Library::NativeWrappersLibrary() {
   return Isolate::Current()->object_store()->native_wrappers_library();
 }
 
 
 const char* Library::ToCString() const {
   const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
@@ skipping 4845 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart