Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 1 | //===--- WhitespaceManager.cpp - Format C++ code --------------------------===// |
| 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 | /// \file |
| 11 | /// \brief This file implements WhitespaceManager class. |
| 12 | /// |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "WhitespaceManager.h" |
| 16 | #include "llvm/ADT/STLExtras.h" |
| 17 | |
| 18 | namespace clang { |
| 19 | namespace format { |
| 20 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 21 | bool |
| 22 | WhitespaceManager::Change::IsBeforeInFile::operator()(const Change &C1, |
| 23 | const Change &C2) const { |
| 24 | return SourceMgr.isBeforeInTranslationUnit( |
| 25 | C1.OriginalWhitespaceRange.getBegin(), |
| 26 | C2.OriginalWhitespaceRange.getBegin()); |
| 27 | } |
Daniel Jasper | 2972d04 | 2013-04-25 08:56:26 +0000 | [diff] [blame] | 28 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 29 | WhitespaceManager::Change::Change( |
| 30 | bool CreateReplacement, const SourceRange &OriginalWhitespaceRange, |
| 31 | unsigned Spaces, unsigned StartOfTokenColumn, unsigned NewlinesBefore, |
| 32 | StringRef PreviousLinePostfix, StringRef CurrentLinePrefix, |
| 33 | tok::TokenKind Kind, bool ContinuesPPDirective) |
| 34 | : CreateReplacement(CreateReplacement), |
| 35 | OriginalWhitespaceRange(OriginalWhitespaceRange), |
| 36 | StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore), |
| 37 | PreviousLinePostfix(PreviousLinePostfix), |
| 38 | CurrentLinePrefix(CurrentLinePrefix), Kind(Kind), |
| 39 | ContinuesPPDirective(ContinuesPPDirective), Spaces(Spaces) {} |
| 40 | |
| 41 | void WhitespaceManager::replaceWhitespace(const AnnotatedToken &Tok, |
| 42 | unsigned Newlines, unsigned Spaces, |
| 43 | unsigned StartOfTokenColumn, |
| 44 | bool InPPDirective) { |
| 45 | Changes.push_back(Change( |
| 46 | true, SourceRange(Tok.FormatTok.WhiteSpaceStart, |
| 47 | Tok.FormatTok.WhiteSpaceStart.getLocWithOffset( |
| 48 | Tok.FormatTok.WhiteSpaceLength)), |
| 49 | Spaces, StartOfTokenColumn, Newlines, "", "", Tok.FormatTok.Tok.getKind(), |
| 50 | InPPDirective && !Tok.FormatTok.IsFirst)); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 51 | |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 52 | // Align line comments if they are trailing or if they continue other |
| 53 | // trailing comments. |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 54 | // FIXME: Pull this out and generalize so it works the same way in broken |
| 55 | // comments and unbroken comments with trailing whitespace. |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 56 | if (Tok.isTrailingComment()) { |
Alexander Kornienko | 919398b | 2013-04-17 17:34:05 +0000 | [diff] [blame] | 57 | SourceLocation TokenEndLoc = Tok.FormatTok.getStartOfNonWhitespace() |
| 58 | .getLocWithOffset(Tok.FormatTok.TokenLength); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 59 | // Remove the comment's trailing whitespace. |
Alexander Kornienko | 919398b | 2013-04-17 17:34:05 +0000 | [diff] [blame] | 60 | if (Tok.FormatTok.TrailingWhiteSpaceLength != 0) |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 61 | Replaces.insert(tooling::Replacement( |
Alexander Kornienko | 919398b | 2013-04-17 17:34:05 +0000 | [diff] [blame] | 62 | SourceMgr, TokenEndLoc, Tok.FormatTok.TrailingWhiteSpaceLength, "")); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 63 | } |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 64 | } |
| 65 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 66 | void WhitespaceManager::addUntouchableToken(const FormatToken &Tok, |
| 67 | bool InPPDirective) { |
| 68 | Changes.push_back(Change( |
| 69 | false, |
| 70 | SourceRange(Tok.WhiteSpaceStart, |
| 71 | Tok.WhiteSpaceStart.getLocWithOffset(Tok.WhiteSpaceLength)), |
| 72 | Tok.WhiteSpaceLength - Tok.NewlinesBefore, |
| 73 | SourceMgr.getSpellingColumnNumber(Tok.Tok.getLocation()) - 1, |
| 74 | Tok.NewlinesBefore, "", "", Tok.Tok.getKind(), |
| 75 | InPPDirective && !Tok.IsFirst)); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 76 | } |
| 77 | |
| 78 | void WhitespaceManager::breakToken(const FormatToken &Tok, unsigned Offset, |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 79 | unsigned ReplaceChars, |
| 80 | StringRef PreviousPostfix, |
| 81 | StringRef CurrentPrefix, bool InPPDirective, |
| 82 | unsigned Spaces) { |
| 83 | Changes.push_back(Change( |
| 84 | true, SourceRange(Tok.getStartOfNonWhitespace().getLocWithOffset(Offset), |
| 85 | Tok.getStartOfNonWhitespace().getLocWithOffset( |
| 86 | Offset + ReplaceChars)), |
| 87 | Spaces, Spaces, 1, PreviousPostfix, CurrentPrefix, |
| 88 | // FIXME: Unify token adjustment, so we don't split it between |
| 89 | // BreakableToken and the WhitespaceManager. That would also allow us to |
| 90 | // correctly store a tok::TokenKind instead of rolling our own enum. |
| 91 | tok::unknown, InPPDirective && !Tok.IsFirst)); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 92 | } |
| 93 | |
| 94 | void WhitespaceManager::addReplacement(const SourceLocation &SourceLoc, |
| 95 | unsigned ReplaceChars, StringRef Text) { |
| 96 | Replaces.insert( |
| 97 | tooling::Replacement(SourceMgr, SourceLoc, ReplaceChars, Text)); |
| 98 | } |
| 99 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 100 | const tooling::Replacements &WhitespaceManager::generateReplacements() { |
| 101 | if (Changes.empty()) |
| 102 | return Replaces; |
| 103 | |
| 104 | std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr)); |
| 105 | calculateLineBreakInformation(); |
| 106 | alignTrailingComments(); |
| 107 | alignEscapedNewlines(); |
| 108 | generateChanges(); |
| 109 | |
| 110 | return Replaces; |
| 111 | } |
| 112 | |
| 113 | void WhitespaceManager::calculateLineBreakInformation() { |
| 114 | Changes[0].PreviousEndOfTokenColumn = 0; |
| 115 | for (unsigned i = 1, e = Changes.size(); i != e; ++i) { |
| 116 | unsigned OriginalWhitespaceStart = |
| 117 | SourceMgr.getFileOffset(Changes[i].OriginalWhitespaceRange.getBegin()); |
| 118 | unsigned PreviousOriginalWhitespaceEnd = SourceMgr.getFileOffset( |
| 119 | Changes[i - 1].OriginalWhitespaceRange.getEnd()); |
| 120 | Changes[i - 1].TokenLength = |
| 121 | OriginalWhitespaceStart - PreviousOriginalWhitespaceEnd + |
| 122 | Changes[i].PreviousLinePostfix.size() + |
| 123 | Changes[i - 1].CurrentLinePrefix.size(); |
| 124 | |
| 125 | Changes[i].PreviousEndOfTokenColumn = |
| 126 | Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength; |
| 127 | |
| 128 | Changes[i - 1].IsTrailingComment = |
| 129 | (Changes[i].NewlinesBefore > 0 || Changes[i].Kind == tok::eof) && |
| 130 | Changes[i - 1].Kind == tok::comment; |
| 131 | } |
| 132 | Changes.back().IsTrailingComment = Changes.back().Kind == tok::comment; |
| 133 | } |
| 134 | |
| 135 | void WhitespaceManager::alignTrailingComments() { |
| 136 | unsigned MinColumn = 0; |
| 137 | unsigned MaxColumn = UINT_MAX; |
| 138 | unsigned StartOfSequence = 0; |
| 139 | bool BreakBeforeNext = false; |
| 140 | unsigned Newlines = 0; |
| 141 | for (unsigned i = 0, e = Changes.size(); i != e; ++i) { |
| 142 | unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn; |
| 143 | // FIXME: Correctly handle ChangeMaxColumn in PP directives. |
| 144 | unsigned ChangeMaxColumn = Style.ColumnLimit - Changes[i].TokenLength; |
| 145 | Newlines += Changes[i].NewlinesBefore; |
| 146 | if (Changes[i].IsTrailingComment) { |
| 147 | if (BreakBeforeNext || Newlines > 1 || |
| 148 | (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) || |
| 149 | // Break the comment sequence if the previous line did not end |
| 150 | // in a trailing comment. |
| 151 | (Changes[i].NewlinesBefore == 1 && i > 0 && |
| 152 | !Changes[i - 1].IsTrailingComment)) { |
| 153 | alignTrailingComments(StartOfSequence, i, MinColumn); |
| 154 | MinColumn = ChangeMinColumn; |
| 155 | MaxColumn = ChangeMaxColumn; |
| 156 | StartOfSequence = i; |
| 157 | } else { |
| 158 | MinColumn = std::max(MinColumn, ChangeMinColumn); |
| 159 | MaxColumn = std::min(MaxColumn, ChangeMaxColumn); |
| 160 | } |
| 161 | BreakBeforeNext = |
| 162 | (i == 0) || (Changes[i].NewlinesBefore > 1) || |
| 163 | (Changes[i].NewlinesBefore == 1 && !Changes[i - 1].IsTrailingComment); |
| 164 | Newlines = 0; |
| 165 | } |
| 166 | } |
| 167 | alignTrailingComments(StartOfSequence, Changes.size(), MinColumn); |
| 168 | } |
| 169 | |
| 170 | void WhitespaceManager::alignTrailingComments(unsigned Start, unsigned End, |
| 171 | unsigned Column) { |
| 172 | for (unsigned i = Start; i != End; ++i) { |
| 173 | if (Changes[i].IsTrailingComment) { |
| 174 | assert(Column >= Changes[i].StartOfTokenColumn); |
| 175 | Changes[i].Spaces += Column - Changes[i].StartOfTokenColumn; |
| 176 | Changes[i].StartOfTokenColumn = Column; |
| 177 | } |
| 178 | } |
| 179 | } |
| 180 | |
| 181 | void WhitespaceManager::alignEscapedNewlines() { |
| 182 | unsigned MaxEndOfLine = 0; |
| 183 | unsigned StartOfMacro = 0; |
| 184 | for (unsigned i = 1, e = Changes.size(); i < e; ++i) { |
| 185 | Change &C = Changes[i]; |
| 186 | if (C.NewlinesBefore > 0) { |
| 187 | if (C.ContinuesPPDirective) { |
| 188 | if (Style.AlignEscapedNewlinesLeft) |
| 189 | MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine); |
| 190 | else |
| 191 | MaxEndOfLine = Style.ColumnLimit; |
| 192 | } else { |
| 193 | alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine); |
| 194 | MaxEndOfLine = 0; |
| 195 | StartOfMacro = i; |
| 196 | } |
| 197 | } |
| 198 | } |
| 199 | alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine); |
| 200 | } |
| 201 | |
| 202 | void WhitespaceManager::alignEscapedNewlines(unsigned Start, unsigned End, |
| 203 | unsigned Column) { |
| 204 | for (unsigned i = Start; i < End; ++i) { |
| 205 | Change &C = Changes[i]; |
| 206 | if (C.NewlinesBefore > 0) { |
| 207 | assert(C.ContinuesPPDirective); |
| 208 | if (C.PreviousEndOfTokenColumn + 1 > Column) |
| 209 | C.EscapedNewlineColumn = 0; |
| 210 | else |
| 211 | C.EscapedNewlineColumn = Column; |
| 212 | } |
| 213 | } |
| 214 | } |
| 215 | |
| 216 | void WhitespaceManager::generateChanges() { |
| 217 | for (unsigned i = 0, e = Changes.size(); i != e; ++i) { |
| 218 | const Change &C = Changes[i]; |
| 219 | if (C.CreateReplacement) { |
| 220 | std::string ReplacementText = |
| 221 | C.PreviousLinePostfix + |
| 222 | (C.ContinuesPPDirective |
| 223 | ? getNewLineText(C.NewlinesBefore, C.Spaces, |
| 224 | C.PreviousEndOfTokenColumn, |
| 225 | C.EscapedNewlineColumn) |
| 226 | : getNewLineText(C.NewlinesBefore, C.Spaces)) + |
| 227 | C.CurrentLinePrefix; |
| 228 | storeReplacement(C.OriginalWhitespaceRange, ReplacementText); |
| 229 | } |
| 230 | } |
| 231 | } |
| 232 | |
| 233 | void WhitespaceManager::storeReplacement(const SourceRange &Range, |
| 234 | StringRef Text) { |
| 235 | unsigned WhitespaceLength = SourceMgr.getFileOffset(Range.getEnd()) - |
| 236 | SourceMgr.getFileOffset(Range.getBegin()); |
| 237 | // Don't create a replacement, if it does not change anything. |
| 238 | if (StringRef(SourceMgr.getCharacterData(Range.getBegin()), |
| 239 | WhitespaceLength) == |
| 240 | Text) |
| 241 | return; |
| 242 | Replaces.insert(tooling::Replacement( |
| 243 | SourceMgr, CharSourceRange::getCharRange(Range), Text)); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 244 | } |
| 245 | |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 246 | std::string WhitespaceManager::getNewLineText(unsigned NewLines, |
| 247 | unsigned Spaces) { |
Manuel Klimek | 7c9a93e | 2013-05-13 09:22:11 +0000 | [diff] [blame] | 248 | return std::string(NewLines, '\n') + getIndentText(Spaces); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | std::string WhitespaceManager::getNewLineText(unsigned NewLines, |
| 252 | unsigned Spaces, |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 253 | unsigned PreviousEndOfTokenColumn, |
Daniel Jasper | 2972d04 | 2013-04-25 08:56:26 +0000 | [diff] [blame] | 254 | unsigned EscapedNewlineColumn) { |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 255 | std::string NewLineText; |
| 256 | if (NewLines > 0) { |
| 257 | unsigned Offset = |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame^] | 258 | std::min<int>(EscapedNewlineColumn - 1, PreviousEndOfTokenColumn); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 259 | for (unsigned i = 0; i < NewLines; ++i) { |
Daniel Jasper | 2972d04 | 2013-04-25 08:56:26 +0000 | [diff] [blame] | 260 | NewLineText += std::string(EscapedNewlineColumn - Offset - 1, ' '); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 261 | NewLineText += "\\\n"; |
| 262 | Offset = 0; |
| 263 | } |
| 264 | } |
Manuel Klimek | 7c9a93e | 2013-05-13 09:22:11 +0000 | [diff] [blame] | 265 | return NewLineText + getIndentText(Spaces); |
| 266 | } |
| 267 | |
| 268 | std::string WhitespaceManager::getIndentText(unsigned Spaces) { |
Manuel Klimek | 967d9e9 | 2013-05-13 12:53:04 +0000 | [diff] [blame] | 269 | if (!Style.UseTab) |
Manuel Klimek | 7c9a93e | 2013-05-13 09:22:11 +0000 | [diff] [blame] | 270 | return std::string(Spaces, ' '); |
Manuel Klimek | 967d9e9 | 2013-05-13 12:53:04 +0000 | [diff] [blame] | 271 | |
Manuel Klimek | 7c9a93e | 2013-05-13 09:22:11 +0000 | [diff] [blame] | 272 | return std::string(Spaces / Style.IndentWidth, '\t') + |
| 273 | std::string(Spaces % Style.IndentWidth, ' '); |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 274 | } |
| 275 | |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 276 | } // namespace format |
| 277 | } // namespace clang |