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

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, 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.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <cstdarg>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/dfe.h"
 #include "bin/eventhandler.h"
 #include "bin/file.h"
 #include "bin/loader.h"
 #include "bin/log.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/vmservice_impl.h"
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
 
-#include "platform/hashmap.h"
 #include "platform/globals.h"
 #include "platform/growable_array.h"
+#include "platform/hashmap.h"
 
 namespace dart {
 namespace bin {
 
 DFE dfe;
 
 // 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;
 
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     intptr_t exit_code = 0;                                                    \
     Log::PrintErr("Error: %s\n", Dart_GetError(result));                       \
     if (Dart_IsCompilationError(result)) {                                     \
       exit_code = kCompilationErrorExitCode;                                   \
     } else if (Dart_IsApiError(result)) {                                      \
       exit_code = kApiErrorExitCode;                                           \
     } else {                                                                   \
       exit_code = kErrorExitCode;                                              \
     }                                                                          \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     exit(exit_code);                                                           \
   }
 
-
 // The core snapshot to use when creating isolates. Normally NULL, but loaded
 // from a file when creating script snapshots.
 const uint8_t* isolate_snapshot_data = NULL;
 const uint8_t* isolate_snapshot_instructions = NULL;
 
-
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
 enum SnapshotKind {
   kCore,
   kCoreJIT,
   kScript,
   kAppAOTBlobs,
   kAppAOTAssembly,
 };
 static SnapshotKind snapshot_kind = kCore;
 static const char* vm_snapshot_data_filename = NULL;
 static const char* vm_snapshot_instructions_filename = NULL;
 static const char* isolate_snapshot_data_filename = NULL;
 static const char* isolate_snapshot_instructions_filename = NULL;
 static const char* assembly_filename = NULL;
 static const char* script_snapshot_filename = NULL;
 static bool dependencies_only = false;
 static bool print_dependencies = false;
 static const char* dependencies_filename = NULL;
 
-
 // Value of the --load-compilation-trace flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* load_compilation_trace_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 state which contains a pointer to the script name for which
 // a snapshot needs to be created (NULL would result in the creation
 // of a generic snapshot that contains only the corelibs).
 static char* app_script_name = NULL;
 
 // Global state that captures the entry point manifest files specified on the
 // command line.
 static CommandLineOptions* entry_points_files = NULL;
 
 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));
 }
 
-
 // The environment provided through the command line using -D options.
 static dart::HashMap* environment = NULL;
 
 static void* GetHashmapKeyFromString(char* key) {
   return reinterpret_cast<void*>(key);
 }
 
 static bool ProcessEnvironmentOption(const char* arg) {
   ASSERT(arg != NULL);
   if (*arg == '\0') {
@@ skipping 32 matching lines @@
     name[name_len] = '\0';
     value = strdup(equals_pos + 1);
   }
   HashMap::Entry* entry = environment->Lookup(GetHashmapKeyFromString(name),
                                               HashMap::StringHash(name), true);
   ASSERT(entry != NULL);  // Lookup adds an entry if key not found.
   entry->value = value;
   return true;
 }
 
-
 static Dart_Handle EnvironmentCallback(Dart_Handle name) {
   uint8_t* utf8_array;
   intptr_t utf8_len;
   Dart_Handle result = Dart_Null();
   Dart_Handle handle = Dart_StringToUTF8(name, &utf8_array, &utf8_len);
   if (Dart_IsError(handle)) {
     handle = Dart_ThrowException(
         DartUtils::NewDartArgumentError(Dart_GetError(handle)));
   } else {
     char* name_chars = reinterpret_cast<char*>(malloc(utf8_len + 1));
@@ skipping 10 matching lines @@
     }
     if (value != NULL) {
       result = Dart_NewStringFromUTF8(reinterpret_cast<const uint8_t*>(value),
                                       strlen(value));
     }
     free(name_chars);
   }
   return result;
 }
 
-
 static const char* ProcessOption(const char* option, const char* name) {
   const intptr_t length = strlen(name);
   if (strncmp(option, name, length) == 0) {
     return (option + length);
   }
   return NULL;
 }
 
-
 static bool ProcessSnapshotKindOption(const char* option) {
   const char* kind = ProcessOption(option, "--snapshot_kind=");
   if (kind == NULL) {
     kind = ProcessOption(option, "--snapshot-kind=");
   }
   if (kind == NULL) {
     return false;
   }
   if (strcmp(kind, "core-jit") == 0) {
     snapshot_kind = kCoreJIT;
@@ skipping 11 matching lines @@
     snapshot_kind = kAppAOTAssembly;
     return true;
   }
   Log::PrintErr(
       "Unrecognized snapshot kind: '%s'\nValid kinds are: "
       "core, script, app-aot-blobs, app-aot-assembly\n",
       kind);
   return false;
 }
 
-
 static bool ProcessVmSnapshotDataOption(const char* option) {
   const char* name = ProcessOption(option, "--vm_snapshot_data=");
   if (name == NULL) {
     name = ProcessOption(option, "--vm-snapshot-data=");
   }
   if (name != NULL) {
     vm_snapshot_data_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessVmSnapshotInstructionsOption(const char* option) {
   const char* name = ProcessOption(option, "--vm_snapshot_instructions=");
   if (name == NULL) {
     name = ProcessOption(option, "--vm-snapshot-instructions=");
   }
   if (name != NULL) {
     vm_snapshot_instructions_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessIsolateSnapshotDataOption(const char* option) {
   const char* name = ProcessOption(option, "--isolate_snapshot_data=");
   if (name == NULL) {
     name = ProcessOption(option, "--isolate-snapshot-data=");
   }
   if (name != NULL) {
     isolate_snapshot_data_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessIsolateSnapshotInstructionsOption(const char* option) {
   const char* name = ProcessOption(option, "--isolate_snapshot_instructions=");
   if (name == NULL) {
     name = ProcessOption(option, "--isolate-snapshot-instructions=");
   }
   if (name != NULL) {
     isolate_snapshot_instructions_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessAssemblyOption(const char* option) {
   const char* name = ProcessOption(option, "--assembly=");
   if (name != NULL) {
     assembly_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessScriptSnapshotOption(const char* option) {
   const char* name = ProcessOption(option, "--script_snapshot=");
   if (name == NULL) {
     name = ProcessOption(option, "--script-snapshot=");
   }
   if (name != NULL) {
     script_snapshot_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessDependenciesOption(const char* option) {
   const char* name = ProcessOption(option, "--dependencies=");
   if (name != NULL) {
     dependencies_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessDependenciesOnlyOption(const char* option) {
   const char* name = ProcessOption(option, "--dependencies_only");
   if (name == NULL) {
     name = ProcessOption(option, "--dependencies-only");
   }
   if (name != NULL) {
     dependencies_only = true;
     return true;
   }
   return false;
@@ skipping 16 matching lines @@
   if (name == NULL) {
     name = ProcessOption(option, "--embedder-entry-points-manifest=");
   }
   if (name != NULL) {
     entry_points_files->AddArgument(name);
     return true;
   }
   return false;
 }
 
-
 static bool ProcessLoadCompilationTraceOption(const char* option) {
   const char* name = ProcessOption(option, "--load_compilation_trace=");
   if (name == NULL) {
     name = ProcessOption(option, "--load-compilation-trace=");
   }
   if (name != NULL) {
     load_compilation_trace_filename = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessPackageRootOption(const char* option) {
   const char* name = ProcessOption(option, "--package_root=");
   if (name == NULL) {
     name = ProcessOption(option, "--package-root=");
   }
   if (name != NULL) {
     commandline_package_root = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessPackagesOption(const char* option) {
   const char* name = ProcessOption(option, "--packages=");
   if (name != NULL) {
     commandline_packages_file = name;
     return true;
   }
   return false;
 }
 
-
 static bool ProcessURLmappingOption(const char* option) {
   const char* mapping = ProcessOption(option, "--url_mapping=");
   if (mapping == NULL) {
     mapping = ProcessOption(option, "--url-mapping=");
   }
   if (mapping != NULL) {
     DartUtils::url_mapping->AddArgument(mapping);
     return true;
   }
   return false;
 }
 
-
 static bool IsSnapshottingForPrecompilation() {
   return (snapshot_kind == kAppAOTBlobs) || (snapshot_kind == kAppAOTAssembly);
 }
 
-
 // Parse out the command line arguments. Returns -1 if the arguments
 // are incorrect, 0 otherwise.
 static int ParseArguments(int argc,
                           char** argv,
                           CommandLineOptions* vm_options,
                           char** script_name) {
   const char* kPrefix = "-";
   const intptr_t kPrefixLen = strlen(kPrefix);
 
   // Skip the binary name.
@@ skipping 105 matching lines @@
   if (IsSnapshottingForPrecompilation() && (entry_points_files->count() == 0)) {
     Log::PrintErr(
         "Building an AOT snapshot requires at least one embedder "
         "entry points manifest.\n\n");
     return -1;
   }
 
   return 0;
 }
 
-
 static void WriteFile(const char* filename,
                       const uint8_t* buffer,
                       const intptr_t size) {
   File* file = File::Open(filename, File::kWriteTruncate);
   if (file == NULL) {
     Log::PrintErr("Error: Unable to write snapshot file: %s\n\n", filename);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
   if (!file->WriteFully(buffer, size)) {
     Log::PrintErr("Error: Unable to write snapshot file: %s\n\n", filename);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
   file->Release();
 }
 
-
 static void ReadFile(const char* filename, uint8_t** buffer, intptr_t* size) {
   File* file = File::Open(filename, File::kRead);
   if (file == NULL) {
     Log::PrintErr("Unable to open file %s\n", filename);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
   *size = file->Length();
   *buffer = reinterpret_cast<uint8_t*>(malloc(*size));
   if (!file->ReadFully(*buffer, *size)) {
     Log::PrintErr("Unable to read file %s\n", filename);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
   file->Release();
 }
 
-
 class UriResolverIsolateScope {
  public:
   UriResolverIsolateScope() {
     ASSERT(isolate != NULL);
     snapshotted_isolate_ = Dart_CurrentIsolate();
     Dart_ExitIsolate();
     Dart_EnterIsolate(isolate);
     Dart_EnterScope();
   }
 
   ~UriResolverIsolateScope() {
     ASSERT(snapshotted_isolate_ != NULL);
     Dart_ExitScope();
     Dart_ExitIsolate();
     Dart_EnterIsolate(snapshotted_isolate_);
   }
 
   static Dart_Isolate isolate;
 
  private:
   Dart_Isolate snapshotted_isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(UriResolverIsolateScope);
 };
 
-
 Dart_Isolate UriResolverIsolateScope::isolate = NULL;
 
-
 static void AddDependency(const char* uri_string) {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
   if (dependencies != NULL) {
     dependencies->Add(strdup(uri_string));
   }
 }
 
-
 static Dart_Handle LoadUrlContents(const char* uri_string) {
   bool failed = false;
   char* error_string = NULL;
   uint8_t* payload = NULL;
   intptr_t payload_length = 0;
   // Switch to the UriResolver Isolate and load the script.
   {
     UriResolverIsolateScope scope;
 
     Dart_Handle resolved_uri = Dart_NewStringFromCString(uri_string);
@@ skipping 11 matching lines @@
   if (!failed) {
     result = Dart_NewStringFromUTF8(payload, payload_length);
     free(payload);
   } else {
     result = Dart_NewApiError(error_string);
     free(error_string);
   }
   return result;
 }
 
-
 static Dart_Handle ResolveUriInWorkingDirectory(const char* script_uri) {
   bool failed = false;
   char* result_string = NULL;
 
   {
     UriResolverIsolateScope scope;
 
     // Run DartUtils::ResolveUriInWorkingDirectory in context of uri resolver
     // isolate.
     Dart_Handle result = DartUtils::ResolveUriInWorkingDirectory(
         DartUtils::NewString(script_uri));
     if (Dart_IsError(result)) {
       failed = true;
       result_string = strdup(Dart_GetError(result));
     } else {
       result_string = strdup(DartUtils::GetStringValue(result));
     }
   }
 
   Dart_Handle result = failed ? Dart_NewApiError(result_string)
                               : DartUtils::NewString(result_string);
   free(result_string);
   return result;
 }
 
-
 static Dart_Handle LoadSnapshotCreationScript(const char* script_name) {
   // First resolve the specified script uri with respect to the original
   // working directory.
   Dart_Handle resolved_uri = ResolveUriInWorkingDirectory(script_name);
   if (Dart_IsError(resolved_uri)) {
     return resolved_uri;
   }
   // Now load the contents of the specified uri.
   const char* resolved_uri_string = DartUtils::GetStringValue(resolved_uri);
   Dart_Handle source = LoadUrlContents(resolved_uri_string);
 
   if (Dart_IsError(source)) {
     return source;
   }
   if ((snapshot_kind == kCore) || (snapshot_kind == kCoreJIT)) {
     return Dart_LoadLibrary(resolved_uri, Dart_Null(), source, 0, 0);
   } else {
     return Dart_LoadScript(resolved_uri, Dart_Null(), source, 0, 0);
   }
 }
 
-
 static Builtin::BuiltinLibraryId BuiltinId(const char* url) {
   if (DartUtils::IsDartBuiltinLibURL(url)) {
     return Builtin::kBuiltinLibrary;
   }
   if (DartUtils::IsDartIOLibURL(url)) {
     return Builtin::kIOLibrary;
   }
   return Builtin::kInvalidLibrary;
 }
 
-
 // Generates a depfile like gcc -M -MF. Must be consumable by Ninja.
 class DependenciesFileWriter : public ValueObject {
  public:
   DependenciesFileWriter() : dependencies_(NULL), file_(NULL), success_(true) {}
 
   void WriteDependencies(MallocGrowableArray<char*>* dependencies) {
     dependencies_ = dependencies;
 
     file_ = File::Open(dependencies_filename, File::kWriteTruncate);
     if (file_ == NULL) {
@@ skipping 80 matching lines @@
     free(escaped_path);
   }
 
   void Write(const char* string) { success_ &= file_->Print("%s", string); }
 
   MallocGrowableArray<char*>* dependencies_;
   File* file_;
   bool success_;
 };
 
-
 static void CreateAndWriteDependenciesFile() {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
   if (dependencies == NULL) {
     return;
   }
 
   Loader::ResolveDependenciesAsFilePaths();
 
@@ skipping 24 matching lines @@
     }
   }
 
   for (intptr_t i = 0; i < dependencies->length(); i++) {
     free(dependencies->At(i));
   }
   delete dependencies;
   isolate_data->set_dependencies(NULL);
 }
 
-
 static Dart_Handle CreateSnapshotLibraryTagHandler(Dart_LibraryTag tag,
                                                    Dart_Handle library,
                                                    Dart_Handle url) {
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
   }
   Dart_Handle library_url = Dart_LibraryUrl(library);
   if (Dart_IsError(library_url)) {
     return Dart_NewApiError("accessing library url failed");
   }
@@ skipping 58 matching lines @@
     return source;
   }
   if (tag == Dart_kImportTag) {
     return Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   } else {
     ASSERT(tag == Dart_kSourceTag);
     return Dart_LoadSource(library, url, Dart_Null(), source, 0, 0);
   }
 }
 
-
 static Dart_Handle LoadGenericSnapshotCreationScript(
     Builtin::BuiltinLibraryId id) {
   Dart_Handle source = Builtin::Source(id);
   if (Dart_IsError(source)) {
     return source;  // source contains the error string.
   }
   Dart_Handle lib;
   // Load the builtin library to make it available in the snapshot
   // for importing.
   lib = Builtin::LoadAndCheckLibrary(id);
   ASSERT(!Dart_IsError(lib));
   return lib;
 }
 
-
 // clang-format off
 static void PrintUsage() {
   Log::PrintErr(
 "Usage:                                                                      \n"
 " gen_snapshot [<vm-flags>] [<options>] [<dart-script-file>]                 \n"
 "                                                                            \n"
 " Global options:                                                            \n"
 "   --package_root=<path>         Where to find packages, that is,           \n"
 "                                 package:...  imports.                      \n"
 "                                                                            \n"
@@ skipping 54 matching lines @@
 " manifest is a comma separated list of three elements. The first entry is   \n"
 " the library URI, the second entry is the class name and the final entry    \n"
 " the function name. The file must be terminated with a newline character.   \n"
 "                                                                            \n"
 "   Example:                                                                 \n"
 "     dart:something,SomeClass,doSomething                                   \n"
 "\n");
 }
 // clang-format on
 
-
 static const char StubNativeFunctionName[] = "StubNativeFunction";
 
-
 void StubNativeFunction(Dart_NativeArguments arguments) {
   // This is a stub function for the resolver
   Dart_SetReturnValue(
       arguments, Dart_NewApiError("<EMBEDDER DID NOT SETUP NATIVE RESOLVER>"));
 }
 
-
 static Dart_NativeFunction StubNativeLookup(Dart_Handle name,
                                             int argument_count,
                                             bool* auto_setup_scope) {
   return &StubNativeFunction;
 }
 
-
 static const uint8_t* StubNativeSymbol(Dart_NativeFunction nf) {
   return reinterpret_cast<const uint8_t*>(StubNativeFunctionName);
 }
 
-
 static void SetupStubNativeResolver(size_t lib_index,
                                     const Dart_QualifiedFunctionName* entry) {
   // TODO(24686): Remove this.
   Dart_Handle library_string = Dart_NewStringFromCString(entry->library_uri);
   DART_CHECK_VALID(library_string);
   Dart_Handle library = Dart_LookupLibrary(library_string);
   // Embedder entry points may be setup in libraries that have not been
   // explicitly loaded by the application script. In such cases, library lookup
   // will fail. Manually load those libraries.
   if (Dart_IsError(library)) {
@@ skipping 14 matching lines @@
     // Do a fresh lookup
     library = Dart_LookupLibrary(library_string);
   }
 
   DART_CHECK_VALID(library);
   Dart_Handle result =
       Dart_SetNativeResolver(library, &StubNativeLookup, &StubNativeSymbol);
   DART_CHECK_VALID(result);
 }
 
-
 // Iterate over all libraries and setup the stub native lookup. This must be
 // run after |SetupStubNativeResolversForPrecompilation| because the former
 // loads some libraries.
 static void SetupStubNativeResolvers() {
   Dart_Handle libraries = Dart_GetLoadedLibraries();
   intptr_t libraries_length;
   Dart_ListLength(libraries, &libraries_length);
   for (intptr_t i = 0; i < libraries_length; i++) {
     Dart_Handle library = Dart_ListGetAt(libraries, i);
     DART_CHECK_VALID(library);
     Dart_NativeEntryResolver old_resolver = NULL;
     Dart_GetNativeResolver(library, &old_resolver);
     if (old_resolver == NULL) {
       Dart_Handle result =
           Dart_SetNativeResolver(library, &StubNativeLookup, &StubNativeSymbol);
       DART_CHECK_VALID(result);
     }
   }
 }
 
-
 static void ImportNativeEntryPointLibrariesIntoRoot(
     const Dart_QualifiedFunctionName* entries) {
   if (entries == NULL) {
     return;
   }
 
   size_t index = 0;
   while (true) {
     Dart_QualifiedFunctionName entry = entries[index++];
     if (entry.library_uri == NULL) {
       // The termination sentinel has null members.
       break;
     }
     Dart_Handle entry_library =
         Dart_LookupLibrary(Dart_NewStringFromCString(entry.library_uri));
     DART_CHECK_VALID(entry_library);
     Dart_Handle import_result = Dart_LibraryImportLibrary(
         entry_library, Dart_RootLibrary(), Dart_EmptyString());
     DART_CHECK_VALID(import_result);
   }
 }
 
-
 static void SetupStubNativeResolversForPrecompilation(
     const Dart_QualifiedFunctionName* entries) {
   if (entries == NULL) {
     return;
   }
 
   // Setup native resolvers for all libraries found in the manifest.
   size_t index = 0;
   while (true) {
     Dart_QualifiedFunctionName entry = entries[index++];
     if (entry.library_uri == NULL) {
       // The termination sentinel has null members.
       break;
     }
     // Setup stub resolvers on loaded libraries
     SetupStubNativeResolver(index, &entry);
   }
 }
 
-
 static void CleanupEntryPointItem(const Dart_QualifiedFunctionName* entry) {
   if (entry == NULL) {
     return;
   }
   // The allocation used for these entries is zero'ed. So even in error cases,
   // references to some entries will be null. Calling this on an already cleaned
   // up entry is programmer error.
   free(const_cast<char*>(entry->library_uri));
   free(const_cast<char*>(entry->class_name));
   free(const_cast<char*>(entry->function_name));
 }
 
-
 static void CleanupEntryPointsCollection(Dart_QualifiedFunctionName* entries) {
   if (entries == NULL) {
     return;
   }
 
   size_t index = 0;
   while (true) {
     Dart_QualifiedFunctionName entry = entries[index++];
     if (entry.library_uri == NULL) {
       break;
     }
     CleanupEntryPointItem(&entry);
   }
   free(entries);
 }
 
-
 char* ParserErrorStringCreate(const char* format, ...) {
   static const size_t kErrorBufferSize = 256;
 
   char* error_buffer =
       reinterpret_cast<char*>(calloc(kErrorBufferSize, sizeof(char)));
   va_list args;
   va_start(args, format);
   vsnprintf(error_buffer, kErrorBufferSize, format, args);
   va_end(args);
 
   // In case of error, the buffer is released by the caller
   return error_buffer;
 }
 
-
 const char* ParseEntryNameForIndex(uint8_t index) {
   switch (index) {
     case 0:
       return "Library";
     case 1:
       return "Class";
     case 2:
       return "Function";
     default:
       return "Unknown";
   }
   return NULL;
 }
 
-
 static bool ParseEntryPointsManifestSingleLine(
     const char* line,
     Dart_QualifiedFunctionName* entry,
     char** error) {
   bool success = true;
   size_t offset = 0;
   for (uint8_t i = 0; i < 3; i++) {
     const char* component = strchr(line + offset, i == 2 ? '\n' : ',');
     if (component == NULL) {
       success = false;
@@ skipping 35 matching lines @@
           *error = ParserErrorStringCreate("Internal parser error\n");
           break;
       }
     }
 
     offset += chars_read + 1;
   }
   return success;
 }
 
-
 int64_t ParseEntryPointsManifestLines(FILE* file,
                                       Dart_QualifiedFunctionName* collection) {
   int64_t entries = 0;
 
   static const int kManifestMaxLineLength = 1024;
   char* line = reinterpret_cast<char*>(malloc(kManifestMaxLineLength));
   size_t line_number = 0;
   while (true) {
     line_number++;
     char* read_line = fgets(line, kManifestMaxLineLength, file);
@@ skipping 23 matching lines @@
     }
 
     entries++;
   }
 
   free(line);
 
   return entries;
 }
 
-
 static Dart_QualifiedFunctionName* ParseEntryPointsManifestFiles() {
   // Total number of entries across all manifest files.
   int64_t entry_count = 0;
 
   // Parse the files once but don't store the results. This is done to first
   // determine the number of entries in the manifest
   for (intptr_t i = 0; i < entry_points_files->count(); i++) {
     const char* path = entry_points_files->GetArgument(i);
 
     FILE* file = fopen(path, "r");
@@ skipping 31 matching lines @@
     fclose(file);
   }
 
   ASSERT(parsed_entry_count == entry_count);
 
   // The entries allocation must be explicitly cleaned up via
   // |CleanupEntryPointsCollection|
   return entries;
 }
 
-
 static Dart_QualifiedFunctionName* ParseEntryPointsManifestIfPresent() {
   Dart_QualifiedFunctionName* entries = ParseEntryPointsManifestFiles();
   if ((entries == NULL) && IsSnapshottingForPrecompilation()) {
     Log::PrintErr(
         "Could not find native embedder entry points during precompilation\n");
     exit(kErrorExitCode);
   }
   return entries;
 }
 
-
 static void LoadCompilationTrace() {
   if ((load_compilation_trace_filename != NULL) &&
       (snapshot_kind == kCoreJIT)) {
     uint8_t* buffer = NULL;
     intptr_t size = 0;
     ReadFile(load_compilation_trace_filename, &buffer, &size);
     Dart_Handle result = Dart_LoadCompilationTrace(buffer, size);
     CHECK_RESULT(result);
   }
 }
 
-
 static void CreateAndWriteCoreSnapshot() {
   ASSERT(snapshot_kind == kCore);
   ASSERT(vm_snapshot_data_filename != NULL);
   ASSERT(isolate_snapshot_data_filename != NULL);
 
   Dart_Handle result;
   uint8_t* vm_snapshot_data_buffer = NULL;
   intptr_t vm_snapshot_data_size = 0;
   uint8_t* isolate_snapshot_data_buffer = NULL;
   intptr_t isolate_snapshot_data_size = 0;
@@ skipping 11 matching lines @@
   if (vm_snapshot_instructions_filename != NULL) {
     WriteFile(vm_snapshot_instructions_filename, NULL, 0);
   }
   WriteFile(isolate_snapshot_data_filename, isolate_snapshot_data_buffer,
             isolate_snapshot_data_size);
   if (isolate_snapshot_instructions_filename != NULL) {
     WriteFile(isolate_snapshot_instructions_filename, NULL, 0);
   }
 }
 
-
 static void CreateAndWriteCoreJITSnapshot() {
   ASSERT(snapshot_kind == kCoreJIT);
   ASSERT(vm_snapshot_data_filename != NULL);
   ASSERT(vm_snapshot_instructions_filename != NULL);
   ASSERT(isolate_snapshot_data_filename != NULL);
   ASSERT(isolate_snapshot_instructions_filename != NULL);
 
   Dart_Handle result;
   uint8_t* vm_snapshot_data_buffer = NULL;
   intptr_t vm_snapshot_data_size = 0;
@@ skipping 19 matching lines @@
             vm_snapshot_data_size);
   WriteFile(vm_snapshot_instructions_filename, vm_snapshot_instructions_buffer,
             vm_snapshot_instructions_size);
   WriteFile(isolate_snapshot_data_filename, isolate_snapshot_data_buffer,
             isolate_snapshot_data_size);
   WriteFile(isolate_snapshot_instructions_filename,
             isolate_snapshot_instructions_buffer,
             isolate_snapshot_instructions_size);
 }
 
-
 static void CreateAndWriteScriptSnapshot() {
   ASSERT(snapshot_kind == kScript);
   ASSERT(script_snapshot_filename != NULL);
 
   // First create a snapshot.
   uint8_t* buffer = NULL;
   intptr_t size = 0;
   Dart_Handle result = Dart_CreateScriptSnapshot(&buffer, &size);
   CHECK_RESULT(result);
 
   // Now write it out to the specified file.
   WriteFile(script_snapshot_filename, buffer, size);
 }
 
-
 static void CreateAndWritePrecompiledSnapshot(
     Dart_QualifiedFunctionName* standalone_entry_points) {
   ASSERT(IsSnapshottingForPrecompilation());
   Dart_Handle result;
 
   // Precompile with specified embedder entry points
   result = Dart_Precompile(standalone_entry_points, NULL, 0);
   CHECK_RESULT(result);
 
   // Create a precompiled snapshot.
@@ skipping 32 matching lines @@
     WriteFile(vm_snapshot_instructions_filename,
               vm_snapshot_instructions_buffer, vm_snapshot_instructions_size);
     WriteFile(isolate_snapshot_data_filename, isolate_snapshot_data_buffer,
               isolate_snapshot_data_size);
     WriteFile(isolate_snapshot_instructions_filename,
               isolate_snapshot_instructions_buffer,
               isolate_snapshot_instructions_size);
   }
 }
 
-
 static void SetupForUriResolution() {
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   if (Dart_IsError(result)) {
     Log::PrintErr("%s\n", Dart_GetError(result));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
   // This is a generic dart snapshot which needs builtin library setup.
   Dart_Handle library =
       LoadGenericSnapshotCreationScript(Builtin::kBuiltinLibrary);
   CHECK_RESULT(library);
 }
 
-
 static void SetupForGenericSnapshotCreation() {
   SetupForUriResolution();
 
   Dart_Handle library = LoadGenericSnapshotCreationScript(Builtin::kIOLibrary);
   CHECK_RESULT(library);
   Dart_Handle result = Dart_FinalizeLoading(false);
   if (Dart_IsError(result)) {
     const char* err_msg = Dart_GetError(library);
     Log::PrintErr("Errors encountered while loading: %s\n", err_msg);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
 }
 
-
 static Dart_Isolate CreateServiceIsolate(const char* script_uri,
                                          const char* main,
                                          const char* package_root,
                                          const char* package_config,
                                          Dart_IsolateFlags* flags,
                                          void* data,
                                          char** error) {
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, package_config, NULL);
   Dart_Isolate isolate = NULL;
@@ skipping 26 matching lines @@
                         false /* server dev mode */,
                         false /* trace_loading */)) {
     *error = strdup(VmService::GetErrorMessage());
     return NULL;
   }
   Dart_ExitScope();
   Dart_ExitIsolate();
   return isolate;
 }
 
-
 static MappedMemory* MapFile(const char* filename,
                              File::MapType type,
                              const uint8_t** buffer) {
   File* file = File::Open(filename, File::kRead);
   if (file == NULL) {
     Log::PrintErr("Failed to open: %s\n", filename);
     exit(kErrorExitCode);
   }
   intptr_t length = file->Length();
   if (length == 0) {
     // Can't map an empty file.
     *buffer = NULL;
     return NULL;
   }
   MappedMemory* mapping = file->Map(type, 0, length);
   if (mapping == NULL) {
     Log::PrintErr("Failed to read: %s\n", filename);
     exit(kErrorExitCode);
   }
   file->Release();
   *buffer = reinterpret_cast<const uint8_t*>(mapping->address());
   return mapping;
 }
 
-
 int main(int argc, char** argv) {
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
 
   // Initialize the URL mapping array.
   CommandLineOptions cmdline_url_mapping(argc);
   DartUtils::url_mapping = &cmdline_url_mapping;
 
   // Initialize the entrypoints array.
   CommandLineOptions entry_points_files_array(argc);
@@ skipping 253 matching lines @@
   delete mapped_isolate_snapshot_instructions;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }