contrib/llvm/tools/clang/lib/ARCMigrate/FileRemapper.cpp

   1 //===--- FileRemapper.cpp - File Remapping Helper -------------------------===//
   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 #include "clang/ARCMigrate/FileRemapper.h"
  11 #include "clang/Basic/Diagnostic.h"
  12 #include "clang/Basic/FileManager.h"
  13 #include "clang/Lex/PreprocessorOptions.h"
  14 #include "llvm/Support/FileSystem.h"
  15 #include "llvm/Support/MemoryBuffer.h"
  16 #include "llvm/Support/Path.h"
  17 #include "llvm/Support/raw_ostream.h"
  18 #include <fstream>
  19
  20 using namespace clang;
  21 using namespace arcmt;
  22
  23 FileRemapper::FileRemapper() {
  24   FileMgr.reset(new FileManager(FileSystemOptions()));
  25 }
  26
  27 FileRemapper::~FileRemapper() {
  28   clear();
  29 }
  30
  31 void FileRemapper::clear(StringRef outputDir) {
  32   for (MappingsTy::iterator
  33          I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I)
  34     resetTarget(I->second);
  35   FromToMappings.clear();
  36   assert(ToFromMappings.empty());
  37   if (!outputDir.empty()) {
  38     std::string infoFile = getRemapInfoFile(outputDir);
  39     llvm::sys::fs::remove(infoFile);
  40   }
  41 }
  42
  43 std::string FileRemapper::getRemapInfoFile(StringRef outputDir) {
  44   assert(!outputDir.empty());
  45   SmallString<128> InfoFile = outputDir;
  46   llvm::sys::path::append(InfoFile, "remap");
  47   return InfoFile.str();
  48 }
  49
  50 bool FileRemapper::initFromDisk(StringRef outputDir, DiagnosticsEngine &Diag,
  51                                 bool ignoreIfFilesChanged) {
  52   std::string infoFile = getRemapInfoFile(outputDir);
  53   return initFromFile(infoFile, Diag, ignoreIfFilesChanged);
  54 }
  55
  56 bool FileRemapper::initFromFile(StringRef filePath, DiagnosticsEngine &Diag,
  57                                 bool ignoreIfFilesChanged) {
  58   assert(FromToMappings.empty() &&
  59          "initFromDisk should be called before any remap calls");
  60   std::string infoFile = filePath;
  61   if (!llvm::sys::fs::exists(infoFile))
  62     return false;
  63
  64   std::vector<std::pair<const FileEntry *, const FileEntry *> > pairs;
  65
  66   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileBuf =
  67       llvm::MemoryBuffer::getFile(infoFile.c_str());
  68   if (!fileBuf)
  69     return report("Error opening file: " + infoFile, Diag);
  70
  71   SmallVector<StringRef, 64> lines;
  72   fileBuf.get()->getBuffer().split(lines, "\n");
  73
  74   for (unsigned idx = 0; idx+3 <= lines.size(); idx += 3) {
  75     StringRef fromFilename = lines[idx];
  76     unsigned long long timeModified;
  77     if (lines[idx+1].getAsInteger(10, timeModified))
  78       return report("Invalid file data: '" + lines[idx+1] + "' not a number",
  79                     Diag);
  80     StringRef toFilename = lines[idx+2];
  81
  82     const FileEntry *origFE = FileMgr->getFile(fromFilename);
  83     if (!origFE) {
  84       if (ignoreIfFilesChanged)
  85         continue;
  86       return report("File does not exist: " + fromFilename, Diag);
  87     }
  88     const FileEntry *newFE = FileMgr->getFile(toFilename);
  89     if (!newFE) {
  90       if (ignoreIfFilesChanged)
  91         continue;
  92       return report("File does not exist: " + toFilename, Diag);
  93     }
  94
  95     if ((uint64_t)origFE->getModificationTime() != timeModified) {
  96       if (ignoreIfFilesChanged)
  97         continue;
  98       return report("File was modified: " + fromFilename, Diag);
  99     }
 100
 101     pairs.push_back(std::make_pair(origFE, newFE));
 102   }
 103
 104   for (unsigned i = 0, e = pairs.size(); i != e; ++i)
 105     remap(pairs[i].first, pairs[i].second);
 106
 107   return false;
 108 }
 109
 110 bool FileRemapper::flushToDisk(StringRef outputDir, DiagnosticsEngine &Diag) {
 111   using namespace llvm::sys;
 112
 113   if (fs::create_directory(outputDir))
 114     return report("Could not create directory: " + outputDir, Diag);
 115
 116   std::string infoFile = getRemapInfoFile(outputDir);
 117   return flushToFile(infoFile, Diag);
 118 }
 119
 120 bool FileRemapper::flushToFile(StringRef outputPath, DiagnosticsEngine &Diag) {
 121   using namespace llvm::sys;
 122
 123   std::error_code EC;
 124   std::string infoFile = outputPath;
 125   llvm::raw_fd_ostream infoOut(infoFile, EC, llvm::sys::fs::F_None);
 126   if (EC)
 127     return report(EC.message(), Diag);
 128
 129   for (MappingsTy::iterator
 130          I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
 131
 132     const FileEntry *origFE = I->first;
 133     SmallString<200> origPath = StringRef(origFE->getName());
 134     fs::make_absolute(origPath);
 135     infoOut << origPath << '\n';
 136     infoOut << (uint64_t)origFE->getModificationTime() << '\n';
 137
 138     if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
 139       SmallString<200> newPath = StringRef(FE->getName());
 140       fs::make_absolute(newPath);
 141       infoOut << newPath << '\n';
 142     } else {
 143
 144       SmallString<64> tempPath;
 145       int fd;
 146       if (fs::createTemporaryFile(path::filename(origFE->getName()),
 147                                   path::extension(origFE->getName()).drop_front(), fd,
 148                                   tempPath))
 149         return report("Could not create file: " + tempPath.str(), Diag);
 150
 151       llvm::raw_fd_ostream newOut(fd, /*shouldClose=*/true);
 152       llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
 153       newOut.write(mem->getBufferStart(), mem->getBufferSize());
 154       newOut.close();
 155
 156       const FileEntry *newE = FileMgr->getFile(tempPath);
 157       remap(origFE, newE);
 158       infoOut << newE->getName() << '\n';
 159     }
 160   }
 161
 162   infoOut.close();
 163   return false;
 164 }
 165
 166 bool FileRemapper::overwriteOriginal(DiagnosticsEngine &Diag,
 167                                      StringRef outputDir) {
 168   using namespace llvm::sys;
 169
 170   for (MappingsTy::iterator
 171          I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
 172     const FileEntry *origFE = I->first;
 173     assert(I->second.is<llvm::MemoryBuffer *>());
 174     if (!fs::exists(origFE->getName()))
 175       return report(StringRef("File does not exist: ") + origFE->getName(),
 176                     Diag);
 177
 178     std::error_code EC;
 179     llvm::raw_fd_ostream Out(origFE->getName(), EC, llvm::sys::fs::F_None);
 180     if (EC)
 181       return report(EC.message(), Diag);
 182
 183     llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
 184     Out.write(mem->getBufferStart(), mem->getBufferSize());
 185     Out.close();
 186   }
 187
 188   clear(outputDir);
 189   return false;
 190 }
 191
 192 void FileRemapper::applyMappings(PreprocessorOptions &PPOpts) const {
 193   for (MappingsTy::const_iterator
 194          I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
 195     if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
 196       PPOpts.addRemappedFile(I->first->getName(), FE->getName());
 197     } else {
 198       llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
 199       PPOpts.addRemappedFile(I->first->getName(), mem);
 200     }
 201   }
 202
 203   PPOpts.RetainRemappedFileBuffers = true;
 204 }
 205
 206 void FileRemapper::remap(StringRef filePath,
 207                          std::unique_ptr<llvm::MemoryBuffer> memBuf) {
 208   remap(getOriginalFile(filePath), std::move(memBuf));
 209 }
 210
 211 void FileRemapper::remap(const FileEntry *file,
 212                          std::unique_ptr<llvm::MemoryBuffer> memBuf) {
 213   assert(file);
 214   Target &targ = FromToMappings[file];
 215   resetTarget(targ);
 216   targ = memBuf.release();
 217 }
 218
 219 void FileRemapper::remap(const FileEntry *file, const FileEntry *newfile) {
 220   assert(file && newfile);
 221   Target &targ = FromToMappings[file];
 222   resetTarget(targ);
 223   targ = newfile;
 224   ToFromMappings[newfile] = file;
 225 }
 226
 227 const FileEntry *FileRemapper::getOriginalFile(StringRef filePath) {
 228   const FileEntry *file = FileMgr->getFile(filePath);
 229   // If we are updating a file that overriden an original file,
 230   // actually update the original file.
 231   llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
 232     I = ToFromMappings.find(file);
 233   if (I != ToFromMappings.end()) {
 234     file = I->second;
 235     assert(FromToMappings.find(file) != FromToMappings.end() &&
 236            "Original file not in mappings!");
 237   }
 238   return file;
 239 }
 240
 241 void FileRemapper::resetTarget(Target &targ) {
 242   if (!targ)
 243     return;
 244
 245   if (llvm::MemoryBuffer *oldmem = targ.dyn_cast<llvm::MemoryBuffer *>()) {
 246     delete oldmem;
 247   } else {
 248     const FileEntry *toFE = targ.get<const FileEntry *>();
 249     ToFromMappings.erase(toFE);
 250   }
 251 }
 252
 253 bool FileRemapper::report(const Twine &err, DiagnosticsEngine &Diag) {
 254   Diag.Report(Diag.getCustomDiagID(DiagnosticsEngine::Error, "%0"))
 255       << err.str();
 256   return true;
 257 }