Introduce library ids and info in the wire protocol

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 5244 matching lines @@
     lib ^= imports.At(i);
     import_url = lib.url();
     if (url.Equals(import_url)) {
       return lib.raw();
     }
   }
   return Library::null();
 }
 
 
+RawLibrary* Library::ImportAt(intptr_t index) const {
+  if ((index < 0) || index >= num_imports()) {
+    return Library::null();
+  }
+  const Array& import_list = Array::Handle(imports());
+  Library& lib = Library::Handle();
+  lib ^= import_list.At(index);
+  return lib.raw();
+}
+
+
+RawLibraryPrefix* Library::ImportPrefixAt(intptr_t index) const {
+  const Library& imported = Library::Handle(ImportAt(index));
+  if (imported.IsNull()) {
+    return LibraryPrefix::null();
+  }
+  DictionaryIterator it(*this);
+  LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
+  Object& obj = Object::Handle();
+  while (it.HasNext()) {
+    obj = it.GetNext();
+    if (obj.IsLibraryPrefix()) {
+      lib_prefix ^= obj.raw();
+      if (lib_prefix.ContainsLibrary(imported)) {
+        return lib_prefix.raw();
+      }
+    }
+  }
+  return LibraryPrefix::null();
+}
+
+
 void Library::AddImport(const Library& library) const {
   Array& imports = Array::Handle(this->imports());
   intptr_t capacity = imports.Length();
   if (num_imports() == capacity) {
     capacity = capacity + kImportsCapacityIncrement;
     imports = Array::Grow(imports, capacity);
     StorePointer(&raw_ptr()->imports_, imports.raw());
   }
   intptr_t index = num_imports();
   imports.SetAt(index, library);
@@ skipping 60 matching lines @@
   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()->loaded_scripts_ = Array::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
+  result.raw_ptr()->index_ = -1;
   result.InitClassDictionary();
   result.InitImportList();
   result.InitImportedIntoList();
   if (import_core_lib) {
     Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     result.AddImport(core_lib);
   }
   return result.raw();
 }
@@ skipping 155 matching lines @@
   return Library::null();
 }
 
 
 void Library::Register() const {
   ASSERT(Library::LookupLibrary(String::Handle(url())) == Library::null());
   ObjectStore* object_store = Isolate::Current()->object_store();
   GrowableObjectArray& libs =
       GrowableObjectArray::Handle(object_store->libraries());
   ASSERT(!libs.IsNull());
+  set_index(libs.Length());

[siva, 2012/05/29 18:07:53]

This is probably ok for now, but there is a proposal to use indirection after
the array has grown to a certain size. We should probably add a GetNextIndex or
some such method to GrowableObjectArray and use that here, so that we don't
forget about this implicit assumption of the length being the index here when
somebody goes and restructures GrowableObjectArray.

[hausner, 2012/05/29 19:48:18]

As we discussed offline, the code and its assumptions is fine.

On 2012/05/29 18:07:53, asiva wrote:

   libs.Add(*this);
 }
 
 
 RawLibrary* Library::CoreLibrary() {
   return Isolate::Current()->object_store()->core_library();
 }
 
 
 RawLibrary* Library::CoreImplLibrary() {
@@ skipping 35 matching lines @@
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
   Library& lib = Library::Handle();
   if ((index >= 0) || (index < num_libs())) {
     Array& libs = Array::Handle(libraries());
     lib ^= libs.At(index);
   }
   return lib.raw();
 }
 
 
-void LibraryPrefix::AddLibrary(const Library& library) const {
-  Library& lib = Library::Handle();
+bool LibraryPrefix::ContainsLibrary(const Library& library) const {
   intptr_t num_current_libs = num_libs();
-
-  // First check if the library is already in the list of libraries imported.
   if (num_current_libs > 0) {
+    Library& lib = Library::Handle();
     const String& url = String::Handle(library.url());
     String& lib_url = String::Handle();
     for (intptr_t i = 0; i < num_current_libs; i++) {
       lib = GetLibrary(i);
       ASSERT(!lib.IsNull());
       lib_url = lib.url();
       if (url.Equals(lib_url)) {
-        return;  // Library already imported with same prefix.
+        return true;
       }
     }
   }
+  return false;
+}
+
+void LibraryPrefix::AddLibrary(const Library& library) const {
+  intptr_t num_current_libs = num_libs();
+
+  // First check if the library is already in the list of libraries imported.
+  if (ContainsLibrary(library)) {
+    return;  // Library already imported with same prefix.
+  }
 
   // The library needs to be added to the list.
   Array& libs = Array::Handle(libraries());
   const intptr_t length = (libs.IsNull()) ? 0 : libs.Length();
   // Grow the list if it is full.
   if (num_current_libs >= length) {
     const intptr_t new_length = length + kIncrementSize;
     libs = Array::Grow(libs, new_length, Heap::kOld);
     set_libraries(libs);
   }
@@ skipping 4468 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