Chris Lattner | 8bd12b8 | 2007-09-15 22:21:22 +0000 | [diff] [blame] | 1 | //===--- Rewriter.cpp - Code rewriting interface --------------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 0bc735f | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | 8bd12b8 | 2007-09-15 22:21:22 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file defines the Rewriter class, which is used for code |
| 11 | // transformations. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
Ted Kremenek | 305c613 | 2012-09-01 05:09:24 +0000 | [diff] [blame] | 15 | #include "clang/Rewrite/Core/Rewriter.h" |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 16 | #include "clang/Basic/Diagnostic.h" |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 17 | #include "clang/Basic/DiagnosticIDs.h" |
| 18 | #include "clang/Basic/FileManager.h" |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 19 | #include "clang/Basic/SourceManager.h" |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 20 | #include "clang/Lex/Lexer.h" |
Benjamin Kramer | 8fe83e1 | 2012-02-04 13:45:25 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/SmallString.h" |
Stephen Hines | c568f1e | 2014-07-21 00:47:37 -0700 | [diff] [blame] | 22 | #include "llvm/Config/llvm-config.h" |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 23 | #include "llvm/Support/FileSystem.h" |
Benjamin Kramer | a93d0f2 | 2012-12-01 17:12:56 +0000 | [diff] [blame] | 24 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | 8bd12b8 | 2007-09-15 22:21:22 +0000 | [diff] [blame] | 25 | using namespace clang; |
| 26 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 27 | raw_ostream &RewriteBuffer::write(raw_ostream &os) const { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 28 | // Walk RewriteRope chunks efficiently using MoveToNextPiece() instead of the |
| 29 | // character iterator. |
| 30 | for (RopePieceBTreeIterator I = begin(), E = end(); I != E; |
| 31 | I.MoveToNextPiece()) |
| 32 | os << I.piece(); |
Nick Lewycky | 0ade808 | 2010-04-16 18:49:45 +0000 | [diff] [blame] | 33 | return os; |
| 34 | } |
| 35 | |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 36 | /// \brief Return true if this character is non-new-line whitespace: |
James Dennett | 8c10f84 | 2012-06-15 22:33:08 +0000 | [diff] [blame] | 37 | /// ' ', '\\t', '\\f', '\\v', '\\r'. |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 38 | static inline bool isWhitespace(unsigned char c) { |
| 39 | switch (c) { |
| 40 | case ' ': |
| 41 | case '\t': |
| 42 | case '\f': |
| 43 | case '\v': |
| 44 | case '\r': |
| 45 | return true; |
| 46 | default: |
| 47 | return false; |
| 48 | } |
| 49 | } |
| 50 | |
| 51 | void RewriteBuffer::RemoveText(unsigned OrigOffset, unsigned Size, |
| 52 | bool removeLineIfEmpty) { |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 53 | // Nothing to remove, exit early. |
| 54 | if (Size == 0) return; |
| 55 | |
| 56 | unsigned RealOffset = getMappedOffset(OrigOffset, true); |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame^] | 57 | assert(RealOffset+Size <= Buffer.size() && "Invalid location"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 58 | |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 59 | // Remove the dead characters. |
Chris Lattner | febe719 | 2008-04-14 07:17:29 +0000 | [diff] [blame] | 60 | Buffer.erase(RealOffset, Size); |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 61 | |
| 62 | // Add a delta so that future changes are offset correctly. |
Eli Friedman | a0978c2 | 2009-05-18 13:56:52 +0000 | [diff] [blame] | 63 | AddReplaceDelta(OrigOffset, -Size); |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 64 | |
| 65 | if (removeLineIfEmpty) { |
| 66 | // Find the line that the remove occurred and if it is completely empty |
| 67 | // remove the line as well. |
| 68 | |
| 69 | iterator curLineStart = begin(); |
| 70 | unsigned curLineStartOffs = 0; |
| 71 | iterator posI = begin(); |
| 72 | for (unsigned i = 0; i != RealOffset; ++i) { |
| 73 | if (*posI == '\n') { |
| 74 | curLineStart = posI; |
| 75 | ++curLineStart; |
| 76 | curLineStartOffs = i + 1; |
| 77 | } |
| 78 | ++posI; |
| 79 | } |
| 80 | |
| 81 | unsigned lineSize = 0; |
| 82 | posI = curLineStart; |
| 83 | while (posI != end() && isWhitespace(*posI)) { |
| 84 | ++posI; |
| 85 | ++lineSize; |
| 86 | } |
| 87 | if (posI != end() && *posI == '\n') { |
| 88 | Buffer.erase(curLineStartOffs, lineSize + 1/* + '\n'*/); |
| 89 | AddReplaceDelta(curLineStartOffs, -(lineSize + 1/* + '\n'*/)); |
| 90 | } |
| 91 | } |
Chris Lattner | 8bd12b8 | 2007-09-15 22:21:22 +0000 | [diff] [blame] | 92 | } |
| 93 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 94 | void RewriteBuffer::InsertText(unsigned OrigOffset, StringRef Str, |
Ted Kremenek | 886c8db | 2008-03-18 21:17:59 +0000 | [diff] [blame] | 95 | bool InsertAfter) { |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 96 | |
Chris Lattner | 03b0710 | 2007-10-13 00:21:23 +0000 | [diff] [blame] | 97 | // Nothing to insert, exit early. |
Daniel Dunbar | d7407dc | 2009-08-19 19:10:30 +0000 | [diff] [blame] | 98 | if (Str.empty()) return; |
Chris Lattner | febe719 | 2008-04-14 07:17:29 +0000 | [diff] [blame] | 99 | |
Ted Kremenek | 886c8db | 2008-03-18 21:17:59 +0000 | [diff] [blame] | 100 | unsigned RealOffset = getMappedOffset(OrigOffset, InsertAfter); |
Daniel Dunbar | d7407dc | 2009-08-19 19:10:30 +0000 | [diff] [blame] | 101 | Buffer.insert(RealOffset, Str.begin(), Str.end()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 102 | |
Chris Lattner | 03b0710 | 2007-10-13 00:21:23 +0000 | [diff] [blame] | 103 | // Add a delta so that future changes are offset correctly. |
Daniel Dunbar | d7407dc | 2009-08-19 19:10:30 +0000 | [diff] [blame] | 104 | AddInsertDelta(OrigOffset, Str.size()); |
Chris Lattner | 8bd12b8 | 2007-09-15 22:21:22 +0000 | [diff] [blame] | 105 | } |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 106 | |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 107 | /// ReplaceText - This method replaces a range of characters in the input |
Chris Lattner | febe719 | 2008-04-14 07:17:29 +0000 | [diff] [blame] | 108 | /// buffer with a new string. This is effectively a combined "remove+insert" |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 109 | /// operation. |
| 110 | void RewriteBuffer::ReplaceText(unsigned OrigOffset, unsigned OrigLength, |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 111 | StringRef NewStr) { |
Eli Friedman | a0978c2 | 2009-05-18 13:56:52 +0000 | [diff] [blame] | 112 | unsigned RealOffset = getMappedOffset(OrigOffset, true); |
Chris Lattner | febe719 | 2008-04-14 07:17:29 +0000 | [diff] [blame] | 113 | Buffer.erase(RealOffset, OrigLength); |
Daniel Dunbar | d7407dc | 2009-08-19 19:10:30 +0000 | [diff] [blame] | 114 | Buffer.insert(RealOffset, NewStr.begin(), NewStr.end()); |
| 115 | if (OrigLength != NewStr.size()) |
| 116 | AddReplaceDelta(OrigOffset, NewStr.size() - OrigLength); |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 117 | } |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 118 | |
| 119 | |
| 120 | //===----------------------------------------------------------------------===// |
| 121 | // Rewriter class |
| 122 | //===----------------------------------------------------------------------===// |
| 123 | |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 124 | /// getRangeSize - Return the size in bytes of the specified range if they |
| 125 | /// are in the same file. If not, this returns -1. |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 126 | int Rewriter::getRangeSize(const CharSourceRange &Range, |
Argyrios Kyrtzidis | fd183ba | 2011-04-13 07:15:11 +0000 | [diff] [blame] | 127 | RewriteOptions opts) const { |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 128 | if (!isRewritable(Range.getBegin()) || |
| 129 | !isRewritable(Range.getEnd())) return -1; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 130 | |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 131 | FileID StartFileID, EndFileID; |
| 132 | unsigned StartOff, EndOff; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 133 | |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 134 | StartOff = getLocationOffsetAndFileID(Range.getBegin(), StartFileID); |
| 135 | EndOff = getLocationOffsetAndFileID(Range.getEnd(), EndFileID); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 136 | |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 137 | if (StartFileID != EndFileID) |
| 138 | return -1; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 139 | |
Chris Lattner | d6690b2 | 2007-10-25 17:18:59 +0000 | [diff] [blame] | 140 | // If edits have been made to this buffer, the delta between the range may |
| 141 | // have changed. |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 142 | std::map<FileID, RewriteBuffer>::const_iterator I = |
Chris Lattner | 075eb6e | 2007-10-25 17:17:34 +0000 | [diff] [blame] | 143 | RewriteBuffers.find(StartFileID); |
Chris Lattner | d6690b2 | 2007-10-25 17:18:59 +0000 | [diff] [blame] | 144 | if (I != RewriteBuffers.end()) { |
Chris Lattner | 075eb6e | 2007-10-25 17:17:34 +0000 | [diff] [blame] | 145 | const RewriteBuffer &RB = I->second; |
Argyrios Kyrtzidis | fd183ba | 2011-04-13 07:15:11 +0000 | [diff] [blame] | 146 | EndOff = RB.getMappedOffset(EndOff, opts.IncludeInsertsAtEndOfRange); |
| 147 | StartOff = RB.getMappedOffset(StartOff, !opts.IncludeInsertsAtBeginOfRange); |
Chris Lattner | 075eb6e | 2007-10-25 17:17:34 +0000 | [diff] [blame] | 148 | } |
| 149 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 150 | |
Chris Lattner | 9d62a5b | 2007-10-17 21:23:07 +0000 | [diff] [blame] | 151 | // Adjust the end offset to the end of the last token, instead of being the |
Chris Lattner | 0a76aae | 2010-06-18 22:45:06 +0000 | [diff] [blame] | 152 | // start of the last token if this is a token range. |
| 153 | if (Range.isTokenRange()) |
| 154 | EndOff += Lexer::MeasureTokenLength(Range.getEnd(), *SourceMgr, *LangOpts); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 155 | |
Chris Lattner | d6690b2 | 2007-10-25 17:18:59 +0000 | [diff] [blame] | 156 | return EndOff-StartOff; |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 157 | } |
| 158 | |
Argyrios Kyrtzidis | fd183ba | 2011-04-13 07:15:11 +0000 | [diff] [blame] | 159 | int Rewriter::getRangeSize(SourceRange Range, RewriteOptions opts) const { |
| 160 | return getRangeSize(CharSourceRange::getTokenRange(Range), opts); |
Chris Lattner | 0a76aae | 2010-06-18 22:45:06 +0000 | [diff] [blame] | 161 | } |
| 162 | |
| 163 | |
Ted Kremenek | 6a12a14 | 2010-01-07 18:00:35 +0000 | [diff] [blame] | 164 | /// getRewrittenText - Return the rewritten form of the text in the specified |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 165 | /// range. If the start or end of the range was unrewritable or if they are |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 166 | /// in different buffers, this returns an empty string. |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 167 | /// |
| 168 | /// Note that this method is not particularly efficient. |
| 169 | /// |
Ted Kremenek | 6a12a14 | 2010-01-07 18:00:35 +0000 | [diff] [blame] | 170 | std::string Rewriter::getRewrittenText(SourceRange Range) const { |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 171 | if (!isRewritable(Range.getBegin()) || |
| 172 | !isRewritable(Range.getEnd())) |
| 173 | return ""; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 174 | |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 175 | FileID StartFileID, EndFileID; |
| 176 | unsigned StartOff, EndOff; |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 177 | StartOff = getLocationOffsetAndFileID(Range.getBegin(), StartFileID); |
| 178 | EndOff = getLocationOffsetAndFileID(Range.getEnd(), EndFileID); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 179 | |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 180 | if (StartFileID != EndFileID) |
| 181 | return ""; // Start and end in different buffers. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 182 | |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 183 | // If edits have been made to this buffer, the delta between the range may |
| 184 | // have changed. |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 185 | std::map<FileID, RewriteBuffer>::const_iterator I = |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 186 | RewriteBuffers.find(StartFileID); |
| 187 | if (I == RewriteBuffers.end()) { |
| 188 | // If the buffer hasn't been rewritten, just return the text from the input. |
| 189 | const char *Ptr = SourceMgr->getCharacterData(Range.getBegin()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 190 | |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 191 | // Adjust the end offset to the end of the last token, instead of being the |
| 192 | // start of the last token. |
Chris Lattner | 2c78b87 | 2009-04-14 23:22:57 +0000 | [diff] [blame] | 193 | EndOff += Lexer::MeasureTokenLength(Range.getEnd(), *SourceMgr, *LangOpts); |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 194 | return std::string(Ptr, Ptr+EndOff-StartOff); |
| 195 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 196 | |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 197 | const RewriteBuffer &RB = I->second; |
| 198 | EndOff = RB.getMappedOffset(EndOff, true); |
| 199 | StartOff = RB.getMappedOffset(StartOff); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 200 | |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 201 | // Adjust the end offset to the end of the last token, instead of being the |
| 202 | // start of the last token. |
Chris Lattner | 2c78b87 | 2009-04-14 23:22:57 +0000 | [diff] [blame] | 203 | EndOff += Lexer::MeasureTokenLength(Range.getEnd(), *SourceMgr, *LangOpts); |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 204 | |
| 205 | // Advance the iterators to the right spot, yay for linear time algorithms. |
| 206 | RewriteBuffer::iterator Start = RB.begin(); |
| 207 | std::advance(Start, StartOff); |
| 208 | RewriteBuffer::iterator End = Start; |
| 209 | std::advance(End, EndOff-StartOff); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 210 | |
Chris Lattner | b5cd09a | 2008-10-03 23:31:16 +0000 | [diff] [blame] | 211 | return std::string(Start, End); |
| 212 | } |
Chris Lattner | 311ff02 | 2007-10-16 22:36:42 +0000 | [diff] [blame] | 213 | |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 214 | unsigned Rewriter::getLocationOffsetAndFileID(SourceLocation Loc, |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 215 | FileID &FID) const { |
Chris Lattner | 54bd7cb | 2008-05-28 16:35:02 +0000 | [diff] [blame] | 216 | assert(Loc.isValid() && "Invalid location"); |
Chris Lattner | de7aeef | 2009-01-26 00:43:02 +0000 | [diff] [blame] | 217 | std::pair<FileID,unsigned> V = SourceMgr->getDecomposedLoc(Loc); |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 218 | FID = V.first; |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 219 | return V.second; |
| 220 | } |
| 221 | |
| 222 | |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 223 | /// getEditBuffer - Get or create a RewriteBuffer for the specified FileID. |
| 224 | /// |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 225 | RewriteBuffer &Rewriter::getEditBuffer(FileID FID) { |
| 226 | std::map<FileID, RewriteBuffer>::iterator I = |
| 227 | RewriteBuffers.lower_bound(FID); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 228 | if (I != RewriteBuffers.end() && I->first == FID) |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 229 | return I->second; |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 230 | I = RewriteBuffers.insert(I, std::make_pair(FID, RewriteBuffer())); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 231 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 232 | StringRef MB = SourceMgr->getBufferData(FID); |
Benjamin Kramer | f6ac97b | 2010-03-16 14:14:31 +0000 | [diff] [blame] | 233 | I->second.Initialize(MB.begin(), MB.end()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 234 | |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 235 | return I->second; |
| 236 | } |
| 237 | |
Chris Lattner | 54a2f07 | 2007-11-02 17:26:47 +0000 | [diff] [blame] | 238 | /// InsertText - Insert the specified string at the specified location in the |
Chris Lattner | aadaf78 | 2008-01-31 19:51:04 +0000 | [diff] [blame] | 239 | /// original buffer. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 240 | bool Rewriter::InsertText(SourceLocation Loc, StringRef Str, |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 241 | bool InsertAfter, bool indentNewLines) { |
Chris Lattner | dcbc5b0 | 2008-01-31 19:37:57 +0000 | [diff] [blame] | 242 | if (!isRewritable(Loc)) return true; |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 243 | FileID FID; |
| 244 | unsigned StartOffs = getLocationOffsetAndFileID(Loc, FID); |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 245 | |
Dylan Noblesmith | f7ccbad | 2012-02-05 02:13:05 +0000 | [diff] [blame] | 246 | SmallString<128> indentedStr; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 247 | if (indentNewLines && Str.find('\n') != StringRef::npos) { |
| 248 | StringRef MB = SourceMgr->getBufferData(FID); |
| 249 | |
| 250 | unsigned lineNo = SourceMgr->getLineNumber(FID, StartOffs) - 1; |
| 251 | const SrcMgr::ContentCache * |
| 252 | Content = SourceMgr->getSLocEntry(FID).getFile().getContentCache(); |
| 253 | unsigned lineOffs = Content->SourceLineCache[lineNo]; |
| 254 | |
| 255 | // Find the whitespace at the start of the line. |
| 256 | StringRef indentSpace; |
| 257 | { |
| 258 | unsigned i = lineOffs; |
| 259 | while (isWhitespace(MB[i])) |
| 260 | ++i; |
| 261 | indentSpace = MB.substr(lineOffs, i-lineOffs); |
| 262 | } |
| 263 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 264 | SmallVector<StringRef, 4> lines; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 265 | Str.split(lines, "\n"); |
| 266 | |
| 267 | for (unsigned i = 0, e = lines.size(); i != e; ++i) { |
| 268 | indentedStr += lines[i]; |
| 269 | if (i < e-1) { |
| 270 | indentedStr += '\n'; |
| 271 | indentedStr += indentSpace; |
| 272 | } |
| 273 | } |
| 274 | Str = indentedStr.str(); |
| 275 | } |
| 276 | |
Daniel Dunbar | d7407dc | 2009-08-19 19:10:30 +0000 | [diff] [blame] | 277 | getEditBuffer(FID).InsertText(StartOffs, Str, InsertAfter); |
Chris Lattner | dcbc5b0 | 2008-01-31 19:37:57 +0000 | [diff] [blame] | 278 | return false; |
Chris Lattner | 54a2f07 | 2007-11-02 17:26:47 +0000 | [diff] [blame] | 279 | } |
| 280 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 281 | bool Rewriter::InsertTextAfterToken(SourceLocation Loc, StringRef Str) { |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 282 | if (!isRewritable(Loc)) return true; |
| 283 | FileID FID; |
| 284 | unsigned StartOffs = getLocationOffsetAndFileID(Loc, FID); |
Argyrios Kyrtzidis | fd183ba | 2011-04-13 07:15:11 +0000 | [diff] [blame] | 285 | RewriteOptions rangeOpts; |
| 286 | rangeOpts.IncludeInsertsAtBeginOfRange = false; |
| 287 | StartOffs += getRangeSize(SourceRange(Loc, Loc), rangeOpts); |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 288 | getEditBuffer(FID).InsertText(StartOffs, Str, /*InsertAfter*/true); |
| 289 | return false; |
| 290 | } |
| 291 | |
Chris Lattner | aadaf78 | 2008-01-31 19:51:04 +0000 | [diff] [blame] | 292 | /// RemoveText - Remove the specified text region. |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 293 | bool Rewriter::RemoveText(SourceLocation Start, unsigned Length, |
Argyrios Kyrtzidis | fd183ba | 2011-04-13 07:15:11 +0000 | [diff] [blame] | 294 | RewriteOptions opts) { |
Chris Lattner | aadaf78 | 2008-01-31 19:51:04 +0000 | [diff] [blame] | 295 | if (!isRewritable(Start)) return true; |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 296 | FileID FID; |
| 297 | unsigned StartOffs = getLocationOffsetAndFileID(Start, FID); |
Argyrios Kyrtzidis | fd183ba | 2011-04-13 07:15:11 +0000 | [diff] [blame] | 298 | getEditBuffer(FID).RemoveText(StartOffs, Length, opts.RemoveLineIfEmpty); |
Chris Lattner | aadaf78 | 2008-01-31 19:51:04 +0000 | [diff] [blame] | 299 | return false; |
Chris Lattner | 674af95 | 2007-10-16 22:51:17 +0000 | [diff] [blame] | 300 | } |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 301 | |
Chris Lattner | 674af95 | 2007-10-16 22:51:17 +0000 | [diff] [blame] | 302 | /// ReplaceText - This method replaces a range of characters in the input |
| 303 | /// buffer with a new string. This is effectively a combined "remove/insert" |
| 304 | /// operation. |
Chris Lattner | aadaf78 | 2008-01-31 19:51:04 +0000 | [diff] [blame] | 305 | bool Rewriter::ReplaceText(SourceLocation Start, unsigned OrigLength, |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 306 | StringRef NewStr) { |
Chris Lattner | aadaf78 | 2008-01-31 19:51:04 +0000 | [diff] [blame] | 307 | if (!isRewritable(Start)) return true; |
Chris Lattner | 2b2453a | 2009-01-17 06:22:33 +0000 | [diff] [blame] | 308 | FileID StartFileID; |
Chris Lattner | 7c23960 | 2007-10-13 00:11:23 +0000 | [diff] [blame] | 309 | unsigned StartOffs = getLocationOffsetAndFileID(Start, StartFileID); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 310 | |
Daniel Dunbar | d7407dc | 2009-08-19 19:10:30 +0000 | [diff] [blame] | 311 | getEditBuffer(StartFileID).ReplaceText(StartOffs, OrigLength, NewStr); |
Chris Lattner | aadaf78 | 2008-01-31 19:51:04 +0000 | [diff] [blame] | 312 | return false; |
Chris Lattner | 8a12c27 | 2007-10-11 18:38:32 +0000 | [diff] [blame] | 313 | } |
Chris Lattner | 01c5748 | 2007-10-17 22:35:30 +0000 | [diff] [blame] | 314 | |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 315 | bool Rewriter::ReplaceText(SourceRange range, SourceRange replacementRange) { |
| 316 | if (!isRewritable(range.getBegin())) return true; |
| 317 | if (!isRewritable(range.getEnd())) return true; |
| 318 | if (replacementRange.isInvalid()) return true; |
| 319 | SourceLocation start = range.getBegin(); |
| 320 | unsigned origLength = getRangeSize(range); |
| 321 | unsigned newLength = getRangeSize(replacementRange); |
| 322 | FileID FID; |
| 323 | unsigned newOffs = getLocationOffsetAndFileID(replacementRange.getBegin(), |
| 324 | FID); |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 325 | StringRef MB = SourceMgr->getBufferData(FID); |
Argyrios Kyrtzidis | b65ed34 | 2011-04-07 18:10:12 +0000 | [diff] [blame] | 326 | return ReplaceText(start, origLength, MB.substr(newOffs, newLength)); |
| 327 | } |
| 328 | |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 329 | bool Rewriter::IncreaseIndentation(CharSourceRange range, |
| 330 | SourceLocation parentIndent) { |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 331 | if (range.isInvalid()) return true; |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 332 | if (!isRewritable(range.getBegin())) return true; |
| 333 | if (!isRewritable(range.getEnd())) return true; |
| 334 | if (!isRewritable(parentIndent)) return true; |
| 335 | |
| 336 | FileID StartFileID, EndFileID, parentFileID; |
| 337 | unsigned StartOff, EndOff, parentOff; |
| 338 | |
| 339 | StartOff = getLocationOffsetAndFileID(range.getBegin(), StartFileID); |
| 340 | EndOff = getLocationOffsetAndFileID(range.getEnd(), EndFileID); |
| 341 | parentOff = getLocationOffsetAndFileID(parentIndent, parentFileID); |
| 342 | |
| 343 | if (StartFileID != EndFileID || StartFileID != parentFileID) |
| 344 | return true; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 345 | if (StartOff > EndOff) |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 346 | return true; |
| 347 | |
| 348 | FileID FID = StartFileID; |
| 349 | StringRef MB = SourceMgr->getBufferData(FID); |
| 350 | |
| 351 | unsigned parentLineNo = SourceMgr->getLineNumber(FID, parentOff) - 1; |
| 352 | unsigned startLineNo = SourceMgr->getLineNumber(FID, StartOff) - 1; |
| 353 | unsigned endLineNo = SourceMgr->getLineNumber(FID, EndOff) - 1; |
| 354 | |
| 355 | const SrcMgr::ContentCache * |
| 356 | Content = SourceMgr->getSLocEntry(FID).getFile().getContentCache(); |
| 357 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 358 | // Find where the lines start. |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 359 | unsigned parentLineOffs = Content->SourceLineCache[parentLineNo]; |
| 360 | unsigned startLineOffs = Content->SourceLineCache[startLineNo]; |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 361 | |
| 362 | // Find the whitespace at the start of each line. |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 363 | StringRef parentSpace, startSpace; |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 364 | { |
| 365 | unsigned i = parentLineOffs; |
| 366 | while (isWhitespace(MB[i])) |
| 367 | ++i; |
| 368 | parentSpace = MB.substr(parentLineOffs, i-parentLineOffs); |
| 369 | |
| 370 | i = startLineOffs; |
| 371 | while (isWhitespace(MB[i])) |
| 372 | ++i; |
| 373 | startSpace = MB.substr(startLineOffs, i-startLineOffs); |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 374 | } |
| 375 | if (parentSpace.size() >= startSpace.size()) |
| 376 | return true; |
| 377 | if (!startSpace.startswith(parentSpace)) |
| 378 | return true; |
| 379 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 380 | StringRef indent = startSpace.substr(parentSpace.size()); |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 381 | |
| 382 | // Indent the lines between start/end offsets. |
| 383 | RewriteBuffer &RB = getEditBuffer(FID); |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 384 | for (unsigned lineNo = startLineNo; lineNo <= endLineNo; ++lineNo) { |
| 385 | unsigned offs = Content->SourceLineCache[lineNo]; |
| 386 | unsigned i = offs; |
| 387 | while (isWhitespace(MB[i])) |
| 388 | ++i; |
| 389 | StringRef origIndent = MB.substr(offs, i-offs); |
| 390 | if (origIndent.startswith(startSpace)) |
| 391 | RB.InsertText(offs, indent, /*InsertAfter=*/false); |
Argyrios Kyrtzidis | 10c8d9e | 2011-04-16 01:03:33 +0000 | [diff] [blame] | 392 | } |
| 393 | |
| 394 | return false; |
| 395 | } |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 396 | |
Benjamin Kramer | c2b914f | 2012-12-01 20:58:01 +0000 | [diff] [blame] | 397 | namespace { |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 398 | // A wrapper for a file stream that atomically overwrites the target. |
| 399 | // |
| 400 | // Creates a file output stream for a temporary file in the constructor, |
| 401 | // which is later accessible via getStream() if ok() return true. |
| 402 | // Flushes the stream and moves the temporary file to the target location |
| 403 | // in the destructor. |
| 404 | class AtomicallyMovedFile { |
| 405 | public: |
| 406 | AtomicallyMovedFile(DiagnosticsEngine &Diagnostics, StringRef Filename, |
| 407 | bool &AllWritten) |
| 408 | : Diagnostics(Diagnostics), Filename(Filename), AllWritten(AllWritten) { |
| 409 | TempFilename = Filename; |
| 410 | TempFilename += "-%%%%%%%%"; |
| 411 | int FD; |
Rafael Espindola | 70e7aec | 2013-07-05 21:13:58 +0000 | [diff] [blame] | 412 | if (llvm::sys::fs::createUniqueFile(TempFilename.str(), FD, TempFilename)) { |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 413 | AllWritten = false; |
| 414 | Diagnostics.Report(clang::diag::err_unable_to_make_temp) |
| 415 | << TempFilename; |
| 416 | } else { |
| 417 | FileStream.reset(new llvm::raw_fd_ostream(FD, /*shouldClose=*/true)); |
| 418 | } |
| 419 | } |
| 420 | |
| 421 | ~AtomicallyMovedFile() { |
| 422 | if (!ok()) return; |
| 423 | |
| 424 | FileStream->flush(); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 425 | #ifdef LLVM_ON_WIN32 |
NAKAMURA Takumi | 2d9c4df | 2012-05-27 12:59:58 +0000 | [diff] [blame] | 426 | // Win32 does not allow rename/removing opened files. |
| 427 | FileStream.reset(); |
| 428 | #endif |
Stephen Hines | c568f1e | 2014-07-21 00:47:37 -0700 | [diff] [blame] | 429 | if (std::error_code ec = |
| 430 | llvm::sys::fs::rename(TempFilename.str(), Filename)) { |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 431 | AllWritten = false; |
| 432 | Diagnostics.Report(clang::diag::err_unable_to_rename_temp) |
| 433 | << TempFilename << Filename << ec.message(); |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 434 | // If the remove fails, there's not a lot we can do - this is already an |
| 435 | // error. |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 436 | llvm::sys::fs::remove(TempFilename.str()); |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 437 | } |
| 438 | } |
| 439 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 440 | bool ok() { return (bool)FileStream; } |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 441 | raw_ostream &getStream() { return *FileStream; } |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 442 | |
| 443 | private: |
| 444 | DiagnosticsEngine &Diagnostics; |
| 445 | StringRef Filename; |
| 446 | SmallString<128> TempFilename; |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 447 | std::unique_ptr<llvm::raw_fd_ostream> FileStream; |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 448 | bool &AllWritten; |
| 449 | }; |
Benjamin Kramer | c2b914f | 2012-12-01 20:58:01 +0000 | [diff] [blame] | 450 | } // end anonymous namespace |
Manuel Klimek | bfbfee5 | 2012-05-22 17:01:35 +0000 | [diff] [blame] | 451 | |
| 452 | bool Rewriter::overwriteChangedFiles() { |
| 453 | bool AllWritten = true; |
| 454 | for (buffer_iterator I = buffer_begin(), E = buffer_end(); I != E; ++I) { |
| 455 | const FileEntry *Entry = |
| 456 | getSourceMgr().getFileEntryForID(I->first); |
| 457 | AtomicallyMovedFile File(getSourceMgr().getDiagnostics(), Entry->getName(), |
| 458 | AllWritten); |
| 459 | if (File.ok()) { |
| 460 | I->second.write(File.getStream()); |
| 461 | } |
| 462 | } |
| 463 | return !AllWritten; |
| 464 | } |