clang-format runtime/bin

runtime/bin/file_win.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_WINDOWS)
 
 #include "bin/file.h"
 
-#include <fcntl.h>  // NOLINT
-#include <io.h>  // NOLINT
-#include <stdio.h>  // NOLINT
-#include <string.h>  // NOLINT
+#include <fcntl.h>     // NOLINT
+#include <io.h>        // NOLINT
+#include <stdio.h>     // NOLINT
+#include <string.h>    // NOLINT
 #include <sys/stat.h>  // NOLINT
 #include <WinIoCtl.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/log.h"
 #include "bin/utils.h"
 #include "bin/utils_win.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() != _fileno(stdout) && handle_->fd() != _fileno(stderr)) {
+  if (!IsClosed() && handle_->fd() != _fileno(stdout) &&
+      handle_->fd() != _fileno(stderr)) {
     Close();
   }
   delete handle_;
 }
 
 
 void File::Close() {
   ASSERT(handle_->fd() >= 0);
   if ((handle_->fd() == _fileno(stdout)) ||
       (handle_->fd() == _fileno(stderr))) {
@@ skipping 124 matching lines @@
     case File::kLockBlockingShared:
     case File::kLockBlockingExclusive: {
       DWORD flags = 0;
       if ((lock == File::kLockShared) || (lock == File::kLockExclusive)) {
         flags |= LOCKFILE_FAIL_IMMEDIATELY;
       }
       if ((lock == File::kLockExclusive) ||
           (lock == File::kLockBlockingExclusive)) {
         flags |= LOCKFILE_EXCLUSIVE_LOCK;
       }
-      rc = LockFileEx(handle, flags, 0,
-                      length_low, length_high, &overlapped);
+      rc = LockFileEx(handle, flags, 0, length_low, length_high, &overlapped);
       break;
     }
     default:
       UNREACHABLE();
   }
   return rc;
 }
 
 
 int64_t File::Length() {
@@ skipping 74 matching lines @@
   int fd = _wopen(system_name.wide(), O_RDONLY | O_CREAT, 0666);
   if (fd < 0) {
     return false;
   }
   return (close(fd) == 0);
 }
 
 
 // This structure is needed for creating and reading Junctions.
 typedef struct _REPARSE_DATA_BUFFER {
-    ULONG  ReparseTag;
-    USHORT ReparseDataLength;
-    USHORT Reserved;
+  ULONG ReparseTag;
+  USHORT ReparseDataLength;
+  USHORT Reserved;
 
-    union {
-        struct {
-            USHORT  SubstituteNameOffset;
-            USHORT  SubstituteNameLength;
-            USHORT  PrintNameOffset;
-            USHORT  PrintNameLength;
-            ULONG   Flags;
-            WCHAR   PathBuffer[1];
-        } SymbolicLinkReparseBuffer;
+  union {
+    struct {
+      USHORT SubstituteNameOffset;
+      USHORT SubstituteNameLength;
+      USHORT PrintNameOffset;
+      USHORT PrintNameLength;
+      ULONG Flags;
+      WCHAR PathBuffer[1];
+    } SymbolicLinkReparseBuffer;
 
-        struct {
-            USHORT  SubstituteNameOffset;
-            USHORT  SubstituteNameLength;
-            USHORT  PrintNameOffset;
-            USHORT  PrintNameLength;
-            WCHAR   PathBuffer[1];
-        } MountPointReparseBuffer;
+    struct {
+      USHORT SubstituteNameOffset;
+      USHORT SubstituteNameLength;
+      USHORT PrintNameOffset;
+      USHORT PrintNameLength;
+      WCHAR PathBuffer[1];
+    } MountPointReparseBuffer;
 
-        struct {
-            UCHAR   DataBuffer[1];
-        } GenericReparseBuffer;
-    };
+    struct {
+      UCHAR DataBuffer[1];
+    } GenericReparseBuffer;
+  };
 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
 
 
 static const int kReparseDataHeaderSize = sizeof ULONG + 2 * sizeof USHORT;
 static const int kMountPointHeaderSize = 4 * sizeof USHORT;
 
 
 bool File::CreateLink(const char* utf8_name, const char* utf8_target) {
   Utf8ToWideScope name(utf8_name);
   int create_status = CreateDirectoryW(name.wide(), NULL);
   // If the directory already existed, treat it as a success.
   if ((create_status == 0) &&
       ((GetLastError() != ERROR_ALREADY_EXISTS) ||
        ((GetFileAttributesW(name.wide()) & FILE_ATTRIBUTE_DIRECTORY) != 0))) {
     return false;
   }
 
   HANDLE dir_handle = CreateFileW(
-      name.wide(),
-      GENERIC_READ | GENERIC_WRITE,
-      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-      NULL,
-      OPEN_EXISTING,
-      FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+      name.wide(), GENERIC_READ | GENERIC_WRITE,
+      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
+      OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
       NULL);
   if (dir_handle == INVALID_HANDLE_VALUE) {
     return false;
   }
 
   Utf8ToWideScope target(utf8_target);
   int target_len = wcslen(target.wide());
   if (target_len > MAX_PATH - 1) {
     CloseHandle(dir_handle);
     return false;
@@ skipping 13 matching lines @@
   reparse_data_buffer->MountPointReparseBuffer.SubstituteNameLength =
       target_len * sizeof WCHAR;
   reparse_data_buffer->MountPointReparseBuffer.PrintNameOffset =
       (target_len + 1) * sizeof WCHAR;
   reparse_data_buffer->MountPointReparseBuffer.PrintNameLength =
       target_len * sizeof WCHAR;
   reparse_data_buffer->ReparseDataLength =
       (target_len + 1) * 2 * sizeof WCHAR + kMountPointHeaderSize;
   DWORD dummy_received_bytes;
   int result = DeviceIoControl(
-      dir_handle,
-      FSCTL_SET_REPARSE_POINT,
-      reparse_data_buffer,
-      reparse_data_buffer->ReparseDataLength + kReparseDataHeaderSize,
-      NULL,
-      0,
-      &dummy_received_bytes,
-      NULL);
+      dir_handle, FSCTL_SET_REPARSE_POINT, reparse_data_buffer,
+      reparse_data_buffer->ReparseDataLength + kReparseDataHeaderSize, NULL, 0,
+      &dummy_received_bytes, NULL);
   free(reparse_data_buffer);
   if (CloseHandle(dir_handle) == 0) {
     return false;
   }
   return (result != 0);
 }
 
 
 bool File::Delete(const char* name) {
   Utf8ToWideScope system_name(name);
@@ skipping 47 matching lines @@
   }
   return false;
 }
 
 
 bool File::Copy(const char* old_path, const char* new_path) {
   File::Type type = GetType(old_path, false);
   if (type == kIsFile) {
     Utf8ToWideScope system_old_path(old_path);
     Utf8ToWideScope system_new_path(new_path);
-    bool success = CopyFileExW(system_old_path.wide(),
-                               system_new_path.wide(),
-                               NULL,
-                               NULL,
-                               NULL,
-                               0) != 0;
+    bool success = CopyFileExW(system_old_path.wide(), system_new_path.wide(),
+                               NULL, NULL, NULL, 0) != 0;
     return success;
   } else {
     SetLastError(ERROR_FILE_NOT_FOUND);
   }
   return false;
 }
 
 
 int64_t File::LengthFromPath(const char* name) {
   struct __stat64 st;
   Utf8ToWideScope system_name(name);
   int stat_status = _wstat64(system_name.wide(), &st);
   if (stat_status == 0) {
     return st.st_size;
   }
   return -1;
 }
 
 
 const char* File::LinkTarget(const char* pathname) {
   const wchar_t* name = StringUtilsWin::Utf8ToWide(pathname);
   HANDLE dir_handle = CreateFileW(
-      name,
-      GENERIC_READ,
-      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-      NULL,
-      OPEN_EXISTING,
-      FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+      name, GENERIC_READ,
+      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
+      OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
       NULL);
   if (dir_handle == INVALID_HANDLE_VALUE) {
     return NULL;
   }
 
   int buffer_size =
       sizeof REPARSE_DATA_BUFFER + 2 * (MAX_PATH + 1) * sizeof WCHAR;
-  REPARSE_DATA_BUFFER* buffer = reinterpret_cast<REPARSE_DATA_BUFFER*>(
-      Dart_ScopeAllocate(buffer_size));
+  REPARSE_DATA_BUFFER* buffer =
+      reinterpret_cast<REPARSE_DATA_BUFFER*>(Dart_ScopeAllocate(buffer_size));
   DWORD received_bytes;  // Value is not used.
-  int result = DeviceIoControl(
-      dir_handle,
-      FSCTL_GET_REPARSE_POINT,
-      NULL,
-      0,
-      buffer,
-      buffer_size,
-      &received_bytes,
-      NULL);
+  int result = DeviceIoControl(dir_handle, FSCTL_GET_REPARSE_POINT, NULL, 0,
+                               buffer, buffer_size, &received_bytes, NULL);
   if (result == 0) {
     DWORD error = GetLastError();
     CloseHandle(dir_handle);
     SetLastError(error);
     return NULL;
   }
   if (CloseHandle(dir_handle) == 0) {
     return NULL;
   }
 
@@ skipping 14 matching lines @@
   }
 
   target_offset /= sizeof(wchar_t);  // Offset and length are in bytes.
   target_length /= sizeof(wchar_t);
   target += target_offset;
   // Remove "\??\" from beginning of target.
   if ((target_length > 4) && (wcsncmp(L"\\??\\", target, 4) == 0)) {
     target += 4;
     target_length -= 4;
   }
-  int utf8_length = WideCharToMultiByte(CP_UTF8,
-                                        0,
-                                        target,
-                                        target_length,
-                                        NULL,
-                                        0,
-                                        NULL,
-                                        NULL);
+  int utf8_length = WideCharToMultiByte(CP_UTF8, 0, target, target_length, NULL,
+                                        0, NULL, NULL);
   char* utf8_target = DartUtils::ScopedCString(utf8_length + 1);
-  if (0 == WideCharToMultiByte(CP_UTF8,
-                               0,
-                               target,
-                               target_length,
-                               utf8_target,
-                               utf8_length,
-                               NULL,
-                               NULL)) {
+  if (0 == WideCharToMultiByte(CP_UTF8, 0, target, target_length, utf8_target,
+                               utf8_length, NULL, NULL)) {
     return NULL;
   }
   utf8_target[utf8_length] = '\0';
   return utf8_target;
 }
 
 
 void File::Stat(const char* name, int64_t* data) {
   File::Type type = GetType(name, false);
   data[kType] = type;
@@ skipping 23 matching lines @@
   }
   return -1;
 }
 
 
 bool File::IsAbsolutePath(const char* pathname) {
   // Should we consider network paths?
   if (pathname == NULL) {
     return false;
   }
-  return ((strlen(pathname) > 2) &&
-      (pathname[1] == ':') &&
-      ((pathname[2] == '\\') || (pathname[2] == '/')));
+  return ((strlen(pathname) > 2) && (pathname[1] == ':') &&
+          ((pathname[2] == '\\') || (pathname[2] == '/')));
 }
 
 
 const char* File::GetCanonicalPath(const char* pathname) {
   Utf8ToWideScope system_name(pathname);
-  HANDLE file_handle = CreateFileW(
-        system_name.wide(),
-        0,
-        FILE_SHARE_READ,
-        NULL,
-        OPEN_EXISTING,
-        FILE_FLAG_BACKUP_SEMANTICS,
-        NULL);
+  HANDLE file_handle =
+      CreateFileW(system_name.wide(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+                  FILE_FLAG_BACKUP_SEMANTICS, NULL);
   if (file_handle == INVALID_HANDLE_VALUE) {
     return NULL;
   }
   wchar_t dummy_buffer[1];
-  int required_size = GetFinalPathNameByHandle(file_handle,
-                                               dummy_buffer,
-                                               0,
-                                               VOLUME_NAME_DOS);
+  int required_size =
+      GetFinalPathNameByHandle(file_handle, dummy_buffer, 0, VOLUME_NAME_DOS);
   if (required_size == 0) {
     DWORD error = GetLastError();
     CloseHandle(file_handle);
     SetLastError(error);
     return NULL;
   }
   wchar_t* path;
   path = reinterpret_cast<wchar_t*>(
       Dart_ScopeAllocate(required_size * sizeof(*path)));
-  int result_size = GetFinalPathNameByHandle(file_handle,
-                                             path,
-                                             required_size,
+  int result_size = GetFinalPathNameByHandle(file_handle, path, required_size,
                                              VOLUME_NAME_DOS);
   ASSERT(result_size <= required_size - 1);
   // Remove leading \\?\ if possible, unless input used it.
   char* result;
-  if ((result_size < MAX_PATH - 1 + 4) &&
-      (result_size > 4) &&
+  if ((result_size < MAX_PATH - 1 + 4) && (result_size > 4) &&
       (wcsncmp(path, L"\\\\?\\", 4) == 0) &&
       (wcsncmp(system_name.wide(), L"\\\\?\\", 4) != 0)) {
     result = StringUtilsWin::WideToUtf8(path + 4);
   } else {
     result = StringUtilsWin::WideToUtf8(path);
   }
   CloseHandle(file_handle);
   return result;
 }
 
@@ skipping 19 matching lines @@
 
 File::Type File::GetType(const char* pathname, bool follow_links) {
   // Convert to wchar_t string.
   Utf8ToWideScope name(pathname);
   DWORD attributes = GetFileAttributesW(name.wide());
   File::Type result = kIsFile;
   if (attributes == INVALID_FILE_ATTRIBUTES) {
     result = kDoesNotExist;
   } else if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     if (follow_links) {
-      HANDLE dir_handle = CreateFileW(
-          name.wide(),
-          0,
-          FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-          NULL,
-          OPEN_EXISTING,
-          FILE_FLAG_BACKUP_SEMANTICS,
-          NULL);
+      HANDLE dir_handle =
+          CreateFileW(name.wide(), 0,
+                      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                      NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
       if (dir_handle == INVALID_HANDLE_VALUE) {
         result = File::kIsLink;
       } else {
         CloseHandle(dir_handle);
         result = File::kIsDirectory;
       }
     } else {
       result = kIsLink;
     }
   } else if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
     result = kIsDirectory;
   }
   return result;
 }
 
 
 File::Identical File::AreIdentical(const char* file_1, const char* file_2) {
   BY_HANDLE_FILE_INFORMATION file_info[2];
-  const char* file_names[2] = { file_1, file_2 };
+  const char* file_names[2] = {file_1, file_2};
   for (int i = 0; i < 2; ++i) {
     Utf8ToWideScope wide_name(file_names[i]);
     HANDLE file_handle = CreateFileW(
-        wide_name.wide(),
-        0,
-        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-        NULL,
+        wide_name.wide(), 0,
+        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
         OPEN_EXISTING,
-        FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
-        NULL);
+        FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
     if (file_handle == INVALID_HANDLE_VALUE) {
       return File::kError;
     }
     int result = GetFileInformationByHandle(file_handle, &file_info[i]);
     if (result == 0) {
       DWORD error = GetLastError();
       CloseHandle(file_handle);
       SetLastError(error);
       return File::kError;
     }
     if (CloseHandle(file_handle) == 0) {
       return File::kError;
     }
   }
   if ((file_info[0].dwVolumeSerialNumber ==
-          file_info[1].dwVolumeSerialNumber) &&
+       file_info[1].dwVolumeSerialNumber) &&
       (file_info[0].nFileIndexHigh == file_info[1].nFileIndexHigh) &&
       (file_info[0].nFileIndexLow == file_info[1].nFileIndexLow)) {
     return kIdentical;
   } else {
     return kDifferent;
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)