VM restart + shutdown fixes

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 96 matching lines @@
 // being allocated.
 static int vm_service_server_port = -1;
 
 
 // Exit code indicating an API error.
 static const int kApiErrorExitCode = 253;
 // Exit code indicating a compilation error.
 static const int kCompilationErrorExitCode = 254;
 // Exit code indicating an unhandled error that is not a compilation error.
 static const int kErrorExitCode = 255;
+// Exit code indicating a vm restart request.  Never returned to the user.
+static const int kRestartRequestExitCode = 1000;
 
 extern bool do_vm_shutdown;  // Defined in bin/process.cc
 static void ErrorExit(int exit_code, const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   Log::VPrintErr(format, arguments);
   va_end(arguments);
   fflush(stderr);
 
   Dart_ExitScope();
@@ skipping 551 matching lines @@
     }
     free(name_chars);
   }
   return result;
 }
 
 
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     *error = strdup(Dart_GetError(result));                                    \
-    *exit_code = Dart_IsCompilationError(result) ? kCompilationErrorExitCode : \
-        (Dart_IsApiError(result) ? kApiErrorExitCode : kErrorExitCode);        \
+    if (Dart_IsCompilationError(result)) {                                     \
+      *exit_code = kCompilationErrorExitCode;                                  \
+    } else if (Dart_IsApiError(result)) {                                      \
+      *exit_code = kApiErrorExitCode;                                          \
+    } else if (Dart_IsVMRestartRequest(result)) {                              \
+      *exit_code = kRestartRequestExitCode;                                    \
+    } else {                                                                   \
+      *exit_code = kErrorExitCode;                                             \
+    }                                                                          \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     return NULL;                                                               \
   }                                                                            \
 
 
 // Returns true on success, false on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(const char* script_uri,
                                                 const char* main,
                                                 const char* package_root,
@@ skipping 95 matching lines @@
     Dart_EnterIsolate(isolate);
     Dart_ShutdownIsolate();
     return NULL;
   }
 
   return isolate;
 }
 
 #undef CHECK_RESULT
 
+
 static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
                                           const char* main,
                                           const char* package_root,
                                           Dart_IsolateFlags* flags,
                                           void* data, char** error) {
   // The VM should never call the isolate helper with a NULL flags.
   ASSERT(flags != NULL);
   ASSERT(flags->version == DART_FLAGS_CURRENT_VERSION);
   IsolateData* parent_isolate_data = reinterpret_cast<IsolateData*>(data);
   int exit_code = 0;
@@ skipping 128 matching lines @@
   }
 
   const char* kFormat = "%s/%s";
   intptr_t len = strlen(script_name) + strlen(func_name) + 2;
   char* buffer = new char[len];
   ASSERT(buffer != NULL);
   snprintf(buffer, len, kFormat, script_name, func_name);
   return buffer;
 }
 
-static void DartExitOnError(Dart_Handle error) {
-  if (!Dart_IsError(error)) {
-    return;
-  }
-  const int exit_code = Dart_IsCompilationError(error) ?
-      kCompilationErrorExitCode : kErrorExitCode;
-  ErrorExit(exit_code, "%s\n", Dart_GetError(error));
-}
-
-
 static void ShutdownIsolate(void* callback_data) {
   IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
   delete isolate_data;
 }
 
 
 static const char* ServiceRequestError(Dart_Handle error) {
   TextBuffer buffer(128);
   buffer.Printf("{\"type\":\"Error\",\"text\":\"Internal error %s\"}",
                 Dart_GetError(error));
@@ skipping 114 matching lines @@
   }
   void* symbol = Extensions::ResolveSymbol(library, symname);
   if (symbol == NULL) {
     Log::PrintErr("Error: Failed to load symbol '%s'\n", symname);
     exit(kErrorExitCode);
   }
   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);
-  bool print_flags_seen = false;
-  bool verbose_debug_seen = false;
-
-  vm_options.AddArgument("--no_write_protect_code");
-  // Perform platform specific initialization.
-  if (!Platform::Initialize()) {
-    Log::PrintErr("Initialization failed\n");
+#define CHECK_RESULT(result)                                                   \
+  if (Dart_IsError(result)) {                                                  \
+    if (Dart_IsVMRestartRequest(result)) {                                     \
+      Dart_ExitScope();                                                        \
+      Dart_ShutdownIsolate();                                                  \
+      return true;                                                             \
+    }                                                                          \
+    const int exit_code = Dart_IsCompilationError(result) ?                    \
+        kCompilationErrorExitCode : kErrorExitCode;                            \
+    ErrorExit(exit_code, "%s\n", Dart_GetError(result));                       \
   }
 
-  // On Windows, the argv strings are code page encoded and not
-  // utf8. We need to convert them to utf8.
-  bool argv_converted = ShellUtils::GetUtf8Argv(argc, argv);
-
-  // Parse command line arguments.
-  if (ParseArguments(argc,
-                     argv,
-                     &vm_options,
-                     &script_name,
-                     &dart_options,
-                     &print_flags_seen,
-                     &verbose_debug_seen) < 0) {
-    if (has_help_option) {
-      PrintUsage();
-      exit(0);
-    } else if (has_version_option) {
-      PrintVersion();
-      exit(0);
-    } else if (print_flags_seen) {
-      // Will set the VM flags, print them out and then we exit as no
-      // script was specified on the command line.
-      Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
-      exit(0);
-    } else {
-      PrintUsage();
-      exit(kErrorExitCode);
-    }
-  }
-
-  Thread::InitOnce();
-
-  if (!DartUtils::SetOriginalWorkingDirectory()) {
-    OSError err;
-    fprintf(stderr, "Error determining current directory: %s\n", err.message());
-    fflush(stderr);
-    exit(kErrorExitCode);
-  }
-
-  if (generate_script_snapshot) {
-    vm_options.AddArgument("--load_deferred_eagerly");
-  }
-
-  Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
-
-  // Start event handler.
-  EventHandler::Start();
-
-  // Start the debugger wire protocol handler if necessary.
-  if (start_debugger) {
-    ASSERT(debug_port >= 0);
-    bool print_msg = verbose_debug_seen || (debug_port == 0);
-    debug_port = DebuggerConnectionHandler::StartHandler(debug_ip, debug_port);
-    if (print_msg) {
-      Log::Print("Debugger listening on port %d\n", debug_port);
-    }
-  } else {
-    DebuggerConnectionHandler::InitForVmService();
-  }
-
-  const uint8_t* instructions_snapshot = NULL;
-  if (has_run_precompiled_snapshot) {
-    instructions_snapshot = reinterpret_cast<const uint8_t*>(
-        LoadLibrarySymbol(kPrecompiledLibraryName, kPrecompiledSymbolName));
-    ReadSnapshotFile(kPrecompiledVmIsolateName, &vm_isolate_snapshot_buffer);
-    ReadSnapshotFile(kPrecompiledIsolateName, &isolate_snapshot_buffer);
-  }
-
-  // Initialize the Dart VM.
-  char* error = Dart_Initialize(
-      vm_isolate_snapshot_buffer, instructions_snapshot,
-      CreateIsolateAndSetup, NULL, NULL, ShutdownIsolate,
-      DartUtils::OpenFile,
-      DartUtils::ReadFile,
-      DartUtils::WriteFile,
-      DartUtils::CloseFile,
-      DartUtils::EntropySource);
-  if (error != NULL) {
-    if (do_vm_shutdown) {
-      DebuggerConnectionHandler::StopHandler();
-      EventHandler::Stop();
-    }
-    fprintf(stderr, "VM initialization failed: %s\n", error);
-    fflush(stderr);
-    free(error);
-    exit(kErrorExitCode);
-  }
-
-  Dart_RegisterIsolateServiceRequestCallback(
-        "getIO", &ServiceGetIOHandler, NULL);
-  Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
-                                 &ServiceStreamCancelCallback);
-
+bool RunMainIsolate(const char* script_name,
+                    CommandLineOptions* dart_options) {
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
+  char* error = NULL;
   int exit_code = 0;
   char* isolate_name = BuildIsolateName(script_name, "main");
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(script_name,
                                                      "main",
                                                      commandline_package_root,
                                                      commandline_packages_file,
                                                      NULL,
                                                      &error,
                                                      &exit_code);
   if (isolate == NULL) {
+    delete [] isolate_name;
+    if (exit_code == kRestartRequestExitCode) {
+      free(error);
+      return true;
+    }
     Log::PrintErr("%s\n", error);
     free(error);
     error = NULL;
-    delete [] isolate_name;
     Process::TerminateExitCodeHandler();
     error = Dart_Cleanup();
     if (error != NULL) {
       Log::PrintErr("VM cleanup failed: %s\n", error);
       free(error);
     }
     if (do_vm_shutdown) {
       DebuggerConnectionHandler::StopHandler();
       EventHandler::Stop();
     }
     exit((exit_code != 0) ? exit_code : kErrorExitCode);
   }
   delete [] isolate_name;
 
   Dart_EnterIsolate(isolate);
   ASSERT(isolate == Dart_CurrentIsolate());
   ASSERT(isolate != NULL);
   Dart_Handle result;
 
   Dart_EnterScope();
 
   if (generate_script_snapshot) {
     // First create a snapshot.
     Dart_Handle result;
     uint8_t* buffer = NULL;
     intptr_t size = 0;
     result = Dart_CreateScriptSnapshot(&buffer, &size);
-    DartExitOnError(result);
+    CHECK_RESULT(result);
 
     // Open the snapshot file.
     File* snapshot_file = File::Open(snapshot_filename, File::kWriteTruncate);
     if (snapshot_file == NULL) {
       ErrorExit(kErrorExitCode,
                 "Unable to open file %s for writing the snapshot\n",
                 snapshot_filename);
     }
 
     // Write the magic number to indicate file is a script snapshot.
@@ skipping 35 matching lines @@
         { "dart:io", "_ProcessStartStatus", "set:_errorMessage" },
         { "dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE" },
         { "dart:io", "_SecureFilterImpl", "get:SIZE" },
         { "dart:vmservice_io", "::", "_addResource" },
         { "dart:vmservice_io", "::", "main" },
         { NULL, NULL, NULL }  // Must be terminated with NULL entries.
       };
 
       const bool reset_fields = has_gen_precompiled_snapshot;
       result = Dart_Precompile(standalone_entry_points, reset_fields);
-      DartExitOnError(result);
+      CHECK_RESULT(result);
     }
 
     if (has_gen_precompiled_snapshot) {
       uint8_t* vm_isolate_buffer = NULL;
       intptr_t vm_isolate_size = 0;
       uint8_t* isolate_buffer = NULL;
       intptr_t isolate_size = 0;
       uint8_t* instructions_buffer = NULL;
       intptr_t instructions_size = 0;
       result = Dart_CreatePrecompiledSnapshot(&vm_isolate_buffer,
                                               &vm_isolate_size,
                                               &isolate_buffer,
                                               &isolate_size,
                                               &instructions_buffer,
                                               &instructions_size);
-      DartExitOnError(result);
+      CHECK_RESULT(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();
-        DartExitOnError(result);
+        CHECK_RESULT(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);
+      CHECK_RESULT(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
+      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);
+      CHECK_RESULT(result);
 
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
-      DartExitOnError(result);
+      CHECK_RESULT(result);
     }
   }
 
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
+
+  // No restart.
+  return false;
+}
+
+#undef CHECK_RESULT
+
+
+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);
+  bool print_flags_seen = false;
+  bool verbose_debug_seen = false;
+
+  vm_options.AddArgument("--no_write_protect_code");
+  // Perform platform specific initialization.
+  if (!Platform::Initialize()) {
+    Log::PrintErr("Initialization failed\n");
+  }
+
+  // On Windows, the argv strings are code page encoded and not
+  // utf8. We need to convert them to utf8.
+  bool argv_converted = ShellUtils::GetUtf8Argv(argc, argv);
+
+  // Parse command line arguments.
+  if (ParseArguments(argc,
+                     argv,
+                     &vm_options,
+                     &script_name,
+                     &dart_options,
+                     &print_flags_seen,
+                     &verbose_debug_seen) < 0) {
+    if (has_help_option) {
+      PrintUsage();
+      exit(0);
+    } else if (has_version_option) {
+      PrintVersion();
+      exit(0);
+    } else if (print_flags_seen) {
+      // Will set the VM flags, print them out and then we exit as no
+      // script was specified on the command line.
+      Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
+      exit(0);
+    } else {
+      PrintUsage();
+      exit(kErrorExitCode);
+    }
+  }
+
+  Thread::InitOnce();
+
+  if (!DartUtils::SetOriginalWorkingDirectory()) {
+    OSError err;
+    fprintf(stderr, "Error determining current directory: %s\n", err.message());
+    fflush(stderr);
+    exit(kErrorExitCode);
+  }
+
+  if (generate_script_snapshot) {
+    vm_options.AddArgument("--load_deferred_eagerly");
+  }
+
+  Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
+
+  // Start event handler.
+  EventHandler::Start();
+
+  // Start the debugger wire protocol handler if necessary.
+  if (start_debugger) {
+    ASSERT(debug_port >= 0);
+    bool print_msg = verbose_debug_seen || (debug_port == 0);
+    debug_port = DebuggerConnectionHandler::StartHandler(debug_ip, debug_port);
+    if (print_msg) {
+      Log::Print("Debugger listening on port %d\n", debug_port);
+    }
+  } else {
+    DebuggerConnectionHandler::InitForVmService();
+  }
+
+  const uint8_t* instructions_snapshot = NULL;
+  if (has_run_precompiled_snapshot) {
+    instructions_snapshot = reinterpret_cast<const uint8_t*>(
+        LoadLibrarySymbol(kPrecompiledLibraryName, kPrecompiledSymbolName));
+    ReadSnapshotFile(kPrecompiledVmIsolateName, &vm_isolate_snapshot_buffer);
+    ReadSnapshotFile(kPrecompiledIsolateName, &isolate_snapshot_buffer);
+  }
+
+  // Initialize the Dart VM.
+  char* error = Dart_Initialize(
+      vm_isolate_snapshot_buffer, instructions_snapshot,
+      CreateIsolateAndSetup, NULL, NULL, ShutdownIsolate,
+      DartUtils::OpenFile,
+      DartUtils::ReadFile,
+      DartUtils::WriteFile,
+      DartUtils::CloseFile,
+      DartUtils::EntropySource);
+  if (error != NULL) {
+    if (do_vm_shutdown) {
+      DebuggerConnectionHandler::StopHandler();
+      EventHandler::Stop();
+    }
+    fprintf(stderr, "VM initialization failed: %s\n", error);
+    fflush(stderr);
+    free(error);
+    exit(kErrorExitCode);
+  }
+
+  Dart_RegisterIsolateServiceRequestCallback(
+        "getIO", &ServiceGetIOHandler, NULL);
+  Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
+                                 &ServiceStreamCancelCallback);
+
+  // 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) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
     free(error);
   }
   if (do_vm_shutdown) {
     DebuggerConnectionHandler::StopHandler();
@@ skipping 19 matching lines @@
   exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }