FileSystem.h revision 360784
1//===- llvm/Support/FileSystem.h - File System OS Concept -------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file declares the llvm::sys::fs namespace. It is designed after 10// TR2/boost filesystem (v3), but modified to remove exception handling and the 11// path class. 12// 13// All functions return an error_code and their actual work via the last out 14// argument. The out argument is defined if and only if errc::success is 15// returned. A function may return any error code in the generic or system 16// category. However, they shall be equivalent to any error conditions listed 17// in each functions respective documentation if the condition applies. [ note: 18// this does not guarantee that error_code will be in the set of explicitly 19// listed codes, but it does guarantee that if any of the explicitly listed 20// errors occur, the correct error_code will be used ]. All functions may 21// return errc::not_enough_memory if there is not enough memory to complete the 22// operation. 23// 24//===----------------------------------------------------------------------===// 25 26#ifndef LLVM_SUPPORT_FILESYSTEM_H 27#define LLVM_SUPPORT_FILESYSTEM_H 28 29#include "llvm/ADT/SmallString.h" 30#include "llvm/ADT/StringRef.h" 31#include "llvm/ADT/Twine.h" 32#include "llvm/Config/llvm-config.h" 33#include "llvm/Support/Chrono.h" 34#include "llvm/Support/Error.h" 35#include "llvm/Support/ErrorHandling.h" 36#include "llvm/Support/ErrorOr.h" 37#include "llvm/Support/MD5.h" 38#include <cassert> 39#include <cstdint> 40#include <ctime> 41#include <memory> 42#include <stack> 43#include <string> 44#include <system_error> 45#include <tuple> 46#include <vector> 47 48#ifdef HAVE_SYS_STAT_H 49#include <sys/stat.h> 50#endif 51 52namespace llvm { 53namespace sys { 54namespace fs { 55 56#if defined(_WIN32) 57// A Win32 HANDLE is a typedef of void* 58using file_t = void *; 59#else 60using file_t = int; 61#endif 62 63extern const file_t kInvalidFile; 64 65/// An enumeration for the file system's view of the type. 66enum class file_type { 67 status_error, 68 file_not_found, 69 regular_file, 70 directory_file, 71 symlink_file, 72 block_file, 73 character_file, 74 fifo_file, 75 socket_file, 76 type_unknown 77}; 78 79/// space_info - Self explanatory. 80struct space_info { 81 uint64_t capacity; 82 uint64_t free; 83 uint64_t available; 84}; 85 86enum perms { 87 no_perms = 0, 88 owner_read = 0400, 89 owner_write = 0200, 90 owner_exe = 0100, 91 owner_all = owner_read | owner_write | owner_exe, 92 group_read = 040, 93 group_write = 020, 94 group_exe = 010, 95 group_all = group_read | group_write | group_exe, 96 others_read = 04, 97 others_write = 02, 98 others_exe = 01, 99 others_all = others_read | others_write | others_exe, 100 all_read = owner_read | group_read | others_read, 101 all_write = owner_write | group_write | others_write, 102 all_exe = owner_exe | group_exe | others_exe, 103 all_all = owner_all | group_all | others_all, 104 set_uid_on_exe = 04000, 105 set_gid_on_exe = 02000, 106 sticky_bit = 01000, 107 all_perms = all_all | set_uid_on_exe | set_gid_on_exe | sticky_bit, 108 perms_not_known = 0xFFFF 109}; 110 111// Helper functions so that you can use & and | to manipulate perms bits: 112inline perms operator|(perms l, perms r) { 113 return static_cast<perms>(static_cast<unsigned short>(l) | 114 static_cast<unsigned short>(r)); 115} 116inline perms operator&(perms l, perms r) { 117 return static_cast<perms>(static_cast<unsigned short>(l) & 118 static_cast<unsigned short>(r)); 119} 120inline perms &operator|=(perms &l, perms r) { 121 l = l | r; 122 return l; 123} 124inline perms &operator&=(perms &l, perms r) { 125 l = l & r; 126 return l; 127} 128inline perms operator~(perms x) { 129 // Avoid UB by explicitly truncating the (unsigned) ~ result. 130 return static_cast<perms>( 131 static_cast<unsigned short>(~static_cast<unsigned short>(x))); 132} 133 134class UniqueID { 135 uint64_t Device; 136 uint64_t File; 137 138public: 139 UniqueID() = default; 140 UniqueID(uint64_t Device, uint64_t File) : Device(Device), File(File) {} 141 142 bool operator==(const UniqueID &Other) const { 143 return Device == Other.Device && File == Other.File; 144 } 145 bool operator!=(const UniqueID &Other) const { return !(*this == Other); } 146 bool operator<(const UniqueID &Other) const { 147 return std::tie(Device, File) < std::tie(Other.Device, Other.File); 148 } 149 150 uint64_t getDevice() const { return Device; } 151 uint64_t getFile() const { return File; } 152}; 153 154/// Represents the result of a call to directory_iterator::status(). This is a 155/// subset of the information returned by a regular sys::fs::status() call, and 156/// represents the information provided by Windows FileFirstFile/FindNextFile. 157class basic_file_status { 158protected: 159 #if defined(LLVM_ON_UNIX) 160 time_t fs_st_atime = 0; 161 time_t fs_st_mtime = 0; 162 uint32_t fs_st_atime_nsec = 0; 163 uint32_t fs_st_mtime_nsec = 0; 164 uid_t fs_st_uid = 0; 165 gid_t fs_st_gid = 0; 166 off_t fs_st_size = 0; 167 #elif defined (_WIN32) 168 uint32_t LastAccessedTimeHigh = 0; 169 uint32_t LastAccessedTimeLow = 0; 170 uint32_t LastWriteTimeHigh = 0; 171 uint32_t LastWriteTimeLow = 0; 172 uint32_t FileSizeHigh = 0; 173 uint32_t FileSizeLow = 0; 174 #endif 175 file_type Type = file_type::status_error; 176 perms Perms = perms_not_known; 177 178public: 179 basic_file_status() = default; 180 181 explicit basic_file_status(file_type Type) : Type(Type) {} 182 183 #if defined(LLVM_ON_UNIX) 184 basic_file_status(file_type Type, perms Perms, time_t ATime, 185 uint32_t ATimeNSec, time_t MTime, uint32_t MTimeNSec, 186 uid_t UID, gid_t GID, off_t Size) 187 : fs_st_atime(ATime), fs_st_mtime(MTime), 188 fs_st_atime_nsec(ATimeNSec), fs_st_mtime_nsec(MTimeNSec), 189 fs_st_uid(UID), fs_st_gid(GID), 190 fs_st_size(Size), Type(Type), Perms(Perms) {} 191#elif defined(_WIN32) 192 basic_file_status(file_type Type, perms Perms, uint32_t LastAccessTimeHigh, 193 uint32_t LastAccessTimeLow, uint32_t LastWriteTimeHigh, 194 uint32_t LastWriteTimeLow, uint32_t FileSizeHigh, 195 uint32_t FileSizeLow) 196 : LastAccessedTimeHigh(LastAccessTimeHigh), 197 LastAccessedTimeLow(LastAccessTimeLow), 198 LastWriteTimeHigh(LastWriteTimeHigh), 199 LastWriteTimeLow(LastWriteTimeLow), FileSizeHigh(FileSizeHigh), 200 FileSizeLow(FileSizeLow), Type(Type), Perms(Perms) {} 201 #endif 202 203 // getters 204 file_type type() const { return Type; } 205 perms permissions() const { return Perms; } 206 207 /// The file access time as reported from the underlying file system. 208 /// 209 /// Also see comments on \c getLastModificationTime() related to the precision 210 /// of the returned value. 211 TimePoint<> getLastAccessedTime() const; 212 213 /// The file modification time as reported from the underlying file system. 214 /// 215 /// The returned value allows for nanosecond precision but the actual 216 /// resolution is an implementation detail of the underlying file system. 217 /// There is no guarantee for what kind of resolution you can expect, the 218 /// resolution can differ across platforms and even across mountpoints on the 219 /// same machine. 220 TimePoint<> getLastModificationTime() const; 221 222 #if defined(LLVM_ON_UNIX) 223 uint32_t getUser() const { return fs_st_uid; } 224 uint32_t getGroup() const { return fs_st_gid; } 225 uint64_t getSize() const { return fs_st_size; } 226 #elif defined (_WIN32) 227 uint32_t getUser() const { 228 return 9999; // Not applicable to Windows, so... 229 } 230 231 uint32_t getGroup() const { 232 return 9999; // Not applicable to Windows, so... 233 } 234 235 uint64_t getSize() const { 236 return (uint64_t(FileSizeHigh) << 32) + FileSizeLow; 237 } 238 #endif 239 240 // setters 241 void type(file_type v) { Type = v; } 242 void permissions(perms p) { Perms = p; } 243}; 244 245/// Represents the result of a call to sys::fs::status(). 246class file_status : public basic_file_status { 247 friend bool equivalent(file_status A, file_status B); 248 249 #if defined(LLVM_ON_UNIX) 250 dev_t fs_st_dev = 0; 251 nlink_t fs_st_nlinks = 0; 252 ino_t fs_st_ino = 0; 253 #elif defined (_WIN32) 254 uint32_t NumLinks = 0; 255 uint32_t VolumeSerialNumber = 0; 256 uint32_t FileIndexHigh = 0; 257 uint32_t FileIndexLow = 0; 258 #endif 259 260public: 261 file_status() = default; 262 263 explicit file_status(file_type Type) : basic_file_status(Type) {} 264 265 #if defined(LLVM_ON_UNIX) 266 file_status(file_type Type, perms Perms, dev_t Dev, nlink_t Links, ino_t Ino, 267 time_t ATime, uint32_t ATimeNSec, 268 time_t MTime, uint32_t MTimeNSec, 269 uid_t UID, gid_t GID, off_t Size) 270 : basic_file_status(Type, Perms, ATime, ATimeNSec, MTime, MTimeNSec, 271 UID, GID, Size), 272 fs_st_dev(Dev), fs_st_nlinks(Links), fs_st_ino(Ino) {} 273 #elif defined(_WIN32) 274 file_status(file_type Type, perms Perms, uint32_t LinkCount, 275 uint32_t LastAccessTimeHigh, uint32_t LastAccessTimeLow, 276 uint32_t LastWriteTimeHigh, uint32_t LastWriteTimeLow, 277 uint32_t VolumeSerialNumber, uint32_t FileSizeHigh, 278 uint32_t FileSizeLow, uint32_t FileIndexHigh, 279 uint32_t FileIndexLow) 280 : basic_file_status(Type, Perms, LastAccessTimeHigh, LastAccessTimeLow, 281 LastWriteTimeHigh, LastWriteTimeLow, FileSizeHigh, 282 FileSizeLow), 283 NumLinks(LinkCount), VolumeSerialNumber(VolumeSerialNumber), 284 FileIndexHigh(FileIndexHigh), FileIndexLow(FileIndexLow) {} 285 #endif 286 287 UniqueID getUniqueID() const; 288 uint32_t getLinkCount() const; 289}; 290 291/// @} 292/// @name Physical Operators 293/// @{ 294 295/// Make \a path an absolute path. 296/// 297/// Makes \a path absolute using the \a current_directory if it is not already. 298/// An empty \a path will result in the \a current_directory. 299/// 300/// /absolute/path => /absolute/path 301/// relative/../path => <current-directory>/relative/../path 302/// 303/// @param path A path that is modified to be an absolute path. 304void make_absolute(const Twine ¤t_directory, SmallVectorImpl<char> &path); 305 306/// Make \a path an absolute path. 307/// 308/// Makes \a path absolute using the current directory if it is not already. An 309/// empty \a path will result in the current directory. 310/// 311/// /absolute/path => /absolute/path 312/// relative/../path => <current-directory>/relative/../path 313/// 314/// @param path A path that is modified to be an absolute path. 315/// @returns errc::success if \a path has been made absolute, otherwise a 316/// platform-specific error_code. 317std::error_code make_absolute(SmallVectorImpl<char> &path); 318 319/// Create all the non-existent directories in path. 320/// 321/// @param path Directories to create. 322/// @returns errc::success if is_directory(path), otherwise a platform 323/// specific error_code. If IgnoreExisting is false, also returns 324/// error if the directory already existed. 325std::error_code create_directories(const Twine &path, 326 bool IgnoreExisting = true, 327 perms Perms = owner_all | group_all); 328 329/// Create the directory in path. 330/// 331/// @param path Directory to create. 332/// @returns errc::success if is_directory(path), otherwise a platform 333/// specific error_code. If IgnoreExisting is false, also returns 334/// error if the directory already existed. 335std::error_code create_directory(const Twine &path, bool IgnoreExisting = true, 336 perms Perms = owner_all | group_all); 337 338/// Create a link from \a from to \a to. 339/// 340/// The link may be a soft or a hard link, depending on the platform. The caller 341/// may not assume which one. Currently on windows it creates a hard link since 342/// soft links require extra privileges. On unix, it creates a soft link since 343/// hard links don't work on SMB file systems. 344/// 345/// @param to The path to hard link to. 346/// @param from The path to hard link from. This is created. 347/// @returns errc::success if the link was created, otherwise a platform 348/// specific error_code. 349std::error_code create_link(const Twine &to, const Twine &from); 350 351/// Create a hard link from \a from to \a to, or return an error. 352/// 353/// @param to The path to hard link to. 354/// @param from The path to hard link from. This is created. 355/// @returns errc::success if the link was created, otherwise a platform 356/// specific error_code. 357std::error_code create_hard_link(const Twine &to, const Twine &from); 358 359/// Collapse all . and .. patterns, resolve all symlinks, and optionally 360/// expand ~ expressions to the user's home directory. 361/// 362/// @param path The path to resolve. 363/// @param output The location to store the resolved path. 364/// @param expand_tilde If true, resolves ~ expressions to the user's home 365/// directory. 366std::error_code real_path(const Twine &path, SmallVectorImpl<char> &output, 367 bool expand_tilde = false); 368 369/// Expands ~ expressions to the user's home directory. On Unix ~user 370/// directories are resolved as well. 371/// 372/// @param path The path to resolve. 373void expand_tilde(const Twine &path, SmallVectorImpl<char> &output); 374 375/// Get the current path. 376/// 377/// @param result Holds the current path on return. 378/// @returns errc::success if the current path has been stored in result, 379/// otherwise a platform-specific error_code. 380std::error_code current_path(SmallVectorImpl<char> &result); 381 382/// Set the current path. 383/// 384/// @param path The path to set. 385/// @returns errc::success if the current path was successfully set, 386/// otherwise a platform-specific error_code. 387std::error_code set_current_path(const Twine &path); 388 389/// Remove path. Equivalent to POSIX remove(). 390/// 391/// @param path Input path. 392/// @returns errc::success if path has been removed or didn't exist, otherwise a 393/// platform-specific error code. If IgnoreNonExisting is false, also 394/// returns error if the file didn't exist. 395std::error_code remove(const Twine &path, bool IgnoreNonExisting = true); 396 397/// Recursively delete a directory. 398/// 399/// @param path Input path. 400/// @returns errc::success if path has been removed or didn't exist, otherwise a 401/// platform-specific error code. 402std::error_code remove_directories(const Twine &path, bool IgnoreErrors = true); 403 404/// Rename \a from to \a to. 405/// 406/// Files are renamed as if by POSIX rename(), except that on Windows there may 407/// be a short interval of time during which the destination file does not 408/// exist. 409/// 410/// @param from The path to rename from. 411/// @param to The path to rename to. This is created. 412std::error_code rename(const Twine &from, const Twine &to); 413 414/// Copy the contents of \a From to \a To. 415/// 416/// @param From The path to copy from. 417/// @param To The path to copy to. This is created. 418std::error_code copy_file(const Twine &From, const Twine &To); 419 420/// Copy the contents of \a From to \a To. 421/// 422/// @param From The path to copy from. 423/// @param ToFD The open file descriptor of the destination file. 424std::error_code copy_file(const Twine &From, int ToFD); 425 426/// Resize path to size. File is resized as if by POSIX truncate(). 427/// 428/// @param FD Input file descriptor. 429/// @param Size Size to resize to. 430/// @returns errc::success if \a path has been resized to \a size, otherwise a 431/// platform-specific error_code. 432std::error_code resize_file(int FD, uint64_t Size); 433 434/// Compute an MD5 hash of a file's contents. 435/// 436/// @param FD Input file descriptor. 437/// @returns An MD5Result with the hash computed, if successful, otherwise a 438/// std::error_code. 439ErrorOr<MD5::MD5Result> md5_contents(int FD); 440 441/// Version of compute_md5 that doesn't require an open file descriptor. 442ErrorOr<MD5::MD5Result> md5_contents(const Twine &Path); 443 444/// @} 445/// @name Physical Observers 446/// @{ 447 448/// Does file exist? 449/// 450/// @param status A basic_file_status previously returned from stat. 451/// @returns True if the file represented by status exists, false if it does 452/// not. 453bool exists(const basic_file_status &status); 454 455enum class AccessMode { Exist, Write, Execute }; 456 457/// Can the file be accessed? 458/// 459/// @param Path Input path. 460/// @returns errc::success if the path can be accessed, otherwise a 461/// platform-specific error_code. 462std::error_code access(const Twine &Path, AccessMode Mode); 463 464/// Does file exist? 465/// 466/// @param Path Input path. 467/// @returns True if it exists, false otherwise. 468inline bool exists(const Twine &Path) { 469 return !access(Path, AccessMode::Exist); 470} 471 472/// Can we execute this file? 473/// 474/// @param Path Input path. 475/// @returns True if we can execute it, false otherwise. 476bool can_execute(const Twine &Path); 477 478/// Can we write this file? 479/// 480/// @param Path Input path. 481/// @returns True if we can write to it, false otherwise. 482inline bool can_write(const Twine &Path) { 483 return !access(Path, AccessMode::Write); 484} 485 486/// Do file_status's represent the same thing? 487/// 488/// @param A Input file_status. 489/// @param B Input file_status. 490/// 491/// assert(status_known(A) || status_known(B)); 492/// 493/// @returns True if A and B both represent the same file system entity, false 494/// otherwise. 495bool equivalent(file_status A, file_status B); 496 497/// Do paths represent the same thing? 498/// 499/// assert(status_known(A) || status_known(B)); 500/// 501/// @param A Input path A. 502/// @param B Input path B. 503/// @param result Set to true if stat(A) and stat(B) have the same device and 504/// inode (or equivalent). 505/// @returns errc::success if result has been successfully set, otherwise a 506/// platform-specific error_code. 507std::error_code equivalent(const Twine &A, const Twine &B, bool &result); 508 509/// Simpler version of equivalent for clients that don't need to 510/// differentiate between an error and false. 511inline bool equivalent(const Twine &A, const Twine &B) { 512 bool result; 513 return !equivalent(A, B, result) && result; 514} 515 516/// Is the file mounted on a local filesystem? 517/// 518/// @param path Input path. 519/// @param result Set to true if \a path is on fixed media such as a hard disk, 520/// false if it is not. 521/// @returns errc::success if result has been successfully set, otherwise a 522/// platform specific error_code. 523std::error_code is_local(const Twine &path, bool &result); 524 525/// Version of is_local accepting an open file descriptor. 526std::error_code is_local(int FD, bool &result); 527 528/// Simpler version of is_local for clients that don't need to 529/// differentiate between an error and false. 530inline bool is_local(const Twine &Path) { 531 bool Result; 532 return !is_local(Path, Result) && Result; 533} 534 535/// Simpler version of is_local accepting an open file descriptor for 536/// clients that don't need to differentiate between an error and false. 537inline bool is_local(int FD) { 538 bool Result; 539 return !is_local(FD, Result) && Result; 540} 541 542/// Does status represent a directory? 543/// 544/// @param Path The path to get the type of. 545/// @param Follow For symbolic links, indicates whether to return the file type 546/// of the link itself, or of the target. 547/// @returns A value from the file_type enumeration indicating the type of file. 548file_type get_file_type(const Twine &Path, bool Follow = true); 549 550/// Does status represent a directory? 551/// 552/// @param status A basic_file_status previously returned from status. 553/// @returns status.type() == file_type::directory_file. 554bool is_directory(const basic_file_status &status); 555 556/// Is path a directory? 557/// 558/// @param path Input path. 559/// @param result Set to true if \a path is a directory (after following 560/// symlinks, false if it is not. Undefined otherwise. 561/// @returns errc::success if result has been successfully set, otherwise a 562/// platform-specific error_code. 563std::error_code is_directory(const Twine &path, bool &result); 564 565/// Simpler version of is_directory for clients that don't need to 566/// differentiate between an error and false. 567inline bool is_directory(const Twine &Path) { 568 bool Result; 569 return !is_directory(Path, Result) && Result; 570} 571 572/// Does status represent a regular file? 573/// 574/// @param status A basic_file_status previously returned from status. 575/// @returns status_known(status) && status.type() == file_type::regular_file. 576bool is_regular_file(const basic_file_status &status); 577 578/// Is path a regular file? 579/// 580/// @param path Input path. 581/// @param result Set to true if \a path is a regular file (after following 582/// symlinks), false if it is not. Undefined otherwise. 583/// @returns errc::success if result has been successfully set, otherwise a 584/// platform-specific error_code. 585std::error_code is_regular_file(const Twine &path, bool &result); 586 587/// Simpler version of is_regular_file for clients that don't need to 588/// differentiate between an error and false. 589inline bool is_regular_file(const Twine &Path) { 590 bool Result; 591 if (is_regular_file(Path, Result)) 592 return false; 593 return Result; 594} 595 596/// Does status represent a symlink file? 597/// 598/// @param status A basic_file_status previously returned from status. 599/// @returns status_known(status) && status.type() == file_type::symlink_file. 600bool is_symlink_file(const basic_file_status &status); 601 602/// Is path a symlink file? 603/// 604/// @param path Input path. 605/// @param result Set to true if \a path is a symlink file, false if it is not. 606/// Undefined otherwise. 607/// @returns errc::success if result has been successfully set, otherwise a 608/// platform-specific error_code. 609std::error_code is_symlink_file(const Twine &path, bool &result); 610 611/// Simpler version of is_symlink_file for clients that don't need to 612/// differentiate between an error and false. 613inline bool is_symlink_file(const Twine &Path) { 614 bool Result; 615 if (is_symlink_file(Path, Result)) 616 return false; 617 return Result; 618} 619 620/// Does this status represent something that exists but is not a 621/// directory or regular file? 622/// 623/// @param status A basic_file_status previously returned from status. 624/// @returns exists(s) && !is_regular_file(s) && !is_directory(s) 625bool is_other(const basic_file_status &status); 626 627/// Is path something that exists but is not a directory, 628/// regular file, or symlink? 629/// 630/// @param path Input path. 631/// @param result Set to true if \a path exists, but is not a directory, regular 632/// file, or a symlink, false if it does not. Undefined otherwise. 633/// @returns errc::success if result has been successfully set, otherwise a 634/// platform-specific error_code. 635std::error_code is_other(const Twine &path, bool &result); 636 637/// Get file status as if by POSIX stat(). 638/// 639/// @param path Input path. 640/// @param result Set to the file status. 641/// @param follow When true, follows symlinks. Otherwise, the symlink itself is 642/// statted. 643/// @returns errc::success if result has been successfully set, otherwise a 644/// platform-specific error_code. 645std::error_code status(const Twine &path, file_status &result, 646 bool follow = true); 647 648/// A version for when a file descriptor is already available. 649std::error_code status(int FD, file_status &Result); 650 651#ifdef _WIN32 652/// A version for when a file descriptor is already available. 653std::error_code status(file_t FD, file_status &Result); 654#endif 655 656/// Get file creation mode mask of the process. 657/// 658/// @returns Mask reported by umask(2) 659/// @note There is no umask on Windows. This function returns 0 always 660/// on Windows. This function does not return an error_code because 661/// umask(2) never fails. It is not thread safe. 662unsigned getUmask(); 663 664/// Set file permissions. 665/// 666/// @param Path File to set permissions on. 667/// @param Permissions New file permissions. 668/// @returns errc::success if the permissions were successfully set, otherwise 669/// a platform-specific error_code. 670/// @note On Windows, all permissions except *_write are ignored. Using any of 671/// owner_write, group_write, or all_write will make the file writable. 672/// Otherwise, the file will be marked as read-only. 673std::error_code setPermissions(const Twine &Path, perms Permissions); 674 675/// Vesion of setPermissions accepting a file descriptor. 676/// TODO Delete the path based overload once we implement the FD based overload 677/// on Windows. 678std::error_code setPermissions(int FD, perms Permissions); 679 680/// Get file permissions. 681/// 682/// @param Path File to get permissions from. 683/// @returns the permissions if they were successfully retrieved, otherwise a 684/// platform-specific error_code. 685/// @note On Windows, if the file does not have the FILE_ATTRIBUTE_READONLY 686/// attribute, all_all will be returned. Otherwise, all_read | all_exe 687/// will be returned. 688ErrorOr<perms> getPermissions(const Twine &Path); 689 690/// Get file size. 691/// 692/// @param Path Input path. 693/// @param Result Set to the size of the file in \a Path. 694/// @returns errc::success if result has been successfully set, otherwise a 695/// platform-specific error_code. 696inline std::error_code file_size(const Twine &Path, uint64_t &Result) { 697 file_status Status; 698 std::error_code EC = status(Path, Status); 699 if (EC) 700 return EC; 701 Result = Status.getSize(); 702 return std::error_code(); 703} 704 705/// Set the file modification and access time. 706/// 707/// @returns errc::success if the file times were successfully set, otherwise a 708/// platform-specific error_code or errc::function_not_supported on 709/// platforms where the functionality isn't available. 710std::error_code setLastAccessAndModificationTime(int FD, TimePoint<> AccessTime, 711 TimePoint<> ModificationTime); 712 713/// Simpler version that sets both file modification and access time to the same 714/// time. 715inline std::error_code setLastAccessAndModificationTime(int FD, 716 TimePoint<> Time) { 717 return setLastAccessAndModificationTime(FD, Time, Time); 718} 719 720/// Is status available? 721/// 722/// @param s Input file status. 723/// @returns True if status() != status_error. 724bool status_known(const basic_file_status &s); 725 726/// Is status available? 727/// 728/// @param path Input path. 729/// @param result Set to true if status() != status_error. 730/// @returns errc::success if result has been successfully set, otherwise a 731/// platform-specific error_code. 732std::error_code status_known(const Twine &path, bool &result); 733 734enum CreationDisposition : unsigned { 735 /// CD_CreateAlways - When opening a file: 736 /// * If it already exists, truncate it. 737 /// * If it does not already exist, create a new file. 738 CD_CreateAlways = 0, 739 740 /// CD_CreateNew - When opening a file: 741 /// * If it already exists, fail. 742 /// * If it does not already exist, create a new file. 743 CD_CreateNew = 1, 744 745 /// CD_OpenExisting - When opening a file: 746 /// * If it already exists, open the file with the offset set to 0. 747 /// * If it does not already exist, fail. 748 CD_OpenExisting = 2, 749 750 /// CD_OpenAlways - When opening a file: 751 /// * If it already exists, open the file with the offset set to 0. 752 /// * If it does not already exist, create a new file. 753 CD_OpenAlways = 3, 754}; 755 756enum FileAccess : unsigned { 757 FA_Read = 1, 758 FA_Write = 2, 759}; 760 761enum OpenFlags : unsigned { 762 OF_None = 0, 763 F_None = 0, // For compatibility 764 765 /// The file should be opened in text mode on platforms that make this 766 /// distinction. 767 OF_Text = 1, 768 F_Text = 1, // For compatibility 769 770 /// The file should be opened in append mode. 771 OF_Append = 2, 772 F_Append = 2, // For compatibility 773 774 /// Delete the file on close. Only makes a difference on windows. 775 OF_Delete = 4, 776 777 /// When a child process is launched, this file should remain open in the 778 /// child process. 779 OF_ChildInherit = 8, 780 781 /// Force files Atime to be updated on access. Only makes a difference on windows. 782 OF_UpdateAtime = 16, 783}; 784 785/// Create a potentially unique file name but does not create it. 786/// 787/// Generates a unique path suitable for a temporary file but does not 788/// open or create the file. The name is based on \a Model with '%' 789/// replaced by a random char in [0-9a-f]. If \a MakeAbsolute is true 790/// then the system's temp directory is prepended first. If \a MakeAbsolute 791/// is false the current directory will be used instead. 792/// 793/// This function does not check if the file exists. If you want to be sure 794/// that the file does not yet exist, you should use use enough '%' characters 795/// in your model to ensure this. Each '%' gives 4-bits of entropy so you can 796/// use 32 of them to get 128 bits of entropy. 797/// 798/// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s 799/// 800/// @param Model Name to base unique path off of. 801/// @param ResultPath Set to the file's path. 802/// @param MakeAbsolute Whether to use the system temp directory. 803void createUniquePath(const Twine &Model, SmallVectorImpl<char> &ResultPath, 804 bool MakeAbsolute); 805 806/// Create a uniquely named file. 807/// 808/// Generates a unique path suitable for a temporary file and then opens it as a 809/// file. The name is based on \a Model with '%' replaced by a random char in 810/// [0-9a-f]. If \a Model is not an absolute path, the temporary file will be 811/// created in the current directory. 812/// 813/// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s 814/// 815/// This is an atomic operation. Either the file is created and opened, or the 816/// file system is left untouched. 817/// 818/// The intended use is for files that are to be kept, possibly after 819/// renaming them. For example, when running 'clang -c foo.o', the file can 820/// be first created as foo-abc123.o and then renamed. 821/// 822/// @param Model Name to base unique path off of. 823/// @param ResultFD Set to the opened file's file descriptor. 824/// @param ResultPath Set to the opened file's absolute path. 825/// @returns errc::success if Result{FD,Path} have been successfully set, 826/// otherwise a platform-specific error_code. 827std::error_code createUniqueFile(const Twine &Model, int &ResultFD, 828 SmallVectorImpl<char> &ResultPath, 829 unsigned Mode = all_read | all_write); 830 831/// Simpler version for clients that don't want an open file. An empty 832/// file will still be created. 833std::error_code createUniqueFile(const Twine &Model, 834 SmallVectorImpl<char> &ResultPath, 835 unsigned Mode = all_read | all_write); 836 837/// Represents a temporary file. 838/// 839/// The temporary file must be eventually discarded or given a final name and 840/// kept. 841/// 842/// The destructor doesn't implicitly discard because there is no way to 843/// properly handle errors in a destructor. 844class TempFile { 845 bool Done = false; 846 TempFile(StringRef Name, int FD); 847 848public: 849 /// This creates a temporary file with createUniqueFile and schedules it for 850 /// deletion with sys::RemoveFileOnSignal. 851 static Expected<TempFile> create(const Twine &Model, 852 unsigned Mode = all_read | all_write); 853 TempFile(TempFile &&Other); 854 TempFile &operator=(TempFile &&Other); 855 856 // Name of the temporary file. 857 std::string TmpName; 858 859 // The open file descriptor. 860 int FD = -1; 861 862 // Keep this with the given name. 863 Error keep(const Twine &Name); 864 865 // Keep this with the temporary name. 866 Error keep(); 867 868 // Delete the file. 869 Error discard(); 870 871 // This checks that keep or delete was called. 872 ~TempFile(); 873}; 874 875/// Create a file in the system temporary directory. 876/// 877/// The filename is of the form prefix-random_chars.suffix. Since the directory 878/// is not know to the caller, Prefix and Suffix cannot have path separators. 879/// The files are created with mode 0600. 880/// 881/// This should be used for things like a temporary .s that is removed after 882/// running the assembler. 883std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, 884 int &ResultFD, 885 SmallVectorImpl<char> &ResultPath); 886 887/// Simpler version for clients that don't want an open file. An empty 888/// file will still be created. 889std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, 890 SmallVectorImpl<char> &ResultPath); 891 892std::error_code createUniqueDirectory(const Twine &Prefix, 893 SmallVectorImpl<char> &ResultPath); 894 895/// Get a unique name, not currently exisiting in the filesystem. Subject 896/// to race conditions, prefer to use createUniqueFile instead. 897/// 898/// Similar to createUniqueFile, but instead of creating a file only 899/// checks if it exists. This function is subject to race conditions, if you 900/// want to use the returned name to actually create a file, use 901/// createUniqueFile instead. 902std::error_code getPotentiallyUniqueFileName(const Twine &Model, 903 SmallVectorImpl<char> &ResultPath); 904 905/// Get a unique temporary file name, not currently exisiting in the 906/// filesystem. Subject to race conditions, prefer to use createTemporaryFile 907/// instead. 908/// 909/// Similar to createTemporaryFile, but instead of creating a file only 910/// checks if it exists. This function is subject to race conditions, if you 911/// want to use the returned name to actually create a file, use 912/// createTemporaryFile instead. 913std::error_code 914getPotentiallyUniqueTempFileName(const Twine &Prefix, StringRef Suffix, 915 SmallVectorImpl<char> &ResultPath); 916 917inline OpenFlags operator|(OpenFlags A, OpenFlags B) { 918 return OpenFlags(unsigned(A) | unsigned(B)); 919} 920 921inline OpenFlags &operator|=(OpenFlags &A, OpenFlags B) { 922 A = A | B; 923 return A; 924} 925 926inline FileAccess operator|(FileAccess A, FileAccess B) { 927 return FileAccess(unsigned(A) | unsigned(B)); 928} 929 930inline FileAccess &operator|=(FileAccess &A, FileAccess B) { 931 A = A | B; 932 return A; 933} 934 935/// @brief Opens a file with the specified creation disposition, access mode, 936/// and flags and returns a file descriptor. 937/// 938/// The caller is responsible for closing the file descriptor once they are 939/// finished with it. 940/// 941/// @param Name The path of the file to open, relative or absolute. 942/// @param ResultFD If the file could be opened successfully, its descriptor 943/// is stored in this location. Otherwise, this is set to -1. 944/// @param Disp Value specifying the existing-file behavior. 945/// @param Access Value specifying whether to open the file in read, write, or 946/// read-write mode. 947/// @param Flags Additional flags. 948/// @param Mode The access permissions of the file, represented in octal. 949/// @returns errc::success if \a Name has been opened, otherwise a 950/// platform-specific error_code. 951std::error_code openFile(const Twine &Name, int &ResultFD, 952 CreationDisposition Disp, FileAccess Access, 953 OpenFlags Flags, unsigned Mode = 0666); 954 955/// @brief Opens a file with the specified creation disposition, access mode, 956/// and flags and returns a platform-specific file object. 957/// 958/// The caller is responsible for closing the file object once they are 959/// finished with it. 960/// 961/// @param Name The path of the file to open, relative or absolute. 962/// @param Disp Value specifying the existing-file behavior. 963/// @param Access Value specifying whether to open the file in read, write, or 964/// read-write mode. 965/// @param Flags Additional flags. 966/// @param Mode The access permissions of the file, represented in octal. 967/// @returns errc::success if \a Name has been opened, otherwise a 968/// platform-specific error_code. 969Expected<file_t> openNativeFile(const Twine &Name, CreationDisposition Disp, 970 FileAccess Access, OpenFlags Flags, 971 unsigned Mode = 0666); 972 973/// Converts from a Posix file descriptor number to a native file handle. 974/// On Windows, this retreives the underlying handle. On non-Windows, this is a 975/// no-op. 976file_t convertFDToNativeFile(int FD); 977 978#ifndef _WIN32 979inline file_t convertFDToNativeFile(int FD) { return FD; } 980#endif 981 982/// Return an open handle to standard in. On Unix, this is typically FD 0. 983/// Returns kInvalidFile when the stream is closed. 984file_t getStdinHandle(); 985 986/// Return an open handle to standard out. On Unix, this is typically FD 1. 987/// Returns kInvalidFile when the stream is closed. 988file_t getStdoutHandle(); 989 990/// Return an open handle to standard error. On Unix, this is typically FD 2. 991/// Returns kInvalidFile when the stream is closed. 992file_t getStderrHandle(); 993 994/// Reads \p Buf.size() bytes from \p FileHandle into \p Buf. Returns the number 995/// of bytes actually read. On Unix, this is equivalent to `return ::read(FD, 996/// Buf.data(), Buf.size())`, with error reporting. Returns 0 when reaching EOF. 997/// 998/// @param FileHandle File to read from. 999/// @param Buf Buffer to read into. 1000/// @returns The number of bytes read, or error. 1001Expected<size_t> readNativeFile(file_t FileHandle, MutableArrayRef<char> Buf); 1002 1003/// Reads \p Buf.size() bytes from \p FileHandle at offset \p Offset into \p 1004/// Buf. If 'pread' is available, this will use that, otherwise it will use 1005/// 'lseek'. Returns the number of bytes actually read. Returns 0 when reaching 1006/// EOF. 1007/// 1008/// @param FileHandle File to read from. 1009/// @param Buf Buffer to read into. 1010/// @param Offset Offset into the file at which the read should occur. 1011/// @returns The number of bytes read, or error. 1012Expected<size_t> readNativeFileSlice(file_t FileHandle, 1013 MutableArrayRef<char> Buf, 1014 uint64_t Offset); 1015 1016/// @brief Opens the file with the given name in a write-only or read-write 1017/// mode, returning its open file descriptor. If the file does not exist, it 1018/// is created. 1019/// 1020/// The caller is responsible for closing the file descriptor once they are 1021/// finished with it. 1022/// 1023/// @param Name The path of the file to open, relative or absolute. 1024/// @param ResultFD If the file could be opened successfully, its descriptor 1025/// is stored in this location. Otherwise, this is set to -1. 1026/// @param Flags Additional flags used to determine whether the file should be 1027/// opened in, for example, read-write or in write-only mode. 1028/// @param Mode The access permissions of the file, represented in octal. 1029/// @returns errc::success if \a Name has been opened, otherwise a 1030/// platform-specific error_code. 1031inline std::error_code 1032openFileForWrite(const Twine &Name, int &ResultFD, 1033 CreationDisposition Disp = CD_CreateAlways, 1034 OpenFlags Flags = OF_None, unsigned Mode = 0666) { 1035 return openFile(Name, ResultFD, Disp, FA_Write, Flags, Mode); 1036} 1037 1038/// @brief Opens the file with the given name in a write-only or read-write 1039/// mode, returning its open file descriptor. If the file does not exist, it 1040/// is created. 1041/// 1042/// The caller is responsible for closing the freeing the file once they are 1043/// finished with it. 1044/// 1045/// @param Name The path of the file to open, relative or absolute. 1046/// @param Flags Additional flags used to determine whether the file should be 1047/// opened in, for example, read-write or in write-only mode. 1048/// @param Mode The access permissions of the file, represented in octal. 1049/// @returns a platform-specific file descriptor if \a Name has been opened, 1050/// otherwise an error object. 1051inline Expected<file_t> openNativeFileForWrite(const Twine &Name, 1052 CreationDisposition Disp, 1053 OpenFlags Flags, 1054 unsigned Mode = 0666) { 1055 return openNativeFile(Name, Disp, FA_Write, Flags, Mode); 1056} 1057 1058/// @brief Opens the file with the given name in a write-only or read-write 1059/// mode, returning its open file descriptor. If the file does not exist, it 1060/// is created. 1061/// 1062/// The caller is responsible for closing the file descriptor once they are 1063/// finished with it. 1064/// 1065/// @param Name The path of the file to open, relative or absolute. 1066/// @param ResultFD If the file could be opened successfully, its descriptor 1067/// is stored in this location. Otherwise, this is set to -1. 1068/// @param Flags Additional flags used to determine whether the file should be 1069/// opened in, for example, read-write or in write-only mode. 1070/// @param Mode The access permissions of the file, represented in octal. 1071/// @returns errc::success if \a Name has been opened, otherwise a 1072/// platform-specific error_code. 1073inline std::error_code openFileForReadWrite(const Twine &Name, int &ResultFD, 1074 CreationDisposition Disp, 1075 OpenFlags Flags, 1076 unsigned Mode = 0666) { 1077 return openFile(Name, ResultFD, Disp, FA_Write | FA_Read, Flags, Mode); 1078} 1079 1080/// @brief Opens the file with the given name in a write-only or read-write 1081/// mode, returning its open file descriptor. If the file does not exist, it 1082/// is created. 1083/// 1084/// The caller is responsible for closing the freeing the file once they are 1085/// finished with it. 1086/// 1087/// @param Name The path of the file to open, relative or absolute. 1088/// @param Flags Additional flags used to determine whether the file should be 1089/// opened in, for example, read-write or in write-only mode. 1090/// @param Mode The access permissions of the file, represented in octal. 1091/// @returns a platform-specific file descriptor if \a Name has been opened, 1092/// otherwise an error object. 1093inline Expected<file_t> openNativeFileForReadWrite(const Twine &Name, 1094 CreationDisposition Disp, 1095 OpenFlags Flags, 1096 unsigned Mode = 0666) { 1097 return openNativeFile(Name, Disp, FA_Write | FA_Read, Flags, Mode); 1098} 1099 1100/// @brief Opens the file with the given name in a read-only mode, returning 1101/// its open file descriptor. 1102/// 1103/// The caller is responsible for closing the file descriptor once they are 1104/// finished with it. 1105/// 1106/// @param Name The path of the file to open, relative or absolute. 1107/// @param ResultFD If the file could be opened successfully, its descriptor 1108/// is stored in this location. Otherwise, this is set to -1. 1109/// @param RealPath If nonnull, extra work is done to determine the real path 1110/// of the opened file, and that path is stored in this 1111/// location. 1112/// @returns errc::success if \a Name has been opened, otherwise a 1113/// platform-specific error_code. 1114std::error_code openFileForRead(const Twine &Name, int &ResultFD, 1115 OpenFlags Flags = OF_None, 1116 SmallVectorImpl<char> *RealPath = nullptr); 1117 1118/// @brief Opens the file with the given name in a read-only mode, returning 1119/// its open file descriptor. 1120/// 1121/// The caller is responsible for closing the freeing the file once they are 1122/// finished with it. 1123/// 1124/// @param Name The path of the file to open, relative or absolute. 1125/// @param RealPath If nonnull, extra work is done to determine the real path 1126/// of the opened file, and that path is stored in this 1127/// location. 1128/// @returns a platform-specific file descriptor if \a Name has been opened, 1129/// otherwise an error object. 1130Expected<file_t> 1131openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None, 1132 SmallVectorImpl<char> *RealPath = nullptr); 1133 1134/// @brief Close the file object. This should be used instead of ::close for 1135/// portability. On error, the caller should assume the file is closed, as is 1136/// the case for Process::SafelyCloseFileDescriptor 1137/// 1138/// @param F On input, this is the file to close. On output, the file is 1139/// set to kInvalidFile. 1140/// 1141/// @returns An error code if closing the file failed. Typically, an error here 1142/// means that the filesystem may have failed to perform some buffered writes. 1143std::error_code closeFile(file_t &F); 1144 1145std::error_code getUniqueID(const Twine Path, UniqueID &Result); 1146 1147/// Get disk space usage information. 1148/// 1149/// Note: Users must be careful about "Time Of Check, Time Of Use" kind of bug. 1150/// Note: Windows reports results according to the quota allocated to the user. 1151/// 1152/// @param Path Input path. 1153/// @returns a space_info structure filled with the capacity, free, and 1154/// available space on the device \a Path is on. A platform specific error_code 1155/// is returned on error. 1156ErrorOr<space_info> disk_space(const Twine &Path); 1157 1158/// This class represents a memory mapped file. It is based on 1159/// boost::iostreams::mapped_file. 1160class mapped_file_region { 1161public: 1162 enum mapmode { 1163 readonly, ///< May only access map via const_data as read only. 1164 readwrite, ///< May access map via data and modify it. Written to path. 1165 priv ///< May modify via data, but changes are lost on destruction. 1166 }; 1167 1168private: 1169 /// Platform-specific mapping state. 1170 size_t Size; 1171 void *Mapping; 1172#ifdef _WIN32 1173 sys::fs::file_t FileHandle; 1174#endif 1175 mapmode Mode; 1176 1177 std::error_code init(sys::fs::file_t FD, uint64_t Offset, mapmode Mode); 1178 1179public: 1180 mapped_file_region() = delete; 1181 mapped_file_region(mapped_file_region&) = delete; 1182 mapped_file_region &operator =(mapped_file_region&) = delete; 1183 1184 /// \param fd An open file descriptor to map. Does not take ownership of fd. 1185 mapped_file_region(sys::fs::file_t fd, mapmode mode, size_t length, uint64_t offset, 1186 std::error_code &ec); 1187 1188 ~mapped_file_region(); 1189 1190 size_t size() const; 1191 char *data() const; 1192 1193 /// Get a const view of the data. Modifying this memory has undefined 1194 /// behavior. 1195 const char *const_data() const; 1196 1197 /// \returns The minimum alignment offset must be. 1198 static int alignment(); 1199}; 1200 1201/// Return the path to the main executable, given the value of argv[0] from 1202/// program startup and the address of main itself. In extremis, this function 1203/// may fail and return an empty path. 1204std::string getMainExecutable(const char *argv0, void *MainExecAddr); 1205 1206/// @} 1207/// @name Iterators 1208/// @{ 1209 1210/// directory_entry - A single entry in a directory. 1211class directory_entry { 1212 // FIXME: different platforms make different information available "for free" 1213 // when traversing a directory. The design of this class wraps most of the 1214 // information in basic_file_status, so on platforms where we can't populate 1215 // that whole structure, callers end up paying for a stat(). 1216 // std::filesystem::directory_entry may be a better model. 1217 std::string Path; 1218 file_type Type = file_type::type_unknown; // Most platforms can provide this. 1219 bool FollowSymlinks = true; // Affects the behavior of status(). 1220 basic_file_status Status; // If available. 1221 1222public: 1223 explicit directory_entry(const Twine &Path, bool FollowSymlinks = true, 1224 file_type Type = file_type::type_unknown, 1225 basic_file_status Status = basic_file_status()) 1226 : Path(Path.str()), Type(Type), FollowSymlinks(FollowSymlinks), 1227 Status(Status) {} 1228 1229 directory_entry() = default; 1230 1231 void replace_filename(const Twine &Filename, file_type Type, 1232 basic_file_status Status = basic_file_status()); 1233 1234 const std::string &path() const { return Path; } 1235 // Get basic information about entry file (a subset of fs::status()). 1236 // On most platforms this is a stat() call. 1237 // On windows the information was already retrieved from the directory. 1238 ErrorOr<basic_file_status> status() const; 1239 // Get the type of this file. 1240 // On most platforms (Linux/Mac/Windows/BSD), this was already retrieved. 1241 // On some platforms (e.g. Solaris) this is a stat() call. 1242 file_type type() const { 1243 if (Type != file_type::type_unknown) 1244 return Type; 1245 auto S = status(); 1246 return S ? S->type() : file_type::type_unknown; 1247 } 1248 1249 bool operator==(const directory_entry& RHS) const { return Path == RHS.Path; } 1250 bool operator!=(const directory_entry& RHS) const { return !(*this == RHS); } 1251 bool operator< (const directory_entry& RHS) const; 1252 bool operator<=(const directory_entry& RHS) const; 1253 bool operator> (const directory_entry& RHS) const; 1254 bool operator>=(const directory_entry& RHS) const; 1255}; 1256 1257namespace detail { 1258 1259 struct DirIterState; 1260 1261 std::error_code directory_iterator_construct(DirIterState &, StringRef, bool); 1262 std::error_code directory_iterator_increment(DirIterState &); 1263 std::error_code directory_iterator_destruct(DirIterState &); 1264 1265 /// Keeps state for the directory_iterator. 1266 struct DirIterState { 1267 ~DirIterState() { 1268 directory_iterator_destruct(*this); 1269 } 1270 1271 intptr_t IterationHandle = 0; 1272 directory_entry CurrentEntry; 1273 }; 1274 1275} // end namespace detail 1276 1277/// directory_iterator - Iterates through the entries in path. There is no 1278/// operator++ because we need an error_code. If it's really needed we can make 1279/// it call report_fatal_error on error. 1280class directory_iterator { 1281 std::shared_ptr<detail::DirIterState> State; 1282 bool FollowSymlinks = true; 1283 1284public: 1285 explicit directory_iterator(const Twine &path, std::error_code &ec, 1286 bool follow_symlinks = true) 1287 : FollowSymlinks(follow_symlinks) { 1288 State = std::make_shared<detail::DirIterState>(); 1289 SmallString<128> path_storage; 1290 ec = detail::directory_iterator_construct( 1291 *State, path.toStringRef(path_storage), FollowSymlinks); 1292 } 1293 1294 explicit directory_iterator(const directory_entry &de, std::error_code &ec, 1295 bool follow_symlinks = true) 1296 : FollowSymlinks(follow_symlinks) { 1297 State = std::make_shared<detail::DirIterState>(); 1298 ec = detail::directory_iterator_construct( 1299 *State, de.path(), FollowSymlinks); 1300 } 1301 1302 /// Construct end iterator. 1303 directory_iterator() = default; 1304 1305 // No operator++ because we need error_code. 1306 directory_iterator &increment(std::error_code &ec) { 1307 ec = directory_iterator_increment(*State); 1308 return *this; 1309 } 1310 1311 const directory_entry &operator*() const { return State->CurrentEntry; } 1312 const directory_entry *operator->() const { return &State->CurrentEntry; } 1313 1314 bool operator==(const directory_iterator &RHS) const { 1315 if (State == RHS.State) 1316 return true; 1317 if (!RHS.State) 1318 return State->CurrentEntry == directory_entry(); 1319 if (!State) 1320 return RHS.State->CurrentEntry == directory_entry(); 1321 return State->CurrentEntry == RHS.State->CurrentEntry; 1322 } 1323 1324 bool operator!=(const directory_iterator &RHS) const { 1325 return !(*this == RHS); 1326 } 1327}; 1328 1329namespace detail { 1330 1331 /// Keeps state for the recursive_directory_iterator. 1332 struct RecDirIterState { 1333 std::stack<directory_iterator, std::vector<directory_iterator>> Stack; 1334 uint16_t Level = 0; 1335 bool HasNoPushRequest = false; 1336 }; 1337 1338} // end namespace detail 1339 1340/// recursive_directory_iterator - Same as directory_iterator except for it 1341/// recurses down into child directories. 1342class recursive_directory_iterator { 1343 std::shared_ptr<detail::RecDirIterState> State; 1344 bool Follow; 1345 1346public: 1347 recursive_directory_iterator() = default; 1348 explicit recursive_directory_iterator(const Twine &path, std::error_code &ec, 1349 bool follow_symlinks = true) 1350 : State(std::make_shared<detail::RecDirIterState>()), 1351 Follow(follow_symlinks) { 1352 State->Stack.push(directory_iterator(path, ec, Follow)); 1353 if (State->Stack.top() == directory_iterator()) 1354 State.reset(); 1355 } 1356 1357 // No operator++ because we need error_code. 1358 recursive_directory_iterator &increment(std::error_code &ec) { 1359 const directory_iterator end_itr = {}; 1360 1361 if (State->HasNoPushRequest) 1362 State->HasNoPushRequest = false; 1363 else { 1364 file_type type = State->Stack.top()->type(); 1365 if (type == file_type::symlink_file && Follow) { 1366 // Resolve the symlink: is it a directory to recurse into? 1367 ErrorOr<basic_file_status> status = State->Stack.top()->status(); 1368 if (status) 1369 type = status->type(); 1370 // Otherwise broken symlink, and we'll continue. 1371 } 1372 if (type == file_type::directory_file) { 1373 State->Stack.push(directory_iterator(*State->Stack.top(), ec, Follow)); 1374 if (State->Stack.top() != end_itr) { 1375 ++State->Level; 1376 return *this; 1377 } 1378 State->Stack.pop(); 1379 } 1380 } 1381 1382 while (!State->Stack.empty() 1383 && State->Stack.top().increment(ec) == end_itr) { 1384 State->Stack.pop(); 1385 --State->Level; 1386 } 1387 1388 // Check if we are done. If so, create an end iterator. 1389 if (State->Stack.empty()) 1390 State.reset(); 1391 1392 return *this; 1393 } 1394 1395 const directory_entry &operator*() const { return *State->Stack.top(); } 1396 const directory_entry *operator->() const { return &*State->Stack.top(); } 1397 1398 // observers 1399 /// Gets the current level. Starting path is at level 0. 1400 int level() const { return State->Level; } 1401 1402 /// Returns true if no_push has been called for this directory_entry. 1403 bool no_push_request() const { return State->HasNoPushRequest; } 1404 1405 // modifiers 1406 /// Goes up one level if Level > 0. 1407 void pop() { 1408 assert(State && "Cannot pop an end iterator!"); 1409 assert(State->Level > 0 && "Cannot pop an iterator with level < 1"); 1410 1411 const directory_iterator end_itr = {}; 1412 std::error_code ec; 1413 do { 1414 if (ec) 1415 report_fatal_error("Error incrementing directory iterator."); 1416 State->Stack.pop(); 1417 --State->Level; 1418 } while (!State->Stack.empty() 1419 && State->Stack.top().increment(ec) == end_itr); 1420 1421 // Check if we are done. If so, create an end iterator. 1422 if (State->Stack.empty()) 1423 State.reset(); 1424 } 1425 1426 /// Does not go down into the current directory_entry. 1427 void no_push() { State->HasNoPushRequest = true; } 1428 1429 bool operator==(const recursive_directory_iterator &RHS) const { 1430 return State == RHS.State; 1431 } 1432 1433 bool operator!=(const recursive_directory_iterator &RHS) const { 1434 return !(*this == RHS); 1435 } 1436}; 1437 1438/// @} 1439 1440} // end namespace fs 1441} // end namespace sys 1442} // end namespace llvm 1443 1444#endif // LLVM_SUPPORT_FILESYSTEM_H 1445