Add functions to list library and script urls in an isolate.

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 4026 matching lines @@
   Smi& used = Smi::Handle();
   used ^= dict.At(dict_size);
   intptr_t used_elements = used.Value() + 1;  // One more element added.
   used = Smi::New(used_elements);
   dict.SetAt(dict_size, used);  // Update used count.
 
   // Rehash if symbol_table is 75% full.
   if (used_elements > ((dict_size / 4) * 3)) {
     GrowDictionary(dict, dict_size);
   }
+
+  // Invalidate the cache of loaded scripts.
+  if (loaded_scripts() != Array::null()) {
+    StorePointer(&raw_ptr()->loaded_scripts_, Array::null());
+  }

[siva, 2012/01/24 18:37:14]

Should this be an assertion that loaded_scripts should always be null over here?

[hausner, 2012/01/24 21:34:42]

See comment below.

 }
 
 
 void Library::AddClass(const Class& cls) const {
   AddObject(cls, String::Handle(cls.Name()));
   // Link class to this library.
   cls.set_library(*this);
 }
 
 
+RawArray* Library::LoadedScripts() const {
+  // We compute the list of loaded scripts lazily. The result is
+  // cached in loaded_scripts_.

[siva, 2012/01/24 18:37:14]

Should we assert that this should be called only after class finalization is
done.

[hausner, 2012/01/24 21:34:42]

I had an assert at first that made sure this is only called when the library is
in load_state_ == RawLibrary::kLoaded. The assert fired for the core libraries,
though.

Rather than figuring out why the core libs are not considered kLoaded, I made
this function more flexible by invalidating the cache whenever anything is
loaded. In all practical sense, I never expect this cache to be invalidated
though.

+  if (loaded_scripts() == Array::null()) {
+    // Iterate over the library dictionary and collect all scripts.
+    GrowableArray<Script*> scripts(8);
+    Object& entry = Object::Handle();
+    Function& func = Function::Handle();
+    Field& field = Field::Handle();
+    Class& cls = Class::Handle();
+    Script& owner_script = Script::Handle();
+    DictionaryIterator it(*this);
+    while (it.HasNext()) {
+      entry = it.GetNext();
+      if (entry.IsClass()) {
+        cls ^= entry.raw();
+      } else if (entry.IsFunction()) {
+        func ^= entry.raw();
+        cls = func.owner();
+      } else if (entry.IsField()) {
+        field ^= entry.raw();
+        cls = field.owner();
+      } else {
+        continue;
+      }
+      owner_script = cls.script();
+      if (owner_script.IsNull()) {
+        continue;
+      }
+      bool is_unique = true;
+      for (int i = 0; i < scripts.length(); i++) {
+        if (scripts[i]->raw() == owner_script.raw()) {
+          // We already have a reference to this script.
+          is_unique = false;
+          break;
+        }
+      }
+      if (is_unique) {
+        // Create a unique script handle and add it to the list of scripts.
+        Script& unique_script = Script::Handle(owner_script.raw());
+        scripts.Add(&unique_script);
+      }
+    }
+
+    // Create the array of scripts and cache it in loaded_scripts_.
+    const Array& loaded_scripts =
+        Array::Handle(Array::New(scripts.length(), Heap::kOld));
+    for (int i = 0; i < scripts.length(); i++) {
+      loaded_scripts.SetAt(i, *scripts[i]);
+    }
+    StorePointer(&raw_ptr()->loaded_scripts_, loaded_scripts.raw());
+  }
+  return loaded_scripts();
+}
+
+
 // TODO(hausner): we might want to add a script dictionary to the
-// library class to make this lookup less cumbersome.
+// library class to make this lookup faster.
 RawScript* Library::LookupScript(const String& url) const {
-  Object& entry = Object::Handle();
-  Class& cls = Class::Handle();
-  Function& func = Function::Handle();
-  Field& field = Field::Handle();
-  Script& owner_script = Script::Handle();
-  String& owner_url = String::Handle();
-
-  DictionaryIterator it(*this);
-  while (it.HasNext()) {
-    entry = it.GetNext();
-    if (entry.IsClass()) {
-      cls ^= entry.raw();
-    } else if (entry.IsFunction()) {
-      func ^= entry.raw();
-      cls = func.owner();
-    } else if (entry.IsField()) {
-      field ^= entry.raw();
-      cls = field.owner();
-    } else {
-      continue;
-    }
-    owner_script = cls.script();
-    if (owner_script.IsNull()) {
-      continue;
-    }
-    owner_url = owner_script.url();
-    if (owner_url.Equals(url)) {
-      return owner_script.raw();
+  const Array& scripts = Array::Handle(LoadedScripts());
+  Script& script = Script::Handle();
+  String& script_url = String::Handle();
+  intptr_t num_scripts = scripts.Length();
+  for (int i = 0; i < num_scripts; i++) {
+    script ^= scripts.At(i);
+    script_url = script.url();
+    if (script_url.Equals(url)) {
+      return script.raw();
     }
   }
   return Script::null();
 }
 
 
 RawFunction* Library::LookupFunctionInSource(const String& script_url,
                                              intptr_t line_number) const {
   Script& script = Script::Handle(LookupScript(script_url));
   if (script.IsNull()) {
@@ skipping 330 matching lines @@
                                       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());
     result.AddImport(core_lib);
@@ skipping 3334 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