Delays creating a snapshot file until after the snapshot is created.

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_debugger_api.h"
@@ skipping 16 matching lines @@
 
 namespace dart {
 namespace bin {
 
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
 extern const uint8_t* snapshot_buffer;
 
 // Global state that stores a pointer to the application script snapshot.
 static bool generate_script_snapshot = false;
-static File* snapshot_file = NULL;
+static const char* snapshot_filename = NULL;
 
 
 // Global state that indicates whether there is a debug breakpoint.
 // This pointer points into an argv buffer and does not need to be
 // free'd.
 static const char* breakpoint_at = NULL;
 
 
 // Global state that indicates whether we should open a connection
 // and listen for a debugger to connect.
@@ skipping 219 matching lines @@
 
 static bool ProcessGenScriptSnapshotOption(const char* filename,
                                            CommandLineOptions* vm_options) {
   if (filename != NULL && strlen(filename) != 0) {
     // Ensure that are already running using a full snapshot.
     if (snapshot_buffer == NULL) {
       Log::PrintErr("Script snapshots cannot be generated in this version of"
                     " dart\n");
       return false;
     }
-    snapshot_file = File::Open(filename, File::kWriteTruncate);
-    if (snapshot_file == NULL) {
-      Log::PrintErr("Unable to open file %s for writing the snapshot\n",
-                    filename);
-      return false;
-    }
+    snapshot_filename = filename;
     generate_script_snapshot = true;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessEnableVmServiceOption(const char* option_value,
                                          CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
@@ skipping 773 matching lines @@
   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);
 
+    // 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;
   } 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.
     Dart_Handle builtin_lib =
         Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
     result = Dart_LibraryImportLibrary(builtin_lib, root_lib, Dart_Null());
 
     if (has_compile_all) {
@@ skipping 76 matching lines @@
   exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }