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

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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/dfe.h"
 #include "bin/directory.h"
 #include "bin/embedded_dart_io.h"
 #include "bin/error_exit.h"
@@ skipping 89 matching lines @@
 // 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 compile_all = false;
 static bool parse_all = false;
 
-
 // Global flag that is used to indicate that we want to use blobs/mmap instead
 // of assembly/shared libraries for precompilation.
 static bool use_blobs = false;
 
-
 // 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 trace_loading = false;
 
-
 static char* app_script_uri = NULL;
 static const uint8_t* app_isolate_snapshot_data = NULL;
 static const uint8_t* app_isolate_snapshot_instructions = NULL;
 
-
 static Dart_Isolate main_isolate = NULL;
 
-
 static const char* DEFAULT_VM_SERVICE_SERVER_IP = "localhost";
 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;
 // True when we are running in development mode and cross origin security
 // checks are disabled.
 static bool vm_service_dev_mode = false;
 
-
 // The environment provided through the command line using -D options.
 static dart::HashMap* environment = 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));
 }
 
-
 static bool version_option = false;
 static bool ProcessVersionOption(const char* arg,
                                  CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
   version_option = true;
   return true;
 }
 
-
 static bool help_option = false;
 static bool ProcessHelpOption(const char* arg, CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
   help_option = true;
   return true;
 }
 
-
 static bool verbose_option = false;
 static bool ProcessVerboseOption(const char* arg,
                                  CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
   verbose_option = true;
   return true;
 }
 
-
 static bool ProcessPackageRootOption(const char* arg,
                                      CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   commandline_package_root = arg;
   return true;
 }
 
-
 static bool ProcessPackagesOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   commandline_packages_file = arg;
   return true;
 }
 
-
 static bool ProcessSaveCompilationTraceOption(const char* arg,
                                               CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   save_compilation_trace_filename = arg;
   return true;
 }
 
-
 static bool ProcessLoadCompilationTraceOption(const char* arg,
                                               CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   load_compilation_trace_filename = arg;
   return true;
 }
 
-
 static bool ProcessSaveFeedbackOption(const char* arg,
                                       CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   save_feedback_filename = arg;
   return true;
 }
 
-
 static bool ProcessLoadFeedbackOption(const char* arg,
                                       CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   load_feedback_filename = arg;
   return true;
 }
 
-
 static void* GetHashmapKeyFromString(char* key) {
   return reinterpret_cast<void*>(key);
 }
 
-
 static bool ExtractPortAndAddress(const char* option_value,
                                   int* out_port,
                                   const char** out_ip,
                                   int default_port,
                                   const char* default_ip) {
   // [option_value] has to be one of the following formats:
   //   - ""
   //   - ":8181"
   //   - "=8181"
   //   - ":8181/192.168.0.1"
@@ skipping 16 matching lines @@
     *out_ip = default_ip;
     *out_port = port;
     return true;
   }
 
   *out_ip = slash + 1;
   *out_port = port;
   return true;
 }
 
-
 static bool ProcessEnvironmentOption(const char* arg,
                                      CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '\0') {
     // Ignore empty -D option.
     Log::PrintErr("No arguments given to -D option, ignoring it\n");
     return true;
   }
   // Split the name=value part of the -Dname=value argument.
   const char* equals_pos = strchr(arg, '=');
@@ skipping 22 matching lines @@
                                               HashMap::StringHash(name), true);
   ASSERT(entry != NULL);  // Lookup adds an entry if key not found.
   if (entry->value != NULL) {
     free(name);
     free(entry->value);
   }
   entry->value = value;
   return true;
 }
 
-
 static bool ProcessCompileAllOption(const char* arg,
                                     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   compile_all = true;
   return true;
 }
 
-
 static bool ProcessParseAllOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   parse_all = true;
   return true;
 }
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 static bool ProcessFrontendOption(const char* filename,
                                   CommandLineOptions* vm_options) {
   ASSERT(filename != NULL);
   if (filename[0] == '\0') {
     return false;
   }
   dfe.set_frontend_filename(filename);
   vm_options->AddArgument("--use-dart-frontend");
   return true;
 }
 
-
 static bool ProcessKernelBinariesOption(const char* dirname,
                                         CommandLineOptions* vm_options) {
   ASSERT(dirname != NULL);
   if (dirname[0] == '\0') {
     return false;
   }
   dfe.SetKernelBinaries(dirname);
   return true;
 }
 #endif
 
-
 static bool ProcessUseBlobsOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   use_blobs = true;
   return true;
 }
 
-
 static bool ProcessSnapshotFilenameOption(const char* filename,
                                           CommandLineOptions* vm_options) {
   snapshot_filename = filename;
   if (gen_snapshot_kind == kNone) {
     gen_snapshot_kind = kScript;  // Default behavior.
   }
   return true;
 }
 
-
 static bool ProcessSnapshotKindOption(const char* kind,
                                       CommandLineOptions* vm_options) {
   if (strcmp(kind, "script") == 0) {
     gen_snapshot_kind = kScript;
     return true;
   } else if (strcmp(kind, "app-aot") == 0) {
     gen_snapshot_kind = kAppAOT;
     return true;
   } else if (strcmp(kind, "app-jit") == 0) {
     gen_snapshot_kind = kAppJIT;
     return true;
   }
   Log::PrintErr(
       "Unrecognized snapshot kind: '%s'\nValid kinds are: "
       "script, app-aot, app-jit\n",
       kind);
   return false;
 }
 
-
 static bool ProcessSnapshotDepsFilenameOption(const char* filename,
                                               CommandLineOptions* vm_options) {
   snapshot_deps_filename = filename;
   return true;
 }
 
-
 static bool ProcessEnableVmServiceOption(const char* option_value,
                                          CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
 
   if (!ExtractPortAndAddress(
           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. "
         "Use --enable-vm-service[=<port number>[/<bind address>]]\n");
     return false;
   }
 
   return true;
 }
 
-
 static bool ProcessDisableServiceOriginCheckOption(
     const char* option_value,
     CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
   Log::PrintErr(
       "WARNING: You are running with the service protocol in an "
       "insecure mode.\n");
   vm_service_dev_mode = true;
   return true;
 }
 
-
 static bool ProcessObserveOption(const char* option_value,
                                  CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
 
   if (!ExtractPortAndAddress(
           option_value, &vm_service_server_port, &vm_service_server_ip,
           DEFAULT_VM_SERVICE_SERVER_PORT, DEFAULT_VM_SERVICE_SERVER_IP)) {
     Log::PrintErr(
         "unrecognized --observe option syntax. "
         "Use --observe[=<port number>[/<bind address>]]\n");
     return false;
   }
 
   // These options should also be documented in the help message.
   vm_options->AddArgument("--pause-isolates-on-exit");
   vm_options->AddArgument("--pause-isolates-on-unhandled-exceptions");
   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;
   }
   trace_loading = true;
   return true;
 }
 
-
 static bool ProcessHotReloadTestModeOption(const char* arg,
                                            CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
 
   // Identity reload.
   vm_options->AddArgument("--identity_reload");
   // Start reloading quickly.
   vm_options->AddArgument("--reload_every=4");
   // Reload from optimized and unoptimized code.
   vm_options->AddArgument("--reload_every_optimized=false");
   // Reload less frequently as time goes on.
   vm_options->AddArgument("--reload_every_back_off");
   // Ensure that every isolate has reloaded once before exiting.
   vm_options->AddArgument("--check_reloaded");
 
   return true;
 }
 
-
 static bool ProcessHotReloadRollbackTestModeOption(
     const char* arg,
     CommandLineOptions* vm_options) {
   // Identity reload.
   vm_options->AddArgument("--identity_reload");
   // Start reloading quickly.
   vm_options->AddArgument("--reload_every=4");
   // Reload from optimized and unoptimized code.
   vm_options->AddArgument("--reload_every_optimized=false");
   // Reload less frequently as time goes on.
   vm_options->AddArgument("--reload_every_back_off");
   // Ensure that every isolate has reloaded once before exiting.
   vm_options->AddArgument("--check_reloaded");
   // Force all reloads to fail and execute the rollback code.
   vm_options->AddArgument("--reload_force_rollback");
 
   return true;
 }
 
-
 extern bool short_socket_read;
 
 extern bool short_socket_write;
 
 static bool ProcessShortSocketReadOption(const char* arg,
                                          CommandLineOptions* vm_options) {
   short_socket_read = true;
   return true;
 }
 
-
 static bool ProcessShortSocketWriteOption(const char* arg,
                                           CommandLineOptions* vm_options) {
   short_socket_write = true;
   return true;
 }
 
-
 extern const char* commandline_root_certs_file;
 extern const char* commandline_root_certs_cache;
 
 static bool ProcessRootCertsFileOption(const char* arg,
                                        CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   if (commandline_root_certs_cache != NULL) {
     Log::PrintErr(
         "Only one of --root-certs-file and --root-certs-cache "
         "may be specified");
     return false;
   }
   commandline_root_certs_file = arg;
   return true;
 }
 
-
 static bool ProcessRootCertsCacheOption(const char* arg,
                                         CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '-') {
     return false;
   }
   if (commandline_root_certs_file != NULL) {
     Log::PrintErr(
         "Only one of --root-certs-file and --root-certs-cache "
         "may be specified");
     return false;
   }
   commandline_root_certs_cache = arg;
   return true;
 }
 
-
 static struct {
   const char* option_name;
   bool (*process)(const char* option, CommandLineOptions* vm_options);
 } main_options[] = {
     // Standard options shared with dart2js.
     {"-D", ProcessEnvironmentOption},
     {"-h", ProcessHelpOption},
     {"--help", ProcessHelpOption},
     {"--packages=", ProcessPackagesOption},
     {"--package-root=", ProcessPackageRootOption},
@@ skipping 21 matching lines @@
     {"--load-feedback=", ProcessLoadFeedbackOption},
     {"--trace-loading", ProcessTraceLoadingOption},
     {"--hot-reload-test-mode", ProcessHotReloadTestModeOption},
     {"--hot-reload-rollback-test-mode", ProcessHotReloadRollbackTestModeOption},
     {"--short_socket_read", ProcessShortSocketReadOption},
     {"--short_socket_write", ProcessShortSocketWriteOption},
     {"--root-certs-file=", ProcessRootCertsFileOption},
     {"--root-certs-cache=", ProcessRootCertsCacheOption},
     {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);
   while (name != NULL) {
     int length = strlen(name);
     if ((option_length >= length) && (strncmp(option, name, length) == 0)) {
       if (main_options[i].process(option + length, vm_options)) {
         return true;
       }
     }
     i += 1;
     name = main_options[i].option_name;
   }
   return false;
 }
 
-
 // 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,
                           CommandLineOptions* dart_options,
                           bool* print_flags_seen,
                           bool* verbose_debug_seen) {
   const char* kPrefix = "--";
@@ skipping 96 matching lines @@
   if ((gen_snapshot_kind != kNone) && vm_run_app_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;
   }
   for (int i = 0; i < options_count; i++) {
     Dart_Handle argument_value = DartUtils::NewString(options->GetArgument(i));
     if (Dart_IsError(argument_value)) {
       return argument_value;
     }
     Dart_Handle result = Dart_ListSetAt(dart_arguments, i, argument_value);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return dart_arguments;
 }
 
-
 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;
 }
 
-
 #define SAVE_ERROR_AND_EXIT(result)                                            \
   *error = strdup(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();                                                      \
   return NULL;
 
-
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     SAVE_ERROR_AND_EXIT(result);                                               \
   }
 
-
 #define CHECK_RESULT_CLEANUP(result, cleanup)                                  \
   if (Dart_IsError(result)) {                                                  \
     delete (cleanup);                                                          \
     SAVE_ERROR_AND_EXIT(result);                                               \
   }
 
-
 static void SnapshotOnExitHook(int64_t exit_code) {
   if (Dart_CurrentIsolate() != main_isolate) {
     Log::PrintErr(
         "A snapshot was requested, but a secondary isolate "
         "performed a hard exit (%" Pd64 ").\n",
         exit_code);
     Platform::Exit(kErrorExitCode);
   }
   if (exit_code == 0) {
     Snapshot::GenerateAppJIT(snapshot_filename);
   }
 }
 
-
 static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
                                        bool is_main_isolate,
                                        const char* script_uri,
                                        const char* package_root,
                                        const char* packages_config,
                                        bool set_native_resolvers,
                                        bool isolate_run_app_snapshot,
                                        char** error,
                                        int* exit_code) {
   Dart_EnterScope();
@@ skipping 85 matching lines @@
   if (!retval) {
     *error = strdup("Invalid isolate state - Unable to make it runnable");
     Dart_EnterIsolate(isolate);
     Dart_ShutdownIsolate();
     return NULL;
   }
 
   return isolate;
 }
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 // Returns newly created Kernel Isolate on success, NULL on failure.
 // For now we only support the kernel isolate coming up from an
 // application snapshot or from sources which are compiled by the
 // VM parser.
 static Dart_Isolate CreateAndSetupKernelIsolate(const char* main,
                                                 const char* package_root,
                                                 const char* packages_config,
                                                 Dart_IsolateFlags* flags,
                                                 char** error,
@@ skipping 31 matching lines @@
     delete isolate_data;
     return NULL;
   }
 
   return IsolateSetupHelper(isolate, false, script_uri, package_root,
                             packages_config, isolate_snapshot_data,
                             isolate_run_app_snapshot, error, exit_code);
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-
 // Returns newly created Service Isolate on success, NULL on failure.
 // For now we only support the service isolate coming up from sources
 // which are compiled by the VM parser.
 static Dart_Isolate CreateAndSetupServiceIsolate(const char* script_uri,
                                                  const char* main,
                                                  const char* package_root,
                                                  const char* packages_config,
                                                  Dart_IsolateFlags* flags,
                                                  char** error,
                                                  int* exit_code) {
@@ skipping 59 matching lines @@
     result = Dart_CompileAll();
     CHECK_RESULT(result);
   }
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
   Dart_ExitScope();
   Dart_ExitIsolate();
   return isolate;
 }
 
-
 // Returns newly created Isolate on success, NULL on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
                                                 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);
@@ skipping 68 matching lines @@
   }
 
   bool set_native_resolvers = (kernel_program || isolate_snapshot_data);
   return IsolateSetupHelper(isolate, is_main_isolate, script_uri, package_root,
                             packages_config, set_native_resolvers,
                             isolate_run_app_snapshot, error, exit_code);
 }
 
 #undef CHECK_RESULT
 
-
 static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
                                           const char* main,
                                           const char* package_root,
                                           const char* package_config,
                                           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);
@@ skipping 15 matching lines @@
     return CreateAndSetupServiceIsolate(script_uri, main, package_root,
                                         package_config, flags, error,
                                         &exit_code);
   }
   bool is_main_isolate = false;
   return CreateIsolateAndSetupHelper(is_main_isolate, script_uri, main,
                                      package_root, package_config, flags, error,
                                      &exit_code);
 }
 
-
 static void PrintVersion() {
   Log::PrintErr("Dart VM version: %s\n", Dart_VersionString());
 }
 
-
 // clang-format off
 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 (!verbose_option) {
     Log::PrintErr(
 "Common options:\n"
@@ skipping 74 matching lines @@
 #endif  // !defined(HOST_OS_MACOS)
 "\n"
 "The following options are only used for VM development and may\n"
 "be changed in any future version:\n");
     const char* print_flags = "--print_flags";
     Dart_SetVMFlags(1, &print_flags);
   }
 }
 // clang-format on
 
-
 char* BuildIsolateName(const char* script_name, const char* func_name) {
   // Skip past any slashes in the script name.
   const char* last_slash = strrchr(script_name, '/');
   if (last_slash != NULL) {
     script_name = last_slash + 1;
   }
 
   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 OnIsolateShutdown(void* callback_data) {
   IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
   isolate_data->OnIsolateShutdown();
 }
 
-
 static void DeleteIsolateData(void* callback_data) {
   IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
   delete isolate_data;
 }
 
-
 static const char* kStdoutStreamId = "Stdout";
 static const char* kStderrStreamId = "Stderr";
 
-
 static bool ServiceStreamListenCallback(const char* stream_id) {
   if (strcmp(stream_id, kStdoutStreamId) == 0) {
     SetCaptureStdout(true);
     return true;
   } else if (strcmp(stream_id, kStderrStreamId) == 0) {
     SetCaptureStderr(true);
     return true;
   }
   return false;
 }
 
-
 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 bool FileModifiedCallback(const char* url, int64_t since) {
   if (strncmp(url, "file:///", 8) == 0) {
     // If it isn't a file on local disk, we don't know if it has been
     // modified.
     return true;
   }
   int64_t data[File::kStatSize];
   File::Stat(url + 7, data);
   if (data[File::kType] == File::kDoesNotExist) {
     return true;
   }
   bool modified = data[File::kModifiedTime] > since;
   return modified;
 }
 
-
 static void GenerateAppAOTSnapshot() {
   if (use_blobs) {
     Snapshot::GenerateAppAOTAsBlobs(snapshot_filename);
   } else {
     Snapshot::GenerateAppAOTAsAssembly(snapshot_filename);
   }
 }
 
-
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     const int exit_code = Dart_IsCompilationError(result)                      \
                               ? kCompilationErrorExitCode                      \
                               : kErrorExitCode;                                \
     ErrorExit(exit_code, "%s\n", Dart_GetError(result));                       \
   }
 
-
 static void WriteFile(const char* filename,
                       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\n", filename);
   }
   if (!file->WriteFully(buffer, size)) {
     ErrorExit(kErrorExitCode, "Unable to write file %s\n", filename);
   }
   file->Release();
 }
 
-
 static void ReadFile(const char* filename, uint8_t** buffer, intptr_t* size) {
   File* file = File::Open(filename, File::kRead);
   if (file == NULL) {
     ErrorExit(kErrorExitCode, "Unable to open file %s\n", filename);
   }
   *size = file->Length();
   *buffer = reinterpret_cast<uint8_t*>(malloc(*size));
   if (!file->ReadFully(*buffer, *size)) {
     ErrorExit(kErrorExitCode, "Unable to read file %s\n", filename);
   }
   file->Release();
 }
 
-
 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;
   bool is_main_isolate = true;
   int exit_code = 0;
   char* isolate_name = BuildIsolateName(script_name, "main");
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(
       is_main_isolate, script_name, "main", commandline_package_root,
       commandline_packages_file, NULL, &error, &exit_code);
@@ skipping 27 matching lines @@
   } 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 ((gen_snapshot_kind == kAppAOT) || (gen_snapshot_kind == kAppJIT)) {
-      // Load the embedder's portion of the VM service's Dart code so it will
-      // be included in the app snapshot.
+// Load the embedder's portion of the VM service's Dart code so it will
+// be included in the app snapshot.
 #if defined(DART_PRECOMPILED_RUNTIME)
       if (!VmService::LoadForGenPrecompiled(NULL)) {
 #else
       if (!VmService::LoadForGenPrecompiled(dfe.kernel_vmservice_io())) {
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
         Log::PrintErr("VM service loading failed: %s\n",
                       VmService::GetErrorMessage());
         exit(kErrorExitCode);
       }
     }
@@ skipping 185 matching lines @@
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // No restart.
   return false;
 }
 
 #undef CHECK_RESULT
 
-
 // Observatory assets are only needed in the regular dart binary.
 #if !defined(DART_PRECOMPILER) && !defined(NO_OBSERVATORY)
 extern unsigned int observatory_assets_archive_len;
 extern const uint8_t* observatory_assets_archive;
 
-
 // |input| is assumed to be a gzipped stream.
 // This function allocates the output buffer in the C heap and the caller
 // is responsible for freeing it.
 void Decompress(const uint8_t* input,
                 unsigned int input_len,
                 uint8_t** output,
                 unsigned int* output_length) {
   ASSERT(input != NULL);
   ASSERT(input_len > 0);
   ASSERT(output != NULL);
@@ skipping 45 matching lines @@
 
     // We've processed size_in bytes.
     input_cursor += size_in;
 
     // We're finished decompressing when zlib tells us.
   } while (ret != Z_STREAM_END);
 
   inflateEnd(&strm);
 }
 
-
 Dart_Handle GetVMServiceAssetsArchiveCallback() {
   uint8_t* decompressed = NULL;
   unsigned int decompressed_len = 0;
   Decompress(observatory_assets_archive, observatory_assets_archive_len,
              &decompressed, &decompressed_len);
   Dart_Handle tar_file =
       DartUtils::MakeUint8Array(decompressed, decompressed_len);
   // Free decompressed memory as it has been copied into a Dart array.
   free(decompressed);
   return tar_file;
 }
 #else   // !defined(DART_PRECOMPILER)
 static Dart_GetVMServiceAssetsArchive GetVMServiceAssetsArchiveCallback = NULL;
 #endif  // !defined(DART_PRECOMPILER)
 
-
 void main(int argc, char** argv) {
   char* script_name;
   const int EXTRA_VM_ARGUMENTS = 8;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
   CommandLineOptions dart_options(argc);
   bool print_flags_seen = false;
   bool verbose_debug_seen = false;
 
   // Perform platform specific initialization.
   if (!Platform::Initialize()) {
@@ skipping 154 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }