Restructure code to enable reloading when a kernel dill file is specified on the command line inste…

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 813 matching lines @@
     Snapshot::GenerateAppJIT(snapshot_filename);
   }
 }
 
 
 static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
                                        bool is_main_isolate,
                                        const char* script_uri,
                                        const char* package_root,
                                        const char* packages_config,
-                                       void* kernel_program,
                                        bool set_native_resolvers,
                                        bool isolate_run_app_snapshot,
                                        char** error,
                                        int* exit_code) {
   Dart_EnterScope();
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
+  void* kernel_program = isolate_data->kernel_program;
 
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   CHECK_RESULT(result);
 
   if (kernel_program != NULL) {
     Dart_Handle result = Dart_LoadKernel(kernel_program);
     CHECK_RESULT(result);
   }
   if (set_native_resolvers) {
@@ skipping 119 matching lines @@
       new IsolateData(script_uri, package_root, packages_config, app_snapshot);
   Dart_Isolate isolate = Dart_CreateIsolate(
       script_uri, main, isolate_snapshot_data, isolate_snapshot_instructions,
       flags, isolate_data, error);
   if (isolate == NULL) {
     delete isolate_data;
     return NULL;
   }
 
   return IsolateSetupHelper(isolate, false, script_uri, package_root,
-                            packages_config, NULL, isolate_snapshot_data,
+                            packages_config, isolate_snapshot_data,
                             isolate_run_app_snapshot, error, exit_code);
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
 
 // Returns newly created Service Isolate on success, NULL on failure.
 // For now we only support the service isolate coming up from sources
 // which are compiled by the VM parser.
 static Dart_Isolate CreateAndSetupServiceIsolate(const char* script_uri,
                                                  const char* main,
@@ skipping 60 matching lines @@
                                                 const char* package_root,
                                                 const char* packages_config,
                                                 Dart_IsolateFlags* flags,
                                                 char** error,
                                                 int* exit_code) {
   ASSERT(script_uri != NULL);
   void* kernel_platform = NULL;
   void* kernel_program = NULL;
   AppSnapshot* app_snapshot = NULL;
 
+  IsolateData* isolate_data =
+      new IsolateData(script_uri, package_root, packages_config, app_snapshot);
+  if (is_main_isolate && (snapshot_deps_filename != NULL)) {
+    isolate_data->set_dependencies(new MallocGrowableArray<char*>());
+  }
+
 #if defined(DART_PRECOMPILED_RUNTIME)
   // AOT: All isolates start from the app snapshot.
   bool isolate_run_app_snapshot = true;
   const uint8_t* isolate_snapshot_data = app_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       app_isolate_snapshot_instructions;
 #else
   // JIT: Main isolate starts from the app snapshot, if any. Other isolates
   // use the core libraries snapshot.
   bool isolate_run_app_snapshot = false;
@@ skipping 10 matching lines @@
     app_snapshot = Snapshot::TryReadAppSnapshot(script_uri);
     if (app_snapshot != NULL) {
       isolate_run_app_snapshot = true;
       const uint8_t* ignore_vm_snapshot_data;
       const uint8_t* ignore_vm_snapshot_instructions;
       app_snapshot->SetBuffers(
           &ignore_vm_snapshot_data, &ignore_vm_snapshot_instructions,
           &isolate_snapshot_data, &isolate_snapshot_instructions);
     }
   }
-  const uint8_t* platform_file = NULL;
-  if (dfe.UsePlatformBinary()) {
-    intptr_t platform_length = -1;
-    bool success = dfe.TryReadKernelFile(dfe.platform_binary_filename(),
-                                         &platform_file, &platform_length);
-    if (!success) {
-      *error = strdup("The platform binary is not a valid Dart Kernel file.");
-      *exit_code = kErrorExitCode;
-      return NULL;
+  if (!isolate_run_app_snapshot) {
+    kernel_platform = dfe.kernel_platform();
+    kernel_program = dfe.ReadScript(script_uri);
+    if (kernel_program == NULL && dfe.UseDartFrontend()) {
+      kernel_program = dfe.CompileAndReadScript(script_uri, error, exit_code);
+      if (kernel_program == NULL) {
+        return NULL;
+      }
     }
-    kernel_platform = Dart_ReadKernelBinary(platform_file, platform_length);
-  }
-
-  bool is_kernel = false;
-  const uint8_t* kernel_file = NULL;
-  intptr_t kernel_length = -1;
-  if (dfe.UseDartFrontend()) {
-    Dart_KernelCompilationResult result = Dart_CompileToKernel(script_uri);
-    *error = result.error;  // Copy error message (if any).
-    switch (result.status) {
-      case Dart_KernelCompilationStatus_Ok:
-        is_kernel = true;
-        kernel_file = result.kernel;
-        kernel_length = result.kernel_size;
-        break;
-      case Dart_KernelCompilationStatus_Error:
-        *exit_code = kCompilationErrorExitCode;
-        break;
-      case Dart_KernelCompilationStatus_Crash:
-        *exit_code = kDartFrontendErrorExitCode;
-        break;
-      case Dart_KernelCompilationStatus_Unknown:
-        *exit_code = kErrorExitCode;
-        break;
-    }
-    if (!is_kernel) {
-      free(const_cast<uint8_t*>(platform_file));
-      delete reinterpret_cast<kernel::Program*>(kernel_platform);
-      return NULL;
-    }
-  } else if (!isolate_run_app_snapshot) {
-    is_kernel = dfe.TryReadKernelFile(script_uri, &kernel_file, &kernel_length);
-  }
-
-  if (is_kernel) {
-    kernel_program = Dart_ReadKernelBinary(kernel_file, kernel_length);
+    isolate_data->kernel_program = kernel_program;
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-  IsolateData* isolate_data =
-      new IsolateData(script_uri, package_root, packages_config, app_snapshot);
-  if (is_main_isolate && (snapshot_deps_filename != NULL)) {
-    isolate_data->set_dependencies(new MallocGrowableArray<char*>());
-  }
   Dart_Isolate isolate = NULL;
   if (kernel_platform != NULL) {
     isolate = Dart_CreateIsolateFromKernel(script_uri, main, kernel_platform,
                                            flags, isolate_data, error);
   } else if (kernel_program != NULL) {
     isolate = Dart_CreateIsolateFromKernel(script_uri, main, kernel_program,
                                            flags, isolate_data, error);
   } else {
     isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
                                  isolate_snapshot_instructions, flags,
                                  isolate_data, error);
   }
   if (isolate == NULL) {
     delete isolate_data;
     return NULL;
   }
 
+  bool set_native_resolvers = (kernel_program || isolate_snapshot_data);
   return IsolateSetupHelper(isolate, is_main_isolate, script_uri, package_root,
-                            packages_config, kernel_program,
-                            (kernel_program || isolate_snapshot_data),
+                            packages_config, set_native_resolvers,
                             isolate_run_app_snapshot, error, exit_code);
 }
 
 #undef CHECK_RESULT
 
 
 static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
                                           const char* main,
                                           const char* package_root,
                                           const char* package_config,
@@ skipping 655 matching lines @@
     EventHandler::Stop();
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     Platform::Exit(kErrorExitCode);
   }
 
   Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
                                  &ServiceStreamCancelCallback);
   Dart_SetFileModifiedCallback(&FileModifiedCallback);
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
+  // If a kernel platform binary file is specified, read it. This
+  // step will become redundant once we have the snapshot version
+  // of the kernel core/platform libraries.
+  if (dfe.UsePlatformBinary()) {
+    if (dfe.ReadPlatform() == NULL) {
+      Log::PrintErr("The platform binary is not a valid Dart Kernel file.");
+      Platform::Exit(kErrorExitCode);
+    }
+  }
+#endif
+
   // Run the main isolate until we aren't told to restart.
   while (RunMainIsolate(script_name, &dart_options)) {
     Log::PrintErr("Restarting VM\n");
   }
 
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   error = Dart_Cleanup();
   if (error != NULL) {
@@ skipping 26 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }