1 //===--- BreakableToken.cpp - Format C++ code -----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief Contains implementation of BreakableToken class and classes derived
14 //===----------------------------------------------------------------------===//
16 #include "BreakableToken.h"
17 #include "clang/Basic/CharInfo.h"
18 #include "clang/Format/Format.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/Support/Debug.h"
23 #define DEBUG_TYPE "format-token-breaker"
28 static const char *const Blanks = " \t\v\f\r";
29 static bool IsBlank(char C) {
42 static BreakableToken::Split getCommentSplit(StringRef Text,
43 unsigned ContentStartColumn,
46 encoding::Encoding Encoding) {
47 if (ColumnLimit <= ContentStartColumn + 1)
48 return BreakableToken::Split(StringRef::npos, 0);
50 unsigned MaxSplit = ColumnLimit - ContentStartColumn + 1;
51 unsigned MaxSplitBytes = 0;
53 for (unsigned NumChars = 0;
54 NumChars < MaxSplit && MaxSplitBytes < Text.size();) {
55 unsigned BytesInChar =
56 encoding::getCodePointNumBytes(Text[MaxSplitBytes], Encoding);
58 encoding::columnWidthWithTabs(Text.substr(MaxSplitBytes, BytesInChar),
59 ContentStartColumn, TabWidth, Encoding);
60 MaxSplitBytes += BytesInChar;
63 StringRef::size_type SpaceOffset = Text.find_last_of(Blanks, MaxSplitBytes);
64 if (SpaceOffset == StringRef::npos ||
65 // Don't break at leading whitespace.
66 Text.find_last_not_of(Blanks, SpaceOffset) == StringRef::npos) {
67 // Make sure that we don't break at leading whitespace that
68 // reaches past MaxSplit.
69 StringRef::size_type FirstNonWhitespace = Text.find_first_not_of(Blanks);
70 if (FirstNonWhitespace == StringRef::npos)
71 // If the comment is only whitespace, we cannot split.
72 return BreakableToken::Split(StringRef::npos, 0);
73 SpaceOffset = Text.find_first_of(
74 Blanks, std::max<unsigned>(MaxSplitBytes, FirstNonWhitespace));
76 if (SpaceOffset != StringRef::npos && SpaceOffset != 0) {
77 StringRef BeforeCut = Text.substr(0, SpaceOffset).rtrim(Blanks);
78 StringRef AfterCut = Text.substr(SpaceOffset).ltrim(Blanks);
79 return BreakableToken::Split(BeforeCut.size(),
80 AfterCut.begin() - BeforeCut.end());
82 return BreakableToken::Split(StringRef::npos, 0);
85 static BreakableToken::Split
86 getStringSplit(StringRef Text, unsigned UsedColumns, unsigned ColumnLimit,
87 unsigned TabWidth, encoding::Encoding Encoding) {
88 // FIXME: Reduce unit test case.
90 return BreakableToken::Split(StringRef::npos, 0);
91 if (ColumnLimit <= UsedColumns)
92 return BreakableToken::Split(StringRef::npos, 0);
93 unsigned MaxSplit = ColumnLimit - UsedColumns;
94 StringRef::size_type SpaceOffset = 0;
95 StringRef::size_type SlashOffset = 0;
96 StringRef::size_type WordStartOffset = 0;
97 StringRef::size_type SplitPoint = 0;
98 for (unsigned Chars = 0;;) {
100 if (Text[0] == '\\') {
101 Advance = encoding::getEscapeSequenceLength(Text);
104 Advance = encoding::getCodePointNumBytes(Text[0], Encoding);
105 Chars += encoding::columnWidthWithTabs(
106 Text.substr(0, Advance), UsedColumns + Chars, TabWidth, Encoding);
109 if (Chars > MaxSplit || Text.size() <= Advance)
112 if (IsBlank(Text[0]))
113 SpaceOffset = SplitPoint;
115 SlashOffset = SplitPoint;
116 if (Advance == 1 && !isAlphanumeric(Text[0]))
117 WordStartOffset = SplitPoint;
119 SplitPoint += Advance;
120 Text = Text.substr(Advance);
123 if (SpaceOffset != 0)
124 return BreakableToken::Split(SpaceOffset + 1, 0);
125 if (SlashOffset != 0)
126 return BreakableToken::Split(SlashOffset + 1, 0);
127 if (WordStartOffset != 0)
128 return BreakableToken::Split(WordStartOffset + 1, 0);
130 return BreakableToken::Split(SplitPoint, 0);
131 return BreakableToken::Split(StringRef::npos, 0);
134 unsigned BreakableSingleLineToken::getLineCount() const { return 1; }
136 unsigned BreakableSingleLineToken::getLineLengthAfterSplit(
137 unsigned LineIndex, unsigned Offset, StringRef::size_type Length) const {
138 return StartColumn + Prefix.size() + Postfix.size() +
139 encoding::columnWidthWithTabs(Line.substr(Offset, Length),
140 StartColumn + Prefix.size(),
141 Style.TabWidth, Encoding);
144 BreakableSingleLineToken::BreakableSingleLineToken(
145 const FormatToken &Tok, unsigned IndentLevel, unsigned StartColumn,
146 StringRef Prefix, StringRef Postfix, bool InPPDirective,
147 encoding::Encoding Encoding, const FormatStyle &Style)
148 : BreakableToken(Tok, IndentLevel, InPPDirective, Encoding, Style),
149 StartColumn(StartColumn), Prefix(Prefix), Postfix(Postfix) {
150 assert(Tok.TokenText.endswith(Postfix));
151 Line = Tok.TokenText.substr(
152 Prefix.size(), Tok.TokenText.size() - Prefix.size() - Postfix.size());
155 BreakableStringLiteral::BreakableStringLiteral(
156 const FormatToken &Tok, unsigned IndentLevel, unsigned StartColumn,
157 StringRef Prefix, StringRef Postfix, bool InPPDirective,
158 encoding::Encoding Encoding, const FormatStyle &Style)
159 : BreakableSingleLineToken(Tok, IndentLevel, StartColumn, Prefix, Postfix,
160 InPPDirective, Encoding, Style) {}
162 BreakableToken::Split
163 BreakableStringLiteral::getSplit(unsigned LineIndex, unsigned TailOffset,
164 unsigned ColumnLimit) const {
165 return getStringSplit(Line.substr(TailOffset),
166 StartColumn + Prefix.size() + Postfix.size(),
167 ColumnLimit, Style.TabWidth, Encoding);
170 void BreakableStringLiteral::insertBreak(unsigned LineIndex,
171 unsigned TailOffset, Split Split,
172 WhitespaceManager &Whitespaces) {
173 unsigned LeadingSpaces = StartColumn;
174 // The '@' of an ObjC string literal (@"Test") does not become part of the
176 // FIXME: It might be a cleaner solution to merge the tokens as a
177 // precomputation step.
178 if (Prefix.startswith("@"))
180 Whitespaces.replaceWhitespaceInToken(
181 Tok, Prefix.size() + TailOffset + Split.first, Split.second, Postfix,
182 Prefix, InPPDirective, 1, IndentLevel, LeadingSpaces);
185 static StringRef getLineCommentIndentPrefix(StringRef Comment) {
186 static const char *const KnownPrefixes[] = {"///", "//", "//!"};
187 StringRef LongestPrefix;
188 for (StringRef KnownPrefix : KnownPrefixes) {
189 if (Comment.startswith(KnownPrefix)) {
190 size_t PrefixLength = KnownPrefix.size();
191 while (PrefixLength < Comment.size() && Comment[PrefixLength] == ' ')
193 if (PrefixLength > LongestPrefix.size())
194 LongestPrefix = Comment.substr(0, PrefixLength);
197 return LongestPrefix;
200 BreakableLineComment::BreakableLineComment(
201 const FormatToken &Token, unsigned IndentLevel, unsigned StartColumn,
202 bool InPPDirective, encoding::Encoding Encoding, const FormatStyle &Style)
203 : BreakableSingleLineToken(Token, IndentLevel, StartColumn,
204 getLineCommentIndentPrefix(Token.TokenText), "",
205 InPPDirective, Encoding, Style) {
206 OriginalPrefix = Prefix;
207 if (Token.TokenText.size() > Prefix.size() &&
208 isAlphanumeric(Token.TokenText[Prefix.size()])) {
211 else if (Prefix == "///")
213 else if (Prefix == "//!")
218 BreakableToken::Split
219 BreakableLineComment::getSplit(unsigned LineIndex, unsigned TailOffset,
220 unsigned ColumnLimit) const {
221 return getCommentSplit(Line.substr(TailOffset), StartColumn + Prefix.size(),
222 ColumnLimit, Style.TabWidth, Encoding);
225 void BreakableLineComment::insertBreak(unsigned LineIndex, unsigned TailOffset,
227 WhitespaceManager &Whitespaces) {
228 Whitespaces.replaceWhitespaceInToken(
229 Tok, OriginalPrefix.size() + TailOffset + Split.first, Split.second,
230 Postfix, Prefix, InPPDirective, /*Newlines=*/1, IndentLevel, StartColumn);
233 void BreakableLineComment::replaceWhitespace(unsigned LineIndex,
234 unsigned TailOffset, Split Split,
235 WhitespaceManager &Whitespaces) {
236 Whitespaces.replaceWhitespaceInToken(
237 Tok, OriginalPrefix.size() + TailOffset + Split.first, Split.second, "",
238 "", /*InPPDirective=*/false, /*Newlines=*/0, /*IndentLevel=*/0,
242 void BreakableLineComment::replaceWhitespaceBefore(
243 unsigned LineIndex, WhitespaceManager &Whitespaces) {
244 if (OriginalPrefix != Prefix) {
245 Whitespaces.replaceWhitespaceInToken(Tok, OriginalPrefix.size(), 0, "", "",
246 /*InPPDirective=*/false,
247 /*Newlines=*/0, /*IndentLevel=*/0,
252 BreakableBlockComment::BreakableBlockComment(
253 const FormatToken &Token, unsigned IndentLevel, unsigned StartColumn,
254 unsigned OriginalStartColumn, bool FirstInLine, bool InPPDirective,
255 encoding::Encoding Encoding, const FormatStyle &Style)
256 : BreakableToken(Token, IndentLevel, InPPDirective, Encoding, Style) {
257 StringRef TokenText(Token.TokenText);
258 assert(TokenText.startswith("/*") && TokenText.endswith("*/"));
259 TokenText.substr(2, TokenText.size() - 4).split(Lines, "\n");
261 int IndentDelta = StartColumn - OriginalStartColumn;
262 LeadingWhitespace.resize(Lines.size());
263 StartOfLineColumn.resize(Lines.size());
264 StartOfLineColumn[0] = StartColumn + 2;
265 for (size_t i = 1; i < Lines.size(); ++i)
266 adjustWhitespace(i, IndentDelta);
269 if (Lines.size() == 1 && !FirstInLine) {
270 // Comments for which FirstInLine is false can start on arbitrary column,
271 // and available horizontal space can be too small to align consecutive
272 // lines with the first one.
273 // FIXME: We could, probably, align them to current indentation level, but
274 // now we just wrap them without stars.
277 for (size_t i = 1, e = Lines.size(); i < e && !Decoration.empty(); ++i) {
278 // If the last line is empty, the closing "*/" will have a star.
279 if (i + 1 == e && Lines[i].empty())
281 if (!Lines[i].empty() && i + 1 != e && Decoration.startswith(Lines[i]))
283 while (!Lines[i].startswith(Decoration))
284 Decoration = Decoration.substr(0, Decoration.size() - 1);
287 LastLineNeedsDecoration = true;
288 IndentAtLineBreak = StartOfLineColumn[0] + 1;
289 for (size_t i = 1; i < Lines.size(); ++i) {
290 if (Lines[i].empty()) {
291 if (i + 1 == Lines.size()) {
292 // Empty last line means that we already have a star as a part of the
293 // trailing */. We also need to preserve whitespace, so that */ is
294 // correctly indented.
295 LastLineNeedsDecoration = false;
296 } else if (Decoration.empty()) {
297 // For all other lines, set the start column to 0 if they're empty, so
298 // we do not insert trailing whitespace anywhere.
299 StartOfLineColumn[i] = 0;
304 // The first line already excludes the star.
305 // For all other lines, adjust the line to exclude the star and
306 // (optionally) the first whitespace.
307 unsigned DecorationSize =
308 Decoration.startswith(Lines[i]) ? Lines[i].size() : Decoration.size();
309 StartOfLineColumn[i] += DecorationSize;
310 Lines[i] = Lines[i].substr(DecorationSize);
311 LeadingWhitespace[i] += DecorationSize;
312 if (!Decoration.startswith(Lines[i]))
314 std::min<int>(IndentAtLineBreak, std::max(0, StartOfLineColumn[i]));
316 IndentAtLineBreak = std::max<unsigned>(IndentAtLineBreak, Decoration.size());
318 llvm::dbgs() << "IndentAtLineBreak " << IndentAtLineBreak << "\n";
319 for (size_t i = 0; i < Lines.size(); ++i) {
320 llvm::dbgs() << i << " |" << Lines[i] << "| " << LeadingWhitespace[i]
326 void BreakableBlockComment::adjustWhitespace(unsigned LineIndex,
328 // When in a preprocessor directive, the trailing backslash in a block comment
329 // is not needed, but can serve a purpose of uniformity with necessary escaped
330 // newlines outside the comment. In this case we remove it here before
331 // trimming the trailing whitespace. The backslash will be re-added later when
332 // inserting a line break.
333 size_t EndOfPreviousLine = Lines[LineIndex - 1].size();
334 if (InPPDirective && Lines[LineIndex - 1].endswith("\\"))
337 // Calculate the end of the non-whitespace text in the previous line.
339 Lines[LineIndex - 1].find_last_not_of(Blanks, EndOfPreviousLine);
340 if (EndOfPreviousLine == StringRef::npos)
341 EndOfPreviousLine = 0;
344 // Calculate the start of the non-whitespace text in the current line.
345 size_t StartOfLine = Lines[LineIndex].find_first_not_of(Blanks);
346 if (StartOfLine == StringRef::npos)
347 StartOfLine = Lines[LineIndex].rtrim("\r\n").size();
349 StringRef Whitespace = Lines[LineIndex].substr(0, StartOfLine);
350 // Adjust Lines to only contain relevant text.
351 Lines[LineIndex - 1] = Lines[LineIndex - 1].substr(0, EndOfPreviousLine);
352 Lines[LineIndex] = Lines[LineIndex].substr(StartOfLine);
353 // Adjust LeadingWhitespace to account all whitespace between the lines
354 // to the current line.
355 LeadingWhitespace[LineIndex] =
356 Lines[LineIndex].begin() - Lines[LineIndex - 1].end();
358 // Adjust the start column uniformly across all lines.
359 StartOfLineColumn[LineIndex] =
360 encoding::columnWidthWithTabs(Whitespace, 0, Style.TabWidth, Encoding) +
364 unsigned BreakableBlockComment::getLineCount() const { return Lines.size(); }
366 unsigned BreakableBlockComment::getLineLengthAfterSplit(
367 unsigned LineIndex, unsigned Offset, StringRef::size_type Length) const {
368 unsigned ContentStartColumn = getContentStartColumn(LineIndex, Offset);
369 return ContentStartColumn +
370 encoding::columnWidthWithTabs(Lines[LineIndex].substr(Offset, Length),
371 ContentStartColumn, Style.TabWidth,
373 // The last line gets a "*/" postfix.
374 (LineIndex + 1 == Lines.size() ? 2 : 0);
377 BreakableToken::Split
378 BreakableBlockComment::getSplit(unsigned LineIndex, unsigned TailOffset,
379 unsigned ColumnLimit) const {
380 return getCommentSplit(Lines[LineIndex].substr(TailOffset),
381 getContentStartColumn(LineIndex, TailOffset),
382 ColumnLimit, Style.TabWidth, Encoding);
385 void BreakableBlockComment::insertBreak(unsigned LineIndex, unsigned TailOffset,
387 WhitespaceManager &Whitespaces) {
388 StringRef Text = Lines[LineIndex].substr(TailOffset);
389 StringRef Prefix = Decoration;
390 if (LineIndex + 1 == Lines.size() &&
391 Text.size() == Split.first + Split.second) {
392 // For the last line we need to break before "*/", but not to add "* ".
396 unsigned BreakOffsetInToken =
397 Text.data() - Tok.TokenText.data() + Split.first;
398 unsigned CharsToRemove = Split.second;
399 assert(IndentAtLineBreak >= Decoration.size());
400 Whitespaces.replaceWhitespaceInToken(
401 Tok, BreakOffsetInToken, CharsToRemove, "", Prefix, InPPDirective, 1,
402 IndentLevel, IndentAtLineBreak - Decoration.size());
405 void BreakableBlockComment::replaceWhitespace(unsigned LineIndex,
406 unsigned TailOffset, Split Split,
407 WhitespaceManager &Whitespaces) {
408 StringRef Text = Lines[LineIndex].substr(TailOffset);
409 unsigned BreakOffsetInToken =
410 Text.data() - Tok.TokenText.data() + Split.first;
411 unsigned CharsToRemove = Split.second;
412 Whitespaces.replaceWhitespaceInToken(
413 Tok, BreakOffsetInToken, CharsToRemove, "", "", /*InPPDirective=*/false,
414 /*Newlines=*/0, /*IndentLevel=*/0, /*Spaces=*/1);
417 void BreakableBlockComment::replaceWhitespaceBefore(
418 unsigned LineIndex, WhitespaceManager &Whitespaces) {
421 StringRef Prefix = Decoration;
422 if (Lines[LineIndex].empty()) {
423 if (LineIndex + 1 == Lines.size()) {
424 if (!LastLineNeedsDecoration) {
425 // If the last line was empty, we don't need a prefix, as the */ will
426 // line up with the decoration (if it exists).
429 } else if (!Decoration.empty()) {
430 // For other empty lines, if we do have a decoration, adapt it to not
431 // contain a trailing whitespace.
432 Prefix = Prefix.substr(0, 1);
435 if (StartOfLineColumn[LineIndex] == 1) {
436 // This line starts immediately after the decorating *.
437 Prefix = Prefix.substr(0, 1);
441 unsigned WhitespaceOffsetInToken = Lines[LineIndex].data() -
442 Tok.TokenText.data() -
443 LeadingWhitespace[LineIndex];
444 Whitespaces.replaceWhitespaceInToken(
445 Tok, WhitespaceOffsetInToken, LeadingWhitespace[LineIndex], "", Prefix,
446 InPPDirective, 1, IndentLevel,
447 StartOfLineColumn[LineIndex] - Prefix.size());
451 BreakableBlockComment::getContentStartColumn(unsigned LineIndex,
452 unsigned TailOffset) const {
453 // If we break, we always break at the predefined indent.
455 return IndentAtLineBreak;
456 return std::max(0, StartOfLineColumn[LineIndex]);
459 } // namespace format