1 //===- llvm/Support/FileSystem.h - File System OS Concept -------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
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
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
24 //===----------------------------------------------------------------------===//
26 #ifndef LLVM_SUPPORT_FILESYSTEM_H
27 #define LLVM_SUPPORT_FILESYSTEM_H
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"
44 #include <system_error>
48 #ifdef HAVE_SYS_STAT_H
57 // A Win32 HANDLE is a typedef of void*
58 using file_t
= void *;
63 extern const file_t kInvalidFile
;
65 /// An enumeration for the file system's view of the type.
66 enum class file_type
{
79 /// space_info - Self explanatory.
91 owner_all
= owner_read
| owner_write
| owner_exe
,
95 group_all
= group_read
| group_write
| group_exe
,
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,
107 all_perms
= all_all
| set_uid_on_exe
| set_gid_on_exe
| sticky_bit
,
108 perms_not_known
= 0xFFFF
111 // Helper functions so that you can use & and | to manipulate perms bits:
112 inline perms
operator|(perms l
, perms r
) {
113 return static_cast<perms
>(static_cast<unsigned short>(l
) |
114 static_cast<unsigned short>(r
));
116 inline perms
operator&(perms l
, perms r
) {
117 return static_cast<perms
>(static_cast<unsigned short>(l
) &
118 static_cast<unsigned short>(r
));
120 inline perms
&operator|=(perms
&l
, perms r
) {
124 inline perms
&operator&=(perms
&l
, perms r
) {
128 inline 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
)));
139 UniqueID() = default;
140 UniqueID(uint64_t Device
, uint64_t File
) : Device(Device
), File(File
) {}
142 bool operator==(const UniqueID
&Other
) const {
143 return Device
== Other
.Device
&& File
== Other
.File
;
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
);
150 uint64_t getDevice() const { return Device
; }
151 uint64_t getFile() const { return File
; }
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.
157 class basic_file_status
{
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;
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;
175 file_type Type
= file_type::status_error
;
176 perms Perms
= perms_not_known
;
179 basic_file_status() = default;
181 explicit basic_file_status(file_type Type
) : Type(Type
) {}
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
) {}
204 file_type
type() const { return Type
; }
205 perms
permissions() const { return Perms
; }
207 /// The file access time as reported from the underlying file system.
209 /// Also see comments on \c getLastModificationTime() related to the precision
210 /// of the returned value.
211 TimePoint
<> getLastAccessedTime() const;
213 /// The file modification time as reported from the underlying file system.
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
220 TimePoint
<> getLastModificationTime() const;
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...
231 uint32_t getGroup() const {
232 return 9999; // Not applicable to Windows, so...
235 uint64_t getSize() const {
236 return (uint64_t(FileSizeHigh
) << 32) + FileSizeLow
;
241 void type(file_type v
) { Type
= v
; }
242 void permissions(perms p
) { Perms
= p
; }
245 /// Represents the result of a call to sys::fs::status().
246 class file_status
: public basic_file_status
{
247 friend bool equivalent(file_status A
, file_status B
);
249 #if defined(LLVM_ON_UNIX)
251 nlink_t fs_st_nlinks
= 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;
261 file_status() = default;
263 explicit file_status(file_type Type
) : basic_file_status(Type
) {}
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
,
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
,
283 NumLinks(LinkCount
), VolumeSerialNumber(VolumeSerialNumber
),
284 FileIndexHigh(FileIndexHigh
), FileIndexLow(FileIndexLow
) {}
287 UniqueID
getUniqueID() const;
288 uint32_t getLinkCount() const;
292 /// @name Physical Operators
295 /// Make \a path an absolute path.
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.
300 /// /absolute/path => /absolute/path
301 /// relative/../path => <current-directory>/relative/../path
303 /// @param path A path that is modified to be an absolute path.
304 void make_absolute(const Twine
¤t_directory
, SmallVectorImpl
<char> &path
);
306 /// Make \a path an absolute path.
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.
311 /// /absolute/path => /absolute/path
312 /// relative/../path => <current-directory>/relative/../path
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.
317 std::error_code
make_absolute(SmallVectorImpl
<char> &path
);
319 /// Create all the non-existent directories in path.
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.
325 std::error_code
create_directories(const Twine
&path
,
326 bool IgnoreExisting
= true,
327 perms Perms
= owner_all
| group_all
);
329 /// Create the directory in path.
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.
335 std::error_code
create_directory(const Twine
&path
, bool IgnoreExisting
= true,
336 perms Perms
= owner_all
| group_all
);
338 /// Create a link from \a from to \a to.
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.
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.
349 std::error_code
create_link(const Twine
&to
, const Twine
&from
);
351 /// Create a hard link from \a from to \a to, or return an error.
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.
357 std::error_code
create_hard_link(const Twine
&to
, const Twine
&from
);
359 /// Collapse all . and .. patterns, resolve all symlinks, and optionally
360 /// expand ~ expressions to the user's home directory.
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
366 std::error_code
real_path(const Twine
&path
, SmallVectorImpl
<char> &output
,
367 bool expand_tilde
= false);
369 /// Expands ~ expressions to the user's home directory. On Unix ~user
370 /// directories are resolved as well.
372 /// @param path The path to resolve.
373 void expand_tilde(const Twine
&path
, SmallVectorImpl
<char> &output
);
375 /// Get the current path.
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.
380 std::error_code
current_path(SmallVectorImpl
<char> &result
);
382 /// Set the current path.
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.
387 std::error_code
set_current_path(const Twine
&path
);
389 /// Remove path. Equivalent to POSIX remove().
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.
395 std::error_code
remove(const Twine
&path
, bool IgnoreNonExisting
= true);
397 /// Recursively delete a directory.
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.
402 std::error_code
remove_directories(const Twine
&path
, bool IgnoreErrors
= true);
404 /// Rename \a from to \a to.
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
410 /// @param from The path to rename from.
411 /// @param to The path to rename to. This is created.
412 std::error_code
rename(const Twine
&from
, const Twine
&to
);
414 /// Copy the contents of \a From to \a To.
416 /// @param From The path to copy from.
417 /// @param To The path to copy to. This is created.
418 std::error_code
copy_file(const Twine
&From
, const Twine
&To
);
420 /// Copy the contents of \a From to \a To.
422 /// @param From The path to copy from.
423 /// @param ToFD The open file descriptor of the destination file.
424 std::error_code
copy_file(const Twine
&From
, int ToFD
);
426 /// Resize path to size. File is resized as if by POSIX truncate().
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.
432 std::error_code
resize_file(int FD
, uint64_t Size
);
434 /// Compute an MD5 hash of a file's contents.
436 /// @param FD Input file descriptor.
437 /// @returns An MD5Result with the hash computed, if successful, otherwise a
439 ErrorOr
<MD5::MD5Result
> md5_contents(int FD
);
441 /// Version of compute_md5 that doesn't require an open file descriptor.
442 ErrorOr
<MD5::MD5Result
> md5_contents(const Twine
&Path
);
445 /// @name Physical Observers
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
453 bool exists(const basic_file_status
&status
);
455 enum class AccessMode
{ Exist
, Write
, Execute
};
457 /// Can the file be accessed?
459 /// @param Path Input path.
460 /// @returns errc::success if the path can be accessed, otherwise a
461 /// platform-specific error_code.
462 std::error_code
access(const Twine
&Path
, AccessMode Mode
);
466 /// @param Path Input path.
467 /// @returns True if it exists, false otherwise.
468 inline bool exists(const Twine
&Path
) {
469 return !access(Path
, AccessMode::Exist
);
472 /// Can we execute this file?
474 /// @param Path Input path.
475 /// @returns True if we can execute it, false otherwise.
476 bool can_execute(const Twine
&Path
);
478 /// Can we write this file?
480 /// @param Path Input path.
481 /// @returns True if we can write to it, false otherwise.
482 inline bool can_write(const Twine
&Path
) {
483 return !access(Path
, AccessMode::Write
);
486 /// Do file_status's represent the same thing?
488 /// @param A Input file_status.
489 /// @param B Input file_status.
491 /// assert(status_known(A) || status_known(B));
493 /// @returns True if A and B both represent the same file system entity, false
495 bool equivalent(file_status A
, file_status B
);
497 /// Do paths represent the same thing?
499 /// assert(status_known(A) || status_known(B));
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.
507 std::error_code
equivalent(const Twine
&A
, const Twine
&B
, bool &result
);
509 /// Simpler version of equivalent for clients that don't need to
510 /// differentiate between an error and false.
511 inline bool equivalent(const Twine
&A
, const Twine
&B
) {
513 return !equivalent(A
, B
, result
) && result
;
516 /// Is the file mounted on a local filesystem?
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.
523 std::error_code
is_local(const Twine
&path
, bool &result
);
525 /// Version of is_local accepting an open file descriptor.
526 std::error_code
is_local(int FD
, bool &result
);
528 /// Simpler version of is_local for clients that don't need to
529 /// differentiate between an error and false.
530 inline bool is_local(const Twine
&Path
) {
532 return !is_local(Path
, Result
) && Result
;
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.
537 inline bool is_local(int FD
) {
539 return !is_local(FD
, Result
) && Result
;
542 /// Does status represent a directory?
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.
548 file_type
get_file_type(const Twine
&Path
, bool Follow
= true);
550 /// Does status represent a directory?
552 /// @param status A basic_file_status previously returned from status.
553 /// @returns status.type() == file_type::directory_file.
554 bool is_directory(const basic_file_status
&status
);
556 /// Is path a directory?
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.
563 std::error_code
is_directory(const Twine
&path
, bool &result
);
565 /// Simpler version of is_directory for clients that don't need to
566 /// differentiate between an error and false.
567 inline bool is_directory(const Twine
&Path
) {
569 return !is_directory(Path
, Result
) && Result
;
572 /// Does status represent a regular file?
574 /// @param status A basic_file_status previously returned from status.
575 /// @returns status_known(status) && status.type() == file_type::regular_file.
576 bool is_regular_file(const basic_file_status
&status
);
578 /// Is path a regular file?
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.
585 std::error_code
is_regular_file(const Twine
&path
, bool &result
);
587 /// Simpler version of is_regular_file for clients that don't need to
588 /// differentiate between an error and false.
589 inline bool is_regular_file(const Twine
&Path
) {
591 if (is_regular_file(Path
, Result
))
596 /// Does status represent a symlink file?
598 /// @param status A basic_file_status previously returned from status.
599 /// @returns status_known(status) && status.type() == file_type::symlink_file.
600 bool is_symlink_file(const basic_file_status
&status
);
602 /// Is path a symlink file?
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.
609 std::error_code
is_symlink_file(const Twine
&path
, bool &result
);
611 /// Simpler version of is_symlink_file for clients that don't need to
612 /// differentiate between an error and false.
613 inline bool is_symlink_file(const Twine
&Path
) {
615 if (is_symlink_file(Path
, Result
))
620 /// Does this status represent something that exists but is not a
621 /// directory or regular file?
623 /// @param status A basic_file_status previously returned from status.
624 /// @returns exists(s) && !is_regular_file(s) && !is_directory(s)
625 bool is_other(const basic_file_status
&status
);
627 /// Is path something that exists but is not a directory,
628 /// regular file, or symlink?
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.
635 std::error_code
is_other(const Twine
&path
, bool &result
);
637 /// Get file status as if by POSIX stat().
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
643 /// @returns errc::success if result has been successfully set, otherwise a
644 /// platform-specific error_code.
645 std::error_code
status(const Twine
&path
, file_status
&result
,
648 /// A version for when a file descriptor is already available.
649 std::error_code
status(int FD
, file_status
&Result
);
652 /// A version for when a file descriptor is already available.
653 std::error_code
status(file_t FD
, file_status
&Result
);
656 /// Get file creation mode mask of the process.
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.
664 /// Set file permissions.
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.
673 std::error_code
setPermissions(const Twine
&Path
, perms Permissions
);
675 /// Vesion of setPermissions accepting a file descriptor.
676 /// TODO Delete the path based overload once we implement the FD based overload
678 std::error_code
setPermissions(int FD
, perms Permissions
);
680 /// Get file permissions.
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.
688 ErrorOr
<perms
> getPermissions(const Twine
&Path
);
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.
696 inline std::error_code
file_size(const Twine
&Path
, uint64_t &Result
) {
698 std::error_code EC
= status(Path
, Status
);
701 Result
= Status
.getSize();
702 return std::error_code();
705 /// Set the file modification and access time.
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.
710 std::error_code
setLastAccessAndModificationTime(int FD
, TimePoint
<> AccessTime
,
711 TimePoint
<> ModificationTime
);
713 /// Simpler version that sets both file modification and access time to the same
715 inline std::error_code
setLastAccessAndModificationTime(int FD
,
717 return setLastAccessAndModificationTime(FD
, Time
, Time
);
720 /// Is status available?
722 /// @param s Input file status.
723 /// @returns True if status() != status_error.
724 bool status_known(const basic_file_status
&s
);
726 /// Is status available?
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.
732 std::error_code
status_known(const Twine
&path
, bool &result
);
734 enum 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.
740 /// CD_CreateNew - When opening a file:
741 /// * If it already exists, fail.
742 /// * If it does not already exist, create a new file.
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.
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.
756 enum FileAccess
: unsigned {
761 enum OpenFlags
: unsigned {
763 F_None
= 0, // For compatibility
765 /// The file should be opened in text mode on platforms that make this
768 F_Text
= 1, // For compatibility
770 /// The file should be opened in append mode.
772 F_Append
= 2, // For compatibility
774 /// Delete the file on close. Only makes a difference on windows.
777 /// When a child process is launched, this file should remain open in the
781 /// Force files Atime to be updated on access. Only makes a difference on windows.
785 /// Create a potentially unique file name but does not create it.
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.
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.
798 /// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s
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.
803 void createUniquePath(const Twine
&Model
, SmallVectorImpl
<char> &ResultPath
,
806 /// Create a uniquely named file.
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.
813 /// Example: clang-%%-%%-%%-%%-%%.s => clang-a0-b1-c2-d3-e4.s
815 /// This is an atomic operation. Either the file is created and opened, or the
816 /// file system is left untouched.
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.
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.
827 std::error_code
createUniqueFile(const Twine
&Model
, int &ResultFD
,
828 SmallVectorImpl
<char> &ResultPath
,
829 unsigned Mode
= all_read
| all_write
);
831 /// Simpler version for clients that don't want an open file. An empty
832 /// file will still be created.
833 std::error_code
createUniqueFile(const Twine
&Model
,
834 SmallVectorImpl
<char> &ResultPath
,
835 unsigned Mode
= all_read
| all_write
);
837 /// Represents a temporary file.
839 /// The temporary file must be eventually discarded or given a final name and
842 /// The destructor doesn't implicitly discard because there is no way to
843 /// properly handle errors in a destructor.
846 TempFile(StringRef Name
, int FD
);
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
);
856 // Name of the temporary file.
859 // The open file descriptor.
862 // Keep this with the given name.
863 Error
keep(const Twine
&Name
);
865 // Keep this with the temporary name.
871 // This checks that keep or delete was called.
875 /// Create a file in the system temporary directory.
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.
881 /// This should be used for things like a temporary .s that is removed after
882 /// running the assembler.
883 std::error_code
createTemporaryFile(const Twine
&Prefix
, StringRef Suffix
,
885 SmallVectorImpl
<char> &ResultPath
);
887 /// Simpler version for clients that don't want an open file. An empty
888 /// file will still be created.
889 std::error_code
createTemporaryFile(const Twine
&Prefix
, StringRef Suffix
,
890 SmallVectorImpl
<char> &ResultPath
);
892 std::error_code
createUniqueDirectory(const Twine
&Prefix
,
893 SmallVectorImpl
<char> &ResultPath
);
895 /// Get a unique name, not currently exisiting in the filesystem. Subject
896 /// to race conditions, prefer to use createUniqueFile instead.
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.
902 std::error_code
getPotentiallyUniqueFileName(const Twine
&Model
,
903 SmallVectorImpl
<char> &ResultPath
);
905 /// Get a unique temporary file name, not currently exisiting in the
906 /// filesystem. Subject to race conditions, prefer to use createTemporaryFile
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.
914 getPotentiallyUniqueTempFileName(const Twine
&Prefix
, StringRef Suffix
,
915 SmallVectorImpl
<char> &ResultPath
);
917 inline OpenFlags
operator|(OpenFlags A
, OpenFlags B
) {
918 return OpenFlags(unsigned(A
) | unsigned(B
));
921 inline OpenFlags
&operator|=(OpenFlags
&A
, OpenFlags B
) {
926 inline FileAccess
operator|(FileAccess A
, FileAccess B
) {
927 return FileAccess(unsigned(A
) | unsigned(B
));
930 inline FileAccess
&operator|=(FileAccess
&A
, FileAccess B
) {
935 /// @brief Opens a file with the specified creation disposition, access mode,
936 /// and flags and returns a file descriptor.
938 /// The caller is responsible for closing the file descriptor once they are
939 /// finished with it.
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
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.
951 std::error_code
openFile(const Twine
&Name
, int &ResultFD
,
952 CreationDisposition Disp
, FileAccess Access
,
953 OpenFlags Flags
, unsigned Mode
= 0666);
955 /// @brief Opens a file with the specified creation disposition, access mode,
956 /// and flags and returns a platform-specific file object.
958 /// The caller is responsible for closing the file object once they are
959 /// finished with it.
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
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.
969 Expected
<file_t
> openNativeFile(const Twine
&Name
, CreationDisposition Disp
,
970 FileAccess Access
, OpenFlags Flags
,
971 unsigned Mode
= 0666);
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
976 file_t
convertFDToNativeFile(int FD
);
979 inline file_t
convertFDToNativeFile(int FD
) { return FD
; }
982 /// Return an open handle to standard in. On Unix, this is typically FD 0.
983 /// Returns kInvalidFile when the stream is closed.
984 file_t
getStdinHandle();
986 /// Return an open handle to standard out. On Unix, this is typically FD 1.
987 /// Returns kInvalidFile when the stream is closed.
988 file_t
getStdoutHandle();
990 /// Return an open handle to standard error. On Unix, this is typically FD 2.
991 /// Returns kInvalidFile when the stream is closed.
992 file_t
getStderrHandle();
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.
998 /// @param FileHandle File to read from.
999 /// @param Buf Buffer to read into.
1000 /// @returns The number of bytes read, or error.
1001 Expected
<size_t> readNativeFile(file_t FileHandle
, MutableArrayRef
<char> Buf
);
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
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.
1012 Expected
<size_t> readNativeFileSlice(file_t FileHandle
,
1013 MutableArrayRef
<char> Buf
,
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
1020 /// The caller is responsible for closing the file descriptor once they are
1021 /// finished with it.
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.
1031 inline std::error_code
1032 openFileForWrite(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
);
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
1042 /// The caller is responsible for closing the freeing the file once they are
1043 /// finished with it.
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.
1051 inline Expected
<file_t
> openNativeFileForWrite(const Twine
&Name
,
1052 CreationDisposition Disp
,
1054 unsigned Mode
= 0666) {
1055 return openNativeFile(Name
, Disp
, FA_Write
, Flags
, Mode
);
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
1062 /// The caller is responsible for closing the file descriptor once they are
1063 /// finished with it.
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.
1073 inline std::error_code
openFileForReadWrite(const Twine
&Name
, int &ResultFD
,
1074 CreationDisposition Disp
,
1076 unsigned Mode
= 0666) {
1077 return openFile(Name
, ResultFD
, Disp
, FA_Write
| FA_Read
, Flags
, Mode
);
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
1084 /// The caller is responsible for closing the freeing the file once they are
1085 /// finished with it.
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.
1093 inline Expected
<file_t
> openNativeFileForReadWrite(const Twine
&Name
,
1094 CreationDisposition Disp
,
1096 unsigned Mode
= 0666) {
1097 return openNativeFile(Name
, Disp
, FA_Write
| FA_Read
, Flags
, Mode
);
1100 /// @brief Opens the file with the given name in a read-only mode, returning
1101 /// its open file descriptor.
1103 /// The caller is responsible for closing the file descriptor once they are
1104 /// finished with it.
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
1112 /// @returns errc::success if \a Name has been opened, otherwise a
1113 /// platform-specific error_code.
1114 std::error_code
openFileForRead(const Twine
&Name
, int &ResultFD
,
1115 OpenFlags Flags
= OF_None
,
1116 SmallVectorImpl
<char> *RealPath
= nullptr);
1118 /// @brief Opens the file with the given name in a read-only mode, returning
1119 /// its open file descriptor.
1121 /// The caller is responsible for closing the freeing the file once they are
1122 /// finished with it.
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
1128 /// @returns a platform-specific file descriptor if \a Name has been opened,
1129 /// otherwise an error object.
1131 openNativeFileForRead(const Twine
&Name
, OpenFlags Flags
= OF_None
,
1132 SmallVectorImpl
<char> *RealPath
= nullptr);
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
1138 /// @param F On input, this is the file to close. On output, the file is
1139 /// set to kInvalidFile.
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.
1143 std::error_code
closeFile(file_t
&F
);
1145 std::error_code
getUniqueID(const Twine Path
, UniqueID
&Result
);
1147 /// Get disk space usage information.
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.
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.
1156 ErrorOr
<space_info
> disk_space(const Twine
&Path
);
1158 /// This class represents a memory mapped file. It is based on
1159 /// boost::iostreams::mapped_file.
1160 class mapped_file_region
{
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.
1169 /// Platform-specific mapping state.
1173 sys::fs::file_t FileHandle
;
1177 std::error_code
init(sys::fs::file_t FD
, uint64_t Offset
, mapmode Mode
);
1180 mapped_file_region() = delete;
1181 mapped_file_region(mapped_file_region
&) = delete;
1182 mapped_file_region
&operator =(mapped_file_region
&) = delete;
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
);
1188 ~mapped_file_region();
1190 size_t size() const;
1193 /// Get a const view of the data. Modifying this memory has undefined
1195 const char *const_data() const;
1197 /// \returns The minimum alignment offset must be.
1198 static int alignment();
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.
1204 std::string
getMainExecutable(const char *argv0
, void *MainExecAddr
);
1210 /// directory_entry - A single entry in a directory.
1211 class 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.
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.
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
),
1229 directory_entry() = default;
1231 void replace_filename(const Twine
&Filename
, file_type Type
,
1232 basic_file_status Status
= basic_file_status());
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
)
1246 return S
? S
->type() : file_type::type_unknown
;
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;
1259 struct DirIterState
;
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
&);
1265 /// Keeps state for the directory_iterator.
1266 struct DirIterState
{
1268 directory_iterator_destruct(*this);
1271 intptr_t IterationHandle
= 0;
1272 directory_entry CurrentEntry
;
1275 } // end namespace detail
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.
1280 class directory_iterator
{
1281 std::shared_ptr
<detail::DirIterState
> State
;
1282 bool FollowSymlinks
= true;
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
);
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
);
1302 /// Construct end iterator.
1303 directory_iterator() = default;
1305 // No operator++ because we need error_code.
1306 directory_iterator
&increment(std::error_code
&ec
) {
1307 ec
= directory_iterator_increment(*State
);
1311 const directory_entry
&operator*() const { return State
->CurrentEntry
; }
1312 const directory_entry
*operator->() const { return &State
->CurrentEntry
; }
1314 bool operator==(const directory_iterator
&RHS
) const {
1315 if (State
== RHS
.State
)
1318 return State
->CurrentEntry
== directory_entry();
1320 return RHS
.State
->CurrentEntry
== directory_entry();
1321 return State
->CurrentEntry
== RHS
.State
->CurrentEntry
;
1324 bool operator!=(const directory_iterator
&RHS
) const {
1325 return !(*this == RHS
);
1331 /// Keeps state for the recursive_directory_iterator.
1332 struct RecDirIterState
{
1333 std::stack
<directory_iterator
, std::vector
<directory_iterator
>> Stack
;
1335 bool HasNoPushRequest
= false;
1338 } // end namespace detail
1340 /// recursive_directory_iterator - Same as directory_iterator except for it
1341 /// recurses down into child directories.
1342 class recursive_directory_iterator
{
1343 std::shared_ptr
<detail::RecDirIterState
> State
;
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())
1357 // No operator++ because we need error_code.
1358 recursive_directory_iterator
&increment(std::error_code
&ec
) {
1359 const directory_iterator end_itr
= {};
1361 if (State
->HasNoPushRequest
)
1362 State
->HasNoPushRequest
= false;
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();
1369 type
= status
->type();
1370 // Otherwise broken symlink, and we'll continue.
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
) {
1382 while (!State
->Stack
.empty()
1383 && State
->Stack
.top().increment(ec
) == end_itr
) {
1388 // Check if we are done. If so, create an end iterator.
1389 if (State
->Stack
.empty())
1395 const directory_entry
&operator*() const { return *State
->Stack
.top(); }
1396 const directory_entry
*operator->() const { return &*State
->Stack
.top(); }
1399 /// Gets the current level. Starting path is at level 0.
1400 int level() const { return State
->Level
; }
1402 /// Returns true if no_push has been called for this directory_entry.
1403 bool no_push_request() const { return State
->HasNoPushRequest
; }
1406 /// Goes up one level if Level > 0.
1408 assert(State
&& "Cannot pop an end iterator!");
1409 assert(State
->Level
> 0 && "Cannot pop an iterator with level < 1");
1411 const directory_iterator end_itr
= {};
1415 report_fatal_error("Error incrementing directory iterator.");
1418 } while (!State
->Stack
.empty()
1419 && State
->Stack
.top().increment(ec
) == end_itr
);
1421 // Check if we are done. If so, create an end iterator.
1422 if (State
->Stack
.empty())
1426 /// Does not go down into the current directory_entry.
1427 void no_push() { State
->HasNoPushRequest
= true; }
1429 bool operator==(const recursive_directory_iterator
&RHS
) const {
1430 return State
== RHS
.State
;
1433 bool operator!=(const recursive_directory_iterator
&RHS
) const {
1434 return !(*this == RHS
);
1440 } // end namespace fs
1441 } // end namespace sys
1442 } // end namespace llvm
1444 #endif // LLVM_SUPPORT_FILESYSTEM_H