• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
21 bool WhitespaceManager::Change::IsBeforeInFile::
operator ()(const Change & C1,const Change & C2) const22 operator()(const Change &C1, const Change &C2) const {
23   return SourceMgr.isBeforeInTranslationUnit(
24       C1.OriginalWhitespaceRange.getBegin(),
25       C2.OriginalWhitespaceRange.getBegin());
26 }
27 
Change(bool CreateReplacement,SourceRange OriginalWhitespaceRange,unsigned IndentLevel,int Spaces,unsigned StartOfTokenColumn,unsigned NewlinesBefore,StringRef PreviousLinePostfix,StringRef CurrentLinePrefix,tok::TokenKind Kind,bool ContinuesPPDirective,bool IsStartOfDeclName,bool IsInsideToken)28 WhitespaceManager::Change::Change(
29     bool CreateReplacement, SourceRange OriginalWhitespaceRange,
30     unsigned IndentLevel, int Spaces, unsigned StartOfTokenColumn,
31     unsigned NewlinesBefore, StringRef PreviousLinePostfix,
32     StringRef CurrentLinePrefix, tok::TokenKind Kind, bool ContinuesPPDirective,
33     bool IsStartOfDeclName, bool IsInsideToken)
34     : CreateReplacement(CreateReplacement),
35       OriginalWhitespaceRange(OriginalWhitespaceRange),
36       StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore),
37       PreviousLinePostfix(PreviousLinePostfix),
38       CurrentLinePrefix(CurrentLinePrefix), Kind(Kind),
39       ContinuesPPDirective(ContinuesPPDirective),
40       IsStartOfDeclName(IsStartOfDeclName), IndentLevel(IndentLevel),
41       Spaces(Spaces), IsInsideToken(IsInsideToken), IsTrailingComment(false),
42       TokenLength(0), PreviousEndOfTokenColumn(0), EscapedNewlineColumn(0),
43       StartOfBlockComment(nullptr), IndentationOffset(0) {}
44 
reset()45 void WhitespaceManager::reset() {
46   Changes.clear();
47   Replaces.clear();
48 }
49 
replaceWhitespace(FormatToken & Tok,unsigned Newlines,unsigned IndentLevel,unsigned Spaces,unsigned StartOfTokenColumn,bool InPPDirective)50 void WhitespaceManager::replaceWhitespace(FormatToken &Tok, unsigned Newlines,
51                                           unsigned IndentLevel, unsigned Spaces,
52                                           unsigned StartOfTokenColumn,
53                                           bool InPPDirective) {
54   if (Tok.Finalized)
55     return;
56   Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue;
57   Changes.push_back(
58       Change(/*CreateReplacement=*/true, Tok.WhitespaceRange, IndentLevel,
59              Spaces, StartOfTokenColumn, Newlines, "", "", Tok.Tok.getKind(),
60              InPPDirective && !Tok.IsFirst,
61              Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName),
62              /*IsInsideToken=*/false));
63 }
64 
addUntouchableToken(const FormatToken & Tok,bool InPPDirective)65 void WhitespaceManager::addUntouchableToken(const FormatToken &Tok,
66                                             bool InPPDirective) {
67   if (Tok.Finalized)
68     return;
69   Changes.push_back(Change(
70       /*CreateReplacement=*/false, Tok.WhitespaceRange, /*IndentLevel=*/0,
71       /*Spaces=*/0, Tok.OriginalColumn, Tok.NewlinesBefore, "", "",
72       Tok.Tok.getKind(), InPPDirective && !Tok.IsFirst,
73       Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName),
74       /*IsInsideToken=*/false));
75 }
76 
replaceWhitespaceInToken(const FormatToken & Tok,unsigned Offset,unsigned ReplaceChars,StringRef PreviousPostfix,StringRef CurrentPrefix,bool InPPDirective,unsigned Newlines,unsigned IndentLevel,int Spaces)77 void WhitespaceManager::replaceWhitespaceInToken(
78     const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars,
79     StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective,
80     unsigned Newlines, unsigned IndentLevel, int Spaces) {
81   if (Tok.Finalized)
82     return;
83   SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset);
84   Changes.push_back(Change(
85       true, SourceRange(Start, Start.getLocWithOffset(ReplaceChars)),
86       IndentLevel, Spaces, std::max(0, Spaces), Newlines, PreviousPostfix,
87       CurrentPrefix, Tok.is(TT_LineComment) ? tok::comment : tok::unknown,
88       InPPDirective && !Tok.IsFirst,
89       Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName),
90       /*IsInsideToken=*/Newlines == 0));
91 }
92 
generateReplacements()93 const tooling::Replacements &WhitespaceManager::generateReplacements() {
94   if (Changes.empty())
95     return Replaces;
96 
97   std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr));
98   calculateLineBreakInformation();
99   alignConsecutiveDeclarations();
100   alignConsecutiveAssignments();
101   alignTrailingComments();
102   alignEscapedNewlines();
103   generateChanges();
104 
105   return Replaces;
106 }
107 
calculateLineBreakInformation()108 void WhitespaceManager::calculateLineBreakInformation() {
109   Changes[0].PreviousEndOfTokenColumn = 0;
110   Change *LastOutsideTokenChange = &Changes[0];
111   for (unsigned i = 1, e = Changes.size(); i != e; ++i) {
112     unsigned OriginalWhitespaceStart =
113         SourceMgr.getFileOffset(Changes[i].OriginalWhitespaceRange.getBegin());
114     unsigned PreviousOriginalWhitespaceEnd = SourceMgr.getFileOffset(
115         Changes[i - 1].OriginalWhitespaceRange.getEnd());
116     Changes[i - 1].TokenLength = OriginalWhitespaceStart -
117                                  PreviousOriginalWhitespaceEnd +
118                                  Changes[i].PreviousLinePostfix.size() +
119                                  Changes[i - 1].CurrentLinePrefix.size();
120 
121     // If there are multiple changes in this token, sum up all the changes until
122     // the end of the line.
123     if (Changes[i - 1].IsInsideToken)
124       LastOutsideTokenChange->TokenLength +=
125           Changes[i - 1].TokenLength + Changes[i - 1].Spaces;
126     else
127       LastOutsideTokenChange = &Changes[i - 1];
128 
129     Changes[i].PreviousEndOfTokenColumn =
130         Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength;
131 
132     Changes[i - 1].IsTrailingComment =
133         (Changes[i].NewlinesBefore > 0 || Changes[i].Kind == tok::eof ||
134          (Changes[i].IsInsideToken && Changes[i].Kind == tok::comment)) &&
135         Changes[i - 1].Kind == tok::comment;
136   }
137   // FIXME: The last token is currently not always an eof token; in those
138   // cases, setting TokenLength of the last token to 0 is wrong.
139   Changes.back().TokenLength = 0;
140   Changes.back().IsTrailingComment = Changes.back().Kind == tok::comment;
141 
142   const WhitespaceManager::Change *LastBlockComment = nullptr;
143   for (auto &Change : Changes) {
144     // Reset the IsTrailingComment flag for changes inside of trailing comments
145     // so they don't get realigned later.
146     if (Change.IsInsideToken)
147       Change.IsTrailingComment = false;
148     Change.StartOfBlockComment = nullptr;
149     Change.IndentationOffset = 0;
150     if (Change.Kind == tok::comment) {
151       LastBlockComment = &Change;
152     } else if (Change.Kind == tok::unknown) {
153       if ((Change.StartOfBlockComment = LastBlockComment))
154         Change.IndentationOffset =
155             Change.StartOfTokenColumn -
156             Change.StartOfBlockComment->StartOfTokenColumn;
157     } else {
158       LastBlockComment = nullptr;
159     }
160   }
161 }
162 
163 // Align a single sequence of tokens, see AlignTokens below.
164 template <typename F>
165 static void
AlignTokenSequence(unsigned Start,unsigned End,unsigned Column,F && Matches,SmallVector<WhitespaceManager::Change,16> & Changes)166 AlignTokenSequence(unsigned Start, unsigned End, unsigned Column, F &&Matches,
167                    SmallVector<WhitespaceManager::Change, 16> &Changes) {
168   bool FoundMatchOnLine = false;
169   int Shift = 0;
170   for (unsigned i = Start; i != End; ++i) {
171     if (Changes[i].NewlinesBefore > 0) {
172       FoundMatchOnLine = false;
173       Shift = 0;
174     }
175 
176     // If this is the first matching token to be aligned, remember by how many
177     // spaces it has to be shifted, so the rest of the changes on the line are
178     // shifted by the same amount
179     if (!FoundMatchOnLine && Matches(Changes[i])) {
180       FoundMatchOnLine = true;
181       Shift = Column - Changes[i].StartOfTokenColumn;
182       Changes[i].Spaces += Shift;
183     }
184 
185     assert(Shift >= 0);
186     Changes[i].StartOfTokenColumn += Shift;
187     if (i + 1 != Changes.size())
188       Changes[i + 1].PreviousEndOfTokenColumn += Shift;
189   }
190 }
191 
192 // Walk through all of the changes and find sequences of matching tokens to
193 // align. To do so, keep track of the lines and whether or not a matching token
194 // was found on a line. If a matching token is found, extend the current
195 // sequence. If the current line cannot be part of a sequence, e.g. because
196 // there is an empty line before it or it contains only non-matching tokens,
197 // finalize the previous sequence.
198 template <typename F>
AlignTokens(const FormatStyle & Style,F && Matches,SmallVector<WhitespaceManager::Change,16> & Changes)199 static void AlignTokens(const FormatStyle &Style, F &&Matches,
200                         SmallVector<WhitespaceManager::Change, 16> &Changes) {
201   unsigned MinColumn = 0;
202   unsigned MaxColumn = UINT_MAX;
203 
204   // Line number of the start and the end of the current token sequence.
205   unsigned StartOfSequence = 0;
206   unsigned EndOfSequence = 0;
207 
208   // Keep track of the nesting level of matching tokens, i.e. the number of
209   // surrounding (), [], or {}. We will only align a sequence of matching
210   // token that share the same scope depth.
211   //
212   // FIXME: This could use FormatToken::NestingLevel information, but there is
213   // an outstanding issue wrt the brace scopes.
214   unsigned NestingLevelOfLastMatch = 0;
215   unsigned NestingLevel = 0;
216 
217   // Keep track of the number of commas before the matching tokens, we will only
218   // align a sequence of matching tokens if they are preceded by the same number
219   // of commas.
220   unsigned CommasBeforeLastMatch = 0;
221   unsigned CommasBeforeMatch = 0;
222 
223   // Whether a matching token has been found on the current line.
224   bool FoundMatchOnLine = false;
225 
226   // Aligns a sequence of matching tokens, on the MinColumn column.
227   //
228   // Sequences start from the first matching token to align, and end at the
229   // first token of the first line that doesn't need to be aligned.
230   //
231   // We need to adjust the StartOfTokenColumn of each Change that is on a line
232   // containing any matching token to be aligned and located after such token.
233   auto AlignCurrentSequence = [&] {
234     if (StartOfSequence > 0 && StartOfSequence < EndOfSequence)
235       AlignTokenSequence(StartOfSequence, EndOfSequence, MinColumn, Matches,
236                          Changes);
237     MinColumn = 0;
238     MaxColumn = UINT_MAX;
239     StartOfSequence = 0;
240     EndOfSequence = 0;
241   };
242 
243   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
244     if (Changes[i].NewlinesBefore != 0) {
245       CommasBeforeMatch = 0;
246       EndOfSequence = i;
247       // If there is a blank line, or if the last line didn't contain any
248       // matching token, the sequence ends here.
249       if (Changes[i].NewlinesBefore > 1 || !FoundMatchOnLine)
250         AlignCurrentSequence();
251 
252       FoundMatchOnLine = false;
253     }
254 
255     if (Changes[i].Kind == tok::comma) {
256       ++CommasBeforeMatch;
257     } else if (Changes[i].Kind == tok::r_brace ||
258                Changes[i].Kind == tok::r_paren ||
259                Changes[i].Kind == tok::r_square) {
260       --NestingLevel;
261     } else if (Changes[i].Kind == tok::l_brace ||
262                Changes[i].Kind == tok::l_paren ||
263                Changes[i].Kind == tok::l_square) {
264       // We want sequences to skip over child scopes if possible, but not the
265       // other way around.
266       NestingLevelOfLastMatch = std::min(NestingLevelOfLastMatch, NestingLevel);
267       ++NestingLevel;
268     }
269 
270     if (!Matches(Changes[i]))
271       continue;
272 
273     // If there is more than one matching token per line, or if the number of
274     // preceding commas, or the scope depth, do not match anymore, end the
275     // sequence.
276     if (FoundMatchOnLine || CommasBeforeMatch != CommasBeforeLastMatch ||
277         NestingLevel != NestingLevelOfLastMatch)
278       AlignCurrentSequence();
279 
280     CommasBeforeLastMatch = CommasBeforeMatch;
281     NestingLevelOfLastMatch = NestingLevel;
282     FoundMatchOnLine = true;
283 
284     if (StartOfSequence == 0)
285       StartOfSequence = i;
286 
287     unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
288     int LineLengthAfter = -Changes[i].Spaces;
289     for (unsigned j = i; j != e && Changes[j].NewlinesBefore == 0; ++j)
290       LineLengthAfter += Changes[j].Spaces + Changes[j].TokenLength;
291     unsigned ChangeMaxColumn = Style.ColumnLimit - LineLengthAfter;
292 
293     // If we are restricted by the maximum column width, end the sequence.
294     if (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn ||
295         CommasBeforeLastMatch != CommasBeforeMatch) {
296       AlignCurrentSequence();
297       StartOfSequence = i;
298     }
299 
300     MinColumn = std::max(MinColumn, ChangeMinColumn);
301     MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
302   }
303 
304   EndOfSequence = Changes.size();
305   AlignCurrentSequence();
306 }
307 
alignConsecutiveAssignments()308 void WhitespaceManager::alignConsecutiveAssignments() {
309   if (!Style.AlignConsecutiveAssignments)
310     return;
311 
312   AlignTokens(Style,
313               [&](const Change &C) {
314                 // Do not align on equal signs that are first on a line.
315                 if (C.NewlinesBefore > 0)
316                   return false;
317 
318                 // Do not align on equal signs that are last on a line.
319                 if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
320                   return false;
321 
322                 return C.Kind == tok::equal;
323               },
324               Changes);
325 }
326 
alignConsecutiveDeclarations()327 void WhitespaceManager::alignConsecutiveDeclarations() {
328   if (!Style.AlignConsecutiveDeclarations)
329     return;
330 
331   // FIXME: Currently we don't handle properly the PointerAlignment: Right
332   // The * and & are not aligned and are left dangling. Something has to be done
333   // about it, but it raises the question of alignment of code like:
334   //   const char* const* v1;
335   //   float const* v2;
336   //   SomeVeryLongType const& v3;
337 
338   AlignTokens(Style, [](Change const &C) { return C.IsStartOfDeclName; },
339               Changes);
340 }
341 
alignTrailingComments()342 void WhitespaceManager::alignTrailingComments() {
343   unsigned MinColumn = 0;
344   unsigned MaxColumn = UINT_MAX;
345   unsigned StartOfSequence = 0;
346   bool BreakBeforeNext = false;
347   unsigned Newlines = 0;
348   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
349     if (Changes[i].StartOfBlockComment)
350       continue;
351     Newlines += Changes[i].NewlinesBefore;
352     if (!Changes[i].IsTrailingComment)
353       continue;
354 
355     unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn;
356     unsigned ChangeMaxColumn = Style.ColumnLimit - Changes[i].TokenLength;
357 
358     // If we don't create a replacement for this change, we have to consider
359     // it to be immovable.
360     if (!Changes[i].CreateReplacement)
361       ChangeMaxColumn = ChangeMinColumn;
362 
363     if (i + 1 != e && Changes[i + 1].ContinuesPPDirective)
364       ChangeMaxColumn -= 2;
365     // If this comment follows an } in column 0, it probably documents the
366     // closing of a namespace and we don't want to align it.
367     bool FollowsRBraceInColumn0 = i > 0 && Changes[i].NewlinesBefore == 0 &&
368                                   Changes[i - 1].Kind == tok::r_brace &&
369                                   Changes[i - 1].StartOfTokenColumn == 0;
370     bool WasAlignedWithStartOfNextLine = false;
371     if (Changes[i].NewlinesBefore == 1) { // A comment on its own line.
372       unsigned CommentColumn = SourceMgr.getSpellingColumnNumber(
373           Changes[i].OriginalWhitespaceRange.getEnd());
374       for (unsigned j = i + 1; j != e; ++j) {
375         if (Changes[j].Kind == tok::comment ||
376             Changes[j].Kind == tok::unknown)
377           // Skip over comments and unknown tokens. "unknown tokens are used for
378           // the continuation of multiline comments.
379           continue;
380 
381         unsigned NextColumn = SourceMgr.getSpellingColumnNumber(
382             Changes[j].OriginalWhitespaceRange.getEnd());
383         // The start of the next token was previously aligned with the
384         // start of this comment.
385         WasAlignedWithStartOfNextLine =
386             CommentColumn == NextColumn ||
387             CommentColumn == NextColumn + Style.IndentWidth;
388         break;
389       }
390     }
391     if (!Style.AlignTrailingComments || FollowsRBraceInColumn0) {
392       alignTrailingComments(StartOfSequence, i, MinColumn);
393       MinColumn = ChangeMinColumn;
394       MaxColumn = ChangeMinColumn;
395       StartOfSequence = i;
396     } else if (BreakBeforeNext || Newlines > 1 ||
397                (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) ||
398                // Break the comment sequence if the previous line did not end
399                // in a trailing comment.
400                (Changes[i].NewlinesBefore == 1 && i > 0 &&
401                 !Changes[i - 1].IsTrailingComment) ||
402                WasAlignedWithStartOfNextLine) {
403       alignTrailingComments(StartOfSequence, i, MinColumn);
404       MinColumn = ChangeMinColumn;
405       MaxColumn = ChangeMaxColumn;
406       StartOfSequence = i;
407     } else {
408       MinColumn = std::max(MinColumn, ChangeMinColumn);
409       MaxColumn = std::min(MaxColumn, ChangeMaxColumn);
410     }
411     BreakBeforeNext =
412         (i == 0) || (Changes[i].NewlinesBefore > 1) ||
413         // Never start a sequence with a comment at the beginning of
414         // the line.
415         (Changes[i].NewlinesBefore == 1 && StartOfSequence == i);
416     Newlines = 0;
417   }
418   alignTrailingComments(StartOfSequence, Changes.size(), MinColumn);
419 }
420 
alignTrailingComments(unsigned Start,unsigned End,unsigned Column)421 void WhitespaceManager::alignTrailingComments(unsigned Start, unsigned End,
422                                               unsigned Column) {
423   for (unsigned i = Start; i != End; ++i) {
424     int Shift = 0;
425     if (Changes[i].IsTrailingComment) {
426       Shift = Column - Changes[i].StartOfTokenColumn;
427     }
428     if (Changes[i].StartOfBlockComment) {
429       Shift = Changes[i].IndentationOffset +
430               Changes[i].StartOfBlockComment->StartOfTokenColumn -
431               Changes[i].StartOfTokenColumn;
432     }
433     assert(Shift >= 0);
434     Changes[i].Spaces += Shift;
435     if (i + 1 != End)
436       Changes[i + 1].PreviousEndOfTokenColumn += Shift;
437     Changes[i].StartOfTokenColumn += Shift;
438   }
439 }
440 
alignEscapedNewlines()441 void WhitespaceManager::alignEscapedNewlines() {
442   unsigned MaxEndOfLine =
443       Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit;
444   unsigned StartOfMacro = 0;
445   for (unsigned i = 1, e = Changes.size(); i < e; ++i) {
446     Change &C = Changes[i];
447     if (C.NewlinesBefore > 0) {
448       if (C.ContinuesPPDirective) {
449         MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine);
450       } else {
451         alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine);
452         MaxEndOfLine = Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit;
453         StartOfMacro = i;
454       }
455     }
456   }
457   alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine);
458 }
459 
alignEscapedNewlines(unsigned Start,unsigned End,unsigned Column)460 void WhitespaceManager::alignEscapedNewlines(unsigned Start, unsigned End,
461                                              unsigned Column) {
462   for (unsigned i = Start; i < End; ++i) {
463     Change &C = Changes[i];
464     if (C.NewlinesBefore > 0) {
465       assert(C.ContinuesPPDirective);
466       if (C.PreviousEndOfTokenColumn + 1 > Column)
467         C.EscapedNewlineColumn = 0;
468       else
469         C.EscapedNewlineColumn = Column;
470     }
471   }
472 }
473 
generateChanges()474 void WhitespaceManager::generateChanges() {
475   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
476     const Change &C = Changes[i];
477     if (i > 0) {
478       assert(Changes[i - 1].OriginalWhitespaceRange.getBegin() !=
479                  C.OriginalWhitespaceRange.getBegin() &&
480              "Generating two replacements for the same location");
481     }
482     if (C.CreateReplacement) {
483       std::string ReplacementText = C.PreviousLinePostfix;
484       if (C.ContinuesPPDirective)
485         appendNewlineText(ReplacementText, C.NewlinesBefore,
486                           C.PreviousEndOfTokenColumn, C.EscapedNewlineColumn);
487       else
488         appendNewlineText(ReplacementText, C.NewlinesBefore);
489       appendIndentText(ReplacementText, C.IndentLevel, std::max(0, C.Spaces),
490                        C.StartOfTokenColumn - std::max(0, C.Spaces));
491       ReplacementText.append(C.CurrentLinePrefix);
492       storeReplacement(C.OriginalWhitespaceRange, ReplacementText);
493     }
494   }
495 }
496 
storeReplacement(SourceRange Range,StringRef Text)497 void WhitespaceManager::storeReplacement(SourceRange Range,
498                                          StringRef Text) {
499   unsigned WhitespaceLength = SourceMgr.getFileOffset(Range.getEnd()) -
500                               SourceMgr.getFileOffset(Range.getBegin());
501   // Don't create a replacement, if it does not change anything.
502   if (StringRef(SourceMgr.getCharacterData(Range.getBegin()),
503                 WhitespaceLength) == Text)
504     return;
505   Replaces.insert(tooling::Replacement(
506       SourceMgr, CharSourceRange::getCharRange(Range), Text));
507 }
508 
appendNewlineText(std::string & Text,unsigned Newlines)509 void WhitespaceManager::appendNewlineText(std::string &Text,
510                                           unsigned Newlines) {
511   for (unsigned i = 0; i < Newlines; ++i)
512     Text.append(UseCRLF ? "\r\n" : "\n");
513 }
514 
appendNewlineText(std::string & Text,unsigned Newlines,unsigned PreviousEndOfTokenColumn,unsigned EscapedNewlineColumn)515 void WhitespaceManager::appendNewlineText(std::string &Text, unsigned Newlines,
516                                           unsigned PreviousEndOfTokenColumn,
517                                           unsigned EscapedNewlineColumn) {
518   if (Newlines > 0) {
519     unsigned Offset =
520         std::min<int>(EscapedNewlineColumn - 1, PreviousEndOfTokenColumn);
521     for (unsigned i = 0; i < Newlines; ++i) {
522       Text.append(EscapedNewlineColumn - Offset - 1, ' ');
523       Text.append(UseCRLF ? "\\\r\n" : "\\\n");
524       Offset = 0;
525     }
526   }
527 }
528 
appendIndentText(std::string & Text,unsigned IndentLevel,unsigned Spaces,unsigned WhitespaceStartColumn)529 void WhitespaceManager::appendIndentText(std::string &Text,
530                                          unsigned IndentLevel, unsigned Spaces,
531                                          unsigned WhitespaceStartColumn) {
532   switch (Style.UseTab) {
533   case FormatStyle::UT_Never:
534     Text.append(Spaces, ' ');
535     break;
536   case FormatStyle::UT_Always: {
537     unsigned FirstTabWidth =
538         Style.TabWidth - WhitespaceStartColumn % Style.TabWidth;
539     // Indent with tabs only when there's at least one full tab.
540     if (FirstTabWidth + Style.TabWidth <= Spaces) {
541       Spaces -= FirstTabWidth;
542       Text.append("\t");
543     }
544     Text.append(Spaces / Style.TabWidth, '\t');
545     Text.append(Spaces % Style.TabWidth, ' ');
546     break;
547   }
548   case FormatStyle::UT_ForIndentation:
549     if (WhitespaceStartColumn == 0) {
550       unsigned Indentation = IndentLevel * Style.IndentWidth;
551       // This happens, e.g. when a line in a block comment is indented less than
552       // the first one.
553       if (Indentation > Spaces)
554         Indentation = Spaces;
555       unsigned Tabs = Indentation / Style.TabWidth;
556       Text.append(Tabs, '\t');
557       Spaces -= Tabs * Style.TabWidth;
558     }
559     Text.append(Spaces, ' ');
560     break;
561   case FormatStyle::UT_ForContinuationAndIndentation:
562     if (WhitespaceStartColumn == 0) {
563       unsigned Tabs = Spaces / Style.TabWidth;
564       Text.append(Tabs, '\t');
565       Spaces -= Tabs * Style.TabWidth;
566     }
567     Text.append(Spaces, ' ');
568     break;
569   }
570 }
571 
572 } // namespace format
573 } // namespace clang
574