- Include sources in gen_snapshot and dart_no_snapshot to allow

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/class_finalizer.h"
@@ skipping 12 matching lines @@
 
 typedef struct {
   ObjectStore::BootstrapLibraryId index_;
   const char* uri_;
   const char** source_paths_;
   const char* patch_uri_;
   const char** patch_paths_;
 } bootstrap_lib_props;
 
 
+enum {
+  kPathsUriOffset = 0,
+  kPathsFileOffset = 1,
+  kPathsSourceOffset = 2,
+  kPathsEntryLength = 3
+};
+
+
 static bootstrap_lib_props bootstrap_libraries[] = {
   INIT_LIBRARY(ObjectStore::kCore,
                core,
                Bootstrap::core_source_paths_,
                Bootstrap::core_patch_paths_),
   INIT_LIBRARY(ObjectStore::kAsync,
                async,
                Bootstrap::async_source_paths_,
                Bootstrap::async_patch_paths_),
   INIT_LIBRARY(ObjectStore::kConvert,
@@ skipping 36 matching lines @@
                _vmservice,
                Bootstrap::_vmservice_source_paths_,
                Bootstrap::_vmservice_patch_paths_),
   { ObjectStore::kNone, NULL, NULL, NULL, NULL }
 };
 
 
 static RawString* GetLibrarySource(const Library& lib,
                                    const String& uri,
                                    bool patch) {
-  // First check if this is a valid boot strap library and find it's index
+  // First check if this is a valid bootstrap library and find it's index
   // in the 'bootstrap_libraries' table above.
   intptr_t index;
   const String& lib_uri = String::Handle(lib.url());
   for (index = 0;
        bootstrap_libraries[index].index_ != ObjectStore::kNone;
        ++index) {
     if (lib_uri.Equals(bootstrap_libraries[index].uri_)) {
       break;
     }
   }
   if (bootstrap_libraries[index].index_ == ObjectStore::kNone) {
-    return String::null();  // Library is not a boot strap library.
+    return String::null();  // Library is not a bootstrap library.
   }
 
   // Try to read the source using the path specified for the uri.
   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.
   }
   const char* source_path = NULL;
-  for (intptr_t i = 0; source_paths[i] != NULL; i += 2) {
-    if (uri.Equals(source_paths[i])) {
-      source_path = source_paths[i + 1];
+  const char* source_data = NULL;
+  for (intptr_t i = 0; source_paths[i] != NULL; i += kPathsEntryLength) {
+    if (uri.Equals(source_paths[i + kPathsUriOffset])) {
+      source_path = source_paths[i + kPathsFileOffset];
+      source_data = source_paths[i + kPathsSourceOffset];
       break;
     }
   }
-  if (source_path == NULL) {
+  if ((source_path == NULL) && (source_data == NULL)) {
     return String::null();  // Uri does not exist in path mapping information.
   }
 
+  const uint8_t* utf8_array = NULL;
+  intptr_t file_length = -1;
+
   Dart_FileOpenCallback file_open = Isolate::file_open_callback();
   Dart_FileReadCallback file_read = Isolate::file_read_callback();
   Dart_FileCloseCallback file_close = Isolate::file_close_callback();
-  if (file_open == NULL || file_read == NULL || file_close == NULL) {
-    return String::null();  // File operations are not supported.
+  if ((file_open == NULL || file_read == NULL || file_close == NULL)) {
+    if (source_data == NULL) {
+      return String::null();
+    }
+    file_length = strlen(source_data);
+    utf8_array = reinterpret_cast<const uint8_t*>(source_data);
+  } else {
+    void* stream = (*file_open)(source_path, false);
+    if (stream == NULL) {
+      if (source_data == NULL) {
+        return String::null();
+      }
+      file_length = strlen(source_data);
+      utf8_array = reinterpret_cast<const uint8_t*>(source_data);
+    } else {
+      (*file_read)(&utf8_array, &file_length, stream);
+      (*file_close)(stream);
+      if (file_length == -1) {
+        return String::null();
+      }
+      ASSERT(utf8_array != NULL);

[siva, 2015/11/17 19:37:55]

This assert can move down to the else block as it is valid in both cases now.

[Ivan Posva, 2015/11/17 22:50:26]

Simplified the whole logic around here. Did not like it too much with the
multiple jumps out in the middle.

+    }
   }
-
-  void* stream = (*file_open)(source_path, false);
-  if (stream == NULL) {
-    return String::null();
-  }
-
-  const uint8_t* utf8_array = NULL;
-  intptr_t file_length = -1;
-  (*file_read)(&utf8_array, &file_length, stream);
-  if (file_length == -1) {
-    return String::null();
-  }
-  ASSERT(utf8_array != NULL);
-
-  (*file_close)(stream);
-
   return String::FromUTF8(utf8_array, file_length);
 }
 
 
 static RawError* Compile(const Library& library, const Script& script) {
   bool update_lib_status = (script.kind() == RawScript::kScriptTag ||
                             script.kind() == RawScript::kLibraryTag);
   if (update_lib_status) {
     library.SetLoadInProgress();
   }
@@ skipping 76 matching lines @@
                                 const Library& lib,
                                 const String& patch_uri,
                                 const char** patch_files) {
   String& patch_file_uri = String::Handle(zone);
   String& source = String::Handle(zone);
   Script& script = Script::Handle(zone);
   Error& error = Error::Handle(zone);
   const Array& strings = Array::Handle(zone, Array::New(3));
   strings.SetAt(0, patch_uri);
   strings.SetAt(1, Symbols::Slash());
-  for (intptr_t j = 0; patch_files[j] != NULL; j += 2) {
-    patch_file_uri = String::New(patch_files[j]);
+  for (intptr_t j = 0; patch_files[j] != NULL; j += kPathsEntryLength) {
+    patch_file_uri = String::New(patch_files[j + kPathsUriOffset]);
     source = GetLibrarySource(lib, patch_file_uri, true);
     if (source.IsNull()) {
       const String& message = String::Handle(
           String::NewFormatted("Unable to find dart patch source for %s",
                                patch_file_uri.ToCString()));
       return ApiError::New(message);
     }
     // 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);
@@ skipping 86 matching lines @@
     Compiler::CompileClass(cls);
   }
 
   // Restore the library tag handler for the isolate.
   isolate->set_library_tag_handler(saved_tag_handler);
 
   return error.raw();
 }
 
 }  // namespace dart