Path.inc revision 309124
1261991Sdim//===- llvm/Support/Windows/Path.inc - Windows Path Impl --------*- C++ -*-===// 2218885Sdim// 3218885Sdim// The LLVM Compiler Infrastructure 4218885Sdim// 5218885Sdim// This file is distributed under the University of Illinois Open Source 6218885Sdim// License. See LICENSE.TXT for details. 7218885Sdim// 8218885Sdim//===----------------------------------------------------------------------===// 9218885Sdim// 10261991Sdim// This file implements the Windows specific implementation of the Path API. 11218885Sdim// 12218885Sdim//===----------------------------------------------------------------------===// 13218885Sdim 14218885Sdim//===----------------------------------------------------------------------===// 15261991Sdim//=== WARNING: Implementation here must contain only generic Windows code that 16261991Sdim//=== is guaranteed to work on *all* Windows variants. 17218885Sdim//===----------------------------------------------------------------------===// 18218885Sdim 19261991Sdim#include "llvm/ADT/STLExtras.h" 20276479Sdim#include "llvm/Support/WindowsError.h" 21261991Sdim#include <fcntl.h> 22261991Sdim#include <io.h> 23261991Sdim#include <sys/stat.h> 24261991Sdim#include <sys/types.h> 25218885Sdim 26276479Sdim// These two headers must be included last, and make sure shlobj is required 27276479Sdim// after Windows.h to make sure it picks up our definition of _WIN32_WINNT 28276479Sdim#include "WindowsSupport.h" 29276479Sdim#include <shlobj.h> 30276479Sdim 31261991Sdim#undef max 32218885Sdim 33261991Sdim// MinGW doesn't define this. 34261991Sdim#ifndef _ERRNO_T_DEFINED 35261991Sdim#define _ERRNO_T_DEFINED 36261991Sdimtypedef int errno_t; 37261991Sdim#endif 38218885Sdim 39261991Sdim#ifdef _MSC_VER 40261991Sdim# pragma comment(lib, "advapi32.lib") // This provides CryptAcquireContextW. 41296417Sdim# pragma comment(lib, "ole32.lib") // This provides CoTaskMemFree 42261991Sdim#endif 43218885Sdim 44261991Sdimusing namespace llvm; 45218885Sdim 46261991Sdimusing llvm::sys::windows::UTF8ToUTF16; 47261991Sdimusing llvm::sys::windows::UTF16ToUTF8; 48280031Sdimusing llvm::sys::path::widenPath; 49218885Sdim 50276479Sdimstatic bool is_separator(const wchar_t value) { 51276479Sdim switch (value) { 52276479Sdim case L'\\': 53276479Sdim case L'/': 54276479Sdim return true; 55276479Sdim default: 56276479Sdim return false; 57218885Sdim } 58218885Sdim} 59218885Sdim 60261991Sdimnamespace llvm { 61261991Sdimnamespace sys { 62280031Sdimnamespace path { 63280031Sdim 64280031Sdim// Convert a UTF-8 path to UTF-16. Also, if the absolute equivalent of the 65280031Sdim// path is longer than CreateDirectory can tolerate, make it absolute and 66280031Sdim// prefixed by '\\?\'. 67280031Sdimstd::error_code widenPath(const Twine &Path8, 68280031Sdim SmallVectorImpl<wchar_t> &Path16) { 69280031Sdim const size_t MaxDirLen = MAX_PATH - 12; // Must leave room for 8.3 filename. 70280031Sdim 71280031Sdim // Several operations would convert Path8 to SmallString; more efficient to 72280031Sdim // do it once up front. 73280031Sdim SmallString<128> Path8Str; 74280031Sdim Path8.toVector(Path8Str); 75280031Sdim 76280031Sdim // If we made this path absolute, how much longer would it get? 77280031Sdim size_t CurPathLen; 78280031Sdim if (llvm::sys::path::is_absolute(Twine(Path8Str))) 79280031Sdim CurPathLen = 0; // No contribution from current_path needed. 80280031Sdim else { 81280031Sdim CurPathLen = ::GetCurrentDirectoryW(0, NULL); 82280031Sdim if (CurPathLen == 0) 83288943Sdim return mapWindowsError(::GetLastError()); 84280031Sdim } 85280031Sdim 86280031Sdim // Would the absolute path be longer than our limit? 87280031Sdim if ((Path8Str.size() + CurPathLen) >= MaxDirLen && 88280031Sdim !Path8Str.startswith("\\\\?\\")) { 89280031Sdim SmallString<2*MAX_PATH> FullPath("\\\\?\\"); 90280031Sdim if (CurPathLen) { 91280031Sdim SmallString<80> CurPath; 92280031Sdim if (std::error_code EC = llvm::sys::fs::current_path(CurPath)) 93280031Sdim return EC; 94280031Sdim FullPath.append(CurPath); 95280031Sdim } 96280031Sdim // Traverse the requested path, canonicalizing . and .. as we go (because 97280031Sdim // the \\?\ prefix is documented to treat them as real components). 98280031Sdim // The iterators don't report separators and append() always attaches 99280031Sdim // preferred_separator so we don't need to call native() on the result. 100280031Sdim for (llvm::sys::path::const_iterator I = llvm::sys::path::begin(Path8Str), 101280031Sdim E = llvm::sys::path::end(Path8Str); 102280031Sdim I != E; ++I) { 103280031Sdim if (I->size() == 1 && *I == ".") 104280031Sdim continue; 105280031Sdim if (I->size() == 2 && *I == "..") 106280031Sdim llvm::sys::path::remove_filename(FullPath); 107280031Sdim else 108280031Sdim llvm::sys::path::append(FullPath, *I); 109280031Sdim } 110280031Sdim return UTF8ToUTF16(FullPath, Path16); 111280031Sdim } 112280031Sdim 113280031Sdim // Just use the caller's original path. 114280031Sdim return UTF8ToUTF16(Path8Str, Path16); 115280031Sdim} 116280031Sdim} // end namespace path 117280031Sdim 118261991Sdimnamespace fs { 119218885Sdim 120261991Sdimstd::string getMainExecutable(const char *argv0, void *MainExecAddr) { 121261991Sdim SmallVector<wchar_t, MAX_PATH> PathName; 122261991Sdim DWORD Size = ::GetModuleFileNameW(NULL, PathName.data(), PathName.capacity()); 123218885Sdim 124261991Sdim // A zero return value indicates a failure other than insufficient space. 125261991Sdim if (Size == 0) 126261991Sdim return ""; 127218885Sdim 128261991Sdim // Insufficient space is determined by a return value equal to the size of 129261991Sdim // the buffer passed in. 130261991Sdim if (Size == PathName.capacity()) 131261991Sdim return ""; 132218885Sdim 133261991Sdim // On success, GetModuleFileNameW returns the number of characters written to 134261991Sdim // the buffer not including the NULL terminator. 135261991Sdim PathName.set_size(Size); 136218885Sdim 137261991Sdim // Convert the result from UTF-16 to UTF-8. 138261991Sdim SmallVector<char, MAX_PATH> PathNameUTF8; 139261991Sdim if (UTF16ToUTF8(PathName.data(), PathName.size(), PathNameUTF8)) 140261991Sdim return ""; 141218885Sdim 142261991Sdim return std::string(PathNameUTF8.data()); 143218885Sdim} 144218885Sdim 145261991SdimUniqueID file_status::getUniqueID() const { 146261991Sdim // The file is uniquely identified by the volume serial number along 147261991Sdim // with the 64-bit file identifier. 148261991Sdim uint64_t FileID = (static_cast<uint64_t>(FileIndexHigh) << 32ULL) | 149261991Sdim static_cast<uint64_t>(FileIndexLow); 150261991Sdim 151261991Sdim return UniqueID(VolumeSerialNumber, FileID); 152218885Sdim} 153218885Sdim 154309124SdimErrorOr<space_info> disk_space(const Twine &Path) { 155309124Sdim ULARGE_INTEGER Avail, Total, Free; 156309124Sdim if (!::GetDiskFreeSpaceExA(Path.str().c_str(), &Avail, &Total, &Free)) 157309124Sdim return mapWindowsError(::GetLastError()); 158309124Sdim space_info SpaceInfo; 159309124Sdim SpaceInfo.capacity = 160309124Sdim (static_cast<uint64_t>(Total.HighPart) << 32) + Total.LowPart; 161309124Sdim SpaceInfo.free = (static_cast<uint64_t>(Free.HighPart) << 32) + Free.LowPart; 162309124Sdim SpaceInfo.available = 163309124Sdim (static_cast<uint64_t>(Avail.HighPart) << 32) + Avail.LowPart; 164309124Sdim return SpaceInfo; 165309124Sdim} 166309124Sdim 167309124SdimTimeValue file_status::getLastAccessedTime() const { 168309124Sdim ULARGE_INTEGER UI; 169309124Sdim UI.LowPart = LastAccessedTimeLow; 170309124Sdim UI.HighPart = LastAccessedTimeHigh; 171309124Sdim 172309124Sdim TimeValue Ret; 173309124Sdim Ret.fromWin32Time(UI.QuadPart); 174309124Sdim return Ret; 175309124Sdim} 176309124Sdim 177261991SdimTimeValue file_status::getLastModificationTime() const { 178261991Sdim ULARGE_INTEGER UI; 179261991Sdim UI.LowPart = LastWriteTimeLow; 180261991Sdim UI.HighPart = LastWriteTimeHigh; 181218885Sdim 182261991Sdim TimeValue Ret; 183261991Sdim Ret.fromWin32Time(UI.QuadPart); 184261991Sdim return Ret; 185218885Sdim} 186218885Sdim 187276479Sdimstd::error_code current_path(SmallVectorImpl<char> &result) { 188261991Sdim SmallVector<wchar_t, MAX_PATH> cur_path; 189261991Sdim DWORD len = MAX_PATH; 190218885Sdim 191261991Sdim do { 192261991Sdim cur_path.reserve(len); 193261991Sdim len = ::GetCurrentDirectoryW(cur_path.capacity(), cur_path.data()); 194218885Sdim 195261991Sdim // A zero return value indicates a failure other than insufficient space. 196261991Sdim if (len == 0) 197288943Sdim return mapWindowsError(::GetLastError()); 198218885Sdim 199261991Sdim // If there's insufficient space, the len returned is larger than the len 200261991Sdim // given. 201261991Sdim } while (len > cur_path.capacity()); 202261991Sdim 203261991Sdim // On success, GetCurrentDirectoryW returns the number of characters not 204261991Sdim // including the null-terminator. 205261991Sdim cur_path.set_size(len); 206261991Sdim return UTF16ToUTF8(cur_path.begin(), cur_path.size(), result); 207218885Sdim} 208218885Sdim 209296417Sdimstd::error_code create_directory(const Twine &path, bool IgnoreExisting, 210296417Sdim perms Perms) { 211261991Sdim SmallVector<wchar_t, 128> path_utf16; 212218885Sdim 213280031Sdim if (std::error_code ec = widenPath(path, path_utf16)) 214261991Sdim return ec; 215218885Sdim 216261991Sdim if (!::CreateDirectoryW(path_utf16.begin(), NULL)) { 217276479Sdim DWORD LastError = ::GetLastError(); 218276479Sdim if (LastError != ERROR_ALREADY_EXISTS || !IgnoreExisting) 219288943Sdim return mapWindowsError(LastError); 220276479Sdim } 221218885Sdim 222276479Sdim return std::error_code(); 223218885Sdim} 224218885Sdim 225276479Sdim// We can't use symbolic links for windows. 226276479Sdimstd::error_code create_link(const Twine &to, const Twine &from) { 227261991Sdim // Convert to utf-16. 228261991Sdim SmallVector<wchar_t, 128> wide_from; 229261991Sdim SmallVector<wchar_t, 128> wide_to; 230280031Sdim if (std::error_code ec = widenPath(from, wide_from)) 231276479Sdim return ec; 232280031Sdim if (std::error_code ec = widenPath(to, wide_to)) 233276479Sdim return ec; 234218885Sdim 235276479Sdim if (!::CreateHardLinkW(wide_from.begin(), wide_to.begin(), NULL)) 236288943Sdim return mapWindowsError(::GetLastError()); 237218885Sdim 238276479Sdim return std::error_code(); 239218885Sdim} 240218885Sdim 241276479Sdimstd::error_code remove(const Twine &path, bool IgnoreNonExisting) { 242261991Sdim SmallVector<wchar_t, 128> path_utf16; 243218885Sdim 244276479Sdim file_status ST; 245276479Sdim if (std::error_code EC = status(path, ST)) { 246276479Sdim if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting) 247276479Sdim return EC; 248276479Sdim return std::error_code(); 249261991Sdim } 250261991Sdim 251280031Sdim if (std::error_code ec = widenPath(path, path_utf16)) 252261991Sdim return ec; 253261991Sdim 254276479Sdim if (ST.type() == file_type::directory_file) { 255261991Sdim if (!::RemoveDirectoryW(c_str(path_utf16))) { 256288943Sdim std::error_code EC = mapWindowsError(::GetLastError()); 257276479Sdim if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting) 258276479Sdim return EC; 259276479Sdim } 260276479Sdim return std::error_code(); 261261991Sdim } 262276479Sdim if (!::DeleteFileW(c_str(path_utf16))) { 263288943Sdim std::error_code EC = mapWindowsError(::GetLastError()); 264276479Sdim if (EC != errc::no_such_file_or_directory || !IgnoreNonExisting) 265276479Sdim return EC; 266276479Sdim } 267276479Sdim return std::error_code(); 268218885Sdim} 269218885Sdim 270276479Sdimstd::error_code rename(const Twine &from, const Twine &to) { 271261991Sdim // Convert to utf-16. 272261991Sdim SmallVector<wchar_t, 128> wide_from; 273261991Sdim SmallVector<wchar_t, 128> wide_to; 274280031Sdim if (std::error_code ec = widenPath(from, wide_from)) 275276479Sdim return ec; 276280031Sdim if (std::error_code ec = widenPath(to, wide_to)) 277276479Sdim return ec; 278261991Sdim 279276479Sdim std::error_code ec = std::error_code(); 280296417Sdim 281309124Sdim // Retry while we see recoverable errors. 282296417Sdim // System scanners (eg. indexer) might open the source file when it is written 283296417Sdim // and closed. 284296417Sdim 285309124Sdim bool TryReplace = true; 286309124Sdim 287261991Sdim for (int i = 0; i < 2000; i++) { 288309124Sdim if (i > 0) 289309124Sdim ::Sleep(1); 290296417Sdim 291309124Sdim if (TryReplace) { 292309124Sdim // Try ReplaceFile first, as it is able to associate a new data stream 293309124Sdim // with the destination even if the destination file is currently open. 294309124Sdim if (::ReplaceFileW(wide_to.data(), wide_from.data(), NULL, 0, NULL, NULL)) 295309124Sdim return std::error_code(); 296296417Sdim 297309124Sdim DWORD ReplaceError = ::GetLastError(); 298309124Sdim ec = mapWindowsError(ReplaceError); 299309124Sdim 300309124Sdim // If ReplaceFileW returned ERROR_UNABLE_TO_MOVE_REPLACEMENT or 301309124Sdim // ERROR_UNABLE_TO_MOVE_REPLACEMENT_2, retry but only use MoveFileExW(). 302309124Sdim if (ReplaceError == ERROR_UNABLE_TO_MOVE_REPLACEMENT || 303309124Sdim ReplaceError == ERROR_UNABLE_TO_MOVE_REPLACEMENT_2) { 304309124Sdim TryReplace = false; 305309124Sdim continue; 306309124Sdim } 307309124Sdim // If ReplaceFileW returned ERROR_UNABLE_TO_REMOVE_REPLACED, retry 308309124Sdim // using ReplaceFileW(). 309309124Sdim if (ReplaceError == ERROR_UNABLE_TO_REMOVE_REPLACED) 310309124Sdim continue; 311309124Sdim // We get ERROR_FILE_NOT_FOUND if the destination file is missing. 312309124Sdim // MoveFileEx can handle this case. 313309124Sdim if (ReplaceError != ERROR_ACCESS_DENIED && 314309124Sdim ReplaceError != ERROR_FILE_NOT_FOUND && 315309124Sdim ReplaceError != ERROR_SHARING_VIOLATION) 316309124Sdim break; 317309124Sdim } 318309124Sdim 319261991Sdim if (::MoveFileExW(wide_from.begin(), wide_to.begin(), 320261991Sdim MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING)) 321276479Sdim return std::error_code(); 322296417Sdim 323296417Sdim DWORD MoveError = ::GetLastError(); 324296417Sdim ec = mapWindowsError(MoveError); 325296417Sdim if (MoveError != ERROR_ACCESS_DENIED) break; 326261991Sdim } 327261991Sdim 328261991Sdim return ec; 329218885Sdim} 330218885Sdim 331280031Sdimstd::error_code resize_file(int FD, uint64_t Size) { 332261991Sdim#ifdef HAVE__CHSIZE_S 333280031Sdim errno_t error = ::_chsize_s(FD, Size); 334261991Sdim#else 335280031Sdim errno_t error = ::_chsize(FD, Size); 336261991Sdim#endif 337276479Sdim return std::error_code(error, std::generic_category()); 338218885Sdim} 339218885Sdim 340280031Sdimstd::error_code access(const Twine &Path, AccessMode Mode) { 341280031Sdim SmallVector<wchar_t, 128> PathUtf16; 342218885Sdim 343280031Sdim if (std::error_code EC = widenPath(Path, PathUtf16)) 344280031Sdim return EC; 345218885Sdim 346280031Sdim DWORD Attributes = ::GetFileAttributesW(PathUtf16.begin()); 347218885Sdim 348280031Sdim if (Attributes == INVALID_FILE_ATTRIBUTES) { 349261991Sdim // See if the file didn't actually exist. 350276479Sdim DWORD LastError = ::GetLastError(); 351276479Sdim if (LastError != ERROR_FILE_NOT_FOUND && 352276479Sdim LastError != ERROR_PATH_NOT_FOUND) 353288943Sdim return mapWindowsError(LastError); 354280031Sdim return errc::no_such_file_or_directory; 355280031Sdim } 356218885Sdim 357280031Sdim if (Mode == AccessMode::Write && (Attributes & FILE_ATTRIBUTE_READONLY)) 358280031Sdim return errc::permission_denied; 359218885Sdim 360280031Sdim return std::error_code(); 361261991Sdim} 362218885Sdim 363296417Sdimbool can_execute(const Twine &Path) { 364296417Sdim return !access(Path, AccessMode::Execute) || 365296417Sdim !access(Path + ".exe", AccessMode::Execute); 366296417Sdim} 367296417Sdim 368261991Sdimbool equivalent(file_status A, file_status B) { 369261991Sdim assert(status_known(A) && status_known(B)); 370309124Sdim return A.FileIndexHigh == B.FileIndexHigh && 371309124Sdim A.FileIndexLow == B.FileIndexLow && 372309124Sdim A.FileSizeHigh == B.FileSizeHigh && 373309124Sdim A.FileSizeLow == B.FileSizeLow && 374309124Sdim A.LastAccessedTimeHigh == B.LastAccessedTimeHigh && 375309124Sdim A.LastAccessedTimeLow == B.LastAccessedTimeLow && 376309124Sdim A.LastWriteTimeHigh == B.LastWriteTimeHigh && 377309124Sdim A.LastWriteTimeLow == B.LastWriteTimeLow && 378309124Sdim A.VolumeSerialNumber == B.VolumeSerialNumber; 379218885Sdim} 380218885Sdim 381276479Sdimstd::error_code equivalent(const Twine &A, const Twine &B, bool &result) { 382261991Sdim file_status fsA, fsB; 383276479Sdim if (std::error_code ec = status(A, fsA)) 384276479Sdim return ec; 385276479Sdim if (std::error_code ec = status(B, fsB)) 386276479Sdim return ec; 387261991Sdim result = equivalent(fsA, fsB); 388276479Sdim return std::error_code(); 389261991Sdim} 390218885Sdim 391261991Sdimstatic bool isReservedName(StringRef path) { 392261991Sdim // This list of reserved names comes from MSDN, at: 393261991Sdim // http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx 394296417Sdim static const char *const sReservedNames[] = { "nul", "con", "prn", "aux", 395296417Sdim "com1", "com2", "com3", "com4", 396296417Sdim "com5", "com6", "com7", "com8", 397296417Sdim "com9", "lpt1", "lpt2", "lpt3", 398296417Sdim "lpt4", "lpt5", "lpt6", "lpt7", 399296417Sdim "lpt8", "lpt9" }; 400218885Sdim 401261991Sdim // First, check to see if this is a device namespace, which always 402261991Sdim // starts with \\.\, since device namespaces are not legal file paths. 403261991Sdim if (path.startswith("\\\\.\\")) 404261991Sdim return true; 405261991Sdim 406309124Sdim // Then compare against the list of ancient reserved names. 407261991Sdim for (size_t i = 0; i < array_lengthof(sReservedNames); ++i) { 408261991Sdim if (path.equals_lower(sReservedNames[i])) 409218885Sdim return true; 410218885Sdim } 411218885Sdim 412261991Sdim // The path isn't what we consider reserved. 413218885Sdim return false; 414218885Sdim} 415218885Sdim 416276479Sdimstatic std::error_code getStatus(HANDLE FileHandle, file_status &Result) { 417261991Sdim if (FileHandle == INVALID_HANDLE_VALUE) 418261991Sdim goto handle_status_error; 419261991Sdim 420261991Sdim switch (::GetFileType(FileHandle)) { 421261991Sdim default: 422261991Sdim llvm_unreachable("Don't know anything about this file type"); 423261991Sdim case FILE_TYPE_UNKNOWN: { 424261991Sdim DWORD Err = ::GetLastError(); 425261991Sdim if (Err != NO_ERROR) 426288943Sdim return mapWindowsError(Err); 427261991Sdim Result = file_status(file_type::type_unknown); 428276479Sdim return std::error_code(); 429218885Sdim } 430261991Sdim case FILE_TYPE_DISK: 431261991Sdim break; 432261991Sdim case FILE_TYPE_CHAR: 433261991Sdim Result = file_status(file_type::character_file); 434276479Sdim return std::error_code(); 435261991Sdim case FILE_TYPE_PIPE: 436261991Sdim Result = file_status(file_type::fifo_file); 437276479Sdim return std::error_code(); 438261991Sdim } 439218885Sdim 440261991Sdim BY_HANDLE_FILE_INFORMATION Info; 441261991Sdim if (!::GetFileInformationByHandle(FileHandle, &Info)) 442261991Sdim goto handle_status_error; 443261991Sdim 444261991Sdim { 445261991Sdim file_type Type = (Info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 446261991Sdim ? file_type::directory_file 447261991Sdim : file_type::regular_file; 448261991Sdim Result = 449309124Sdim file_status(Type, Info.ftLastAccessTime.dwHighDateTime, 450309124Sdim Info.ftLastAccessTime.dwLowDateTime, 451309124Sdim Info.ftLastWriteTime.dwHighDateTime, 452261991Sdim Info.ftLastWriteTime.dwLowDateTime, 453261991Sdim Info.dwVolumeSerialNumber, Info.nFileSizeHigh, 454261991Sdim Info.nFileSizeLow, Info.nFileIndexHigh, Info.nFileIndexLow); 455276479Sdim return std::error_code(); 456218885Sdim } 457218885Sdim 458261991Sdimhandle_status_error: 459276479Sdim DWORD LastError = ::GetLastError(); 460276479Sdim if (LastError == ERROR_FILE_NOT_FOUND || 461276479Sdim LastError == ERROR_PATH_NOT_FOUND) 462261991Sdim Result = file_status(file_type::file_not_found); 463276479Sdim else if (LastError == ERROR_SHARING_VIOLATION) 464261991Sdim Result = file_status(file_type::type_unknown); 465218885Sdim else 466261991Sdim Result = file_status(file_type::status_error); 467288943Sdim return mapWindowsError(LastError); 468261991Sdim} 469218885Sdim 470276479Sdimstd::error_code status(const Twine &path, file_status &result) { 471261991Sdim SmallString<128> path_storage; 472261991Sdim SmallVector<wchar_t, 128> path_utf16; 473261991Sdim 474261991Sdim StringRef path8 = path.toStringRef(path_storage); 475261991Sdim if (isReservedName(path8)) { 476261991Sdim result = file_status(file_type::character_file); 477276479Sdim return std::error_code(); 478218885Sdim } 479218885Sdim 480280031Sdim if (std::error_code ec = widenPath(path8, path_utf16)) 481261991Sdim return ec; 482218885Sdim 483261991Sdim DWORD attr = ::GetFileAttributesW(path_utf16.begin()); 484261991Sdim if (attr == INVALID_FILE_ATTRIBUTES) 485261991Sdim return getStatus(INVALID_HANDLE_VALUE, result); 486261991Sdim 487261991Sdim // Handle reparse points. 488261991Sdim if (attr & FILE_ATTRIBUTE_REPARSE_POINT) { 489261991Sdim ScopedFileHandle h( 490261991Sdim ::CreateFileW(path_utf16.begin(), 491261991Sdim 0, // Attributes only. 492261991Sdim FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 493261991Sdim NULL, 494261991Sdim OPEN_EXISTING, 495261991Sdim FILE_FLAG_BACKUP_SEMANTICS, 496261991Sdim 0)); 497261991Sdim if (!h) 498261991Sdim return getStatus(INVALID_HANDLE_VALUE, result); 499218885Sdim } 500261991Sdim 501261991Sdim ScopedFileHandle h( 502261991Sdim ::CreateFileW(path_utf16.begin(), 0, // Attributes only. 503261991Sdim FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, 504261991Sdim NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)); 505261991Sdim if (!h) 506261991Sdim return getStatus(INVALID_HANDLE_VALUE, result); 507261991Sdim 508261991Sdim return getStatus(h, result); 509218885Sdim} 510218885Sdim 511276479Sdimstd::error_code status(int FD, file_status &Result) { 512261991Sdim HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD)); 513261991Sdim return getStatus(FileHandle, Result); 514261991Sdim} 515261991Sdim 516276479Sdimstd::error_code setLastModificationAndAccessTime(int FD, TimeValue Time) { 517261991Sdim ULARGE_INTEGER UI; 518261991Sdim UI.QuadPart = Time.toWin32Time(); 519261991Sdim FILETIME FT; 520261991Sdim FT.dwLowDateTime = UI.LowPart; 521261991Sdim FT.dwHighDateTime = UI.HighPart; 522261991Sdim HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD)); 523261991Sdim if (!SetFileTime(FileHandle, NULL, &FT, &FT)) 524288943Sdim return mapWindowsError(::GetLastError()); 525276479Sdim return std::error_code(); 526261991Sdim} 527261991Sdim 528280031Sdimstd::error_code mapped_file_region::init(int FD, uint64_t Offset, 529280031Sdim mapmode Mode) { 530261991Sdim // Make sure that the requested size fits within SIZE_T. 531280031Sdim if (Size > std::numeric_limits<SIZE_T>::max()) 532261991Sdim return make_error_code(errc::invalid_argument); 533261991Sdim 534280031Sdim HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD)); 535280031Sdim if (FileHandle == INVALID_HANDLE_VALUE) 536280031Sdim return make_error_code(errc::bad_file_descriptor); 537280031Sdim 538261991Sdim DWORD flprotect; 539261991Sdim switch (Mode) { 540261991Sdim case readonly: flprotect = PAGE_READONLY; break; 541261991Sdim case readwrite: flprotect = PAGE_READWRITE; break; 542261991Sdim case priv: flprotect = PAGE_WRITECOPY; break; 543218885Sdim } 544218885Sdim 545280031Sdim HANDLE FileMappingHandle = 546261991Sdim ::CreateFileMappingW(FileHandle, 0, flprotect, 547261991Sdim (Offset + Size) >> 32, 548261991Sdim (Offset + Size) & 0xffffffff, 549261991Sdim 0); 550261991Sdim if (FileMappingHandle == NULL) { 551288943Sdim std::error_code ec = mapWindowsError(GetLastError()); 552261991Sdim return ec; 553218885Sdim } 554218885Sdim 555261991Sdim DWORD dwDesiredAccess; 556261991Sdim switch (Mode) { 557261991Sdim case readonly: dwDesiredAccess = FILE_MAP_READ; break; 558261991Sdim case readwrite: dwDesiredAccess = FILE_MAP_WRITE; break; 559261991Sdim case priv: dwDesiredAccess = FILE_MAP_COPY; break; 560261991Sdim } 561261991Sdim Mapping = ::MapViewOfFile(FileMappingHandle, 562261991Sdim dwDesiredAccess, 563261991Sdim Offset >> 32, 564261991Sdim Offset & 0xffffffff, 565261991Sdim Size); 566261991Sdim if (Mapping == NULL) { 567288943Sdim std::error_code ec = mapWindowsError(GetLastError()); 568261991Sdim ::CloseHandle(FileMappingHandle); 569261991Sdim return ec; 570261991Sdim } 571261991Sdim 572261991Sdim if (Size == 0) { 573261991Sdim MEMORY_BASIC_INFORMATION mbi; 574261991Sdim SIZE_T Result = VirtualQuery(Mapping, &mbi, sizeof(mbi)); 575261991Sdim if (Result == 0) { 576288943Sdim std::error_code ec = mapWindowsError(GetLastError()); 577261991Sdim ::UnmapViewOfFile(Mapping); 578261991Sdim ::CloseHandle(FileMappingHandle); 579261991Sdim return ec; 580218885Sdim } 581261991Sdim Size = mbi.RegionSize; 582218885Sdim } 583218885Sdim 584261991Sdim // Close all the handles except for the view. It will keep the other handles 585261991Sdim // alive. 586261991Sdim ::CloseHandle(FileMappingHandle); 587276479Sdim return std::error_code(); 588218885Sdim} 589218885Sdim 590280031Sdimmapped_file_region::mapped_file_region(int fd, mapmode mode, uint64_t length, 591280031Sdim uint64_t offset, std::error_code &ec) 592280031Sdim : Size(length), Mapping() { 593280031Sdim ec = init(fd, offset, mode); 594280031Sdim if (ec) 595280031Sdim Mapping = 0; 596261991Sdim} 597218885Sdim 598261991Sdimmapped_file_region::~mapped_file_region() { 599261991Sdim if (Mapping) 600261991Sdim ::UnmapViewOfFile(Mapping); 601261991Sdim} 602218885Sdim 603261991Sdimuint64_t mapped_file_region::size() const { 604261991Sdim assert(Mapping && "Mapping failed but used anyway!"); 605261991Sdim return Size; 606261991Sdim} 607218885Sdim 608261991Sdimchar *mapped_file_region::data() const { 609261991Sdim assert(Mapping && "Mapping failed but used anyway!"); 610261991Sdim return reinterpret_cast<char*>(Mapping); 611261991Sdim} 612218885Sdim 613261991Sdimconst char *mapped_file_region::const_data() const { 614261991Sdim assert(Mapping && "Mapping failed but used anyway!"); 615261991Sdim return reinterpret_cast<const char*>(Mapping); 616261991Sdim} 617218885Sdim 618261991Sdimint mapped_file_region::alignment() { 619261991Sdim SYSTEM_INFO SysInfo; 620261991Sdim ::GetSystemInfo(&SysInfo); 621261991Sdim return SysInfo.dwAllocationGranularity; 622261991Sdim} 623218885Sdim 624276479Sdimstd::error_code detail::directory_iterator_construct(detail::DirIterState &it, 625261991Sdim StringRef path){ 626261991Sdim SmallVector<wchar_t, 128> path_utf16; 627218885Sdim 628280031Sdim if (std::error_code ec = widenPath(path, path_utf16)) 629261991Sdim return ec; 630218885Sdim 631261991Sdim // Convert path to the format that Windows is happy with. 632261991Sdim if (path_utf16.size() > 0 && 633261991Sdim !is_separator(path_utf16[path.size() - 1]) && 634261991Sdim path_utf16[path.size() - 1] != L':') { 635261991Sdim path_utf16.push_back(L'\\'); 636261991Sdim path_utf16.push_back(L'*'); 637261991Sdim } else { 638261991Sdim path_utf16.push_back(L'*'); 639261991Sdim } 640218885Sdim 641261991Sdim // Get the first directory entry. 642261991Sdim WIN32_FIND_DATAW FirstFind; 643261991Sdim ScopedFindHandle FindHandle(::FindFirstFileW(c_str(path_utf16), &FirstFind)); 644261991Sdim if (!FindHandle) 645288943Sdim return mapWindowsError(::GetLastError()); 646218885Sdim 647261991Sdim size_t FilenameLen = ::wcslen(FirstFind.cFileName); 648261991Sdim while ((FilenameLen == 1 && FirstFind.cFileName[0] == L'.') || 649261991Sdim (FilenameLen == 2 && FirstFind.cFileName[0] == L'.' && 650261991Sdim FirstFind.cFileName[1] == L'.')) 651261991Sdim if (!::FindNextFileW(FindHandle, &FirstFind)) { 652276479Sdim DWORD LastError = ::GetLastError(); 653261991Sdim // Check for end. 654276479Sdim if (LastError == ERROR_NO_MORE_FILES) 655261991Sdim return detail::directory_iterator_destruct(it); 656288943Sdim return mapWindowsError(LastError); 657261991Sdim } else 658261991Sdim FilenameLen = ::wcslen(FirstFind.cFileName); 659218885Sdim 660261991Sdim // Construct the current directory entry. 661261991Sdim SmallString<128> directory_entry_name_utf8; 662276479Sdim if (std::error_code ec = 663276479Sdim UTF16ToUTF8(FirstFind.cFileName, ::wcslen(FirstFind.cFileName), 664276479Sdim directory_entry_name_utf8)) 665261991Sdim return ec; 666218885Sdim 667261991Sdim it.IterationHandle = intptr_t(FindHandle.take()); 668261991Sdim SmallString<128> directory_entry_path(path); 669288943Sdim path::append(directory_entry_path, directory_entry_name_utf8); 670288943Sdim it.CurrentEntry = directory_entry(directory_entry_path); 671218885Sdim 672276479Sdim return std::error_code(); 673218885Sdim} 674218885Sdim 675276479Sdimstd::error_code detail::directory_iterator_destruct(detail::DirIterState &it) { 676261991Sdim if (it.IterationHandle != 0) 677261991Sdim // Closes the handle if it's valid. 678261991Sdim ScopedFindHandle close(HANDLE(it.IterationHandle)); 679261991Sdim it.IterationHandle = 0; 680261991Sdim it.CurrentEntry = directory_entry(); 681276479Sdim return std::error_code(); 682261991Sdim} 683218885Sdim 684276479Sdimstd::error_code detail::directory_iterator_increment(detail::DirIterState &it) { 685261991Sdim WIN32_FIND_DATAW FindData; 686261991Sdim if (!::FindNextFileW(HANDLE(it.IterationHandle), &FindData)) { 687276479Sdim DWORD LastError = ::GetLastError(); 688261991Sdim // Check for end. 689276479Sdim if (LastError == ERROR_NO_MORE_FILES) 690261991Sdim return detail::directory_iterator_destruct(it); 691288943Sdim return mapWindowsError(LastError); 692261991Sdim } 693218885Sdim 694261991Sdim size_t FilenameLen = ::wcslen(FindData.cFileName); 695261991Sdim if ((FilenameLen == 1 && FindData.cFileName[0] == L'.') || 696261991Sdim (FilenameLen == 2 && FindData.cFileName[0] == L'.' && 697261991Sdim FindData.cFileName[1] == L'.')) 698261991Sdim return directory_iterator_increment(it); 699218885Sdim 700261991Sdim SmallString<128> directory_entry_path_utf8; 701276479Sdim if (std::error_code ec = 702276479Sdim UTF16ToUTF8(FindData.cFileName, ::wcslen(FindData.cFileName), 703276479Sdim directory_entry_path_utf8)) 704261991Sdim return ec; 705218885Sdim 706261991Sdim it.CurrentEntry.replace_filename(Twine(directory_entry_path_utf8)); 707276479Sdim return std::error_code(); 708218885Sdim} 709218885Sdim 710309124Sdimstd::error_code openFileForRead(const Twine &Name, int &ResultFD, 711309124Sdim SmallVectorImpl<char> *RealPath) { 712261991Sdim SmallVector<wchar_t, 128> PathUTF16; 713218885Sdim 714280031Sdim if (std::error_code EC = widenPath(Name, PathUTF16)) 715261991Sdim return EC; 716218885Sdim 717296417Sdim HANDLE H = 718296417Sdim ::CreateFileW(PathUTF16.begin(), GENERIC_READ, 719296417Sdim FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 720296417Sdim NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 721261991Sdim if (H == INVALID_HANDLE_VALUE) { 722276479Sdim DWORD LastError = ::GetLastError(); 723288943Sdim std::error_code EC = mapWindowsError(LastError); 724261991Sdim // Provide a better error message when trying to open directories. 725261991Sdim // This only runs if we failed to open the file, so there is probably 726261991Sdim // no performances issues. 727276479Sdim if (LastError != ERROR_ACCESS_DENIED) 728261991Sdim return EC; 729261991Sdim if (is_directory(Name)) 730276479Sdim return make_error_code(errc::is_a_directory); 731261991Sdim return EC; 732218885Sdim } 733218885Sdim 734261991Sdim int FD = ::_open_osfhandle(intptr_t(H), 0); 735261991Sdim if (FD == -1) { 736261991Sdim ::CloseHandle(H); 737288943Sdim return mapWindowsError(ERROR_INVALID_HANDLE); 738218885Sdim } 739218885Sdim 740309124Sdim // Fetch the real name of the file, if the user asked 741309124Sdim if (RealPath) { 742309124Sdim RealPath->clear(); 743309124Sdim wchar_t RealPathUTF16[MAX_PATH]; 744309124Sdim DWORD CountChars = 745309124Sdim ::GetFinalPathNameByHandleW(H, RealPathUTF16, MAX_PATH, 746309124Sdim FILE_NAME_NORMALIZED); 747309124Sdim if (CountChars > 0 && CountChars < MAX_PATH) { 748309124Sdim // Convert the result from UTF-16 to UTF-8. 749309124Sdim SmallString<MAX_PATH> RealPathUTF8; 750309124Sdim if (!UTF16ToUTF8(RealPathUTF16, CountChars, RealPathUTF8)) 751309124Sdim RealPath->append(RealPathUTF8.data(), 752309124Sdim RealPathUTF8.data() + strlen(RealPathUTF8.data())); 753309124Sdim } 754309124Sdim } 755309124Sdim 756261991Sdim ResultFD = FD; 757276479Sdim return std::error_code(); 758218885Sdim} 759218885Sdim 760276479Sdimstd::error_code openFileForWrite(const Twine &Name, int &ResultFD, 761261991Sdim sys::fs::OpenFlags Flags, unsigned Mode) { 762261991Sdim // Verify that we don't have both "append" and "excl". 763261991Sdim assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) && 764261991Sdim "Cannot specify both 'excl' and 'append' file creation flags!"); 765218885Sdim 766261991Sdim SmallVector<wchar_t, 128> PathUTF16; 767218885Sdim 768280031Sdim if (std::error_code EC = widenPath(Name, PathUTF16)) 769261991Sdim return EC; 770218885Sdim 771261991Sdim DWORD CreationDisposition; 772261991Sdim if (Flags & F_Excl) 773261991Sdim CreationDisposition = CREATE_NEW; 774261991Sdim else if (Flags & F_Append) 775261991Sdim CreationDisposition = OPEN_ALWAYS; 776261991Sdim else 777261991Sdim CreationDisposition = CREATE_ALWAYS; 778261991Sdim 779276479Sdim DWORD Access = GENERIC_WRITE; 780276479Sdim if (Flags & F_RW) 781276479Sdim Access |= GENERIC_READ; 782276479Sdim 783276479Sdim HANDLE H = ::CreateFileW(PathUTF16.begin(), Access, 784261991Sdim FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 785261991Sdim CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL); 786261991Sdim 787261991Sdim if (H == INVALID_HANDLE_VALUE) { 788276479Sdim DWORD LastError = ::GetLastError(); 789288943Sdim std::error_code EC = mapWindowsError(LastError); 790261991Sdim // Provide a better error message when trying to open directories. 791261991Sdim // This only runs if we failed to open the file, so there is probably 792261991Sdim // no performances issues. 793276479Sdim if (LastError != ERROR_ACCESS_DENIED) 794261991Sdim return EC; 795261991Sdim if (is_directory(Name)) 796276479Sdim return make_error_code(errc::is_a_directory); 797261991Sdim return EC; 798221345Sdim } 799218885Sdim 800261991Sdim int OpenFlags = 0; 801261991Sdim if (Flags & F_Append) 802261991Sdim OpenFlags |= _O_APPEND; 803218885Sdim 804276479Sdim if (Flags & F_Text) 805261991Sdim OpenFlags |= _O_TEXT; 806218885Sdim 807261991Sdim int FD = ::_open_osfhandle(intptr_t(H), OpenFlags); 808261991Sdim if (FD == -1) { 809261991Sdim ::CloseHandle(H); 810288943Sdim return mapWindowsError(ERROR_INVALID_HANDLE); 811261991Sdim } 812218885Sdim 813261991Sdim ResultFD = FD; 814276479Sdim return std::error_code(); 815218885Sdim} 816309124Sdim 817309124Sdimstd::error_code getPathFromOpenFD(int FD, SmallVectorImpl<char> &ResultPath) { 818309124Sdim HANDLE FileHandle = reinterpret_cast<HANDLE>(::_get_osfhandle(FD)); 819309124Sdim if (FileHandle == INVALID_HANDLE_VALUE) 820309124Sdim return make_error_code(errc::bad_file_descriptor); 821309124Sdim 822309124Sdim DWORD CharCount; 823309124Sdim SmallVector<wchar_t, 1024> TempPath; 824309124Sdim do { 825309124Sdim CharCount = ::GetFinalPathNameByHandleW(FileHandle, TempPath.begin(), 826309124Sdim TempPath.capacity(), 827309124Sdim FILE_NAME_NORMALIZED); 828309124Sdim if (CharCount < TempPath.capacity()) 829309124Sdim break; 830309124Sdim 831309124Sdim // Reserve sufficient space for the path as well as the null character. Even 832309124Sdim // though the API does not document that it is required, if we reserve just 833309124Sdim // CharCount space, the function call will not store the resulting path and 834309124Sdim // still report success. 835309124Sdim TempPath.reserve(CharCount + 1); 836309124Sdim } while (true); 837309124Sdim 838309124Sdim if (CharCount == 0) 839309124Sdim return mapWindowsError(::GetLastError()); 840309124Sdim 841309124Sdim TempPath.set_size(CharCount); 842309124Sdim 843309124Sdim // On earlier Windows releases, the character count includes the terminating 844309124Sdim // null. 845309124Sdim if (TempPath.back() == L'\0') { 846309124Sdim --CharCount; 847309124Sdim TempPath.pop_back(); 848309124Sdim } 849309124Sdim 850309124Sdim return windows::UTF16ToUTF8(TempPath.data(), CharCount, ResultPath); 851309124Sdim} 852261991Sdim} // end namespace fs 853218885Sdim 854276479Sdimnamespace path { 855296417Sdimstatic bool getKnownFolderPath(KNOWNFOLDERID folderId, 856296417Sdim SmallVectorImpl<char> &result) { 857296417Sdim wchar_t *path = nullptr; 858296417Sdim if (::SHGetKnownFolderPath(folderId, KF_FLAG_CREATE, nullptr, &path) != S_OK) 859276479Sdim return false; 860276479Sdim 861296417Sdim bool ok = !UTF16ToUTF8(path, ::wcslen(path), result); 862296417Sdim ::CoTaskMemFree(path); 863296417Sdim return ok; 864296417Sdim} 865276479Sdim 866296417Sdimbool getUserCacheDir(SmallVectorImpl<char> &Result) { 867296417Sdim return getKnownFolderPath(FOLDERID_LocalAppData, Result); 868276479Sdim} 869276479Sdim 870296417Sdimbool home_directory(SmallVectorImpl<char> &result) { 871296417Sdim return getKnownFolderPath(FOLDERID_Profile, result); 872296417Sdim} 873280031Sdim 874296417Sdimstatic bool getTempDirEnvVar(const wchar_t *Var, SmallVectorImpl<char> &Res) { 875280031Sdim SmallVector<wchar_t, 1024> Buf; 876280031Sdim size_t Size = 1024; 877280031Sdim do { 878280031Sdim Buf.reserve(Size); 879296417Sdim Size = GetEnvironmentVariableW(Var, Buf.data(), Buf.capacity()); 880280031Sdim if (Size == 0) 881280031Sdim return false; 882280031Sdim 883280031Sdim // Try again with larger buffer. 884280031Sdim } while (Size > Buf.capacity()); 885280031Sdim Buf.set_size(Size); 886280031Sdim 887296417Sdim return !windows::UTF16ToUTF8(Buf.data(), Size, Res); 888280031Sdim} 889280031Sdim 890280031Sdimstatic bool getTempDirEnvVar(SmallVectorImpl<char> &Res) { 891296417Sdim const wchar_t *EnvironmentVariables[] = {L"TMP", L"TEMP", L"USERPROFILE"}; 892296417Sdim for (auto *Env : EnvironmentVariables) { 893280031Sdim if (getTempDirEnvVar(Env, Res)) 894280031Sdim return true; 895280031Sdim } 896280031Sdim return false; 897280031Sdim} 898280031Sdim 899280031Sdimvoid system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) { 900280031Sdim (void)ErasedOnReboot; 901280031Sdim Result.clear(); 902280031Sdim 903296417Sdim // Check whether the temporary directory is specified by an environment var. 904296417Sdim // This matches GetTempPath logic to some degree. GetTempPath is not used 905296417Sdim // directly as it cannot handle evn var longer than 130 chars on Windows 7 906296417Sdim // (fixed on Windows 8). 907296417Sdim if (getTempDirEnvVar(Result)) { 908296417Sdim assert(!Result.empty() && "Unexpected empty path"); 909296417Sdim native(Result); // Some Unix-like shells use Unix path separator in $TMP. 910296417Sdim fs::make_absolute(Result); // Make it absolute if not already. 911280031Sdim return; 912296417Sdim } 913280031Sdim 914280031Sdim // Fall back to a system default. 915296417Sdim const char *DefaultResult = "C:\\Temp"; 916280031Sdim Result.append(DefaultResult, DefaultResult + strlen(DefaultResult)); 917280031Sdim} 918276479Sdim} // end namespace path 919276479Sdim 920261991Sdimnamespace windows { 921276479Sdimstd::error_code UTF8ToUTF16(llvm::StringRef utf8, 922276479Sdim llvm::SmallVectorImpl<wchar_t> &utf16) { 923276479Sdim if (!utf8.empty()) { 924276479Sdim int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(), 925276479Sdim utf8.size(), utf16.begin(), 0); 926261991Sdim 927276479Sdim if (len == 0) 928288943Sdim return mapWindowsError(::GetLastError()); 929261991Sdim 930276479Sdim utf16.reserve(len + 1); 931276479Sdim utf16.set_size(len); 932261991Sdim 933276479Sdim len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(), 934276479Sdim utf8.size(), utf16.begin(), utf16.size()); 935261991Sdim 936276479Sdim if (len == 0) 937288943Sdim return mapWindowsError(::GetLastError()); 938276479Sdim } 939261991Sdim 940261991Sdim // Make utf16 null terminated. 941261991Sdim utf16.push_back(0); 942261991Sdim utf16.pop_back(); 943261991Sdim 944276479Sdim return std::error_code(); 945218885Sdim} 946218885Sdim 947280031Sdimstatic 948280031Sdimstd::error_code UTF16ToCodePage(unsigned codepage, const wchar_t *utf16, 949280031Sdim size_t utf16_len, 950280031Sdim llvm::SmallVectorImpl<char> &utf8) { 951276479Sdim if (utf16_len) { 952276479Sdim // Get length. 953280031Sdim int len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.begin(), 954276479Sdim 0, NULL, NULL); 955261991Sdim 956276479Sdim if (len == 0) 957288943Sdim return mapWindowsError(::GetLastError()); 958261991Sdim 959276479Sdim utf8.reserve(len); 960276479Sdim utf8.set_size(len); 961261991Sdim 962276479Sdim // Now do the actual conversion. 963280031Sdim len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, utf8.data(), 964276479Sdim utf8.size(), NULL, NULL); 965261991Sdim 966276479Sdim if (len == 0) 967288943Sdim return mapWindowsError(::GetLastError()); 968276479Sdim } 969261991Sdim 970261991Sdim // Make utf8 null terminated. 971261991Sdim utf8.push_back(0); 972261991Sdim utf8.pop_back(); 973261991Sdim 974276479Sdim return std::error_code(); 975218885Sdim} 976280031Sdim 977280031Sdimstd::error_code UTF16ToUTF8(const wchar_t *utf16, size_t utf16_len, 978280031Sdim llvm::SmallVectorImpl<char> &utf8) { 979280031Sdim return UTF16ToCodePage(CP_UTF8, utf16, utf16_len, utf8); 980280031Sdim} 981280031Sdim 982280031Sdimstd::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len, 983280031Sdim llvm::SmallVectorImpl<char> &utf8) { 984280031Sdim return UTF16ToCodePage(CP_ACP, utf16, utf16_len, utf8); 985280031Sdim} 986309124Sdim 987261991Sdim} // end namespace windows 988261991Sdim} // end namespace sys 989261991Sdim} // end namespace llvm 990