VM: Re-format to use at most one newline between functions

runtime/bin/snapshot_utils.cc

 // Copyright (c) 2017, 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 "bin/snapshot_utils.h"
 
 #include "bin/dartutils.h"
 #include "bin/error_exit.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
@@ skipping 53 matching lines @@
     }
   }
 
  private:
   MappedMemory* vm_data_mapping_;
   MappedMemory* vm_instructions_mapping_;
   MappedMemory* isolate_data_mapping_;
   MappedMemory* isolate_instructions_mapping_;
 };
 
-
 static AppSnapshot* TryReadAppSnapshotBlobs(const char* script_name) {
   File* file = File::Open(script_name, File::kRead);
   if (file == NULL) {
     return NULL;
   }
   if (file->Length() < kAppSnapshotHeaderSize) {
     file->Release();
     return NULL;
   }
   int64_t header[5];
@@ skipping 62 matching lines @@
     if (isolate_instr_mapping == NULL) {
       FATAL1("Failed to memory map snapshot: %s\n", script_name);
     }
   }
 
   file->Release();
   return new MappedAppSnapshot(vm_data_mapping, vm_instr_mapping,
                                isolate_data_mapping, isolate_instr_mapping);
 }
 
-
 #if defined(DART_PRECOMPILED_RUNTIME)
 class DylibAppSnapshot : public AppSnapshot {
  public:
   DylibAppSnapshot(void* library,
                    const uint8_t* vm_snapshot_data,
                    const uint8_t* vm_snapshot_instructions,
                    const uint8_t* isolate_snapshot_data,
                    const uint8_t* isolate_snapshot_instructions)
       : library_(library),
         vm_snapshot_data_(vm_snapshot_data),
@@ skipping 14 matching lines @@
   }
 
  private:
   void* library_;
   const uint8_t* vm_snapshot_data_;
   const uint8_t* vm_snapshot_instructions_;
   const uint8_t* isolate_snapshot_data_;
   const uint8_t* isolate_snapshot_instructions_;
 };
 
-
 static AppSnapshot* TryReadAppSnapshotDynamicLibrary(const char* script_name) {
   void* library = Extensions::LoadExtensionLibrary(script_name);
   if (library == NULL) {
     return NULL;
   }
 
   const uint8_t* vm_data_buffer = reinterpret_cast<const uint8_t*>(
       Extensions::ResolveSymbol(library, kVmSnapshotDataSymbolName));
   if (vm_data_buffer == NULL) {
     FATAL1("Failed to resolve symbol '%s'\n", kVmSnapshotDataSymbolName);
@@ skipping 18 matching lines @@
   if (isolate_instructions_buffer == NULL) {
     FATAL1("Failed to resolve symbol '%s'\n",
            kIsolateSnapshotInstructionsSymbolName);
   }
 
   return new DylibAppSnapshot(library, vm_data_buffer, vm_instructions_buffer,
                               isolate_data_buffer, isolate_instructions_buffer);
 }
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
 
-
 AppSnapshot* Snapshot::TryReadAppSnapshot(const char* script_name) {
   if (File::GetType(script_name, true) != File::kIsFile) {
     // If 'script_name' refers to a pipe, don't read to check for an app
     // snapshot since we cannot rewind if it isn't (and couldn't mmap it in
     // anyway if it was).
     return NULL;
   }
   AppSnapshot* snapshot = TryReadAppSnapshotBlobs(script_name);
   if (snapshot != NULL) {
     return snapshot;
   }
 #if defined(DART_PRECOMPILED_RUNTIME)
   // For testing AOT with the standalone embedder, we also support loading
   // from a dynamic library to simulate what happens on iOS.
   snapshot = TryReadAppSnapshotDynamicLibrary(script_name);
   if (snapshot != NULL) {
     return snapshot;
   }
 #endif  //  defined(DART_PRECOMPILED_RUNTIME)
   return NULL;
 }
 
-
 static void WriteSnapshotFile(const char* filename,
                               bool write_magic_number,
                               const uint8_t* buffer,
                               const intptr_t size) {
   File* file = File::Open(filename, File::kWriteTruncate);
   if (file == NULL) {
     ErrorExit(kErrorExitCode, "Unable to open file %s for writing snapshot\n",
               filename);
   }
 
   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 write file %s for writing snapshot\n",
               filename);
   }
   file->Release();
 }
 
-
 static bool WriteInt64(File* file, int64_t size) {
   return file->WriteFully(&size, sizeof(size));
 }
 
-
 static void WriteAppSnapshot(const char* filename,
                              uint8_t* vm_data_buffer,
                              intptr_t vm_data_size,
                              uint8_t* vm_instructions_buffer,
                              intptr_t vm_instructions_size,
                              uint8_t* isolate_data_buffer,
                              intptr_t isolate_data_size,
                              uint8_t* isolate_instructions_buffer,
                              intptr_t isolate_instructions_size) {
   File* file = File::Open(filename, File::kWriteTruncate);
@@ skipping 32 matching lines @@
                           isolate_instructions_size)) {
       ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n",
                 filename);
     }
   }
 
   file->Flush();
   file->Release();
 }
 
-
 void Snapshot::GenerateScript(const char* snapshot_filename) {
   // 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));
   }
 
   WriteSnapshotFile(snapshot_filename, true, buffer, size);
 }
 
-
 void Snapshot::GenerateAppJIT(const char* snapshot_filename) {
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_DBC)
   // Snapshots with code are not supported on IA32 or DBC.
   uint8_t* isolate_buffer = NULL;
   intptr_t isolate_size = 0;
 
   Dart_Handle result =
       Dart_CreateSnapshot(NULL, NULL, &isolate_buffer, &isolate_size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
@@ skipping 11 matching lines @@
       &isolate_instructions_size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
   WriteAppSnapshot(snapshot_filename, NULL, 0, NULL, 0, isolate_data_buffer,
                    isolate_data_size, isolate_instructions_buffer,
                    isolate_instructions_size);
 #endif
 }
 
-
 void Snapshot::GenerateAppAOTAsBlobs(const char* snapshot_filename) {
   uint8_t* vm_data_buffer = NULL;
   intptr_t vm_data_size = 0;
   uint8_t* vm_instructions_buffer = NULL;
   intptr_t vm_instructions_size = 0;
   uint8_t* isolate_data_buffer = NULL;
   intptr_t isolate_data_size = 0;
   uint8_t* isolate_instructions_buffer = NULL;
   intptr_t isolate_instructions_size = 0;
   Dart_Handle result = Dart_CreateAppAOTSnapshotAsBlobs(
       &vm_data_buffer, &vm_data_size, &vm_instructions_buffer,
       &vm_instructions_size, &isolate_data_buffer, &isolate_data_size,
       &isolate_instructions_buffer, &isolate_instructions_size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
   WriteAppSnapshot(snapshot_filename, vm_data_buffer, vm_data_size,
                    vm_instructions_buffer, vm_instructions_size,
                    isolate_data_buffer, isolate_data_size,
                    isolate_instructions_buffer, isolate_instructions_size);
 }
 
-
 void Snapshot::GenerateAppAOTAsAssembly(const char* snapshot_filename) {
   uint8_t* assembly_buffer = NULL;
   intptr_t assembly_size = 0;
   Dart_Handle result =
       Dart_CreateAppAOTSnapshotAsAssembly(&assembly_buffer, &assembly_size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
   WriteSnapshotFile(snapshot_filename, false, assembly_buffer, assembly_size);
 }
 
 }  // namespace bin
 }  // namespace dart