Add command line options

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 23 matching lines @@
 // vm_isolate_snapshot_buffer points to a snapshot for the vm isolate if we
 // link in a snapshot otherwise it is initialized to NULL.
 extern const uint8_t* vm_isolate_snapshot_buffer;
 
 // isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
 // snapshot otherwise it is initialized to NULL.
 extern const uint8_t* isolate_snapshot_buffer;
 
 // Global state that stores a pointer to the application script snapshot.
 static bool generate_script_snapshot = false;
-static bool generate_script_snapshot_after_run = false;
+static bool generate_full_snapshot_after_run = false;
+static bool run_full_snapshot = false;
 static const char* snapshot_filename = NULL;
 
 
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_package_root = NULL;
 
 // Value of the --packages flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_packages_file = NULL;
 
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
-static bool has_compile_all = false;
+static bool compile_all = false;
 
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions before running main and not compile anything thereafter.
-static bool has_gen_precompiled_snapshot = false;
+static bool gen_precompiled_snapshot = false;
 
 
 // Global flag that is used to indicate that we want to run from a precompiled
 // snapshot.
-static bool has_run_precompiled_snapshot = false;
+static bool run_precompiled_snapshot = false;
 
 
 // Value of the --gen/run_precompiled_snapshot flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* precompiled_snapshot_directory = NULL;
 
 
 // Global flag that is used to indicate that we want to compile everything in
 // the same way as precompilation before main, then continue running in the
 // same process.
-static bool has_noopt = false;
+static bool noopt = false;

[srdjan, 2016/02/05 17:35:02]

I would add a verb to this, as done with all other flags variables (e.g.,
is_noopt or use_noopt).

[siva, 2016/02/05 23:14:18]

Done.

 
 
 extern const char* kPrecompiledLibraryName;
 extern const char* kPrecompiledSymbolName;
 static const char* kPrecompiledVmIsolateName = "precompiled.vmisolate";
 static const char* kPrecompiledIsolateName = "precompiled.isolate";
 static const char* kPrecompiledInstructionsName = "precompiled.S";
-
+static const char* kVMIsolateSuffix = "vmisolate";
+static const char* kIsolateSuffix = "isolate";
 
 // Global flag that is used to indicate that we want to trace resolution of
 // URIs and the loading of libraries, parts and scripts.
-static bool has_trace_loading = false;
+static bool trace_loading = false;
 
 
 static const char* DEFAULT_VM_SERVICE_SERVER_IP = "127.0.0.1";
 static const int DEFAULT_VM_SERVICE_SERVER_PORT = 8181;
 // VM Service options.
 static const char* vm_service_server_ip = DEFAULT_VM_SERVICE_SERVER_IP;
 // The 0 port is a magic value which results in the first available port
 // being allocated.
 static int vm_service_server_port = -1;
 
@@ skipping 42 matching lines @@
 
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
 }
 
 
-static bool has_version_option = false;
+static bool version_option = false;
 static bool ProcessVersionOption(const char* arg,
                                  CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
-  has_version_option = true;
+  version_option = true;
   return true;
 }
 
 
-static bool has_help_option = false;
+static bool help_option = false;
 static bool ProcessHelpOption(const char* arg, CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
-  has_help_option = true;
+  help_option = true;
   return true;
 }
 
 
-static bool has_verbose_option = false;
+static bool verbose_option = false;
 static bool ProcessVerboseOption(const char* arg,
                                  CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
-  has_verbose_option = true;
+  verbose_option = true;
   return true;
 }
 
 
 static bool ProcessPackageRootOption(const char* arg,
                                      CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '\0' || *arg == '-') {
     return false;
   }
@@ skipping 99 matching lines @@
   return true;
 }
 
 
 static bool ProcessCompileAllOption(const char* arg,
                                     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
-  has_compile_all = true;
+  compile_all = true;
   return true;
 }
 
 
 static bool ProcessGenPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
   // Ensure that we are not already running using a full snapshot.
   if (isolate_snapshot_buffer != NULL) {
     Log::PrintErr("Precompiled snapshots must be generated with"
                   " dart_no_snapshot.\n");
     return false;
   }
   ASSERT(arg != NULL);
   if ((arg[0] == '=') || (arg[0] == ':')) {
     precompiled_snapshot_directory = &arg[1];
   } else {
     precompiled_snapshot_directory = arg;
   }
-  has_gen_precompiled_snapshot = true;
+  gen_precompiled_snapshot = true;
   vm_options->AddArgument("--precompilation");
   return true;
 }
 
 
 static bool ProcessRunPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   precompiled_snapshot_directory = arg;
   if ((precompiled_snapshot_directory[0] == '=') ||
       (precompiled_snapshot_directory[0] == ':')) {
     precompiled_snapshot_directory = &precompiled_snapshot_directory[1];
   }
-  has_run_precompiled_snapshot = true;
+  run_precompiled_snapshot = true;
   vm_options->AddArgument("--precompilation");
   return true;
 }
 
 
-static bool ProcessScriptSnapshotOptionHelper(const char* filename,
-                                              bool* snapshot_option) {
-  *snapshot_option = false;
-  if ((filename != NULL) && (strlen(filename) != 0)) {
-    // Ensure that we are already running using a full snapshot.
-    if (isolate_snapshot_buffer == NULL) {
-      Log::PrintErr("Script snapshots cannot be generated in this version of"
-                    " dart\n");
-      return false;
-    }
-    snapshot_filename = filename;
-    *snapshot_option = true;
-    if (generate_script_snapshot && generate_script_snapshot_after_run) {
-      Log::PrintErr("--snapshot and --snapshot-after-run options"
-                    " cannot be specified at the same time\n");
-      return false;
-    }
-    return true;
+static bool ProcessSnapshotOptionHelper(const char* filename,
+                                        bool* snapshot_option) {
+  ASSERT((filename != NULL) && (strlen(filename) != 0));
+  snapshot_filename = filename;
+  *snapshot_option = true;
+  if (generate_script_snapshot && generate_full_snapshot_after_run) {
+    Log::PrintErr("--snapshot and --snapshot-after-run options"
+                  " cannot be specified at the same time\n");
+    *snapshot_option = false;
+    return false;
   }
-  return false;
+  return true;
 }
 
 
 static bool ProcessScriptSnapshotOption(const char* filename,
                                         CommandLineOptions* vm_options) {
-  return ProcessScriptSnapshotOptionHelper(filename, &generate_script_snapshot);
+  if ((filename == NULL) || (strlen(filename) == 0)) {
+    return false;
+  }
+  // Ensure that we are already running using a full snapshot.
+  if (isolate_snapshot_buffer == NULL) {
+    Log::PrintErr("Script snapshots cannot be generated in this version of"
+                  " dart\n");

[srdjan, 2016/02/05 17:35:02]

s/dart/Dart/

[siva, 2016/02/05 23:14:18]

Done.

+    return false;
+  }
+  return ProcessSnapshotOptionHelper(filename, &generate_script_snapshot);
 }
 
 
-static bool ProcessScriptSnapshotAfterRunOption(
+static bool ProcessFullSnapshotAfterRunOption(
     const char* filename, CommandLineOptions* vm_options) {
-  return ProcessScriptSnapshotOptionHelper(filename,
-                                           &generate_script_snapshot_after_run);
+  if ((filename == NULL) || (strlen(filename) == 0)) {
+    return false;
+  }
+  // Ensure that we are running 'dart_no_snapshot'.
+  if (isolate_snapshot_buffer != NULL) {
+    Log::PrintErr("Full Application snapshots must be generated with"
+                  " dart_no_snapshot.\n");
+    return false;
+  }
+  return ProcessSnapshotOptionHelper(filename,
+                                     &generate_full_snapshot_after_run);
 }
 
 
+static bool ProcessRunFullSnapshotOption(
+    const char* filename, CommandLineOptions* vm_options) {
+  // Ensure that we are not running 'dart_no_snapshot'.
+  if (isolate_snapshot_buffer == NULL) {
+    Log::PrintErr("Full Application snapshots cannot be run with"
+                  " dart_no_snapshot.\n");
+    return false;
+  }
+  return ProcessSnapshotOptionHelper(filename, &run_full_snapshot);
+}
+
+
 static bool ProcessEnableVmServiceOption(const char* option_value,
                                          CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
 
   if (!ExtractPortAndIP(option_value,
                         &vm_service_server_port,
                         &vm_service_server_ip,
                         DEFAULT_VM_SERVICE_SERVER_PORT,
                         DEFAULT_VM_SERVICE_SERVER_IP)) {
     Log::PrintErr("unrecognized --enable-vm-service option syntax. "
@@ skipping 24 matching lines @@
   vm_options->AddArgument("--warn-on-pause-with-no-debugger");
   return true;
 }
 
 
 static bool ProcessTraceLoadingOption(const char* arg,
                                       CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
-  has_trace_loading = true;
+  trace_loading = true;
   return true;
 }
 
 
 
 static bool ProcessShutdownOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '\0') {
     do_vm_shutdown = true;
@@ skipping 34 matching lines @@
   { "--version", ProcessVersionOption },
 
   // VM specific options to the standalone dart program.
   { "--compile_all", ProcessCompileAllOption },
   { "--enable-vm-service", ProcessEnableVmServiceOption },
   { "--gen-precompiled-snapshot", ProcessGenPrecompiledSnapshotOption },
   { "--observe", ProcessObserveOption },
   { "--run-precompiled-snapshot", ProcessRunPrecompiledSnapshotOption },
   { "--shutdown", ProcessShutdownOption },
   { "--snapshot=", ProcessScriptSnapshotOption },
-  { "--snapshot-after-run=", ProcessScriptSnapshotAfterRunOption },
+  { "--full-snapshot-after-run=", ProcessFullSnapshotAfterRunOption },
+  { "--run-full-snapshot=", ProcessRunFullSnapshotOption },
   { "--trace-loading", ProcessTraceLoadingOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option,
                                CommandLineOptions* vm_options) {
   int i = 0;
   const char* name = main_options[0].option_name;
   int option_length = strlen(option);
@@ skipping 96 matching lines @@
     i++;
   }
 
   // Verify consistency of arguments.
   if ((commandline_package_root != NULL) &&
       (commandline_packages_file != NULL)) {
     Log::PrintErr("Specifying both a packages directory and a packages "
                   "file is invalid.\n");
     return -1;
   }
-  if (has_noopt) {
-    if (has_gen_precompiled_snapshot) {
+  if (noopt) {
+    if (gen_precompiled_snapshot) {
       Log::PrintErr("Specifying --noopt and --gen_precompiled_snapshot"
                     " is invalid.\n");
       return -1;
     }
-    if (has_run_precompiled_snapshot) {
+    if (run_precompiled_snapshot) {
       Log::PrintErr("Specifying --noopt and --run_precompiled_snapshot"
                     " is invalid.\n");
       return -1;
     }
   }
-  if (has_gen_precompiled_snapshot && has_run_precompiled_snapshot) {
-    Log::PrintErr("Specifying --gen_precompiled_snapshot and"
+  if (run_full_snapshot && run_precompiled_snapshot) {
+    Log::PrintErr("Specifying --run_full_snapshot and"
                   " --run_precompiled_snapshot is invalid.\n");
     return -1;
   }
+  if ((generate_full_snapshot_after_run || gen_precompiled_snapshot) &&
+      (run_full_snapshot || run_precompiled_snapshot)) {
+    Log::PrintErr("Specifying an option to generate a snapshot and"
+                  " run using a snapshot is invalid.\n");
+    return -1;
+  }
 
   return 0;
 }
 
 
 static Dart_Handle CreateRuntimeOptions(CommandLineOptions* options) {
   int options_count = options->count();
   Dart_Handle dart_arguments = Dart_NewList(options_count);
   if (Dart_IsError(dart_arguments)) {
     return dart_arguments;
@@ skipping 65 matching lines @@
 
 // Returns true on success, false on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(const char* script_uri,
                                                 const char* main,
                                                 const char* package_root,
                                                 const char* packages_config,
                                                 Dart_IsolateFlags* flags,
                                                 char** error,
                                                 int* exit_code) {
   ASSERT(script_uri != NULL);
+  if (run_full_snapshot &&
+      !strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME)) {
+    // We do not create a service isolate when running a full application
+    // snapshot.
+    return NULL;
+  }
   IsolateData* isolate_data = new IsolateData(script_uri,
                                               package_root,
                                               packages_config);
   Dart_Isolate isolate = NULL;
 
   isolate = Dart_CreateIsolate(script_uri,
                                main,
                                isolate_snapshot_buffer,
                                flags,
                                isolate_data,
@@ skipping 13 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,
-                          has_run_precompiled_snapshot)) {
+                          run_precompiled_snapshot)) {
       *error = strdup(VmService::GetErrorMessage());
       return NULL;
     }
-    if (has_compile_all) {
+    if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
     Dart_ExitScope();
     Dart_ExitIsolate();
     return isolate;
   }
 
   // Prepare builtin and other core libraries for use to resolve URIs.
   // Set up various closures, e.g: printing, timers etc.
   // Set up 'package root' for URI resolution.
-  result = DartUtils::PrepareForScriptLoading(false, has_trace_loading);
+  result = DartUtils::PrepareForScriptLoading(false, trace_loading);
   CHECK_RESULT(result);
 
-  // Set up the load port provided by the service isolate so that we can
-  // load scripts.
-  result = DartUtils::SetupServiceLoadPort();
-  CHECK_RESULT(result);
+  if (!run_full_snapshot) {
+    // Set up the load port provided by the service isolate so that we can
+    // load scripts.
+    result = DartUtils::SetupServiceLoadPort();
+    CHECK_RESULT(result);
+  }
 
   // Setup package root if specified.
   result = DartUtils::SetupPackageRoot(package_root, packages_config);
   CHECK_RESULT(result);
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
 
-  if (!has_run_precompiled_snapshot) {
+  if (!run_precompiled_snapshot && !run_full_snapshot) {
     // Load the specified application script into the newly created isolate.
-
-    // Load the script.
     result = DartUtils::LoadScript(script_uri);
     CHECK_RESULT(result);
 
     // Run event-loop and wait for script loading to complete.
     result = Dart_RunLoop();
     CHECK_RESULT(result);
 
     if (isolate_data->load_async_id >= 0) {
       Dart_TimelineAsyncEnd("LoadScript", isolate_data->load_async_id);
     }
 
     result = DartUtils::SetupIOLibrary(script_uri);
     CHECK_RESULT(result);
+  } else if (run_full_snapshot) {
+    result = DartUtils::SetupIOLibrary(script_uri);
+    CHECK_RESULT(result);
   }
 
   // Make the isolate runnable so that it is ready to handle messages.
   Dart_ExitScope();
   Dart_ExitIsolate();
   bool retval = Dart_IsolateMakeRunnable(isolate);
   if (!retval) {
     *error = strdup("Invalid isolate state - Unable to make it runnable");
     Dart_EnterIsolate(isolate);
     Dart_ShutdownIsolate();
@@ skipping 36 matching lines @@
   Log::PrintErr("Dart VM version: %s\n", Dart_VersionString());
 }
 
 
 static void PrintUsage() {
   Log::PrintErr(
       "Usage: dart [<vm-flags>] <dart-script-file> [<dart-options>]\n"
       "\n"
       "Executes the Dart script passed as <dart-script-file>.\n"
       "\n");
-  if (!has_verbose_option) {
+  if (!verbose_option) {
     Log::PrintErr(
 "Common options:\n"
 "--checked or -c\n"
 "  Insert runtime type checks and enable assertions (checked mode).\n"
 "--help or -h\n"
 "  Display this message (add -v or --verbose for information about\n"
 "  all VM options).\n"
 "--package-root=<path> or -p<path>\n"
 "  Where to find packages, that is, \"package:...\" imports.\n"
 "--packages=<path>\n"
@@ skipping 148 matching lines @@
 
 static void ServiceStreamCancelCallback(const char* stream_id) {
   if (strcmp(stream_id, kStdoutStreamId) == 0) {
     SetCaptureStdout(false);
   } else if (strcmp(stream_id, kStderrStreamId) == 0) {
     SetCaptureStderr(false);
   }
 }
 
 
-static void WritePrecompiledSnapshotFile(const char* filename,
-                                         const uint8_t* buffer,
-                                         const intptr_t size) {
+static void WriteSnapshotFile(const char* snapshot_directory,
+                              const char* filename,
+                              bool write_magic_number,
+                              const uint8_t* buffer,
+                              const intptr_t size) {
   char* concat = NULL;
   const char* qualified_filename;
-  if (strlen(precompiled_snapshot_directory) > 0) {
-    intptr_t len = snprintf(NULL, 0, "%s/%s",
-                            precompiled_snapshot_directory, filename);
+  if ((snapshot_directory != NULL) && strlen(snapshot_directory) > 0) {
+    intptr_t len = snprintf(NULL, 0, "%s/%s", snapshot_directory, filename);
     concat = new char[len + 1];
-    snprintf(concat, len + 1, "%s/%s",
-             precompiled_snapshot_directory, filename);
+    snprintf(concat, len + 1, "%s/%s", snapshot_directory, filename);
     qualified_filename = concat;
   } else {
     qualified_filename = filename;
   }
 
   File* file = File::Open(qualified_filename, File::kWriteTruncate);
   ASSERT(file != NULL);
+
+  if (write_magic_number) {
+    // Write the magic number to indicate file is a script snapshot.
+    DartUtils::WriteMagicNumber(file);
+  }
+
   if (!file->WriteFully(buffer, size)) {
     ErrorExit(kErrorExitCode,
               "Unable to open file %s for writing snapshot\n",
               qualified_filename);
   }
   delete file;
   if (concat != NULL) {
     delete concat;
   }
 }
 
 
-static void ReadPrecompiledSnapshotFile(const char* filename,
-                                        const uint8_t** buffer) {
+static void ReadSnapshotFile(const char* snapshot_directory,
+                             const char* filename,
+                             const uint8_t** buffer) {
   char* concat = NULL;
   const char* qualified_filename;
-  if (strlen(precompiled_snapshot_directory) > 0) {
-    intptr_t len = snprintf(NULL, 0, "%s/%s",
-                            precompiled_snapshot_directory, filename);
+  if ((snapshot_directory != NULL) && strlen(snapshot_directory) > 0) {
+    intptr_t len = snprintf(NULL, 0, "%s/%s", snapshot_directory, filename);
     concat = new char[len + 1];
-    snprintf(concat, len + 1, "%s/%s",
-             precompiled_snapshot_directory, filename);
+    snprintf(concat, len + 1, "%s/%s", snapshot_directory, filename);
     qualified_filename = concat;
   } else {
     qualified_filename = filename;
   }
 
   void* file = DartUtils::OpenFile(qualified_filename, false);
   if (file == NULL) {
     ErrorExit(kErrorExitCode,
               "Error: Unable to open file %s for reading snapshot\n",
               qualified_filename);
@@ skipping 28 matching lines @@
 
 static void GenerateScriptSnapshot() {
   // First create a snapshot.
   uint8_t* buffer = NULL;
   intptr_t size = 0;
   Dart_Handle result = Dart_CreateScriptSnapshot(&buffer, &size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(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.
-  DartUtils::WriteMagicNumber(snapshot_file);
-
-  // Now write the snapshot out to specified file.
-  bool bytes_written = snapshot_file->WriteFully(buffer, size);
-  ASSERT(bytes_written);
-  delete snapshot_file;
-  snapshot_file = NULL;
+  WriteSnapshotFile(NULL, snapshot_filename, true, buffer, size);
 }
 
 
+static void ComputeSnapshotFilenames(const char* filename,
+                                     char** vm_snapshot_fname,
+                                     char** isolate_snapshot_fname) {
+  intptr_t len = snprintf(NULL, 0, "%s.%s", filename, kVMIsolateSuffix);
+  *vm_snapshot_fname = new char[len + 1];
+  snprintf(*vm_snapshot_fname, len + 1, "%s.%s", filename, kVMIsolateSuffix);
+
+  len = snprintf(NULL, 0, "%s.%s", filename, kIsolateSuffix);
+  *isolate_snapshot_fname = new char[len + 1];
+  snprintf(*isolate_snapshot_fname, len + 1, "%s.%s", filename, kIsolateSuffix);
+}
+
+static void GenerateFullSnapshot() {
+  // Create a full snapshot of the script.
+  Dart_Handle result;
+  uint8_t* vm_isolate_buffer = NULL;
+  intptr_t vm_isolate_size = 0;
+  uint8_t* isolate_buffer = NULL;
+  intptr_t isolate_size = 0;
+  char* vm_snapshot_fname = NULL;
+  char* isolate_snapshot_fname = NULL;
+
+  result = Dart_CreateSnapshot(&vm_isolate_buffer,
+                               &vm_isolate_size,
+                               &isolate_buffer,
+                               &isolate_size);
+  if (Dart_IsError(result)) {
+    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
+  }
+
+  // Compute snapshot file names and write out the snapshot files.
+  ComputeSnapshotFilenames(snapshot_filename,
+                           &vm_snapshot_fname,
+                           &isolate_snapshot_fname);
+  WriteSnapshotFile(NULL,
+                    vm_snapshot_fname,
+                    false,
+                    vm_isolate_buffer,
+                    vm_isolate_size);
+  WriteSnapshotFile(NULL,
+                    isolate_snapshot_fname,
+                    false,
+                    isolate_buffer,
+                    isolate_size);
+}
+
+
 #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));                       \
@@ skipping 47 matching lines @@
     GenerateScriptSnapshot();
   } else {
     // Lookup the library of the root script.
     Dart_Handle root_lib = Dart_RootLibrary();
     // Import the root library into the builtin library so that we can easily
     // lookup the main entry point exported from the root library.
     IsolateData* isolate_data =
         reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
     result = Dart_LibraryImportLibrary(
         isolate_data->builtin_lib(), root_lib, Dart_Null());
-    if (has_gen_precompiled_snapshot) {
+    if (gen_precompiled_snapshot) {
       // Load the embedder's portion of the VM service's Dart code so it will
       // be included in the precompiled snapshot.
       if (!VmService::LoadForGenPrecompiled()) {
         fprintf(stderr,
                 "VM service loading failed: %s\n",
                 VmService::GetErrorMessage());
         fflush(stderr);
         exit(kErrorExitCode);
       }
     }
 
-    if (has_compile_all) {
+    if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
 
-    if (has_noopt || has_gen_precompiled_snapshot) {
+    if (noopt || gen_precompiled_snapshot) {
       Dart_QualifiedFunctionName standalone_entry_points[] = {
         { "dart:_builtin", "::", "_getMainClosure" },
         { "dart:_builtin", "::", "_getPrintClosure" },
         { "dart:_builtin", "::", "_getUriBaseClosure" },
         { "dart:_builtin", "::", "_resolveUri" },
         { "dart:_builtin", "::", "_setWorkingDirectory" },
         { "dart:_builtin", "::", "_setPackageRoot" },
         { "dart:_builtin", "::", "_loadPackagesMap" },
         { "dart:_builtin", "::", "_loadDataAsync" },
         { "dart:io", "::", "_makeUint8ListView" },
@@ skipping 13 matching lines @@
         { "dart:io", "_Platform", "set:_nativeScript" },
         { "dart:io", "_ProcessStartStatus", "set:_errorCode" },
         { "dart:io", "_ProcessStartStatus", "set:_errorMessage" },
         { "dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE" },
         { "dart:io", "_SecureFilterImpl", "get:SIZE" },
         { "dart:vmservice_io", "::", "main" },
         { "dart:vmservice_io", "::", "boot" },
         { NULL, NULL, NULL }  // Must be terminated with NULL entries.
       };
 
-      const bool reset_fields = has_gen_precompiled_snapshot;
+      const bool reset_fields = gen_precompiled_snapshot;
       result = Dart_Precompile(standalone_entry_points, reset_fields);
       CHECK_RESULT(result);
     }
 
-    if (has_gen_precompiled_snapshot) {
+    if (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);
       CHECK_RESULT(result);
-      WritePrecompiledSnapshotFile(kPrecompiledVmIsolateName,
-                                   vm_isolate_buffer,
-                                   vm_isolate_size);
-      WritePrecompiledSnapshotFile(kPrecompiledIsolateName,
-                                   isolate_buffer,
-                                   isolate_size);
-      WritePrecompiledSnapshotFile(kPrecompiledInstructionsName,
-                                   instructions_buffer,
-                                   instructions_size);
+      WriteSnapshotFile(precompiled_snapshot_directory,
+                        kPrecompiledVmIsolateName,
+                        false,
+                        vm_isolate_buffer,
+                        vm_isolate_size);
+      WriteSnapshotFile(precompiled_snapshot_directory,
+                        kPrecompiledIsolateName,
+                        false,
+                        isolate_buffer,
+                        isolate_size);
+      WriteSnapshotFile(precompiled_snapshot_directory,
+                        kPrecompiledInstructionsName,
+                        false,
+                        instructions_buffer,
+                        instructions_size);
     } else {
       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.
@@ skipping 12 matching lines @@
           Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
       result = Dart_Invoke(isolate_lib,
                            Dart_NewStringFromCString("_startMainIsolate"),
                            kNumIsolateArgs, isolate_args);
       CHECK_RESULT(result);
 
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
       CHECK_RESULT(result);
 
-      // Generate a script snapshot after execution if specified.
-      if (generate_script_snapshot_after_run) {
-        GenerateScriptSnapshot();
+      // Generate a full snapshot after execution if specified.
+      if (generate_full_snapshot_after_run) {
+        GenerateFullSnapshot();
       }
     }
   }
 
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // No restart.
   return false;
@@ skipping 103 matching lines @@
   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) {
+    if (help_option) {
       PrintUsage();
       Platform::Exit(0);
-    } else if (has_version_option) {
+    } else if (version_option) {
       PrintVersion();
       Platform::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());
       Platform::Exit(0);
     } else {
       PrintUsage();
       Platform::Exit(kErrorExitCode);
     }
   }
 
   Thread::InitOnce();
 
   if (!DartUtils::SetOriginalWorkingDirectory()) {
     OSError err;
     fprintf(stderr, "Error determining current directory: %s\n", err.message());
     fflush(stderr);
     Platform::Exit(kErrorExitCode);
   }
 
-  if (generate_script_snapshot) {
+  if (generate_script_snapshot || generate_full_snapshot_after_run) {
     vm_options.AddArgument("--load_deferred_eagerly");
   }
 
 #if defined(DART_PRECOMPILER) && !defined(DART_NO_SNAPSHOT)
   // Always set --precompilation with dart_noopt, unless already set by these
   // command line options.
-  if (!has_gen_precompiled_snapshot &&
-      !has_run_precompiled_snapshot) {
-    has_noopt = true;
+  if (!gen_precompiled_snapshot && !run_precompiled_snapshot) {
+    noopt = true;
     vm_options.AddArgument("--precompilation");
   }
 #endif
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Start event handler.
   TimerUtils::InitOnce();
   EventHandler::Start();
 
   const uint8_t* instructions_snapshot = NULL;
-  if (has_run_precompiled_snapshot) {
+  if (run_precompiled_snapshot) {
     instructions_snapshot = reinterpret_cast<const uint8_t*>(
         LoadLibrarySymbol(kPrecompiledLibraryName, kPrecompiledSymbolName));
-    ReadPrecompiledSnapshotFile(kPrecompiledVmIsolateName,
-                                &vm_isolate_snapshot_buffer);
-    ReadPrecompiledSnapshotFile(kPrecompiledIsolateName,
-                                &isolate_snapshot_buffer);
+    ReadSnapshotFile(precompiled_snapshot_directory,
+                     kPrecompiledVmIsolateName,
+                     &vm_isolate_snapshot_buffer);
+    ReadSnapshotFile(precompiled_snapshot_directory,
+                     kPrecompiledIsolateName,
+                     &isolate_snapshot_buffer);
+  } else if (run_full_snapshot) {
+    char* vm_snapshot_fname;
+    char* isolate_snapshot_fname;
+
+    // Compute file names.
+    ComputeSnapshotFilenames(snapshot_filename,
+                             &vm_snapshot_fname,
+                             &isolate_snapshot_fname);
+
+    ReadSnapshotFile(NULL, vm_snapshot_fname, &vm_isolate_snapshot_buffer);
+    ReadSnapshotFile(NULL, isolate_snapshot_fname, &isolate_snapshot_buffer);
+    delete vm_snapshot_fname;
+    delete isolate_snapshot_fname;
   }
 
   // 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,
@@ skipping 50 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }