Ted Kremenek | 30660a8 | 2012-03-06 20:06:33 +0000 | [diff] [blame] | 1 | //===----- EditedSource.cpp - Collection of source edits ------------------===// |
| 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/Edit/EditedSource.h" |
| 11 | #include "clang/Edit/Commit.h" |
| 12 | #include "clang/Edit/EditsReceiver.h" |
| 13 | #include "clang/Lex/Lexer.h" |
| 14 | #include "clang/Basic/SourceManager.h" |
| 15 | #include "llvm/ADT/SmallString.h" |
| 16 | #include "llvm/ADT/Twine.h" |
| 17 | |
| 18 | using namespace clang; |
| 19 | using namespace edit; |
| 20 | |
| 21 | void EditsReceiver::remove(CharSourceRange range) { |
| 22 | replace(range, StringRef()); |
| 23 | } |
| 24 | |
| 25 | StringRef EditedSource::copyString(const Twine &twine) { |
| 26 | llvm::SmallString<128> Data; |
| 27 | return copyString(twine.toStringRef(Data)); |
| 28 | } |
| 29 | |
| 30 | bool EditedSource::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) { |
| 31 | FileEditsTy::iterator FA = getActionForOffset(Offs); |
| 32 | if (FA != FileEdits.end()) { |
| 33 | if (FA->first != Offs) |
| 34 | return false; // position has been removed. |
| 35 | } |
| 36 | |
| 37 | if (SourceMgr.isMacroArgExpansion(OrigLoc)) { |
| 38 | SourceLocation |
| 39 | DefArgLoc = SourceMgr.getImmediateExpansionRange(OrigLoc).first; |
| 40 | SourceLocation |
| 41 | ExpLoc = SourceMgr.getImmediateExpansionRange(DefArgLoc).first; |
| 42 | llvm::DenseMap<unsigned, SourceLocation>::iterator |
| 43 | I = ExpansionToArgMap.find(ExpLoc.getRawEncoding()); |
| 44 | if (I != ExpansionToArgMap.end() && I->second != DefArgLoc) |
| 45 | return false; // Trying to write in a macro argument input that has |
| 46 | // already been written for another argument of the same macro. |
| 47 | } |
| 48 | |
| 49 | return true; |
| 50 | } |
| 51 | |
| 52 | bool EditedSource::commitInsert(SourceLocation OrigLoc, |
| 53 | FileOffset Offs, StringRef text, |
| 54 | bool beforePreviousInsertions) { |
| 55 | if (!canInsertInOffset(OrigLoc, Offs)) |
| 56 | return false; |
| 57 | if (text.empty()) |
| 58 | return true; |
| 59 | |
| 60 | if (SourceMgr.isMacroArgExpansion(OrigLoc)) { |
| 61 | SourceLocation |
| 62 | DefArgLoc = SourceMgr.getImmediateExpansionRange(OrigLoc).first; |
| 63 | SourceLocation |
| 64 | ExpLoc = SourceMgr.getImmediateExpansionRange(DefArgLoc).first; |
| 65 | ExpansionToArgMap[ExpLoc.getRawEncoding()] = DefArgLoc; |
| 66 | } |
| 67 | |
| 68 | FileEdit &FA = FileEdits[Offs]; |
| 69 | if (FA.Text.empty()) { |
| 70 | FA.Text = copyString(text); |
| 71 | return true; |
| 72 | } |
| 73 | |
| 74 | Twine concat; |
| 75 | if (beforePreviousInsertions) |
| 76 | concat = Twine(text) + FA.Text; |
| 77 | else |
| 78 | concat = Twine(FA.Text) + text; |
| 79 | |
| 80 | FA.Text = copyString(concat); |
| 81 | return true; |
| 82 | } |
| 83 | |
| 84 | bool EditedSource::commitInsertFromRange(SourceLocation OrigLoc, |
| 85 | FileOffset Offs, |
| 86 | FileOffset InsertFromRangeOffs, unsigned Len, |
| 87 | bool beforePreviousInsertions) { |
| 88 | if (Len == 0) |
| 89 | return true; |
| 90 | |
| 91 | llvm::SmallString<128> StrVec; |
| 92 | FileOffset BeginOffs = InsertFromRangeOffs; |
| 93 | FileOffset EndOffs = BeginOffs.getWithOffset(Len); |
| 94 | FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs); |
| 95 | if (I != FileEdits.begin()) |
| 96 | --I; |
| 97 | |
| 98 | for (; I != FileEdits.end(); ++I) { |
| 99 | FileEdit &FA = I->second; |
| 100 | FileOffset B = I->first; |
| 101 | FileOffset E = B.getWithOffset(FA.RemoveLen); |
| 102 | |
Argyrios Kyrtzidis | 055b395 | 2012-05-14 22:01:53 +0000 | [diff] [blame] | 103 | if (BeginOffs == B) |
| 104 | break; |
| 105 | |
Ted Kremenek | 30660a8 | 2012-03-06 20:06:33 +0000 | [diff] [blame] | 106 | if (BeginOffs < E) { |
Argyrios Kyrtzidis | 055b395 | 2012-05-14 22:01:53 +0000 | [diff] [blame] | 107 | if (BeginOffs > B) { |
Ted Kremenek | 30660a8 | 2012-03-06 20:06:33 +0000 | [diff] [blame] | 108 | BeginOffs = E; |
| 109 | ++I; |
| 110 | } |
| 111 | break; |
| 112 | } |
| 113 | } |
| 114 | |
| 115 | for (; I != FileEdits.end() && EndOffs > I->first; ++I) { |
| 116 | FileEdit &FA = I->second; |
| 117 | FileOffset B = I->first; |
| 118 | FileOffset E = B.getWithOffset(FA.RemoveLen); |
| 119 | |
| 120 | if (BeginOffs < B) { |
| 121 | bool Invalid = false; |
| 122 | StringRef text = getSourceText(BeginOffs, B, Invalid); |
| 123 | if (Invalid) |
| 124 | return false; |
| 125 | StrVec += text; |
| 126 | } |
| 127 | StrVec += FA.Text; |
| 128 | BeginOffs = E; |
| 129 | } |
| 130 | |
| 131 | if (BeginOffs < EndOffs) { |
| 132 | bool Invalid = false; |
| 133 | StringRef text = getSourceText(BeginOffs, EndOffs, Invalid); |
| 134 | if (Invalid) |
| 135 | return false; |
| 136 | StrVec += text; |
| 137 | } |
| 138 | |
| 139 | return commitInsert(OrigLoc, Offs, StrVec.str(), beforePreviousInsertions); |
| 140 | } |
| 141 | |
| 142 | void EditedSource::commitRemove(SourceLocation OrigLoc, |
| 143 | FileOffset BeginOffs, unsigned Len) { |
| 144 | if (Len == 0) |
| 145 | return; |
| 146 | |
| 147 | FileOffset EndOffs = BeginOffs.getWithOffset(Len); |
| 148 | FileEditsTy::iterator I = FileEdits.upper_bound(BeginOffs); |
| 149 | if (I != FileEdits.begin()) |
| 150 | --I; |
| 151 | |
| 152 | for (; I != FileEdits.end(); ++I) { |
| 153 | FileEdit &FA = I->second; |
| 154 | FileOffset B = I->first; |
| 155 | FileOffset E = B.getWithOffset(FA.RemoveLen); |
| 156 | |
| 157 | if (BeginOffs < E) |
| 158 | break; |
| 159 | } |
| 160 | |
| 161 | FileOffset TopBegin, TopEnd; |
| 162 | FileEdit *TopFA = 0; |
| 163 | |
| 164 | if (I == FileEdits.end()) { |
| 165 | FileEditsTy::iterator |
| 166 | NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit())); |
| 167 | NewI->second.RemoveLen = Len; |
| 168 | return; |
| 169 | } |
| 170 | |
| 171 | FileEdit &FA = I->second; |
| 172 | FileOffset B = I->first; |
| 173 | FileOffset E = B.getWithOffset(FA.RemoveLen); |
| 174 | if (BeginOffs < B) { |
| 175 | FileEditsTy::iterator |
| 176 | NewI = FileEdits.insert(I, std::make_pair(BeginOffs, FileEdit())); |
| 177 | TopBegin = BeginOffs; |
| 178 | TopEnd = EndOffs; |
| 179 | TopFA = &NewI->second; |
| 180 | TopFA->RemoveLen = Len; |
| 181 | } else { |
| 182 | TopBegin = B; |
| 183 | TopEnd = E; |
| 184 | TopFA = &I->second; |
| 185 | if (TopEnd >= EndOffs) |
| 186 | return; |
| 187 | unsigned diff = EndOffs.getOffset() - TopEnd.getOffset(); |
| 188 | TopEnd = EndOffs; |
| 189 | TopFA->RemoveLen += diff; |
| 190 | ++I; |
| 191 | } |
| 192 | |
| 193 | while (I != FileEdits.end()) { |
| 194 | FileEdit &FA = I->second; |
| 195 | FileOffset B = I->first; |
| 196 | FileOffset E = B.getWithOffset(FA.RemoveLen); |
| 197 | |
| 198 | if (B >= TopEnd) |
| 199 | break; |
| 200 | |
| 201 | if (E <= TopEnd) { |
| 202 | FileEdits.erase(I++); |
| 203 | continue; |
| 204 | } |
| 205 | |
| 206 | if (B < TopEnd) { |
| 207 | unsigned diff = E.getOffset() - TopEnd.getOffset(); |
| 208 | TopEnd = E; |
| 209 | TopFA->RemoveLen += diff; |
| 210 | FileEdits.erase(I); |
| 211 | } |
| 212 | |
| 213 | break; |
| 214 | } |
| 215 | } |
| 216 | |
| 217 | bool EditedSource::commit(const Commit &commit) { |
| 218 | if (!commit.isCommitable()) |
| 219 | return false; |
| 220 | |
| 221 | for (edit::Commit::edit_iterator |
| 222 | I = commit.edit_begin(), E = commit.edit_end(); I != E; ++I) { |
| 223 | const edit::Commit::Edit &edit = *I; |
| 224 | switch (edit.Kind) { |
| 225 | case edit::Commit::Act_Insert: |
| 226 | commitInsert(edit.OrigLoc, edit.Offset, edit.Text, edit.BeforePrev); |
| 227 | break; |
| 228 | case edit::Commit::Act_InsertFromRange: |
| 229 | commitInsertFromRange(edit.OrigLoc, edit.Offset, |
| 230 | edit.InsertFromRangeOffs, edit.Length, |
| 231 | edit.BeforePrev); |
| 232 | break; |
| 233 | case edit::Commit::Act_Remove: |
| 234 | commitRemove(edit.OrigLoc, edit.Offset, edit.Length); |
| 235 | break; |
| 236 | } |
| 237 | } |
| 238 | |
| 239 | return true; |
| 240 | } |
| 241 | |
| 242 | static void applyRewrite(EditsReceiver &receiver, |
| 243 | StringRef text, FileOffset offs, unsigned len, |
| 244 | const SourceManager &SM) { |
| 245 | assert(!offs.getFID().isInvalid()); |
| 246 | SourceLocation Loc = SM.getLocForStartOfFile(offs.getFID()); |
| 247 | Loc = Loc.getLocWithOffset(offs.getOffset()); |
| 248 | assert(Loc.isFileID()); |
| 249 | CharSourceRange range = CharSourceRange::getCharRange(Loc, |
| 250 | Loc.getLocWithOffset(len)); |
| 251 | |
| 252 | if (text.empty()) { |
| 253 | assert(len); |
| 254 | receiver.remove(range); |
| 255 | return; |
| 256 | } |
| 257 | |
| 258 | if (len) |
| 259 | receiver.replace(range, text); |
| 260 | else |
| 261 | receiver.insert(Loc, text); |
| 262 | } |
| 263 | |
| 264 | void EditedSource::applyRewrites(EditsReceiver &receiver) { |
| 265 | llvm::SmallString<128> StrVec; |
| 266 | FileOffset CurOffs, CurEnd; |
| 267 | unsigned CurLen; |
| 268 | |
| 269 | if (FileEdits.empty()) |
| 270 | return; |
| 271 | |
| 272 | FileEditsTy::iterator I = FileEdits.begin(); |
| 273 | CurOffs = I->first; |
| 274 | StrVec = I->second.Text; |
| 275 | CurLen = I->second.RemoveLen; |
| 276 | CurEnd = CurOffs.getWithOffset(CurLen); |
| 277 | ++I; |
| 278 | |
| 279 | for (FileEditsTy::iterator E = FileEdits.end(); I != E; ++I) { |
| 280 | FileOffset offs = I->first; |
| 281 | FileEdit act = I->second; |
| 282 | assert(offs >= CurEnd); |
| 283 | |
| 284 | if (offs == CurEnd) { |
| 285 | StrVec += act.Text; |
| 286 | CurLen += act.RemoveLen; |
| 287 | CurEnd.getWithOffset(act.RemoveLen); |
| 288 | continue; |
| 289 | } |
| 290 | |
| 291 | applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr); |
| 292 | CurOffs = offs; |
| 293 | StrVec = act.Text; |
| 294 | CurLen = act.RemoveLen; |
| 295 | CurEnd = CurOffs.getWithOffset(CurLen); |
| 296 | } |
| 297 | |
| 298 | applyRewrite(receiver, StrVec.str(), CurOffs, CurLen, SourceMgr); |
| 299 | } |
| 300 | |
| 301 | void EditedSource::clearRewrites() { |
| 302 | FileEdits.clear(); |
| 303 | StrAlloc.Reset(); |
| 304 | } |
| 305 | |
| 306 | StringRef EditedSource::getSourceText(FileOffset BeginOffs, FileOffset EndOffs, |
| 307 | bool &Invalid) { |
| 308 | assert(BeginOffs.getFID() == EndOffs.getFID()); |
| 309 | assert(BeginOffs <= EndOffs); |
| 310 | SourceLocation BLoc = SourceMgr.getLocForStartOfFile(BeginOffs.getFID()); |
| 311 | BLoc = BLoc.getLocWithOffset(BeginOffs.getOffset()); |
| 312 | assert(BLoc.isFileID()); |
| 313 | SourceLocation |
| 314 | ELoc = BLoc.getLocWithOffset(EndOffs.getOffset() - BeginOffs.getOffset()); |
| 315 | return Lexer::getSourceText(CharSourceRange::getCharRange(BLoc, ELoc), |
| 316 | SourceMgr, LangOpts, &Invalid); |
| 317 | } |
| 318 | |
| 319 | EditedSource::FileEditsTy::iterator |
| 320 | EditedSource::getActionForOffset(FileOffset Offs) { |
| 321 | FileEditsTy::iterator I = FileEdits.upper_bound(Offs); |
| 322 | if (I == FileEdits.begin()) |
| 323 | return FileEdits.end(); |
| 324 | --I; |
| 325 | FileEdit &FA = I->second; |
| 326 | FileOffset B = I->first; |
| 327 | FileOffset E = B.getWithOffset(FA.RemoveLen); |
| 328 | if (Offs >= B && Offs < E) |
| 329 | return I; |
| 330 | |
| 331 | return FileEdits.end(); |
| 332 | } |