| //===--- WhitespaceManager.cpp - Format C++ code --------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// \brief This file implements WhitespaceManager class. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #include "WhitespaceManager.h" |
| #include "llvm/ADT/STLExtras.h" |
| |
| namespace clang { |
| namespace format { |
| |
| bool WhitespaceManager::Change::IsBeforeInFile:: |
| operator()(const Change &C1, const Change &C2) const { |
| return SourceMgr.isBeforeInTranslationUnit( |
| C1.OriginalWhitespaceRange.getBegin(), |
| C2.OriginalWhitespaceRange.getBegin()); |
| } |
| |
| WhitespaceManager::Change::Change(const FormatToken &Tok, |
| bool CreateReplacement, |
| SourceRange OriginalWhitespaceRange, |
| int Spaces, unsigned StartOfTokenColumn, |
| unsigned NewlinesBefore, |
| StringRef PreviousLinePostfix, |
| StringRef CurrentLinePrefix, |
| bool ContinuesPPDirective, bool IsInsideToken) |
| : Tok(&Tok), CreateReplacement(CreateReplacement), |
| OriginalWhitespaceRange(OriginalWhitespaceRange), |
| StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore), |
| PreviousLinePostfix(PreviousLinePostfix), |
| CurrentLinePrefix(CurrentLinePrefix), |
| ContinuesPPDirective(ContinuesPPDirective), Spaces(Spaces), |
| IsInsideToken(IsInsideToken), IsTrailingComment(false), TokenLength(0), |
| PreviousEndOfTokenColumn(0), EscapedNewlineColumn(0), |
| StartOfBlockComment(nullptr), IndentationOffset(0) {} |
| |
| void WhitespaceManager::replaceWhitespace(FormatToken &Tok, unsigned Newlines, |
| unsigned Spaces, |
| unsigned StartOfTokenColumn, |
| bool InPPDirective) { |
| if (Tok.Finalized) |
| return; |
| Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue; |
| Changes.push_back(Change(Tok, /*CreateReplacement=*/true, Tok.WhitespaceRange, |
| Spaces, StartOfTokenColumn, Newlines, "", "", |
| InPPDirective && !Tok.IsFirst, |
| /*IsInsideToken=*/false)); |
| } |
| |
| void WhitespaceManager::addUntouchableToken(const FormatToken &Tok, |
| bool InPPDirective) { |
| if (Tok.Finalized) |
| return; |
| Changes.push_back(Change(Tok, /*CreateReplacement=*/false, |
| Tok.WhitespaceRange, /*Spaces=*/0, |
| Tok.OriginalColumn, Tok.NewlinesBefore, "", "", |
| InPPDirective && !Tok.IsFirst, |
| /*IsInsideToken=*/false)); |
| } |
| |
| llvm::Error |
| WhitespaceManager::addReplacement(const tooling::Replacement &Replacement) { |
| return Replaces.add(Replacement); |
| } |
| |
| void WhitespaceManager::replaceWhitespaceInToken( |
| const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars, |
| StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective, |
| unsigned Newlines, int Spaces) { |
| if (Tok.Finalized) |
| return; |
| SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset); |
| Changes.push_back( |
| Change(Tok, /*CreateReplacement=*/true, |
| SourceRange(Start, Start.getLocWithOffset(ReplaceChars)), Spaces, |
| std::max(0, Spaces), Newlines, PreviousPostfix, CurrentPrefix, |
| InPPDirective && !Tok.IsFirst, /*IsInsideToken=*/true)); |
| } |
| |
| const tooling::Replacements &WhitespaceManager::generateReplacements() { |
| if (Changes.empty()) |
| return Replaces; |
| |
| std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr)); |
| calculateLineBreakInformation(); |
| alignConsecutiveDeclarations(); |
| alignConsecutiveAssignments(); |
| alignTrailingComments(); |
| alignEscapedNewlines(); |
| generateChanges(); |
| |
| return Replaces; |
| } |
| |
| void WhitespaceManager::calculateLineBreakInformation() { |
| Changes[0].PreviousEndOfTokenColumn = 0; |
| Change *LastOutsideTokenChange = &Changes[0]; |
| for (unsigned i = 1, e = Changes.size(); i != e; ++i) { |
| SourceLocation OriginalWhitespaceStart = |
| Changes[i].OriginalWhitespaceRange.getBegin(); |
| SourceLocation PreviousOriginalWhitespaceEnd = |
| Changes[i - 1].OriginalWhitespaceRange.getEnd(); |
| unsigned OriginalWhitespaceStartOffset = |
| SourceMgr.getFileOffset(OriginalWhitespaceStart); |
| unsigned PreviousOriginalWhitespaceEndOffset = |
| SourceMgr.getFileOffset(PreviousOriginalWhitespaceEnd); |
| assert(PreviousOriginalWhitespaceEndOffset <= |
| OriginalWhitespaceStartOffset); |
| const char *const PreviousOriginalWhitespaceEndData = |
| SourceMgr.getCharacterData(PreviousOriginalWhitespaceEnd); |
| StringRef Text(PreviousOriginalWhitespaceEndData, |
| SourceMgr.getCharacterData(OriginalWhitespaceStart) - |
| PreviousOriginalWhitespaceEndData); |
| // Usually consecutive changes would occur in consecutive tokens. This is |
| // not the case however when analyzing some preprocessor runs of the |
| // annotated lines. For example, in this code: |
| // |
| // #if A // line 1 |
| // int i = 1; |
| // #else B // line 2 |
| // int i = 2; |
| // #endif // line 3 |
| // |
| // one of the runs will produce the sequence of lines marked with line 1, 2 |
| // and 3. So the two consecutive whitespace changes just before '// line 2' |
| // and before '#endif // line 3' span multiple lines and tokens: |
| // |
| // #else B{change X}[// line 2 |
| // int i = 2; |
| // ]{change Y}#endif // line 3 |
| // |
| // For this reason, if the text between consecutive changes spans multiple |
| // newlines, the token length must be adjusted to the end of the original |
| // line of the token. |
| auto NewlinePos = Text.find_first_of('\n'); |
| if (NewlinePos == StringRef::npos) { |
| Changes[i - 1].TokenLength = OriginalWhitespaceStartOffset - |
| PreviousOriginalWhitespaceEndOffset + |
| Changes[i].PreviousLinePostfix.size() + |
| Changes[i - 1].CurrentLinePrefix.size(); |
| } else { |
| Changes[i - 1].TokenLength = |
| NewlinePos + Changes[i - 1].CurrentLinePrefix.size(); |
| } |
| |
| // If there are multiple changes in this token, sum up all the changes until |
| // the end of the line. |
| if (Changes[i - 1].IsInsideToken && Changes[i - 1].NewlinesBefore == 0) |
| LastOutsideTokenChange->TokenLength += |
| Changes[i - 1].TokenLength + Changes[i - 1].Spaces; |
| else |
| LastOutsideTokenChange = &Changes[i - 1]; |
| |
| Changes[i].PreviousEndOfTokenColumn = |
| Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength; |
| |
| Changes[i - 1].IsTrailingComment = |
| (Changes[i].NewlinesBefore > 0 || Changes[i].Tok->is(tok::eof) || |
| (Changes[i].IsInsideToken && Changes[i].Tok->is(tok::comment))) && |
| Changes[i - 1].Tok->is(tok::comment) && |
| // FIXME: This is a dirty hack. The problem is that |
| // BreakableLineCommentSection does comment reflow changes and here is |
| // the aligning of trailing comments. Consider the case where we reflow |
| // the second line up in this example: |
| // |
| // // line 1 |
| // // line 2 |
| // |
| // That amounts to 2 changes by BreakableLineCommentSection: |
| // - the first, delimited by (), for the whitespace between the tokens, |
| // - and second, delimited by [], for the whitespace at the beginning |
| // of the second token: |
| // |
| // // line 1( |
| // )[// ]line 2 |
| // |
| // So in the end we have two changes like this: |
| // |
| // // line1()[ ]line 2 |
| // |
| // Note that the OriginalWhitespaceStart of the second change is the |
| // same as the PreviousOriginalWhitespaceEnd of the first change. |
| // In this case, the below check ensures that the second change doesn't |
| // get treated as a trailing comment change here, since this might |
| // trigger additional whitespace to be wrongly inserted before "line 2" |
| // by the comment aligner here. |
| // |
| // For a proper solution we need a mechanism to say to WhitespaceManager |
| // that a particular change breaks the current sequence of trailing |
| // comments. |
| OriginalWhitespaceStart != PreviousOriginalWhitespaceEnd; |
| } |
| // FIXME: The last token is currently not always an eof token; in those |
| // cases, setting TokenLength of the last token to 0 is wrong. |
| Changes.back().TokenLength = 0; |
| Changes.back().IsTrailingComment = Changes.back().Tok->is(tok::comment); |
| |
| const WhitespaceManager::Change *LastBlockComment = nullptr; |
| for (auto &Change : Changes) { |
| // Reset the IsTrailingComment flag for changes inside of trailing comments |
| // so they don't get realigned later. Comment line breaks however still need |
| // to be aligned. |
| if (Change.IsInsideToken && Change.NewlinesBefore == 0) |
| Change.IsTrailingComment = false; |
| Change.StartOfBlockComment = nullptr; |
| Change.IndentationOffset = 0; |
| if (Change.Tok->is(tok::comment)) { |
| if (Change.Tok->is(TT_LineComment) || !Change.IsInsideToken) |
| LastBlockComment = &Change; |
| else { |
| if ((Change.StartOfBlockComment = LastBlockComment)) |
| Change.IndentationOffset = |
| Change.StartOfTokenColumn - |
| Change.StartOfBlockComment->StartOfTokenColumn; |
| } |
| } else { |
| LastBlockComment = nullptr; |
| } |
| } |
| } |
| |
| // Align a single sequence of tokens, see AlignTokens below. |
| template <typename F> |
| static void |
| AlignTokenSequence(unsigned Start, unsigned End, unsigned Column, F &&Matches, |
| SmallVector<WhitespaceManager::Change, 16> &Changes) { |
| bool FoundMatchOnLine = false; |
| int Shift = 0; |
| |
| // ScopeStack keeps track of the current scope depth. It contains indices of |
| // the first token on each scope. |
| // We only run the "Matches" function on tokens from the outer-most scope. |
| // However, we do need to pay special attention to one class of tokens |
| // that are not in the outer-most scope, and that is function parameters |
| // which are split across multiple lines, as illustrated by this example: |
| // double a(int x); |
| // int b(int y, |
| // double z); |
| // In the above example, we need to take special care to ensure that |
| // 'double z' is indented along with it's owning function 'b'. |
| SmallVector<unsigned, 16> ScopeStack; |
| |
| for (unsigned i = Start; i != End; ++i) { |
| if (ScopeStack.size() != 0 && |
| Changes[i].indentAndNestingLevel() < |
| Changes[ScopeStack.back()].indentAndNestingLevel()) |
| ScopeStack.pop_back(); |
| |
| if (i != Start && Changes[i].indentAndNestingLevel() > |
| Changes[i - 1].indentAndNestingLevel()) |
| ScopeStack.push_back(i); |
| |
| bool InsideNestedScope = ScopeStack.size() != 0; |
| |
| if (Changes[i].NewlinesBefore > 0 && !InsideNestedScope) { |
| Shift = 0; |
| FoundMatchOnLine = false; |
| } |
| |
| // If this is the first matching token to be aligned, remember by how many |
| // spaces it has to be shifted, so the rest of the changes on the line are |
| // shifted by the same amount |
| if (!FoundMatchOnLine && !InsideNestedScope && Matches(Changes[i])) { |
| FoundMatchOnLine = true; |
| Shift = Column - Changes[i].StartOfTokenColumn; |
| Changes[i].Spaces += Shift; |
| } |
| |
| // This is for function parameters that are split across multiple lines, |
| // as mentioned in the ScopeStack comment. |
| if (InsideNestedScope && Changes[i].NewlinesBefore > 0) { |
| unsigned ScopeStart = ScopeStack.back(); |
| if (Changes[ScopeStart - 1].Tok->is(TT_FunctionDeclarationName) || |
| (ScopeStart > Start + 1 && |
| Changes[ScopeStart - 2].Tok->is(TT_FunctionDeclarationName))) |
| Changes[i].Spaces += Shift; |
| } |
| |
| assert(Shift >= 0); |
| Changes[i].StartOfTokenColumn += Shift; |
| if (i + 1 != Changes.size()) |
| Changes[i + 1].PreviousEndOfTokenColumn += Shift; |
| } |
| } |
| |
| // Walk through a subset of the changes, starting at StartAt, and find |
| // sequences of matching tokens to align. To do so, keep track of the lines and |
| // whether or not a matching token was found on a line. If a matching token is |
| // found, extend the current sequence. If the current line cannot be part of a |
| // sequence, e.g. because there is an empty line before it or it contains only |
| // non-matching tokens, finalize the previous sequence. |
| // The value returned is the token on which we stopped, either because we |
| // exhausted all items inside Changes, or because we hit a scope level higher |
| // than our initial scope. |
| // This function is recursive. Each invocation processes only the scope level |
| // equal to the initial level, which is the level of Changes[StartAt]. |
| // If we encounter a scope level greater than the initial level, then we call |
| // ourselves recursively, thereby avoiding the pollution of the current state |
| // with the alignment requirements of the nested sub-level. This recursive |
| // behavior is necessary for aligning function prototypes that have one or more |
| // arguments. |
| // If this function encounters a scope level less than the initial level, |
| // it returns the current position. |
| // There is a non-obvious subtlety in the recursive behavior: Even though we |
| // defer processing of nested levels to recursive invocations of this |
| // function, when it comes time to align a sequence of tokens, we run the |
| // alignment on the entire sequence, including the nested levels. |
| // When doing so, most of the nested tokens are skipped, because their |
| // alignment was already handled by the recursive invocations of this function. |
| // However, the special exception is that we do NOT skip function parameters |
| // that are split across multiple lines. See the test case in FormatTest.cpp |
| // that mentions "split function parameter alignment" for an example of this. |
| template <typename F> |
| static unsigned AlignTokens(const FormatStyle &Style, F &&Matches, |
| SmallVector<WhitespaceManager::Change, 16> &Changes, |
| unsigned StartAt) { |
| unsigned MinColumn = 0; |
| unsigned MaxColumn = UINT_MAX; |
| |
| // Line number of the start and the end of the current token sequence. |
| unsigned StartOfSequence = 0; |
| unsigned EndOfSequence = 0; |
| |
| // Measure the scope level (i.e. depth of (), [], {}) of the first token, and |
| // abort when we hit any token in a higher scope than the starting one. |
| auto IndentAndNestingLevel = StartAt < Changes.size() |
| ? Changes[StartAt].indentAndNestingLevel() |
| : std::pair<unsigned, unsigned>(0, 0); |
| |
| // Keep track of the number of commas before the matching tokens, we will only |
| // align a sequence of matching tokens if they are preceded by the same number |
| // of commas. |
| unsigned CommasBeforeLastMatch = 0; |
| unsigned CommasBeforeMatch = 0; |
| |
| // Whether a matching token has been found on the current line. |
| bool FoundMatchOnLine = false; |
| |
| // Aligns a sequence of matching tokens, on the MinColumn column. |
| // |
| // Sequences start from the first matching token to align, and end at the |
| // first token of the first line that doesn't need to be aligned. |
| // |
| // We need to adjust the StartOfTokenColumn of each Change that is on a line |
| // containing any matching token to be aligned and located after such token. |
| auto AlignCurrentSequence = [&] { |
| if (StartOfSequence > 0 && StartOfSequence < EndOfSequence) |
| AlignTokenSequence(StartOfSequence, EndOfSequence, MinColumn, Matches, |
| Changes); |
| MinColumn = 0; |
| MaxColumn = UINT_MAX; |
| StartOfSequence = 0; |
| EndOfSequence = 0; |
| }; |
| |
| unsigned i = StartAt; |
| for (unsigned e = Changes.size(); i != e; ++i) { |
| if (Changes[i].indentAndNestingLevel() < IndentAndNestingLevel) |
| break; |
| |
| if (Changes[i].NewlinesBefore != 0) { |
| CommasBeforeMatch = 0; |
| EndOfSequence = i; |
| // If there is a blank line, or if the last line didn't contain any |
| // matching token, the sequence ends here. |
| if (Changes[i].NewlinesBefore > 1 || !FoundMatchOnLine) |
| AlignCurrentSequence(); |
| |
| FoundMatchOnLine = false; |
| } |
| |
| if (Changes[i].Tok->is(tok::comma)) { |
| ++CommasBeforeMatch; |
| } else if (Changes[i].indentAndNestingLevel() > IndentAndNestingLevel) { |
| // Call AlignTokens recursively, skipping over this scope block. |
| unsigned StoppedAt = AlignTokens(Style, Matches, Changes, i); |
| i = StoppedAt - 1; |
| continue; |
| } |
| |
| if (!Matches(Changes[i])) |
| continue; |
| |
| // If there is more than one matching token per line, or if the number of |
| // preceding commas, do not match anymore, end the sequence. |
| if (FoundMatchOnLine || CommasBeforeMatch != CommasBeforeLastMatch) |
| AlignCurrentSequence(); |
| |
| CommasBeforeLastMatch = CommasBeforeMatch; |
| FoundMatchOnLine = true; |
| |
| if (StartOfSequence == 0) |
| StartOfSequence = i; |
| |
| unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn; |
| int LineLengthAfter = -Changes[i].Spaces; |
| for (unsigned j = i; j != e && Changes[j].NewlinesBefore == 0; ++j) |
| LineLengthAfter += Changes[j].Spaces + Changes[j].TokenLength; |
| unsigned ChangeMaxColumn = Style.ColumnLimit - LineLengthAfter; |
| |
| // If we are restricted by the maximum column width, end the sequence. |
| if (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn || |
| CommasBeforeLastMatch != CommasBeforeMatch) { |
| AlignCurrentSequence(); |
| StartOfSequence = i; |
| } |
| |
| MinColumn = std::max(MinColumn, ChangeMinColumn); |
| MaxColumn = std::min(MaxColumn, ChangeMaxColumn); |
| } |
| |
| EndOfSequence = i; |
| AlignCurrentSequence(); |
| return i; |
| } |
| |
| void WhitespaceManager::alignConsecutiveAssignments() { |
| if (!Style.AlignConsecutiveAssignments) |
| return; |
| |
| AlignTokens(Style, |
| [&](const Change &C) { |
| // Do not align on equal signs that are first on a line. |
| if (C.NewlinesBefore > 0) |
| return false; |
| |
| // Do not align on equal signs that are last on a line. |
| if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0) |
| return false; |
| |
| return C.Tok->is(tok::equal); |
| }, |
| Changes, /*StartAt=*/0); |
| } |
| |
| void WhitespaceManager::alignConsecutiveDeclarations() { |
| if (!Style.AlignConsecutiveDeclarations) |
| return; |
| |
| // FIXME: Currently we don't handle properly the PointerAlignment: Right |
| // The * and & are not aligned and are left dangling. Something has to be done |
| // about it, but it raises the question of alignment of code like: |
| // const char* const* v1; |
| // float const* v2; |
| // SomeVeryLongType const& v3; |
| AlignTokens(Style, |
| [](Change const &C) { |
| // tok::kw_operator is necessary for aligning operator overload |
| // definitions. |
| return C.Tok->is(TT_StartOfName) || |
| C.Tok->is(TT_FunctionDeclarationName) || |
| C.Tok->is(tok::kw_operator); |
| }, |
| Changes, /*StartAt=*/0); |
| } |
| |
| void WhitespaceManager::alignTrailingComments() { |
| unsigned MinColumn = 0; |
| unsigned MaxColumn = UINT_MAX; |
| unsigned StartOfSequence = 0; |
| bool BreakBeforeNext = false; |
| unsigned Newlines = 0; |
| for (unsigned i = 0, e = Changes.size(); i != e; ++i) { |
| if (Changes[i].StartOfBlockComment) |
| continue; |
| Newlines += Changes[i].NewlinesBefore; |
| if (!Changes[i].IsTrailingComment) |
| continue; |
| |
| unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn; |
| unsigned ChangeMaxColumn; |
| |
| if (Style.ColumnLimit == 0) |
| ChangeMaxColumn = UINT_MAX; |
| else if (Style.ColumnLimit >= Changes[i].TokenLength) |
| ChangeMaxColumn = Style.ColumnLimit - Changes[i].TokenLength; |
| else |
| ChangeMaxColumn = ChangeMinColumn; |
| |
| // If we don't create a replacement for this change, we have to consider |
| // it to be immovable. |
| if (!Changes[i].CreateReplacement) |
| ChangeMaxColumn = ChangeMinColumn; |
| |
| if (i + 1 != e && Changes[i + 1].ContinuesPPDirective) |
| ChangeMaxColumn -= 2; |
| // If this comment follows an } in column 0, it probably documents the |
| // closing of a namespace and we don't want to align it. |
| bool FollowsRBraceInColumn0 = i > 0 && Changes[i].NewlinesBefore == 0 && |
| Changes[i - 1].Tok->is(tok::r_brace) && |
| Changes[i - 1].StartOfTokenColumn == 0; |
| bool WasAlignedWithStartOfNextLine = false; |
| if (Changes[i].NewlinesBefore == 1) { // A comment on its own line. |
| unsigned CommentColumn = SourceMgr.getSpellingColumnNumber( |
| Changes[i].OriginalWhitespaceRange.getEnd()); |
| for (unsigned j = i + 1; j != e; ++j) { |
| if (Changes[j].Tok->is(tok::comment)) |
| continue; |
| |
| unsigned NextColumn = SourceMgr.getSpellingColumnNumber( |
| Changes[j].OriginalWhitespaceRange.getEnd()); |
| // The start of the next token was previously aligned with the |
| // start of this comment. |
| WasAlignedWithStartOfNextLine = |
| CommentColumn == NextColumn || |
| CommentColumn == NextColumn + Style.IndentWidth; |
| break; |
| } |
| } |
| if (!Style.AlignTrailingComments || FollowsRBraceInColumn0) { |
| alignTrailingComments(StartOfSequence, i, MinColumn); |
| MinColumn = ChangeMinColumn; |
| MaxColumn = ChangeMinColumn; |
| StartOfSequence = i; |
| } else if (BreakBeforeNext || Newlines > 1 || |
| (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) || |
| // Break the comment sequence if the previous line did not end |
| // in a trailing comment. |
| (Changes[i].NewlinesBefore == 1 && i > 0 && |
| !Changes[i - 1].IsTrailingComment) || |
| WasAlignedWithStartOfNextLine) { |
| alignTrailingComments(StartOfSequence, i, MinColumn); |
| MinColumn = ChangeMinColumn; |
| MaxColumn = ChangeMaxColumn; |
| StartOfSequence = i; |
| } else { |
| MinColumn = std::max(MinColumn, ChangeMinColumn); |
| MaxColumn = std::min(MaxColumn, ChangeMaxColumn); |
| } |
| BreakBeforeNext = |
| (i == 0) || (Changes[i].NewlinesBefore > 1) || |
| // Never start a sequence with a comment at the beginning of |
| // the line. |
| (Changes[i].NewlinesBefore == 1 && StartOfSequence == i); |
| Newlines = 0; |
| } |
| alignTrailingComments(StartOfSequence, Changes.size(), MinColumn); |
| } |
| |
| void WhitespaceManager::alignTrailingComments(unsigned Start, unsigned End, |
| unsigned Column) { |
| for (unsigned i = Start; i != End; ++i) { |
| int Shift = 0; |
| if (Changes[i].IsTrailingComment) { |
| Shift = Column - Changes[i].StartOfTokenColumn; |
| } |
| if (Changes[i].StartOfBlockComment) { |
| Shift = Changes[i].IndentationOffset + |
| Changes[i].StartOfBlockComment->StartOfTokenColumn - |
| Changes[i].StartOfTokenColumn; |
| } |
| assert(Shift >= 0); |
| Changes[i].Spaces += Shift; |
| if (i + 1 != Changes.size()) |
| Changes[i + 1].PreviousEndOfTokenColumn += Shift; |
| Changes[i].StartOfTokenColumn += Shift; |
| } |
| } |
| |
| void WhitespaceManager::alignEscapedNewlines() { |
| if (Style.AlignEscapedNewlines == FormatStyle::ENAS_DontAlign) |
| return; |
| |
| bool AlignLeft = Style.AlignEscapedNewlines == FormatStyle::ENAS_Left; |
| unsigned MaxEndOfLine = AlignLeft ? 0 : Style.ColumnLimit; |
| unsigned StartOfMacro = 0; |
| for (unsigned i = 1, e = Changes.size(); i < e; ++i) { |
| Change &C = Changes[i]; |
| if (C.NewlinesBefore > 0) { |
| if (C.ContinuesPPDirective) { |
| MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine); |
| } else { |
| alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine); |
| MaxEndOfLine = AlignLeft ? 0 : Style.ColumnLimit; |
| StartOfMacro = i; |
| } |
| } |
| } |
| alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine); |
| } |
| |
| void WhitespaceManager::alignEscapedNewlines(unsigned Start, unsigned End, |
| unsigned Column) { |
| for (unsigned i = Start; i < End; ++i) { |
| Change &C = Changes[i]; |
| if (C.NewlinesBefore > 0) { |
| assert(C.ContinuesPPDirective); |
| if (C.PreviousEndOfTokenColumn + 1 > Column) |
| C.EscapedNewlineColumn = 0; |
| else |
| C.EscapedNewlineColumn = Column; |
| } |
| } |
| } |
| |
| void WhitespaceManager::generateChanges() { |
| for (unsigned i = 0, e = Changes.size(); i != e; ++i) { |
| const Change &C = Changes[i]; |
| if (i > 0) { |
| assert(Changes[i - 1].OriginalWhitespaceRange.getBegin() != |
| C.OriginalWhitespaceRange.getBegin() && |
| "Generating two replacements for the same location"); |
| } |
| if (C.CreateReplacement) { |
| std::string ReplacementText = C.PreviousLinePostfix; |
| if (C.ContinuesPPDirective) |
| appendEscapedNewlineText(ReplacementText, C.NewlinesBefore, |
| C.PreviousEndOfTokenColumn, |
| C.EscapedNewlineColumn); |
| else |
| appendNewlineText(ReplacementText, C.NewlinesBefore); |
| appendIndentText(ReplacementText, C.Tok->IndentLevel, |
| std::max(0, C.Spaces), |
| C.StartOfTokenColumn - std::max(0, C.Spaces)); |
| ReplacementText.append(C.CurrentLinePrefix); |
| storeReplacement(C.OriginalWhitespaceRange, ReplacementText); |
| } |
| } |
| } |
| |
| void WhitespaceManager::storeReplacement(SourceRange Range, StringRef Text) { |
| unsigned WhitespaceLength = SourceMgr.getFileOffset(Range.getEnd()) - |
| SourceMgr.getFileOffset(Range.getBegin()); |
| // Don't create a replacement, if it does not change anything. |
| if (StringRef(SourceMgr.getCharacterData(Range.getBegin()), |
| WhitespaceLength) == Text) |
| return; |
| auto Err = Replaces.add(tooling::Replacement( |
| SourceMgr, CharSourceRange::getCharRange(Range), Text)); |
| // FIXME: better error handling. For now, just print an error message in the |
| // release version. |
| if (Err) { |
| llvm::errs() << llvm::toString(std::move(Err)) << "\n"; |
| assert(false); |
| } |
| } |
| |
| void WhitespaceManager::appendNewlineText(std::string &Text, |
| unsigned Newlines) { |
| for (unsigned i = 0; i < Newlines; ++i) |
| Text.append(UseCRLF ? "\r\n" : "\n"); |
| } |
| |
| void WhitespaceManager::appendEscapedNewlineText( |
| std::string &Text, unsigned Newlines, unsigned PreviousEndOfTokenColumn, |
| unsigned EscapedNewlineColumn) { |
| if (Newlines > 0) { |
| unsigned Spaces = |
| std::max<int>(1, EscapedNewlineColumn - PreviousEndOfTokenColumn - 1); |
| for (unsigned i = 0; i < Newlines; ++i) { |
| Text.append(Spaces, ' '); |
| Text.append(UseCRLF ? "\\\r\n" : "\\\n"); |
| Spaces = std::max<int>(0, EscapedNewlineColumn - 1); |
| } |
| } |
| } |
| |
| void WhitespaceManager::appendIndentText(std::string &Text, |
| unsigned IndentLevel, unsigned Spaces, |
| unsigned WhitespaceStartColumn) { |
| switch (Style.UseTab) { |
| case FormatStyle::UT_Never: |
| Text.append(Spaces, ' '); |
| break; |
| case FormatStyle::UT_Always: { |
| unsigned FirstTabWidth = |
| Style.TabWidth - WhitespaceStartColumn % Style.TabWidth; |
| // Indent with tabs only when there's at least one full tab. |
| if (FirstTabWidth + Style.TabWidth <= Spaces) { |
| Spaces -= FirstTabWidth; |
| Text.append("\t"); |
| } |
| Text.append(Spaces / Style.TabWidth, '\t'); |
| Text.append(Spaces % Style.TabWidth, ' '); |
| break; |
| } |
| case FormatStyle::UT_ForIndentation: |
| if (WhitespaceStartColumn == 0) { |
| unsigned Indentation = IndentLevel * Style.IndentWidth; |
| // This happens, e.g. when a line in a block comment is indented less than |
| // the first one. |
| if (Indentation > Spaces) |
| Indentation = Spaces; |
| unsigned Tabs = Indentation / Style.TabWidth; |
| Text.append(Tabs, '\t'); |
| Spaces -= Tabs * Style.TabWidth; |
| } |
| Text.append(Spaces, ' '); |
| break; |
| case FormatStyle::UT_ForContinuationAndIndentation: |
| if (WhitespaceStartColumn == 0) { |
| unsigned Tabs = Spaces / Style.TabWidth; |
| Text.append(Tabs, '\t'); |
| Spaces -= Tabs * Style.TabWidth; |
| } |
| Text.append(Spaces, ' '); |
| break; |
| } |
| } |
| |
| } // namespace format |
| } // namespace clang |
