Line data    Source code

       1             : //===- llvm/Support/FileUtilities.h - File System Utilities -----*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file defines a family of utility functions which are useful for doing
      11             : // various things with files.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_SUPPORT_FILEUTILITIES_H
      16             : #define LLVM_SUPPORT_FILEUTILITIES_H
      17             : 
      18             : #include "llvm/Support/FileSystem.h"
      19             : #include "llvm/Support/Path.h"
      20             : 
      21             : namespace llvm {
      22             : 
      23             :   /// DiffFilesWithTolerance - Compare the two files specified, returning 0 if
      24             :   /// the files match, 1 if they are different, and 2 if there is a file error.
      25             :   /// This function allows you to specify an absolute and relative FP error that
      26             :   /// is allowed to exist.  If you specify a string to fill in for the error
      27             :   /// option, it will set the string to an error message if an error occurs, or
      28             :   /// if the files are different.
      29             :   ///
      30             :   int DiffFilesWithTolerance(StringRef FileA,
      31             :                              StringRef FileB,
      32             :                              double AbsTol, double RelTol,
      33             :                              std::string *Error = nullptr);
      34             : 
      35             : 
      36             :   /// FileRemover - This class is a simple object meant to be stack allocated.
      37             :   /// If an exception is thrown from a region, the object removes the filename
      38             :   /// specified (if deleteIt is true).
      39             :   ///
      40             :   class FileRemover {
      41             :     SmallString<128> Filename;
      42             :     bool DeleteIt;
      43             :   public:
      44        3048 :     FileRemover() : DeleteIt(false) {}
      45             : 
      46             :     explicit FileRemover(const Twine& filename, bool deleteIt = true)
      47          23 :       : DeleteIt(deleteIt) {
      48          23 :       filename.toVector(Filename);
      49             :     }
      50             : 
      51        3092 :     ~FileRemover() {
      52        1546 :       if (DeleteIt) {
      53             :         // Ignore problems deleting the file.
      54        3092 :         sys::fs::remove(Filename);
      55             :       }
      56        1546 :     }
      57             : 
      58             :     /// setFile - Give ownership of the file to the FileRemover so it will
      59             :     /// be removed when the object is destroyed.  If the FileRemover already
      60             :     /// had ownership of a file, remove it first.
      61        1524 :     void setFile(const Twine& filename, bool deleteIt = true) {
      62        1524 :       if (DeleteIt) {
      63             :         // Ignore problems deleting the file.
      64           0 :         sys::fs::remove(Filename);
      65             :       }
      66             : 
      67             :       Filename.clear();
      68        1524 :       filename.toVector(Filename);
      69        1524 :       DeleteIt = deleteIt;
      70        1524 :     }
      71             : 
      72             :     /// releaseFile - Take ownership of the file away from the FileRemover so it
      73             :     /// will not be removed when the object is destroyed.
      74             :     void releaseFile() { DeleteIt = false; }
      75             :   };
      76             : } // End llvm namespace
      77             : 
      78             : #endif