clang-format runtime/bin

runtime/bin/loader.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 
 #include "bin/loader.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/extensions.h"
@@ skipping 15 matching lines @@
       error_(Dart_Null()),
       monitor_(NULL),
       pending_operations_(0),
       results_(NULL),
       results_length_(0),
       results_capacity_(0),
       payload_(NULL),
       payload_length_(0) {
   monitor_ = new Monitor();
   ASSERT(isolate_data_ != NULL);
-  port_ = Dart_NewNativePort("Loader",
-                             Loader::NativeMessageHandler,
-                             false);
+  port_ = Dart_NewNativePort("Loader", Loader::NativeMessageHandler, false);
   isolate_data_->set_loader(this);
   AddLoader(port_, isolate_data_);
 }
 
 
 Loader::~Loader() {
   ASSERT(port_ != ILLEGAL_PORT);
   // Enter the monitor while we close the Dart port. After the Dart port is
   // closed, no more results can be queued.
   monitor_->Enter();
@@ skipping 55 matching lines @@
     // Payload is an error message.
     payload_length = strlen(payload_message->value.as_string);
     payload =
         reinterpret_cast<uint8_t*>(strdup(payload_message->value.as_string));
   } else {
     // Payload is the contents of a file.
     ASSERT(payload_message->type == Dart_CObject_kTypedData);
     ASSERT(payload_message->value.as_typed_data.type == Dart_TypedData_kUint8);
     payload_length = payload_message->value.as_typed_data.length;
     payload = reinterpret_cast<uint8_t*>(malloc(payload_length));
-    memmove(payload,
-            payload_message->value.as_typed_data.values,
+    memmove(payload, payload_message->value.as_typed_data.values,
             payload_length);
   }
 }
 
 
 void Loader::IOResult::Cleanup() {
   free(uri);
   free(resolved_uri);
   free(library_uri);
   free(payload);
@@ skipping 12 matching lines @@
   ASSERT(loader_port != ILLEGAL_PORT);
 
   // Keep in sync with loader.dart.
   const intptr_t _Dart_kInitLoader = 4;
 
   Dart_Handle request = Dart_NewList(8);
   Dart_ListSetAt(request, 0, trace_loader ? Dart_True() : Dart_False());
   Dart_ListSetAt(request, 1, Dart_NewInteger(Dart_GetMainPortId()));
   Dart_ListSetAt(request, 2, Dart_NewInteger(_Dart_kInitLoader));
   Dart_ListSetAt(request, 3, Dart_NewSendPort(port_));
-  Dart_ListSetAt(request, 4,
-                 (package_root == NULL) ? Dart_Null() :
-                      Dart_NewStringFromCString(package_root));
-  Dart_ListSetAt(request, 5,
-                 (packages_file == NULL) ? Dart_Null() :
-                      Dart_NewStringFromCString(packages_file));
-  Dart_ListSetAt(request, 6,
-                      Dart_NewStringFromCString(working_directory));
-  Dart_ListSetAt(request, 7,
-                 (root_script_uri == NULL) ? Dart_Null() :
-                      Dart_NewStringFromCString(root_script_uri));
+  Dart_ListSetAt(request, 4, (package_root == NULL)
+                                 ? Dart_Null()
+                                 : Dart_NewStringFromCString(package_root));
+  Dart_ListSetAt(request, 5, (packages_file == NULL)
+                                 ? Dart_Null()
+                                 : Dart_NewStringFromCString(packages_file));
+  Dart_ListSetAt(request, 6, Dart_NewStringFromCString(working_directory));
+  Dart_ListSetAt(request, 7, (root_script_uri == NULL)
+                                 ? Dart_Null()
+                                 : Dart_NewStringFromCString(root_script_uri));
 
   bool success = Dart_Post(loader_port, request);
   ASSERT(success);
 }
 
 
 void Loader::SendImportExtensionRequest(Dart_Handle url,
                                         Dart_Handle library_url) {
   // This port delivers loading messages to the service isolate.
   Dart_Port loader_port = Builtin::LoadPort();
@@ skipping 38 matching lines @@
     pending_operations_++;
   }
 }
 
 
 void Loader::QueueMessage(Dart_CObject* message) {
   MonitorLocker ml(monitor_);
   if (results_length_ == results_capacity_) {
     // Grow to an initial capacity or double in size.
     results_capacity_ = (results_capacity_ == 0) ? 4 : results_capacity_ * 2;
-    results_ =
-        reinterpret_cast<IOResult*>(
-            realloc(results_,
-                    sizeof(IOResult) * results_capacity_));
+    results_ = reinterpret_cast<IOResult*>(
+        realloc(results_, sizeof(IOResult) * results_capacity_));
     ASSERT(results_ != NULL);
   }
   ASSERT(results_ != NULL);
   ASSERT(results_length_ < results_capacity_);
   results_[results_length_].Setup(message);
   results_length_++;
   ml.Notify();
 }
 
 
@@ skipping 48 matching lines @@
   Dart_Handle library_uri = Dart_Null();
   if (result->library_uri != NULL) {
     library_uri =
         Dart_NewStringFromCString(reinterpret_cast<char*>(result->library_uri));
   }
 
   // A negative result tag indicates a loading error occurred in the service
   // isolate. The payload is a C string of the error message.
   if (result->tag < 0) {
     Dart_Handle library = Dart_LookupLibrary(uri);
-    Dart_Handle error = Dart_NewStringFromUTF8(result->payload,
-                                               result->payload_length);
+    Dart_Handle error =
+        Dart_NewStringFromUTF8(result->payload, result->payload_length);
     // If a library with the given uri exists, give it a chance to handle
     // the error. If the load requests stems from a deferred library load,
     // an IO error is not fatal.
     if (LibraryHandleError(library, error)) {
       return true;
     }
     // Fall through
     loader->error_ = Dart_NewUnhandledExceptionError(error);
     return false;
   }
 
   if (result->tag == _Dart_kImportExtension) {
     ASSERT(library_uri != Dart_Null());
     Dart_Handle library = Dart_LookupLibrary(library_uri);
     ASSERT(!Dart_IsError(library));
     const char* lib_uri = reinterpret_cast<const char*>(result->payload);
     if (strncmp(lib_uri, "http://", 7) == 0 ||
         strncmp(lib_uri, "https://", 8) == 0) {
-      loader->error_ =
-        Dart_NewApiError("Cannot load native extensions over http: or https:");
-        return false;
+      loader->error_ = Dart_NewApiError(
+          "Cannot load native extensions over http: or https:");
+      return false;
     }
     const char* extension_uri = reinterpret_cast<const char*>(result->uri);
     const char* lib_path = NULL;
     if (strncmp(lib_uri, "file://", 7) == 0) {
       lib_path = DartUtils::RemoveScheme(lib_uri);
     } else {
       lib_path = lib_uri;
     }
     const char* extension_path = DartUtils::RemoveScheme(extension_uri);
     if (!File::IsAbsolutePath(extension_path) &&
         PathContainsSeparator(extension_path)) {
       loader->error_ = DartUtils::NewError(
           "Native extension path must be absolute, or simply the file name: %s",
           extension_path);
       return false;
     }
-    Dart_Handle result = Extensions::LoadExtension(lib_path,
-                                                   extension_path,
-                                                   library);
+    Dart_Handle result =
+        Extensions::LoadExtension(lib_path, extension_path, library);
     if (Dart_IsError(result)) {
       loader->error_ = result;
       return false;
     }
     return true;
   }
 
   // Check for payload and load accordingly.
   const uint8_t* payload = result->payload;
   intptr_t payload_length = result->payload_length;
   const DartUtils::MagicNumber payload_type =
       DartUtils::SniffForMagicNumber(&payload, &payload_length);
   Dart_Handle source = Dart_Null();
   if (payload_type == DartUtils::kUnknownMagicNumber) {
-    source = Dart_NewStringFromUTF8(result->payload,
-                                    result->payload_length);
+    source = Dart_NewStringFromUTF8(result->payload, result->payload_length);
     if (Dart_IsError(source)) {
-      loader->error_ = DartUtils::NewError(
-          "%s is not a valid UTF-8 script",
-          reinterpret_cast<char*>(result->uri));
+      loader->error_ =
+          DartUtils::NewError("%s is not a valid UTF-8 script",
+                              reinterpret_cast<char*>(result->uri));
       return false;
     }
   }
   intptr_t tag = result->tag;
 
   // No touching.
   result = NULL;
 
   // We must drop the lock here because the tag handler may be recursively
   // invoked and it will attempt to acquire the lock to queue more work.
   loader->monitor_->Exit();
 
   Dart_Handle dart_result = Dart_Null();
 
   switch (tag) {
     case Dart_kImportTag:
       dart_result = Dart_LoadLibrary(uri, resolved_uri, source, 0, 0);
-    break;
+      break;
     case Dart_kSourceTag: {
       ASSERT(library_uri != Dart_Null());
       Dart_Handle library = Dart_LookupLibrary(library_uri);
       ASSERT(!Dart_IsError(library));
       dart_result = Dart_LoadSource(library, uri, resolved_uri, source, 0, 0);
-    }
-    break;
+    } break;
     case Dart_kScriptTag:
       if (payload_type == DartUtils::kSnapshotMagicNumber) {
         dart_result = Dart_LoadScriptFromSnapshot(payload, payload_length);
       } else if (payload_type == DartUtils::kKernelMagicNumber) {
         dart_result = Dart_LoadKernel(payload, payload_length);
       } else {
         dart_result = Dart_LoadScript(uri, resolved_uri, source, 0, 0);
       }
-    break;
+      break;
     default:
       UNREACHABLE();
   }
 
   // Re-acquire the lock before exiting the function (it was held before entry),
   loader->monitor_->Enter();
   if (Dart_IsError(dart_result)) {
     // Remember the error if we encountered one.
     loader->error_ = dart_result;
     return false;
   }
 
   return true;
 }
 
 
 bool Loader::ProcessUrlLoadResultLocked(Loader* loader,
                                         Loader::IOResult* result) {
   // A negative result tag indicates a loading error occurred in the service
   // isolate. The payload is a C string of the error message.
   if (result->tag < 0) {
-    Dart_Handle error = Dart_NewStringFromUTF8(result->payload,
-                                               result->payload_length);
+    Dart_Handle error =
+        Dart_NewStringFromUTF8(result->payload, result->payload_length);
     loader->error_ = Dart_NewUnhandledExceptionError(error);
     return false;
   }
   loader->payload_length_ = result->payload_length;
   loader->payload_ =
       reinterpret_cast<uint8_t*>(::malloc(loader->payload_length_));
   memmove(loader->payload_, result->payload, loader->payload_length_);
   return true;
 }
 
@@ skipping 14 matching lines @@
 
 
 void Loader::InitForSnapshot(const char* snapshot_uri) {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   ASSERT(isolate_data != NULL);
   ASSERT(!isolate_data->HasLoader());
   // Setup a loader. The constructor does a bunch of leg work.
   Loader* loader = new Loader(isolate_data);
   // Send the init message.
-  loader->Init(isolate_data->package_root,
-               isolate_data->packages_file,
-               DartUtils::original_working_directory,
-               snapshot_uri);
+  loader->Init(isolate_data->package_root, isolate_data->packages_file,
+               DartUtils::original_working_directory, snapshot_uri);
   // Destroy the loader. The destructor does a bunch of leg work.
   delete loader;
 }
 
 
 Dart_Handle Loader::LoadUrlContents(Dart_Handle url,
                                     uint8_t** payload,
                                     intptr_t* payload_length) {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   ASSERT(isolate_data != NULL);
   ASSERT(!isolate_data->HasLoader());
   Loader* loader = NULL;
 
   // Setup the loader. The constructor does a bunch of leg work.
   loader = new Loader(isolate_data);
-  loader->Init(isolate_data->package_root,
-               isolate_data->packages_file,
-               DartUtils::original_working_directory,
-               NULL);
+  loader->Init(isolate_data->package_root, isolate_data->packages_file,
+               DartUtils::original_working_directory, NULL);
   ASSERT(loader != NULL);
   ASSERT(isolate_data->HasLoader());
 
   // Now send a load request to the service isolate.
   loader->SendRequest(Dart_kScriptTag, url, Dart_Null());
 
   // Wait for a reply to the load request.
   loader->BlockUntilComplete(ProcessUrlLoadResultLocked);
 
   // Copy fields from the loader before deleting it.
@@ skipping 40 matching lines @@
     const char* library_url_string = NULL;
     result = Dart_StringToCString(library_url, &library_url_string);
     if (Dart_IsError(result)) {
       return result;
     }
 
     bool is_dart_scheme_url = DartUtils::IsDartSchemeURL(url_string);
     bool is_dart_library = DartUtils::IsDartSchemeURL(library_url_string);
 
     if (is_dart_scheme_url || is_dart_library) {
-      return DartColonLibraryTagHandler(tag,
-                                        library,
-                                        url,
-                                        library_url_string,
+      return DartColonLibraryTagHandler(tag, library, url, library_url_string,
                                         url_string);
     }
   }
 
   if (DartUtils::IsDartExtensionSchemeURL(url_string)) {
     // Handle early error cases for dart-ext: imports.
     if (tag != Dart_kImportTag) {
       return DartUtils::NewError("Dart extensions must use import: '%s'",
                                  url_string);
     }
@@ skipping 16 matching lines @@
 
   // If we are the outer invocation of the tag handler and the tag is an import
   // this means that we are starting a deferred library load.
   const bool is_deferred_import = blocking_call && (tag == Dart_kImportTag);
   if (!isolate_data->HasLoader()) {
     // The isolate doesn't have a loader -- this is the outer invocation which
     // will block.
 
     // Setup the loader. The constructor does a bunch of leg work.
     loader = new Loader(isolate_data);
-    loader->Init(isolate_data->package_root,
-                 isolate_data->packages_file,
+    loader->Init(isolate_data->package_root, isolate_data->packages_file,
                  DartUtils::original_working_directory,
                  (tag == Dart_kScriptTag) ? url_string : NULL);
   } else {
     ASSERT(tag != Dart_kScriptTag);
     // The isolate has a loader -- this is an inner invocation that will queue
     // work with the service isolate.
     // Use the existing loader.
     loader = isolate_data->loader();
   }
   ASSERT(loader != NULL);
   ASSERT(isolate_data->HasLoader());
 
   if (DartUtils::IsDartExtensionSchemeURL(url_string)) {
     loader->SendImportExtensionRequest(url, Dart_LibraryUrl(library));
   } else {
-    loader->SendRequest(tag,
-                        url,
-                        (library != Dart_Null()) ?
-                            Dart_LibraryUrl(library) : Dart_Null());
+    loader->SendRequest(tag, url, (library != Dart_Null())
+                                      ? Dart_LibraryUrl(library)
+                                      : Dart_Null());
   }
 
 
   if (blocking_call) {
     // The outer invocation of the tag handler will block here until all nested
     // invocations complete.
     loader->BlockUntilComplete(ProcessResultLocked);
 
     // Remember the error (if any).
     Dart_Handle error = loader->error();
@@ skipping 36 matching lines @@
                                                Dart_Handle url,
                                                const char* library_url_string,
                                                const char* url_string) {
   // Handle canonicalization, 'import' and 'part' of 'dart:' libraries.
   if (tag == Dart_kCanonicalizeUrl) {
     // These will be handled internally.
     return url;
   } else if (tag == Dart_kImportTag) {
     Builtin::BuiltinLibraryId id = Builtin::FindId(url_string);
     if (id == Builtin::kInvalidLibrary) {
-      return DartUtils::NewError("The built-in library '%s' is not available"
-                                 " on the stand-alone VM.\n", url_string);
+      return DartUtils::NewError(
+          "The built-in library '%s' is not available"
+          " on the stand-alone VM.\n",
+          url_string);
     }
     return Builtin::LoadLibrary(url, id);
   } else {
     ASSERT(tag == Dart_kSourceTag);
     Builtin::BuiltinLibraryId id = Builtin::FindId(library_url_string);
     if (id == Builtin::kInvalidLibrary) {
-      return DartUtils::NewError("The built-in library '%s' is not available"
-                                 " on the stand-alone VM. Trying to load"
-                                 " '%s'.\n", library_url_string, url_string);
+      return DartUtils::NewError(
+          "The built-in library '%s' is not available"
+          " on the stand-alone VM. Trying to load"
+          " '%s'.\n",
+          library_url_string, url_string);
     }
     // Prepend the library URI to form a unique script URI for the part.
     intptr_t len = snprintf(NULL, 0, "%s/%s", library_url_string, url_string);
     char* part_uri = reinterpret_cast<char*>(malloc(len + 1));
     snprintf(part_uri, len + 1, "%s/%s", library_url_string, url_string);
     Dart_Handle part_uri_obj = DartUtils::NewString(part_uri);
     free(part_uri);
-    return Dart_LoadSource(library,
-                           part_uri_obj, Dart_Null(),
+    return Dart_LoadSource(library, part_uri_obj, Dart_Null(),
                            Builtin::PartSource(id, url_string), 0, 0);
   }
   // All cases should have been handled above.
   UNREACHABLE();
   return Dart_Null();
 }
 
 
 void Loader::InitOnce() {
   loader_infos_lock_ = new Mutex();
@@ skipping 10 matching lines @@
 // native message arrives, we use this map to report the I/O result to the
 // correct loader.
 // This happens whenever an isolate begins loading.
 void Loader::AddLoader(Dart_Port port, IsolateData* isolate_data) {
   MutexLocker ml(loader_infos_lock_);
   ASSERT(LoaderForLocked(port) == NULL);
   if (loader_infos_length_ == loader_infos_capacity_) {
     // Grow to an initial capacity or double in size.
     loader_infos_capacity_ =
         (loader_infos_capacity_ == 0) ? 4 : loader_infos_capacity_ * 2;
-    loader_infos_ =
-        reinterpret_cast<Loader::LoaderInfo*>(
-            realloc(loader_infos_,
-                    sizeof(Loader::LoaderInfo) * loader_infos_capacity_));
+    loader_infos_ = reinterpret_cast<Loader::LoaderInfo*>(realloc(
+        loader_infos_, sizeof(Loader::LoaderInfo) * loader_infos_capacity_));
     ASSERT(loader_infos_ != NULL);
     // Initialize new entries.
     for (intptr_t i = loader_infos_length_; i < loader_infos_capacity_; i++) {
       loader_infos_[i].port = ILLEGAL_PORT;
       loader_infos_[i].isolate_data = NULL;
     }
   }
   ASSERT(loader_infos_length_ < loader_infos_capacity_);
   loader_infos_[loader_infos_length_].port = port;
   loader_infos_[loader_infos_length_].isolate_data = isolate_data;
@@ skipping 48 matching lines @@
   MutexLocker ml(loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart