clang-format runtime/bin

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>
@@ skipping 122 matching lines @@
     if (name_len == 0) {
       Log::PrintErr("No name given to -D option\n");
       return false;
     }
     // Split name=value into name and value.
     name = reinterpret_cast<char*>(malloc(name_len + 1));
     strncpy(name, arg, name_len);
     name[name_len] = '\0';
     value = strdup(equals_pos + 1);
   }
-  HashMap::Entry* entry = environment->Lookup(
-      GetHashmapKeyFromString(name), HashMap::StringHash(name), true);
+  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));
     memmove(name_chars, utf8_array, utf8_len);
     name_chars[utf8_len] = '\0';
     const char* value = NULL;
     if (environment != NULL) {
-      HashMap::Entry* entry = environment->Lookup(
-          GetHashmapKeyFromString(name_chars),
-          HashMap::StringHash(name_chars),
-          false);
+      HashMap::Entry* entry =
+          environment->Lookup(GetHashmapKeyFromString(name_chars),
+                              HashMap::StringHash(name_chars), false);
       if (entry != NULL) {
         value = reinterpret_cast<char*>(entry->value);
       }
     }
     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 ProcessVmIsolateSnapshotOption(const char* option) {
@@ skipping 110 matching lines @@
   int i = 1;
 
   // Parse out the vm options.
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
     if (ProcessVmIsolateSnapshotOption(argv[i]) ||
         ProcessIsolateSnapshotOption(argv[i]) ||
         ProcessAssemblyOption(argv[i]) ||
         ProcessInstructionsBlobOption(argv[i]) ||
         ProcessRodataBlobOption(argv[i]) ||
         ProcessEmbedderEntryPointsManifestOption(argv[i]) ||
-        ProcessURLmappingOption(argv[i]) ||
-        ProcessPackageRootOption(argv[i]) ||
-        ProcessPackagesOption(argv[i]) ||
-        ProcessEnvironmentOption(argv[i])) {
+        ProcessURLmappingOption(argv[i]) || ProcessPackageRootOption(argv[i]) ||
+        ProcessPackagesOption(argv[i]) || ProcessEnvironmentOption(argv[i])) {
       i += 1;
       continue;
     }
     vm_options->AddArgument(argv[i]);
     i += 1;
   }
 
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
     i += 1;
   } else {
     *script_name = NULL;
   }
 
   // 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");
+    Log::PrintErr(
+        "Specifying both a packages directory and a packages "
+        "file is invalid.\n");
     return -1;
   }
 
   if (vm_isolate_snapshot_filename == NULL) {
     Log::PrintErr("No vm isolate snapshot output file specified.\n\n");
     return -1;
   }
 
   if (isolate_snapshot_filename == NULL) {
     Log::PrintErr("No isolate snapshot output file specified.\n\n");
     return -1;
   }
 
   bool precompiled_as_assembly = assembly_filename != NULL;
-  bool precompiled_as_blobs = (instructions_blob_filename != NULL) ||
-                              (rodata_blob_filename != NULL);
+  bool precompiled_as_blobs =
+      (instructions_blob_filename != NULL) || (rodata_blob_filename != NULL);
   if (precompiled_as_assembly && precompiled_as_blobs) {
     Log::PrintErr(
-      "Cannot request a precompiled snapshot simultaneously as "
-      "assembly (--assembly=<output.file>) and as blobs "
-      "(--instructions-blob=<output.file> and "
-      "--rodata-blob=<output.file>)\n\n");
+        "Cannot request a precompiled snapshot simultaneously as "
+        "assembly (--assembly=<output.file>) and as blobs "
+        "(--instructions-blob=<output.file> and "
+        "--rodata-blob=<output.file>)\n\n");
     return -1;
   }
   if ((instructions_blob_filename != NULL) != (rodata_blob_filename != NULL)) {
     Log::PrintErr(
-      "Requesting a precompiled snapshot as blobs requires both "
-      "(--instructions-blob=<output.file> and "
-      "--rodata-blob=<output.file>)\n\n");
+        "Requesting a precompiled snapshot as blobs requires both "
+        "(--instructions-blob=<output.file> and "
+        "--rodata-blob=<output.file>)\n\n");
     return -1;
   }
-  if (IsSnapshottingForPrecompilation() &&
-      (entry_points_files->count() == 0)) {
+  if (IsSnapshottingForPrecompilation() && (entry_points_files->count() == 0)) {
     Log::PrintErr(
         "Specifying an instructions snapshot filename indicates precompilation"
         ". But no embedder entry points manifest was specified.\n\n");
     return -1;
   }
 
   return 0;
 }
 
 
@@ skipping 46 matching lines @@
 static Dart_Handle LoadUrlContents(const char* uri_string) {
   bool failed = false;
   char* result_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);
-    Dart_Handle result =  Loader::LoadUrlContents(resolved_uri,
-                                                  &payload,
-                                                  &payload_length);
+    Dart_Handle result =
+        Loader::LoadUrlContents(resolved_uri, &payload, &payload_length);
     if (Dart_IsError(result)) {
       failed = true;
       result_string = strdup(Dart_GetError(result));
     }
   }
   // Switch back to the isolate from which we generate the snapshot and
   // create the source string for the specified uri.
   Dart_Handle result;
   if (!failed) {
     result = Dart_NewStringFromUTF8(payload, payload_length);
@@ skipping 18 matching lines @@
     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);
+  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);
+  Dart_Handle source = LoadUrlContents(resolved_uri_string);
 
   if (Dart_IsError(source)) {
     return source;
   }
   if (IsSnapshottingForPrecompilation()) {
     return Dart_LoadScript(resolved_uri, Dart_Null(), source, 0, 0);
   } else {
     return Dart_LoadLibrary(resolved_uri, Dart_Null(), source, 0, 0);
   }
 }
@@ skipping 14 matching lines @@
                                                    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");
   }
   const char* library_url_string = DartUtils::GetStringValue(library_url);
-  const char* mapped_library_url_string = DartUtils::MapLibraryUrl(
-      library_url_string);
+  const char* mapped_library_url_string =
+      DartUtils::MapLibraryUrl(library_url_string);
   if (mapped_library_url_string != NULL) {
     library_url = ResolveUriInWorkingDirectory(mapped_library_url_string);
     library_url_string = DartUtils::GetStringValue(library_url);
   }
 
   if (!Dart_IsString(url)) {
     return Dart_NewApiError("url is not a string");
   }
   const char* url_string = DartUtils::GetStringValue(url);
   const char* mapped_url_string = DartUtils::MapLibraryUrl(url_string);
@@ skipping 17 matching lines @@
       return Builtin::LoadLibrary(url, builtinId);
     }
     ASSERT(tag == Dart_kSourceTag);
     return DartUtils::NewError("Unable to part '%s' ", url_string);
   }
 
   if (libraryBuiltinId != Builtin::kInvalidLibrary) {
     // Special case for parting sources of a builtin library.
     if (tag == Dart_kSourceTag) {
       return Dart_LoadSource(library, url, Dart_Null(),
-          Builtin::PartSource(libraryBuiltinId, url_string), 0, 0);
+                             Builtin::PartSource(libraryBuiltinId, url_string),
+                             0, 0);
     }
     ASSERT(tag == Dart_kImportTag);
     return DartUtils::NewError("Unable to import '%s' ", url_string);
   }
 
   Dart_Handle resolved_url = url;
   if (mapped_url_string != NULL) {
     // Mapped urls are relative to working directory.
     resolved_url = ResolveUriInWorkingDirectory(mapped_url_string);
     if (Dart_IsError(resolved_url)) {
       return resolved_url;
     }
   }
   const char* resolved_uri_string = DartUtils::GetStringValue(resolved_url);
-  Dart_Handle source =  LoadUrlContents(resolved_uri_string);
+  Dart_Handle source = LoadUrlContents(resolved_uri_string);
   if (Dart_IsError(source)) {
     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"
 "  Writes a snapshot of <dart-script-file> to the specified snapshot files.  \n"
 "  If no <dart-script-file> is passed, a generic snapshot of all the corelibs\n"
 "  is created. It is required to specify the VM isolate snapshot and the     \n"
 "  isolate snapshot. The other flags are related to precompilation and are   \n"
 "  optional.                                                                 \n"
@@ skipping 41 matching lines @@
 "                                                                            \n"
 "    --instructions_blob=<file>        (Precompilation only) Contains the    \n"
 "    --rodata_blob=<file>              instructions and read-only data that  \n"
 "                                      must be mapped into the target binary \n"
 "                                                                            \n"
 "    --embedder_entry_points_manifest=<file> (Precompilation or app          \n"
 "                                      snapshots) Contains embedder's entry  \n"
 "                                      points into Dart code from the C API. \n"
 "\n");
 }
+// clang-format on
 
 
 static void VerifyLoaded(Dart_Handle library) {
   if (Dart_IsError(library)) {
     const char* err_msg = Dart_GetError(library);
     Log::PrintErr("Errors encountered while loading: %s\n", err_msg);
     CHECK_RESULT(library);
   }
   ASSERT(Dart_IsLibrary(library));
 }
 
 
 static const char StubNativeFunctionName[] = "StubNativeFunction";
 
 
 void StubNativeFunction(Dart_NativeArguments arguments) {
   // This is a stub function for the resolver
   UNREACHABLE();
 }
 
 
 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);
+  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)) {
     static const uint32_t kLoadBufferMaxSize = 128;
     char* load_buffer =
         reinterpret_cast<char*>(calloc(kLoadBufferMaxSize, sizeof(char)));
-    snprintf(load_buffer,
-             kLoadBufferMaxSize,
-             "import '%s';",
+    snprintf(load_buffer, kLoadBufferMaxSize, "import '%s';",
              DartUtils::GetStringValue(library_string));
     Dart_Handle script_handle = Dart_NewStringFromCString(load_buffer);
     memset(load_buffer, 0, kLoadBufferMaxSize);
-    snprintf(load_buffer,
-             kLoadBufferMaxSize,
-             "dart:_snapshot_%zu",
-             lib_index);
+    snprintf(load_buffer, kLoadBufferMaxSize, "dart:_snapshot_%zu", lib_index);
     Dart_Handle script_url = Dart_NewStringFromCString(load_buffer);
     free(load_buffer);
-    Dart_Handle loaded = Dart_LoadLibrary(script_url, Dart_Null(),
-                                          script_handle, 0, 0);
+    Dart_Handle loaded =
+        Dart_LoadLibrary(script_url, Dart_Null(), script_handle, 0, 0);
     DART_CHECK_VALID(loaded);
 
     // Do a fresh lookup
     library = Dart_LookupLibrary(library_string);
   }
 
   DART_CHECK_VALID(library);
-  Dart_Handle result =  Dart_SetNativeResolver(library,
-                                               &StubNativeLookup,
-                                               &StubNativeSymbol);
+  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) {
+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));
 }
@@ skipping 40 matching lines @@
     case 2:
       return "Function";
     default:
       return "Unknown";
   }
   return NULL;
 }
 
 
 static bool ParseEntryPointsManifestSingleLine(
-    const char* line, Dart_QualifiedFunctionName* entry, char** error) {
+    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;
       *error = ParserErrorStringCreate(
           "Manifest entries must be comma separated and newline terminated. "
           "Could not parse '%s' on line '%s'",
           ParseEntryNameForIndex(i), line);
@@ skipping 148 matching lines @@
 
 static void CreateAndWriteSnapshot() {
   ASSERT(!IsSnapshottingForPrecompilation());
   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;
 
   // First create a snapshot.
-  result = Dart_CreateSnapshot(&vm_isolate_buffer,
-                               &vm_isolate_size,
-                               &isolate_buffer,
-                               &isolate_size);
+  result = Dart_CreateSnapshot(&vm_isolate_buffer, &vm_isolate_size,
+                               &isolate_buffer, &isolate_size);
   CHECK_RESULT(result);
 
   // Now write the vm isolate and isolate snapshots out to the
   // specified file and exit.
-  WriteSnapshotFile(vm_isolate_snapshot_filename,
-                    vm_isolate_buffer,
+  WriteSnapshotFile(vm_isolate_snapshot_filename, vm_isolate_buffer,
                     vm_isolate_size);
-  WriteSnapshotFile(isolate_snapshot_filename,
-                    isolate_buffer,
-                    isolate_size);
+  WriteSnapshotFile(isolate_snapshot_filename, isolate_buffer, isolate_size);
   Dart_ExitScope();
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
 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, true);
   CHECK_RESULT(result);
 
   // Create a precompiled snapshot.
   bool as_assembly = assembly_filename != NULL;
   if (as_assembly) {
     uint8_t* assembly_buffer = NULL;
     intptr_t assembly_size = 0;
     result = Dart_CreatePrecompiledSnapshotAssembly(&assembly_buffer,
                                                     &assembly_size);
     CHECK_RESULT(result);
-    WriteSnapshotFile(assembly_filename,
-                      assembly_buffer,
-                      assembly_size);
+    WriteSnapshotFile(assembly_filename, assembly_buffer, assembly_size);
   } else {
     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_blob_buffer = NULL;
     intptr_t instructions_blob_size = 0;
     uint8_t* rodata_blob_buffer = NULL;
     intptr_t rodata_blob_size = 0;
-    result = Dart_CreatePrecompiledSnapshotBlob(&vm_isolate_buffer,
-                                                &vm_isolate_size,
-                                                &isolate_buffer,
-                                                &isolate_size,
-                                                &instructions_blob_buffer,
-                                                &instructions_blob_size,
-                                                &rodata_blob_buffer,
-                                                &rodata_blob_size);
+    result = Dart_CreatePrecompiledSnapshotBlob(
+        &vm_isolate_buffer, &vm_isolate_size, &isolate_buffer, &isolate_size,
+        &instructions_blob_buffer, &instructions_blob_size, &rodata_blob_buffer,
+        &rodata_blob_size);
     CHECK_RESULT(result);
-    WriteSnapshotFile(vm_isolate_snapshot_filename,
-                      vm_isolate_buffer,
+    WriteSnapshotFile(vm_isolate_snapshot_filename, vm_isolate_buffer,
                       vm_isolate_size);
-    WriteSnapshotFile(isolate_snapshot_filename,
-                      isolate_buffer,
-                      isolate_size);
-    WriteSnapshotFile(instructions_blob_filename,
-                      instructions_blob_buffer,
+    WriteSnapshotFile(isolate_snapshot_filename, isolate_buffer, isolate_size);
+    WriteSnapshotFile(instructions_blob_filename, instructions_blob_buffer,
                       instructions_blob_size);
-    WriteSnapshotFile(rodata_blob_filename,
-                      rodata_blob_buffer,
+    WriteSnapshotFile(rodata_blob_filename, rodata_blob_buffer,
                       rodata_blob_size);
   }
 
   Dart_ExitScope();
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
@@ skipping 29 matching lines @@
 }
 
 
 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);
+  IsolateData* isolate_data =
+      new IsolateData(script_uri, package_root, package_config);
   Dart_Isolate isolate = NULL;
-  isolate = Dart_CreateIsolate(script_uri,
-                               main,
-                               NULL,
-                               NULL,
-                               isolate_data,
-                               error);
+  isolate =
+      Dart_CreateIsolate(script_uri, main, NULL, NULL, isolate_data, error);
 
   if (isolate == NULL) {
     Log::PrintErr("Error: Could not create service isolate");
     return NULL;
   }
 
   Dart_EnterScope();
   if (!Dart_IsServiceIsolate(isolate)) {
     Log::PrintErr("Error: We only expect to create the service isolate");
     return NULL;
   }
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   // Setup the native resolver.
   Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
   Builtin::LoadAndCheckLibrary(Builtin::kIOLibrary);
   if (Dart_IsError(result)) {
     Log::PrintErr("Error: Could not set tag handler for service isolate");
     return NULL;
   }
   CHECK_RESULT(result);
   ASSERT(Dart_IsServiceIsolate(isolate));
   // Load embedder specific bits and return. Will not start http server.
-  if (!VmService::Setup("127.0.0.1",
-                        -1,
-                        false /* running_precompiled */,
+  if (!VmService::Setup("127.0.0.1", -1, false /* running_precompiled */,
                         false /* server dev mode */)) {
     *error = strdup(VmService::GetErrorMessage());
     return NULL;
   }
   Dart_ExitScope();
   Dart_ExitIsolate();
   return isolate;
 }
 
 
 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);
   entry_points_files = &entry_points_files_array;
 
   // Parse command line arguments.
-  if (ParseArguments(argc,
-                     argv,
-                     &vm_options,
-                     &app_script_name) < 0) {
+  if (ParseArguments(argc, argv, &vm_options, &app_script_name) < 0) {
     PrintUsage();
     return 255;
   }
 
   Thread::InitOnce();
   Loader::InitOnce();
   DartUtils::SetOriginalWorkingDirectory();
   // Start event handler.
   TimerUtils::InitOnce();
   EventHandler::Start();
@@ skipping 31 matching lines @@
   init_params.file_close = DartUtils::CloseFile;
   init_params.entropy_source = DartUtils::EntropySource;
 
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return 255;
   }
 
-  IsolateData* isolate_data = new IsolateData(NULL,
-                                              commandline_package_root,
+  IsolateData* isolate_data = new IsolateData(NULL, commandline_package_root,
                                               commandline_packages_file);
-  Dart_Isolate isolate = Dart_CreateIsolate(
-      NULL, NULL, NULL, NULL, isolate_data, &error);
+  Dart_Isolate isolate =
+      Dart_CreateIsolate(NULL, NULL, NULL, NULL, isolate_data, &error);
   if (isolate == NULL) {
     Log::PrintErr("Error: %s", error);
     free(error);
     exit(255);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
@@ skipping 26 matching lines @@
                                          commandline_packages_file);
     CHECK_RESULT(result);
 
     UriResolverIsolateScope::isolate = isolate;
     Dart_ExitScope();
     Dart_ExitIsolate();
 
     // Now we create an isolate into which we load all the code that needs to
     // be in the snapshot.
     isolate_data = new IsolateData(NULL, NULL, NULL);
-    if (Dart_CreateIsolate(
-            NULL, NULL, NULL, NULL, isolate_data, &error) == NULL) {
+    if (Dart_CreateIsolate(NULL, NULL, NULL, NULL, isolate_data, &error) ==
+        NULL) {
       fprintf(stderr, "%s", error);
       free(error);
       exit(255);
     }
     Dart_EnterScope();
     result = Dart_SetEnvironmentCallback(EnvironmentCallback);
     CHECK_RESULT(result);
 
     // Set up the library tag handler in such a manner that it will use the
     // URL mapping specified on the command line to load the libraries.
@@ skipping 55 matching lines @@
   EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }