clang-format runtime/bin

runtime/bin/file_linux.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 "platform/globals.h"
 #if defined(TARGET_OS_LINUX)
 
 #include "bin/file.h"
 
-#include <errno.h>  // NOLINT
-#include <fcntl.h>  // NOLINT
-#include <libgen.h>  // NOLINT
-#include <sys/mman.h>  // NOLINT
+#include <errno.h>         // NOLINT
+#include <fcntl.h>         // NOLINT
+#include <libgen.h>        // NOLINT
+#include <sys/mman.h>      // NOLINT
 #include <sys/sendfile.h>  // NOLINT
-#include <sys/stat.h>  // NOLINT
-#include <sys/types.h>  // NOLINT
-#include <unistd.h>  // NOLINT
+#include <sys/stat.h>      // NOLINT
+#include <sys/types.h>     // NOLINT
+#include <unistd.h>        // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/log.h"
 #include "platform/signal_blocker.h"
 #include "platform/utils.h"
 
 namespace dart {
 namespace bin {
 
 class FileHandle {
  public:
-  explicit FileHandle(int fd) : fd_(fd) { }
-  ~FileHandle() { }
+  explicit FileHandle(int fd) : fd_(fd) {}
+  ~FileHandle() {}
   int fd() const { return fd_; }
   void set_fd(int fd) { fd_ = fd; }
 
  private:
   int fd_;
 
   DISALLOW_COPY_AND_ASSIGN(FileHandle);
 };
 
 
 File::~File() {
-  if (!IsClosed() &&
-      handle_->fd() != STDOUT_FILENO && handle_->fd() != STDERR_FILENO) {
+  if (!IsClosed() && handle_->fd() != STDOUT_FILENO &&
+      handle_->fd() != STDERR_FILENO) {
     Close();
   }
   delete handle_;
 }
 
 
 void File::Close() {
   ASSERT(handle_->fd() >= 0);
   if (handle_->fd() == STDOUT_FILENO) {
     // If stdout, redirect fd to /dev/null.
@@ skipping 29 matching lines @@
   switch (type) {
     case kReadOnly:
       prot = PROT_READ;
       break;
     case kReadExecute:
       prot = PROT_READ | PROT_EXEC;
       break;
     default:
       return NULL;
   }
-  void* addr = mmap(NULL, length, prot, MAP_PRIVATE,
-                    handle_->fd(), position);
+  void* addr = mmap(NULL, length, prot, MAP_PRIVATE, handle_->fd(), position);
   if (addr == MAP_FAILED) {
     return NULL;
   }
   return addr;
 }
 
 
 int64_t File::Read(void* buffer, int64_t num_bytes) {
   ASSERT(handle_->fd() >= 0);
   return TEMP_FAILURE_RETRY(read(handle_->fd(), buffer, num_bytes));
@@ skipping 124 matching lines @@
   struct stat64 st;
   if (TEMP_FAILURE_RETRY(stat64(name, &st)) == 0) {
     return S_ISREG(st.st_mode);
   } else {
     return false;
   }
 }
 
 
 bool File::Create(const char* name) {
-  int fd = TEMP_FAILURE_RETRY(
-      open64(name, O_RDONLY | O_CREAT | O_CLOEXEC, 0666));
+  int fd =
+      TEMP_FAILURE_RETRY(open64(name, O_RDONLY | O_CREAT | O_CLOEXEC, 0666));
   if (fd < 0) {
     return false;
   }
   return (TEMP_FAILURE_RETRY(close(fd)) == 0);
 }
 
 
 bool File::CreateLink(const char* name, const char* target) {
   return NO_RETRY_EXPECTED(symlink(target, name)) == 0;
 }
@@ skipping 62 matching lines @@
     int new_fd = TEMP_FAILURE_RETRY(
         open64(new_path, O_WRONLY | O_TRUNC | O_CREAT | O_CLOEXEC, st.st_mode));
     if (new_fd < 0) {
       VOID_TEMP_FAILURE_RETRY(close(old_fd));
       return false;
     }
     int64_t offset = 0;
     intptr_t result = 1;
     while (result > 0) {
       // Loop to ensure we copy everything, and not only up to 2GB.
-      result = NO_RETRY_EXPECTED(
-          sendfile64(new_fd, old_fd, &offset, kMaxUint32));
+      result =
+          NO_RETRY_EXPECTED(sendfile64(new_fd, old_fd, &offset, kMaxUint32));
     }
     // From sendfile man pages:
     //   Applications may wish to fall back to read(2)/write(2) in the case
     //   where sendfile() fails with EINVAL or ENOSYS.
     if ((result < 0) && ((errno == EINVAL) || (errno == ENOSYS))) {
       const intptr_t kBufferSize = 8 * KB;
       uint8_t buffer[kBufferSize];
-      while ((result = TEMP_FAILURE_RETRY(
-          read(old_fd, buffer, kBufferSize))) > 0) {
+      while ((result = TEMP_FAILURE_RETRY(read(old_fd, buffer, kBufferSize))) >
+             0) {
         int wrote = TEMP_FAILURE_RETRY(write(new_fd, buffer, result));
         if (wrote != result) {
           result = -1;
           break;
         }
       }
     }
     int e = errno;
     VOID_TEMP_FAILURE_RETRY(close(old_fd));
     VOID_TEMP_FAILURE_RETRY(close(new_fd));
@@ skipping 16 matching lines @@
   struct stat64 st;
   if (TEMP_FAILURE_RETRY(stat64(name, &st)) == 0) {
     return st.st_size;
   }
   return -1;
 }
 
 
 static int64_t TimespecToMilliseconds(const struct timespec& t) {
   return static_cast<int64_t>(t.tv_sec) * 1000L +
-      static_cast<int64_t>(t.tv_nsec) / 1000000L;
+         static_cast<int64_t>(t.tv_nsec) / 1000000L;
 }
 
 
 void File::Stat(const char* name, int64_t* data) {
   struct stat64 st;
   if (TEMP_FAILURE_RETRY(stat64(name, &st)) == 0) {
     if (S_ISREG(st.st_mode)) {
       data[kType] = kIsFile;
     } else if (S_ISDIR(st.st_mode)) {
       data[kType] = kIsDirectory;
@@ skipping 29 matching lines @@
   }
   if (!S_ISLNK(link_stats.st_mode)) {
     errno = ENOENT;
     return NULL;
   }
   // Don't rely on the link_stats.st_size for the size of the link
   // target. For some filesystems, e.g. procfs, this value is always
   // 0. Also the link might have changed before the readlink call.
   const int kBufferSize = PATH_MAX + 1;
   char target[kBufferSize];
-  size_t target_size = TEMP_FAILURE_RETRY(
-      readlink(pathname, target, kBufferSize));
+  size_t target_size =
+      TEMP_FAILURE_RETRY(readlink(pathname, target, kBufferSize));
   if (target_size <= 0) {
     return NULL;
   }
   char* target_name = DartUtils::ScopedCString(target_size + 1);
   ASSERT(target_name != NULL);
   memmove(target_name, target, target_size);
   target_name[target_size] = '\0';
   return target_name;
 }
 
@@ skipping 79 matching lines @@
 
 
 File::Identical File::AreIdentical(const char* file_1, const char* file_2) {
   struct stat64 file_1_info;
   struct stat64 file_2_info;
   if ((TEMP_FAILURE_RETRY(lstat64(file_1, &file_1_info)) == -1) ||
       (TEMP_FAILURE_RETRY(lstat64(file_2, &file_2_info)) == -1)) {
     return File::kError;
   }
   return ((file_1_info.st_ino == file_2_info.st_ino) &&
-          (file_1_info.st_dev == file_2_info.st_dev)) ?
-      File::kIdentical :
-      File::kDifferent;
+          (file_1_info.st_dev == file_2_info.st_dev))
+             ? File::kIdentical
+             : File::kDifferent;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)