Third step towards loading core library scripts directly from the sources

runtime/vm/bootstrap.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/bootstrap.h"
 
 #include "include/dart_api.h"
 
 #include "vm/bootstrap_natives.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_bootstrap, false, "Print the bootstrap source.");
 
 #define INIT_LIBRARY(index, name, source, patch)                               \
   { index,                                                                     \
     "dart:"#name, source,                                                      \
     "dart:"#name"-patch", patch }                                              \
 
 typedef struct {
   intptr_t index_;
   const char* uri_;
   const char** source_paths_;
   const char* patch_uri_;
-  const char* patch_source_;
+  const char** patch_paths_;
 } bootstrap_lib_props;
 
 
 static bootstrap_lib_props bootstrap_libraries[] = {
   INIT_LIBRARY(ObjectStore::kCore,
                core,
                Bootstrap::corelib_source_paths_,
-               Bootstrap::corelib_patch_),
+               Bootstrap::corelib_patch_paths_),
   INIT_LIBRARY(ObjectStore::kAsync,
                async,
                Bootstrap::async_source_paths_,
-               Bootstrap::async_patch_),
+               Bootstrap::async_patch_paths_),
   INIT_LIBRARY(ObjectStore::kCollection,
                collection,
                Bootstrap::collection_source_paths_,
-               Bootstrap::collection_patch_),
+               Bootstrap::collection_patch_paths_),
   INIT_LIBRARY(ObjectStore::kCollectionDev,
                _collection-dev,
                Bootstrap::collection_dev_source_paths_,
-               Bootstrap::collection_dev_patch_),
+               Bootstrap::collection_dev_patch_paths_),
   INIT_LIBRARY(ObjectStore::kCrypto,
                crypto,
                Bootstrap::crypto_source_paths_,
                NULL),
   INIT_LIBRARY(ObjectStore::kIsolate,
                isolate,
                Bootstrap::isolate_source_paths_,
-               Bootstrap::isolate_patch_),
+               Bootstrap::isolate_patch_paths_),
   INIT_LIBRARY(ObjectStore::kJson,
                json,
                Bootstrap::json_source_paths_,
-               Bootstrap::json_patch_),
+               Bootstrap::json_patch_paths_),
   INIT_LIBRARY(ObjectStore::kMath,
                math,
                Bootstrap::math_source_paths_,
-               Bootstrap::math_patch_),
+               Bootstrap::math_patch_paths_),
   INIT_LIBRARY(ObjectStore::kMirrors,
                mirrors,
                Bootstrap::mirrors_source_paths_,
-               Bootstrap::mirrors_patch_),
+               Bootstrap::mirrors_patch_paths_),
   INIT_LIBRARY(ObjectStore::kTypedData,
                typed_data,
                Bootstrap::typed_data_source_paths_,
-               Bootstrap::typed_data_patch_),
+               Bootstrap::typed_data_patch_paths_),
   INIT_LIBRARY(ObjectStore::kUtf,
                utf,
                Bootstrap::utf_source_paths_,
                NULL),
   INIT_LIBRARY(ObjectStore::kUri,
                uri,
                Bootstrap::uri_source_paths_,
                NULL),
 
   { ObjectStore::kNone, NULL, NULL, NULL, NULL }
@@ skipping 10 matching lines @@
   while (bootstrap_libraries[index].index_ != ObjectStore::kNone) {
     if (lib_uri.Equals(bootstrap_libraries[index].uri_)) {
       break;
     }
     index += 1;
   }
   if (bootstrap_libraries[index].index_ == ObjectStore::kNone) {
     return String::null();  // Library is not a boot strap library.
   }
 
-  if (patch) {
-    // TODO(asiva): Replace with actual read of the source file.
-    const char* source = bootstrap_libraries[index].patch_source_;
-    ASSERT(source != NULL);
-    return String::New(source, Heap::kOld);
-  }
-
   // Try to read the source using the path specified for the uri.
-  const char** source_paths = bootstrap_libraries[index].source_paths_;
+  const char** source_paths = patch ?
+      bootstrap_libraries[index].patch_paths_ :
+      bootstrap_libraries[index].source_paths_;
   if (source_paths == NULL) {
     return String::null();  // No path mapping information exists for library.
   }
   intptr_t i = 0;
   const char* source_path = NULL;
   while (source_paths[i] != NULL) {
     if (uri.Equals(source_paths[i])) {
       source_path = source_paths[i + 1];
       break;
     }
@@ skipping 103 matching lines @@
     return Dart_NewApiError("Invalid import of '%s' in a bootstrap library",
                             uri_str.ToCString());
   }
   ASSERT(tag == kSourceTag);
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   ASSERT(!lib.IsNull());
   return LoadPartSource(isolate, lib, uri_str);
 }
 
 
+static RawError* LoadPatchFiles(Isolate* isolate,
+                                const Library& lib,
+                                const String& patch_uri,
+                                const char** patch_files) {
+  String& patch_file_uri = String::Handle(isolate);
+  String& source = String::Handle(isolate);
+  Script& script = Script::Handle(isolate);
+  Error& error = Error::Handle(isolate);
+  const Array& strings = Array::Handle(isolate, Array::New(3));
+  strings.SetAt(0, patch_uri);
+  strings.SetAt(1, Symbols::Slash());
+  intptr_t j = 0;
+  while (patch_files[j] != NULL) {
+    patch_file_uri = String::New(patch_files[j]);
+    source = GetLibrarySource(lib, patch_file_uri, true);
+    if (source.IsNull()) {
+      return Api::UnwrapErrorHandle(
+          isolate,
+          Api::NewError("Unable to find dart patch source for %s",
+                        patch_file_uri.ToCString())).raw();
+    }
+    // Prepend the patch library URI to form a unique script URI for the patch.
+    strings.SetAt(2, patch_file_uri);
+    patch_file_uri = String::ConcatAll(strings);
+    script = Script::New(patch_file_uri, source, RawScript::kPatchTag);
+    error = lib.Patch(script);
+    if (!error.IsNull()) {
+      return error.raw();
+    }
+    j += 2;
+  }
+  return Error::null();
+}
+
+
 RawError* Bootstrap::LoadandCompileScripts() {
   Isolate* isolate = Isolate::Current();
   String& uri = String::Handle();
   String& patch_uri = String::Handle();
   String& source = String::Handle();
   Script& script = Script::Handle();
   Library& lib = Library::Handle();
   Error& error = Error::Handle();
   Dart_LibraryTagHandler saved_tag_handler = isolate->library_tag_handler();
 
@@ skipping 12 matching lines @@
     lib = Library::LookupLibrary(uri);
     if (lib.IsNull()) {
       lib = Library::NewLibraryHelper(uri, false);
       lib.Register();
     }
     isolate->object_store()->set_bootstrap_library(
         bootstrap_libraries[i].index_, lib);
     i = i + 1;
   }
 
-  // Load and compile bootstrap libraries.
+  // Load, compile and patch bootstrap libraries.
   i = 0;
   while (bootstrap_libraries[i].index_ != ObjectStore::kNone) {
     uri = Symbols::New(bootstrap_libraries[i].uri_);
     lib = Library::LookupLibrary(uri);
     ASSERT(!lib.IsNull());
     source = GetLibrarySource(lib, uri, false);
     if (source.IsNull()) {
       error ^= Api::UnwrapErrorHandle(
           isolate, Api::NewError("Unable to find dart source for %s",
                                  uri.ToCString())).raw();
       break;
     }
     script = Script::New(uri, source, RawScript::kLibraryTag);
     error = Compile(lib, script);
     if (!error.IsNull()) {
       break;
     }
     // If a patch exists, load and patch the script.
-    if (bootstrap_libraries[i].patch_source_ != NULL) {
-      patch_uri = String::New(bootstrap_libraries[i].patch_uri_,
-                              Heap::kOld);
-      source = GetLibrarySource(lib, uri, true);
-      if (source.IsNull()) {
-        error ^= Api::UnwrapErrorHandle(
-            isolate, Api::NewError("Unable to find dart patch source for %s",
-                                   uri.ToCString())).raw();
-        break;
-      }
-      script = Script::New(patch_uri, source, RawScript::kPatchTag);
-      error = lib.Patch(script);
+    if (bootstrap_libraries[i].patch_paths_ != NULL) {
+      patch_uri = Symbols::New(bootstrap_libraries[i].patch_uri_);
+      error = LoadPatchFiles(isolate,
+                             lib,
+                             patch_uri,
+                             bootstrap_libraries[i].patch_paths_);
       if (!error.IsNull()) {
         break;
       }
     }
     i = i + 1;
   }
   if (error.IsNull()) {
     SetupNativeResolver();
   }
 
   // Exit the Dart scope.
   Dart_ExitScope();
 
   // Restore the library tag handler for the isolate.
   isolate->set_library_tag_handler(saved_tag_handler);
 
   return error.raw();
 }
 
 }  // namespace dart