Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- llvm/Support/FileUtilities.h - File System Utilities -----*- 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 defines a family of utility functions which are useful for doing
  10. // various things with files.
  11. //
  12. //===----------------------------------------------------------------------===//
  13.  
  14. #ifndef LLVM_SUPPORT_FILEUTILITIES_H
  15. #define LLVM_SUPPORT_FILEUTILITIES_H
  16.  
  17. #include "llvm/ADT/StringRef.h"
  18. #include "llvm/Support/Error.h"
  19. #include "llvm/Support/FileSystem.h"
  20.  
  21. #include <system_error>
  22.  
  23. namespace llvm {
  24.  
  25.   /// DiffFilesWithTolerance - Compare the two files specified, returning 0 if
  26.   /// the files match, 1 if they are different, and 2 if there is a file error.
  27.   /// This function allows you to specify an absolute and relative FP error that
  28.   /// is allowed to exist.  If you specify a string to fill in for the error
  29.   /// option, it will set the string to an error message if an error occurs, or
  30.   /// if the files are different.
  31.   ///
  32.   int DiffFilesWithTolerance(StringRef FileA,
  33.                              StringRef FileB,
  34.                              double AbsTol, double RelTol,
  35.                              std::string *Error = nullptr);
  36.  
  37.  
  38.   /// FileRemover - This class is a simple object meant to be stack allocated.
  39.   /// If an exception is thrown from a region, the object removes the filename
  40.   /// specified (if deleteIt is true).
  41.   ///
  42.   class FileRemover {
  43.     SmallString<128> Filename;
  44.     bool DeleteIt;
  45.   public:
  46.     FileRemover() : DeleteIt(false) {}
  47.  
  48.     explicit FileRemover(const Twine& filename, bool deleteIt = true)
  49.       : DeleteIt(deleteIt) {
  50.       filename.toVector(Filename);
  51.     }
  52.  
  53.     ~FileRemover() {
  54.       if (DeleteIt) {
  55.         // Ignore problems deleting the file.
  56.         sys::fs::remove(Filename);
  57.       }
  58.     }
  59.  
  60.     /// setFile - Give ownership of the file to the FileRemover so it will
  61.     /// be removed when the object is destroyed.  If the FileRemover already
  62.     /// had ownership of a file, remove it first.
  63.     void setFile(const Twine& filename, bool deleteIt = true) {
  64.       if (DeleteIt) {
  65.         // Ignore problems deleting the file.
  66.         sys::fs::remove(Filename);
  67.       }
  68.  
  69.       Filename.clear();
  70.       filename.toVector(Filename);
  71.       DeleteIt = deleteIt;
  72.     }
  73.  
  74.     /// releaseFile - Take ownership of the file away from the FileRemover so it
  75.     /// will not be removed when the object is destroyed.
  76.     void releaseFile() { DeleteIt = false; }
  77.   };
  78.  
  79.   enum class atomic_write_error {
  80.     failed_to_create_uniq_file = 0,
  81.     output_stream_error,
  82.     failed_to_rename_temp_file
  83.   };
  84.  
  85.   class AtomicFileWriteError : public llvm::ErrorInfo<AtomicFileWriteError> {
  86.   public:
  87.     AtomicFileWriteError(atomic_write_error Error) : Error(Error) {}
  88.  
  89.     void log(raw_ostream &OS) const override;
  90.  
  91.     const atomic_write_error Error;
  92.     static char ID;
  93.  
  94.   private:
  95.     // Users are not expected to use error_code.
  96.     std::error_code convertToErrorCode() const override {
  97.       return llvm::inconvertibleErrorCode();
  98.     }
  99.   };
  100.  
  101.   // atomic_write_error + whatever the Writer can return
  102.  
  103.   /// Creates a unique file with name according to the given \p TempPathModel,
  104.   /// writes content of \p Buffer to the file and renames it to \p FinalPath.
  105.   ///
  106.   /// \returns \c AtomicFileWriteError in case of error.
  107.   llvm::Error writeFileAtomically(StringRef TempPathModel, StringRef FinalPath,
  108.                                   StringRef Buffer);
  109.  
  110.   llvm::Error
  111.   writeFileAtomically(StringRef TempPathModel, StringRef FinalPath,
  112.                       std::function<llvm::Error(llvm::raw_ostream &)> Writer);
  113.  
  114.   /// FilePermssionsApplier helps to copy permissions from an input file to
  115.   /// an output one. It memorizes the status of the input file and can apply
  116.   /// permissions and dates to the output file.
  117.   class FilePermissionsApplier {
  118.   public:
  119.     static Expected<FilePermissionsApplier> create(StringRef InputFilename);
  120.  
  121.     /// Apply stored permissions to the \p OutputFilename.
  122.     /// Copy LastAccess and ModificationTime if \p CopyDates is true.
  123.     /// Overwrite stored permissions if \p OverwritePermissions is specified.
  124.     Error
  125.     apply(StringRef OutputFilename, bool CopyDates = false,
  126.           std::optional<sys::fs::perms> OverwritePermissions = std::nullopt);
  127.  
  128.   private:
  129.     FilePermissionsApplier(StringRef InputFilename, sys::fs::file_status Status)
  130.         : InputFilename(InputFilename), InputStatus(Status) {}
  131.  
  132.     StringRef InputFilename;
  133.     sys::fs::file_status InputStatus;
  134.   };
  135. } // End llvm namespace
  136.  
  137. #endif
  138.