First step towards generation of application script snapshots

vm/dart_api_impl.cc

 // Copyright (c) 2011, 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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 591 matching lines @@
 static uint8_t* ApiAllocator(uint8_t* ptr,
                              intptr_t old_size,
                              intptr_t new_size) {
   uword new_ptr = Api::Reallocate(reinterpret_cast<uword>(ptr),
                                   old_size,
                                   new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
-DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** snapshot_buffer,
-                                            intptr_t* snapshot_size) {
+DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** buffer,
+                                            intptr_t* size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  if (snapshot_buffer == NULL || snapshot_size == NULL) {
-    return Api::Error("Invalid input parameters to Dart_CreateSnapshot");
+  if (buffer == NULL) {
+    return Api::Error("%s expects argument 'buffer' to be non-null.",
+                      CURRENT_FUNC);
+  }
+  if (size == NULL) {
+    return Api::Error("%s expects argument 'size' to be non-null.",
+                      CURRENT_FUNC);
   }
   const char* msg = CheckIsolateState(isolate,
                                       ClassFinalizer::kGeneratingSnapshot);
   if (msg != NULL) {
     return Api::Error(msg);
   }
   // Since this is only a snapshot the root library should not be set.
   isolate->object_store()->set_root_library(Library::Handle());
-  SnapshotWriter writer(true, snapshot_buffer, ApiAllocator);
+  SnapshotWriter writer(Snapshot::kFull, buffer, ApiAllocator);
   writer.WriteFullSnapshot();
-  *snapshot_size = writer.Size();
+  *size = writer.Size();
+  return Api::Success();
+}
+
+
+DART_EXPORT Dart_Handle Dart_CreateScriptSnapshot(Dart_Handle library,
+                                                  uint8_t** buffer,
+                                                  intptr_t* size) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (buffer == NULL) {
+    return Api::Error("%s expects argument 'buffer' to be non-null.",
+                      CURRENT_FUNC);
+  }
+  if (size == NULL) {
+    return Api::Error("%s expects argument 'size' to be non-null.",
+                      CURRENT_FUNC);
+  }
+  const Library& root_lib = Api::UnwrapLibraryHandle(library);
+  if (root_lib.IsNull()) {
+    RETURN_TYPE_ERROR(library, Library);
+  }
+  const char* msg = CheckIsolateState(isolate);
+  if (msg != NULL) {
+    return Api::Error(msg);
+  }
+  ScriptSnapshotWriter writer(root_lib, buffer, ApiAllocator);
+  writer.WriteScriptSnapshot();
+  *size = writer.Size();
   return Api::Success();
 }
 
 
 // --- Messages and Ports ---
 
 
 DART_EXPORT void Dart_SetMessageCallbacks(
     Dart_PostMessageCallback post_message_callback,
     Dart_ClosePortCallback close_port_callback) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ASSERT(post_message_callback != NULL);
   ASSERT(close_port_callback != NULL);
   isolate->set_post_message_callback(post_message_callback);
   isolate->set_close_port_callback(close_port_callback);
 }
 
 
 static RawInstance* DeserializeMessage(void* data) {
   // Create a snapshot object using the buffer.
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(data);
-  ASSERT(snapshot->IsPartialSnapshot());
+  ASSERT(snapshot->IsMessageSnapshot());
 
   // Read object back from the snapshot.
   Isolate* isolate = Isolate::Current();
   SnapshotReader reader(snapshot, isolate->heap(), isolate->object_store());
   Instance& instance = Instance::Handle();
   instance ^= reader.ReadObject();
   return instance.raw();
 }
 
 
@@ skipping 75 matching lines @@
   return PortMap::PostMessage(port_id, kNoReplyPort, Api::CastMessage(buffer));
 }
 
 
 DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   DARTSCOPE_NOCHECKS(isolate);
   const Object& object = Object::Handle(Api::UnwrapHandle(handle));
   uint8_t* data = NULL;
-  SnapshotWriter writer(false, &data, &allocator);
+  SnapshotWriter writer(Snapshot::kMessage, &data, &allocator);
   writer.WriteObject(object.raw());
   writer.FinalizeBuffer();
   return PortMap::PostMessage(port_id, kNoReplyPort, Api::CastMessage(data));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& class_name = String::Handle(String::NewSymbol("SendPortImpl"));
@@ skipping 1444 matching lines @@
   CompileSource(isolate,
                 library,
                 url_str,
                 source_str,
                 RawScript::kScript,
                 &result);
   return result;
 }
 
 
+DART_EXPORT Dart_Handle Dart_LoadScriptFromSnapshot(const uint8_t* buffer) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (buffer == NULL) {
+    return Api::Error("%s expects argument 'buffer' to be non-null.",
+                      CURRENT_FUNC);
+  }
+  const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
+  if (!snapshot->IsScriptSnapshot()) {
+    return Api::Error("%s expects parameter 'buffer' to be a script type"
+                      " snapshot", CURRENT_FUNC);
+  }
+  Library& library = Library::Handle(isolate->object_store()->root_library());
+  if (!library.IsNull()) {
+    const String& library_url = String::Handle(library.url());
+    return Api::Error("%s: A script has already been loaded from '%s'.",
+                      CURRENT_FUNC, library_url.ToCString());
+  }
+  SnapshotReader reader(snapshot, isolate->heap(), isolate->object_store());
+  const Object& tmp = Object::Handle(reader.ReadObject());
+  if (!tmp.IsLibrary()) {
+    return Api::Error("%s: Unable to deserialize snapshot correctly.",
+                      CURRENT_FUNC);
+  }
+  library ^= tmp.raw();
+  isolate->object_store()->set_root_library(library);
+  return Api::NewLocalHandle(library);
+}
+
+
 DEFINE_FLAG(bool, compile_all, false, "Eagerly compile all code.");
 
 static void CompileAll(Isolate* isolate, Dart_Handle* result) {
   *result = Api::Success();
   if (FLAG_compile_all) {
     ASSERT(isolate != NULL);
     LongJump* base = isolate->long_jump_base();
     LongJump jump;
     isolate->set_long_jump_base(&jump);
     if (setjmp(*jump.Set()) == 0) {
@@ skipping 185 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart