1 //===----- Commit.cpp - A unit of 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/Commit.h" 11 #include "clang/Basic/SourceManager.h" 12 #include "clang/Edit/EditedSource.h" 13 #include "clang/Lex/Lexer.h" 14 #include "clang/Lex/PPConditionalDirectiveRecord.h" 15 16 using namespace clang; 17 using namespace edit; 18 19 SourceLocation Commit::Edit::getFileLocation(SourceManager &SM) const { 20 SourceLocation Loc = SM.getLocForStartOfFile(Offset.getFID()); 21 Loc = Loc.getLocWithOffset(Offset.getOffset()); 22 assert(Loc.isFileID()); 23 return Loc; 24 } 25 26 CharSourceRange Commit::Edit::getFileRange(SourceManager &SM) const { 27 SourceLocation Loc = getFileLocation(SM); 28 return CharSourceRange::getCharRange(Loc, Loc.getLocWithOffset(Length)); 29 } 30 31 CharSourceRange Commit::Edit::getInsertFromRange(SourceManager &SM) const { 32 SourceLocation Loc = SM.getLocForStartOfFile(InsertFromRangeOffs.getFID()); 33 Loc = Loc.getLocWithOffset(InsertFromRangeOffs.getOffset()); 34 assert(Loc.isFileID()); 35 return CharSourceRange::getCharRange(Loc, Loc.getLocWithOffset(Length)); 36 } 37 38 Commit::Commit(EditedSource &Editor) 39 : SourceMgr(Editor.getSourceManager()), LangOpts(Editor.getLangOpts()), 40 PPRec(Editor.getPPCondDirectiveRecord()), 41 Editor(&Editor), IsCommitable(true) { } 42 43 bool Commit::insert(SourceLocation loc, StringRef text, 44 bool afterToken, bool beforePreviousInsertions) { 45 if (text.empty()) 46 return true; 47 48 FileOffset Offs; 49 if ((!afterToken && !canInsert(loc, Offs)) || 50 ( afterToken && !canInsertAfterToken(loc, Offs, loc))) { 51 IsCommitable = false; 52 return false; 53 } 54 55 addInsert(loc, Offs, text, beforePreviousInsertions); 56 return true; 57 } 58 59 bool Commit::insertFromRange(SourceLocation loc, 60 CharSourceRange range, 61 bool afterToken, bool beforePreviousInsertions) { 62 FileOffset RangeOffs; 63 unsigned RangeLen; 64 if (!canRemoveRange(range, RangeOffs, RangeLen)) { 65 IsCommitable = false; 66 return false; 67 } 68 69 FileOffset Offs; 70 if ((!afterToken && !canInsert(loc, Offs)) || 71 ( afterToken && !canInsertAfterToken(loc, Offs, loc))) { 72 IsCommitable = false; 73 return false; 74 } 75 76 if (PPRec && 77 PPRec->areInDifferentConditionalDirectiveRegion(loc, range.getBegin())) { 78 IsCommitable = false; 79 return false; 80 } 81 82 addInsertFromRange(loc, Offs, RangeOffs, RangeLen, beforePreviousInsertions); 83 return true; 84 } 85 86 bool Commit::remove(CharSourceRange range) { 87 FileOffset Offs; 88 unsigned Len; 89 if (!canRemoveRange(range, Offs, Len)) { 90 IsCommitable = false; 91 return false; 92 } 93 94 addRemove(range.getBegin(), Offs, Len); 95 return true; 96 } 97 98 bool Commit::insertWrap(StringRef before, CharSourceRange range, 99 StringRef after) { 100 bool commitableBefore = insert(range.getBegin(), before, /*afterToken=*/false, 101 /*beforePreviousInsertions=*/true); 102 bool commitableAfter; 103 if (range.isTokenRange()) 104 commitableAfter = insertAfterToken(range.getEnd(), after); 105 else 106 commitableAfter = insert(range.getEnd(), after); 107 108 return commitableBefore && commitableAfter; 109 } 110 111 bool Commit::replace(CharSourceRange range, StringRef text) { 112 if (text.empty()) 113 return remove(range); 114 115 FileOffset Offs; 116 unsigned Len; 117 if (!canInsert(range.getBegin(), Offs) || !canRemoveRange(range, Offs, Len)) { 118 IsCommitable = false; 119 return false; 120 } 121 122 addRemove(range.getBegin(), Offs, Len); 123 addInsert(range.getBegin(), Offs, text, false); 124 return true; 125 } 126 127 bool Commit::replaceWithInner(CharSourceRange range, 128 CharSourceRange replacementRange) { 129 FileOffset OuterBegin; 130 unsigned OuterLen; 131 if (!canRemoveRange(range, OuterBegin, OuterLen)) { 132 IsCommitable = false; 133 return false; 134 } 135 136 FileOffset InnerBegin; 137 unsigned InnerLen; 138 if (!canRemoveRange(replacementRange, InnerBegin, InnerLen)) { 139 IsCommitable = false; 140 return false; 141 } 142 143 FileOffset OuterEnd = OuterBegin.getWithOffset(OuterLen); 144 FileOffset InnerEnd = InnerBegin.getWithOffset(InnerLen); 145 if (OuterBegin.getFID() != InnerBegin.getFID() || 146 InnerBegin < OuterBegin || 147 InnerBegin > OuterEnd || 148 InnerEnd > OuterEnd) { 149 IsCommitable = false; 150 return false; 151 } 152 153 addRemove(range.getBegin(), 154 OuterBegin, InnerBegin.getOffset() - OuterBegin.getOffset()); 155 addRemove(replacementRange.getEnd(), 156 InnerEnd, OuterEnd.getOffset() - InnerEnd.getOffset()); 157 return true; 158 } 159 160 bool Commit::replaceText(SourceLocation loc, StringRef text, 161 StringRef replacementText) { 162 if (text.empty() || replacementText.empty()) 163 return true; 164 165 FileOffset Offs; 166 unsigned Len; 167 if (!canReplaceText(loc, replacementText, Offs, Len)) { 168 IsCommitable = false; 169 return false; 170 } 171 172 addRemove(loc, Offs, Len); 173 addInsert(loc, Offs, text, false); 174 return true; 175 } 176 177 void Commit::addInsert(SourceLocation OrigLoc, FileOffset Offs, StringRef text, 178 bool beforePreviousInsertions) { 179 if (text.empty()) 180 return; 181 182 Edit data; 183 data.Kind = Act_Insert; 184 data.OrigLoc = OrigLoc; 185 data.Offset = Offs; 186 data.Text = text.copy(StrAlloc); 187 data.BeforePrev = beforePreviousInsertions; 188 CachedEdits.push_back(data); 189 } 190 191 void Commit::addInsertFromRange(SourceLocation OrigLoc, FileOffset Offs, 192 FileOffset RangeOffs, unsigned RangeLen, 193 bool beforePreviousInsertions) { 194 if (RangeLen == 0) 195 return; 196 197 Edit data; 198 data.Kind = Act_InsertFromRange; 199 data.OrigLoc = OrigLoc; 200 data.Offset = Offs; 201 data.InsertFromRangeOffs = RangeOffs; 202 data.Length = RangeLen; 203 data.BeforePrev = beforePreviousInsertions; 204 CachedEdits.push_back(data); 205 } 206 207 void Commit::addRemove(SourceLocation OrigLoc, 208 FileOffset Offs, unsigned Len) { 209 if (Len == 0) 210 return; 211 212 Edit data; 213 data.Kind = Act_Remove; 214 data.OrigLoc = OrigLoc; 215 data.Offset = Offs; 216 data.Length = Len; 217 CachedEdits.push_back(data); 218 } 219 220 bool Commit::canInsert(SourceLocation loc, FileOffset &offs) { 221 if (loc.isInvalid()) 222 return false; 223 224 if (loc.isMacroID()) 225 isAtStartOfMacroExpansion(loc, &loc); 226 227 const SourceManager &SM = SourceMgr; 228 while (SM.isMacroArgExpansion(loc)) 229 loc = SM.getImmediateSpellingLoc(loc); 230 231 if (loc.isMacroID()) 232 if (!isAtStartOfMacroExpansion(loc, &loc)) 233 return false; 234 235 if (SM.isInSystemHeader(loc)) 236 return false; 237 238 std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc); 239 if (locInfo.first.isInvalid()) 240 return false; 241 offs = FileOffset(locInfo.first, locInfo.second); 242 return canInsertInOffset(loc, offs); 243 } 244 245 bool Commit::canInsertAfterToken(SourceLocation loc, FileOffset &offs, 246 SourceLocation &AfterLoc) { 247 if (loc.isInvalid()) 248 249 return false; 250 251 SourceLocation spellLoc = SourceMgr.getSpellingLoc(loc); 252 unsigned tokLen = Lexer::MeasureTokenLength(spellLoc, SourceMgr, LangOpts); 253 AfterLoc = loc.getLocWithOffset(tokLen); 254 255 if (loc.isMacroID()) 256 isAtEndOfMacroExpansion(loc, &loc); 257 258 const SourceManager &SM = SourceMgr; 259 while (SM.isMacroArgExpansion(loc)) 260 loc = SM.getImmediateSpellingLoc(loc); 261 262 if (loc.isMacroID()) 263 if (!isAtEndOfMacroExpansion(loc, &loc)) 264 return false; 265 266 if (SM.isInSystemHeader(loc)) 267 return false; 268 269 loc = Lexer::getLocForEndOfToken(loc, 0, SourceMgr, LangOpts); 270 if (loc.isInvalid()) 271 return false; 272 273 std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc); 274 if (locInfo.first.isInvalid()) 275 return false; 276 offs = FileOffset(locInfo.first, locInfo.second); 277 return canInsertInOffset(loc, offs); 278 } 279 280 bool Commit::canInsertInOffset(SourceLocation OrigLoc, FileOffset Offs) { 281 for (unsigned i = 0, e = CachedEdits.size(); i != e; ++i) { 282 Edit &act = CachedEdits[i]; 283 if (act.Kind == Act_Remove) { 284 if (act.Offset.getFID() == Offs.getFID() && 285 Offs > act.Offset && Offs < act.Offset.getWithOffset(act.Length)) 286 return false; // position has been removed. 287 } 288 } 289 290 if (!Editor) 291 return true; 292 return Editor->canInsertInOffset(OrigLoc, Offs); 293 } 294 295 bool Commit::canRemoveRange(CharSourceRange range, 296 FileOffset &Offs, unsigned &Len) { 297 const SourceManager &SM = SourceMgr; 298 range = Lexer::makeFileCharRange(range, SM, LangOpts); 299 if (range.isInvalid()) 300 return false; 301 302 if (range.getBegin().isMacroID() || range.getEnd().isMacroID()) 303 return false; 304 if (SM.isInSystemHeader(range.getBegin()) || 305 SM.isInSystemHeader(range.getEnd())) 306 return false; 307 308 if (PPRec && PPRec->rangeIntersectsConditionalDirective(range.getAsRange())) 309 return false; 310 311 std::pair<FileID, unsigned> beginInfo = SM.getDecomposedLoc(range.getBegin()); 312 std::pair<FileID, unsigned> endInfo = SM.getDecomposedLoc(range.getEnd()); 313 if (beginInfo.first != endInfo.first || 314 beginInfo.second > endInfo.second) 315 return false; 316 317 Offs = FileOffset(beginInfo.first, beginInfo.second); 318 Len = endInfo.second - beginInfo.second; 319 return true; 320 } 321 322 bool Commit::canReplaceText(SourceLocation loc, StringRef text, 323 FileOffset &Offs, unsigned &Len) { 324 assert(!text.empty()); 325 326 if (!canInsert(loc, Offs)) 327 return false; 328 329 // Try to load the file buffer. 330 bool invalidTemp = false; 331 StringRef file = SourceMgr.getBufferData(Offs.getFID(), &invalidTemp); 332 if (invalidTemp) 333 return false; 334 335 Len = text.size(); 336 return file.substr(Offs.getOffset()).startswith(text); 337 } 338 339 bool Commit::isAtStartOfMacroExpansion(SourceLocation loc, 340 SourceLocation *MacroBegin) const { 341 return Lexer::isAtStartOfMacroExpansion(loc, SourceMgr, LangOpts, MacroBegin); 342 } 343 bool Commit::isAtEndOfMacroExpansion(SourceLocation loc, 344 SourceLocation *MacroEnd) const { 345 return Lexer::isAtEndOfMacroExpansion(loc, SourceMgr, LangOpts, MacroEnd); 346 } 347
