First step towards loading the core library scripts directly from the sources

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/cpu.h"
@@ skipping 659 matching lines @@
                                   const Library& lib) {
   ASSERT(public_class_name.Length() > 0);
   ASSERT(public_class_name.CharAt(0) == '_');
   String& str = String::Handle();
   str = lib.PrivateName(public_class_name);
   cls.set_name(str);
   lib.AddClass(cls);
 }
 
 
 #define LOAD_LIBRARY(name, raw_name)                                           \

[Ivan Posva, 2013/04/29 04:42:32]

This is now an empty macro.

[siva, 2013/04/29 17:35:58]

Yes, removed it.

On 2013/04/29 04:42:32, Ivan Posva wrote:

-  url = Symbols::Dart##name().raw();                                           \
-  lib = Library::LookupLibrary(url);                                           \
-  if (lib.IsNull()) {                                                          \
-    lib = Library::NewLibraryHelper(url, true);                                \
-    lib.Register();                                                            \
-  }                                                                            \
-  isolate->object_store()->set_##raw_name##_library(lib);                      \
-
-#define INIT_LIBRARY(name, raw_name, has_patch)                                \
-  LOAD_LIBRARY(name, raw_name)                                                 \
-  script = Bootstrap::Load##name##Script(false);                               \
-  error = Bootstrap::Compile(lib, script);                                     \
-  if (!error.IsNull()) {                                                       \
-    return error.raw();                                                        \
-  }                                                                            \
-  if (has_patch) {                                                             \
-    script = Bootstrap::Load##name##Script(true);                              \
-    error = lib.Patch(script);                                                 \
-    if (!error.IsNull()) {                                                     \
-      return error.raw();                                                      \
-    }                                                                          \
-  }                                                                            \
 
 
 RawError* Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
   Type& type = Type::Handle();
   Array& array = Array::Handle();
-  String& url = String::Handle();
   Library& lib = Library::Handle();
-  Script& script = Script::Handle();
-  Error& error = Error::Handle();
 
   // All RawArray fields will be initialized to an empty array, therefore
   // initialize array class first.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   // Array and ImmutableArray are the only VM classes that are parameterized.
   // Since they are pre-finalized, CalculateFieldOffsets() is not called, so we
   // need to set the offset of their type_arguments_ field, which is explicitly
   // declared in RawArray.
@@ skipping 110 matching lines @@
   RegisterClass(cls, Symbols::StackTrace(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
   RegisterPrivateClass(cls, Symbols::JSSyntaxRegExp(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   // Initialize the base interfaces used by the core VM classes.
-  script = Bootstrap::LoadCoreScript(false);
+  const Script& core_script = Script::Handle(Bootstrap::LoadCoreScript());
 
   // Allocate and initialize the pre-allocated classes in the core library.
   cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
   cls.set_name(Symbols::Object());
-  cls.set_script(script);
+  cls.set_script(core_script);
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = object_store->type_class();
   RegisterPrivateClass(cls, Symbols::Type(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
@@ skipping 30 matching lines @@
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
   // Setup some default native field classes which can be extended for
   // specifying native fields in dart classes.
   Library::InitNativeWrappersLibrary(isolate);
   ASSERT(isolate->object_store()->native_wrappers_library() != Library::null());
 
   // Pre-register the typed_data library so the native class implementations
   // can be hooked up before compiling it.
-  LOAD_LIBRARY(TypedData, typed_data);
+  lib = Library::LookupLibrary(Symbols::DartTypedData());
+  if (lib.IsNull()) {
+    lib = Library::NewLibraryHelper(Symbols::DartTypedData(), true);
+    lib.Register();
+    isolate->object_store()->set_bootstrap_library(ObjectStore::kTypedData,
+                                                   lib);
+  }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
   const intptr_t typed_data_class_array_length =
       RawObject::NumberOfTypedDataClasses();
   Array& typed_data_classes =
       Array::Handle(Array::New(typed_data_class_array_length));
   int index = 0;
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);                      \
   index = kTypedData##clazz##Cid - kTypedDataInt8ArrayCid;                     \
@@ skipping 58 matching lines @@
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_type(type);
 
   cls = Class::New<Number>();
   RegisterClass(cls, Symbols::Number(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_number_type(type);
 
-  cls = Class::New<Instance>(Symbols::Int(), script, Scanner::kDummyTokenIndex);
+  cls = Class::New<Instance>(Symbols::Int(),
+                             core_script,
+                             Scanner::kDummyTokenIndex);
   RegisterClass(cls, Symbols::Int(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_type(type);
 
   cls = Class::New<Instance>(Symbols::Double(),
-                             script,
+                             core_script,
                              Scanner::kDummyTokenIndex);
   RegisterClass(cls, Symbols::Double(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_type(type);
 
   name = Symbols::New("String");
-  cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
+  cls = Class::New<Instance>(name, core_script, Scanner::kDummyTokenIndex);
   RegisterClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_type(type);
 
   cls = Class::New<Instance>(Symbols::List(),
-                             script,
+                             core_script,
                              Scanner::kDummyTokenIndex);
   RegisterClass(cls, Symbols::List(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   object_store->set_list_class(cls);
 
   cls = object_store->bool_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_type(type);
 
   cls = object_store->smi_class();
@@ skipping 19 matching lines @@
   // The class 'dynamic' is registered in the class dictionary because its name
   // is a built-in identifier, rather than a reserved keyword. Its name is not
   // heap allocated, because the class resides in the VM isolate.
   // The corresponding type, the "unknown type", is stored in the object store.
   cls = dynamic_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_dynamic_type(type);
 
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
-  INIT_LIBRARY(Core, core, true);
-
-  INIT_LIBRARY(Async, async, true);
-  INIT_LIBRARY(Collection, collection, true);
-  INIT_LIBRARY(CollectionDev, collection_dev, true);
-  INIT_LIBRARY(Crypto, crypto, false);
-  INIT_LIBRARY(Isolate, isolate, true);
-  INIT_LIBRARY(Json, json, true);
-  INIT_LIBRARY(Math, math, true);
-  INIT_LIBRARY(Mirrors, mirrors, true);
-  INIT_LIBRARY(TypedData, typed_data, true);
-  INIT_LIBRARY(Utf, utf, false);
-  INIT_LIBRARY(Uri, uri, false);
-
-  Bootstrap::SetupNativeResolver();
+  const Error& error =
+      Error::Handle(Bootstrap::LoadandCompileScripts(core_script));
+  if (!error.IsNull()) {
+    return error.raw();
+  }
 
   // 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();
   MarkInvisibleFunctions();
 
   // Set up the intrinsic state of all functions (core, math and scalar list).
@@ skipping 5369 matching lines @@
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
 
 
 void Library::InitCoreLibrary(Isolate* isolate) {
   const String& core_lib_url = Symbols::DartCore();
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
   core_lib.Register();
-  isolate->object_store()->set_core_library(core_lib);
+  isolate->object_store()->set_bootstrap_library(ObjectStore::kCore, core_lib);
   isolate->object_store()->set_root_library(Library::Handle());
 
   // Hook up predefined classes without setting their library pointers. These
   // classes are coming from the VM isolate, and are shared between multiple
   // isolates so setting their library pointers would be wrong.
   const Class& cls = Class::Handle(Object::dynamic_class());
   core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
 
 
@@ skipping 6726 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart