More precompiled snapshotting.

runtime/bin/main.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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 703 matching lines @@
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
   CHECK_RESULT(result);
 
   if (Dart_IsServiceIsolate(isolate)) {
     // If this is the service isolate, load embedder specific bits and return.
     if (!VmService::Setup(vm_service_server_ip, vm_service_server_port)) {
       *error = strdup(VmService::GetErrorMessage());
       return NULL;
     }
-    if (has_gen_precompiled_snapshot) {
-      result = Dart_Precompile();
-      CHECK_RESULT(result);
-    } else if (has_compile_all) {
+    if (has_compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
     Dart_ExitScope();
     Dart_ExitIsolate();
     return isolate;
   }
 
   // Load the specified application script into the newly created isolate.
 
@@ skipping 297 matching lines @@
   capture_stdio = (capture_stdout || capture_stderr);
 }
 
 
 static void WriteSnapshotFile(const char* filename,
                               const uint8_t* buffer,
                               const intptr_t size) {
   File* file = File::Open(filename, File::kWriteTruncate);
   ASSERT(file != NULL);
   if (!file->WriteFully(buffer, size)) {
-    Log::PrintErr("Error: Failed to write snapshot file.\n\n");
+    ErrorExit(kErrorExitCode,
+              "Unable to open file %s for writing snapshot\n",
+              filename);
   }
   delete file;
 }
 
 
 static void ReadSnapshotFile(const char* filename,
                              const uint8_t** buffer) {
   void* file = DartUtils::OpenFile(filename, false);
   if (file == NULL) {
-    Log::PrintErr("Error: Failed to open '%s'.\n\n", filename);
-    exit(kErrorExitCode);
+    ErrorExit(kErrorExitCode,
+              "Error: Unable to open file %s for reading snapshot\n", filename);
   }
   intptr_t len = -1;
   DartUtils::ReadFile(buffer, &len, file);
   if (*buffer == NULL || len == -1) {
-    Log::PrintErr("Error: Failed to read '%s'.\n\n", filename);
-    exit(kErrorExitCode);
+    ErrorExit(kErrorExitCode,
+              "Error: Unable to read snapshot file %s\n", filename);
   }
   DartUtils::CloseFile(file);
 }
 
 
 static void* LoadLibrarySymbol(const char* libname, const char* symname) {
   void* library = Extensions::LoadExtensionLibrary(libname);
   if (library == NULL) {
-    Log::PrintErr("Error: Failed to load library '%s'.\n\n", libname);
-    exit(kErrorExitCode);
+    ErrorExit(kErrorExitCode,
+              "Error: Failed to load library '%s'\n", libname);
   }
   void* symbol = Extensions::ResolveSymbol(library, symname);
   if (symbol == NULL) {
-    Log::PrintErr("Failed to load symbol '%s'\n", symname);
-    exit(kErrorExitCode);
+    ErrorExit(kErrorExitCode,
+              "Error: Failed to load symbol '%s'\n", symname);
   }
   return symbol;
 }
 
 
 void main(int argc, char** argv) {
   char* script_name;
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
   CommandLineOptions dart_options(argc);
@@ skipping 188 matching lines @@
       DartExitOnError(result);
       WriteSnapshotFile(kPrecompiledVmIsolateName,
                         vm_isolate_buffer,
                         vm_isolate_size);
       WriteSnapshotFile(kPrecompiledIsolateName,
                         isolate_buffer,
                         isolate_size);
       WriteSnapshotFile(kPrecompiledInstructionsName,
                         instructions_buffer,
                         instructions_size);
-    } else if (has_compile_all) {
-      result = Dart_CompileAll();
+    } else {
+      if (has_compile_all) {
+        result = Dart_CompileAll();
+        DartExitOnError(result);
+      }
+
+      if (Dart_IsNull(root_lib)) {
+        ErrorExit(kErrorExitCode,
+                  "Unable to find root library for '%s'\n",
+                  script_name);
+      }
+
+      // The helper function _getMainClosure creates a closure for the main
+      // entry point which is either explicitly or implictly exported from the
+      // root library.
+      Dart_Handle main_closure = Dart_Invoke(builtin_lib,
+          Dart_NewStringFromCString("_getMainClosure"), 0, NULL);
+      DartExitOnError(main_closure);
+
+      // Set debug breakpoint if specified on the command line before calling
+      // the main function.
+      if (breakpoint_at != NULL) {
+        result = SetBreakpoint(breakpoint_at, root_lib);
+        if (Dart_IsError(result)) {
+          ErrorExit(kErrorExitCode,
+                    "Error setting breakpoint at '%s': %s\n",
+                    breakpoint_at,
+                    Dart_GetError(result));
+        }
+      }
+
+      // Call _startIsolate in the isolate library to enable dispatching the
+      // initial startup message.
+      const intptr_t kNumIsolateArgs = 2;
+      Dart_Handle isolate_args[kNumIsolateArgs];
+      isolate_args[0] = main_closure;                         // entryPoint
+      isolate_args[1] = CreateRuntimeOptions(&dart_options);  // args
+
+      Dart_Handle isolate_lib =
+          Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
+      result = Dart_Invoke(isolate_lib,
+                           Dart_NewStringFromCString("_startMainIsolate"),
+                           kNumIsolateArgs, isolate_args);
+      DartExitOnError(result);
+
+      // Keep handling messages until the last active receive port is closed.
+      result = Dart_RunLoop();
       DartExitOnError(result);
     }
-
-    if (Dart_IsNull(root_lib)) {
-      ErrorExit(kErrorExitCode,
-                "Unable to find root library for '%s'\n",
-                script_name);
-    }
-
-    // The helper function _getMainClosure creates a closure for the main
-    // entry point which is either explicitly or implictly exported from the
-    // root library.
-    Dart_Handle main_closure = Dart_Invoke(
-        builtin_lib, Dart_NewStringFromCString("_getMainClosure"), 0, NULL);
-    DartExitOnError(main_closure);
-
-    // Set debug breakpoint if specified on the command line before calling
-    // the main function.
-    if (breakpoint_at != NULL) {
-      result = SetBreakpoint(breakpoint_at, root_lib);
-      if (Dart_IsError(result)) {
-        ErrorExit(kErrorExitCode,
-                  "Error setting breakpoint at '%s': %s\n",
-                  breakpoint_at,
-                  Dart_GetError(result));
-      }
-    }
-
-    // Call _startIsolate in the isolate library to enable dispatching the
-    // initial startup message.
-    const intptr_t kNumIsolateArgs = 2;
-    Dart_Handle isolate_args[kNumIsolateArgs];
-    isolate_args[0] = main_closure;                         // entryPoint
-    isolate_args[1] = CreateRuntimeOptions(&dart_options);  // args
-
-    Dart_Handle isolate_lib = Dart_LookupLibrary(
-        Dart_NewStringFromCString("dart:isolate"));
-    result = Dart_Invoke(isolate_lib,
-                         Dart_NewStringFromCString("_startMainIsolate"),
-                         kNumIsolateArgs, isolate_args);
-    DartExitOnError(result);
-
-    // Keep handling messages until the last active receive port is closed.
-    result = Dart_RunLoop();
-    DartExitOnError(result);
   }
 
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   error = Dart_Cleanup();
   if (error != NULL) {
@@ skipping 24 matching lines @@
   exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }