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