Replace linked list of loaded libraries

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 479 matching lines @@
   object_store->set_symbol_table(array);
 
   // canonical_type_arguments_ are NULL terminated.
   array = Array::New(4);
   object_store->set_canonical_type_arguments(array);
 
   // Pre-allocate the OneByteString class needed by the symbol table.
   cls = Class::New<OneByteString>();
   object_store->set_one_byte_string_class(cls);
 
+  // Set up the libraries array before initializing the core library.
+  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());
 
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
   object_store->set_pending_classes(pending_classes);
@@ skipping 4789 matching lines @@
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.raw_ptr()->name_ = url.raw();
   result.raw_ptr()->url_ = url.raw();
   result.raw_ptr()->private_key_ = Scanner::AllocatePrivateKey(result);
   result.raw_ptr()->dictionary_ = Array::Empty();
   result.raw_ptr()->anonymous_classes_ = Array::Empty();
   result.raw_ptr()->num_anonymous_ = 0;
   result.raw_ptr()->imports_ = Array::Empty();
-  result.raw_ptr()->next_registered_ = Library::null();
   result.raw_ptr()->loaded_scripts_ = Array::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.InitClassDictionary();
   result.InitImportList();
   result.InitImportedIntoList();
   if (import_core_lib) {
     Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
@@ skipping 77 matching lines @@
     cls_name = String::NewSymbol(name_buffer);
     Class::NewNativeWrapper(&native_flds_lib, cls_name, fld_cnt);
   }
 }
 
 
 RawLibrary* Library::LookupLibrary(const String &url) {
   Isolate* isolate = Isolate::Current();
   Library& lib = Library::Handle(isolate, Library::null());
   String& lib_url = String::Handle(isolate, String::null());
-  lib = isolate->object_store()->registered_libraries();
-  while (!lib.IsNull()) {
+  GrowableObjectArray& libs = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->libraries());
+  for (int i = 0; i < libs.Length(); i++) {
+    lib ^= libs.At(i);
     lib_url = lib.url();
     if (lib_url.Equals(url)) {
       return lib.raw();
     }
-    lib = lib.next_registered();
   }
   return Library::null();
 }
 
 
 RawString* Library::CheckForDuplicateDefinition() {
-  Library& lib = Library::Handle();
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
-  lib ^= object_store->registered_libraries();
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(object_store->libraries());
+  Library& lib = Library::Handle();
   String& error_message = String::Handle();
-  while (!lib.IsNull()) {
+  for (int i = 0; i < libs.Length(); i++) {
+    lib ^= libs.At(i);
     error_message = lib.FindDuplicateDefinition();
     if (!error_message.IsNull()) {
       return error_message.raw();
     }
-    lib ^= lib.next_registered();
   }
   return String::null();
 }
 
 
 bool Library::IsKeyUsed(intptr_t key) {
   intptr_t lib_key;
+  const GrowableObjectArray& libs = GrowableObjectArray::Handle(
+      Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
-  lib = Isolate::Current()->object_store()->registered_libraries();
   String& lib_url = String::Handle();
-  while (!lib.IsNull()) {
+  for (int i = 0; i < libs.Length(); i++) {
+    lib ^= libs.At(i);
     lib_url ^= lib.url();
     lib_key = lib_url.Hash();
     if (lib_key == key) {
       return true;
     }
-    lib = lib.next_registered();
   }
   return false;
 }
 
 
 RawString* Library::PrivateName(const String& name) const {
   ASSERT(ShouldBePrivate(name));
   // ASSERT(strchr(name, '@') == NULL);
   String& str = String::Handle();
   str ^= name.raw();
   str = String::Concat(str, String::Handle(this->private_key()));
   str = String::NewSymbol(str);
   return str.raw();
 }
 
 
+RawLibrary* Library::GetLibrary(intptr_t index) {
+  Isolate* isolate = Isolate::Current();
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(isolate->object_store()->libraries());
+  ASSERT(!libs.IsNull());
+  if ((0 <= index) && (index < libs.Length())) {
+    Library& lib = Library::Handle();
+    lib ^= libs.At(index);
+    return lib.raw();
+  }
+  return Library::null();
+}
+
+
 void Library::Register() const {
   ASSERT(Library::LookupLibrary(String::Handle(url())) == Library::null());
-  raw_ptr()->next_registered_ =
-      Isolate::Current()->object_store()->registered_libraries();
-  Isolate::Current()->object_store()->set_registered_libraries(*this);
+  ObjectStore* object_store = Isolate::Current()->object_store();
+  GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(object_store->libraries());
+  ASSERT(!libs.IsNull());
+  libs.Add(*this);
 }
 
 
 RawLibrary* Library::CoreLibrary() {
   return Isolate::Current()->object_store()->core_library();
 }
 
 
 RawLibrary* Library::CoreImplLibrary() {
   return Isolate::Current()->object_store()->core_impl_library();
@@ skipping 179 matching lines @@
 }
 
 
 void LibraryPrefix::set_num_libs(intptr_t value) const {
   raw_ptr()->num_libs_ = value;
 }
 
 
 RawError* Library::CompileAll() {
   Error& error = Error::Handle();
-  Library& lib = Library::Handle(
-      Isolate::Current()->object_store()->registered_libraries());
+  const GrowableObjectArray& libs = GrowableObjectArray::Handle(
+      Isolate::Current()->object_store()->libraries());
+  Library& lib = Library::Handle();
   Class& cls = Class::Handle();
-  while (!lib.IsNull()) {
+  for (int i = 0; i < libs.Length(); i++) {
+    lib ^= libs.At(i);
     ClassDictionaryIterator it(lib);
     while (it.HasNext()) {
       cls ^= it.GetNextClass();
       if (!cls.is_interface()) {
         error = Compiler::CompileAllFunctions(cls);
         if (!error.IsNull()) {
           return error.raw();
         }
       }
     }
     Array& anon_classes = Array::Handle(lib.raw_ptr()->anonymous_classes_);
     for (int i = 0; i < lib.raw_ptr()->num_anonymous_; i++) {
       cls ^= anon_classes.At(i);
       ASSERT(!cls.is_interface());
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
-    lib = lib.next_registered();
   }
   return error.raw();
 }
 
 
 RawInstructions* Instructions::New(intptr_t size) {
   const Class& instructions_class = Class::Handle(Object::instructions_class());
   Instructions& result = Instructions::Handle();
   {
     uword aligned_size = Instructions::InstanceSize(size);
@@ skipping 4315 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