Implement export clause in VM

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 5366 matching lines @@
     GrowDictionary(dict, dict_size);
   }
 
   // Invalidate the cache of loaded scripts.
   if (loaded_scripts() != Array::null()) {
     StorePointer(&raw_ptr()->loaded_scripts_, Array::null());
   }
 }
 
 
+// Lookup a name in the library's export namespace.

[siva, 2012/10/08 20:17:42]

maybe "library's exported namespace."

The name LookupExport also is a bit confusing as it seems to imply that we would
look for the name in the exports.

I would get rid of this function and just inline the
if (HasExports()) {
  ...
}

Stuff in Namespace::Lookup....

[Ivan Posva, 2012/10/08 21:35:50]

I will change it so that LookupExport will only lookup symbols in the exports,
and adapt the use further below.

[Ivan Posva, 2012/10/09 00:53:19]

Done.

+RawObject* Library::LookupExport(const String& name) const {
+  intptr_t ignore = 0;
+  Object& obj = Object::Handle(LookupEntry(name, &ignore));
+  if (!obj.IsNull()) {
+    return obj.raw();
+  }
+  if (HasExports()) {
+    const Array& exports = Array::Handle(this->exports());
+    Namespace& ns = Namespace::Handle();
+    for (int i = 0; i < exports.Length(); i++) {
+      ns ^= exports.At(i);
+      obj = ns.Lookup(name);
+      if (!obj.IsNull()) {
+        return obj.raw();
+      }
+    }
+  }
+  return Object::null();
+}
+
+
 RawObject* Library::LookupEntry(const String& name, intptr_t *index) const {
   Isolate* isolate = Isolate::Current();
   const Array& dict = Array::Handle(isolate, dictionary());
   intptr_t dict_size = dict.Length() - 1;
   *index = name.Hash() % dict_size;
 
   Object& entry = Object::Handle(isolate);
   String& entry_name = String::Handle(isolate);
   entry = dict.At(*index);
   // Search the entry in the hash set.
@@ skipping 336 matching lines @@
     intptr_t new_len = (num_anonymous == 0) ? 4 : num_anonymous * 2;
     anon_array = Array::Grow(anon_array, new_len);
     StorePointer(&raw_ptr()->anonymous_classes_, anon_array.raw());
   }
   anon_array.SetAt(num_anonymous, cls);
   num_anonymous++;
   raw_ptr()->num_anonymous_ = num_anonymous;
 }
 
 
-RawLibrary* Library::LookupImport(const String& url) const {
-  Isolate* isolate = Isolate::Current();
-  const Array& imports = Array::Handle(isolate, this->imports());
-  intptr_t num_imports = this->num_imports();
-  Namespace& import = Namespace::Handle(isolate, Namespace::null());
-  Library& lib = Library::Handle(isolate, Library::null());
-  String& import_url = String::Handle(isolate, String::null());
-  for (int i = 0; i < num_imports; i++) {
-    import ^= imports.At(i);
-    lib = import.library();
-    import_url = lib.url();
-    if (url.Equals(import_url)) {
-      return lib.raw();
-    }
-  }
-  return Library::null();
-}
-
-
 RawLibrary* Library::ImportLibraryAt(intptr_t index) const {
   Namespace& import = Namespace::Handle(ImportAt(index));
   if (import.IsNull()) {
     return Library::null();
   }
   return import.library();
 }
 
 
 RawNamespace* Library::ImportAt(intptr_t index) const {
@@ skipping 40 matching lines @@
     capacity = capacity + kImportsCapacityIncrement;
     imports = Array::Grow(imports, capacity);
     StorePointer(&raw_ptr()->imports_, imports.raw());
   }
   intptr_t index = num_imports();
   imports.SetAt(index, ns);
   set_num_imports(index + 1);
 }
 
 
+// Convenience function to determine whether the export list is
+// non-empty.
+bool Library::HasExports() const {
+  return exports() != Object::empty_array();
+}
+
+
+// We add one namespace at a time to the exports array and don't
+// pre-allocate any unused capacity. The assumption is that
+// re-exports are quite rare.
+void Library::AddExport(const Namespace& ns) const {
+  Array &exports = Array::Handle(this->exports());
+  intptr_t num_exports = exports.Length();
+  exports = Array::Grow(exports, num_exports + 1);
+  StorePointer(&raw_ptr()->exports_, exports.raw());
+  exports.SetAt(num_exports, ns);
+}
+
+
 void Library::InitClassDictionary() const {
   // The last element of the dictionary specifies the number of in use slots.
   // TODO(iposva): Find reasonable initial size.
   const int kInitialElementCount = 16;
 
   const Array& dictionary =
       Array::Handle(Array::New(kInitialElementCount + 1, Heap::kOld));
   dictionary.SetAt(kInitialElementCount, Smi::Handle(Smi::New(0)));
   StorePointer(&raw_ptr()->dictionary_, dictionary.raw());
 }
@@ skipping 19 matching lines @@
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, url.raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
   result.raw_ptr()->private_key_ = Scanner::AllocatePrivateKey(result);
   result.raw_ptr()->dictionary_ = Object::empty_array();
   result.raw_ptr()->anonymous_classes_ = Object::empty_array();
   result.raw_ptr()->num_anonymous_ = 0;
   result.raw_ptr()->imports_ = Object::empty_array();
+  result.raw_ptr()->exports_ = Object::empty_array();
   result.raw_ptr()->loaded_scripts_ = Array::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.set_debuggable(false);
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.raw_ptr()->index_ = -1;
   result.InitClassDictionary();
   result.InitImportList();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(Library::CoreLibrary());
@@ skipping 388 matching lines @@
     // There is a list of visible names. The name we're looking for is not
     // contained in the list, so it is hidden.
     return true;
   }
   // The name is not filtered out.
   return false;
 }
 
 
 RawObject* Namespace::Lookup(const String& name) const {
-  intptr_t i = 0;
   const Library& lib = Library::Handle(library());
-  const Object& obj = Object::Handle(lib.LookupEntry(name, &i));
+  const Object& obj = Object::Handle(lib.LookupExport(name));
   if (obj.IsNull() || HidesName(name)) {
     return Object::null();
   }
   return obj.raw();
 }
 
 
 RawNamespace* Namespace::New() {
   ASSERT(Object::namespace_class() != Class::null());
   RawObject* raw = Object::Allocate(Namespace::kClassId,
@@ skipping 5892 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart