unsigned
ContinuationIndenter::addMultilineStringLiteral(const FormatToken &Current,
LineState &State) {
- StringRef Text = Current.TokenText;
- // We can only affect layout of the first and the last line, so the penalty
- // for all other lines is constant, and we ignore it.
- size_t FirstLineBreak = Text.find('\n');
- size_t LastLineBreak = Text.find_last_of('\n');
- assert(FirstLineBreak != StringRef::npos);
- unsigned StartColumn = State.Column - Current.CodePointCount;
- State.Column =
- encoding::getCodePointCount(Text.substr(LastLineBreak + 1), Encoding);
-
// Break before further function parameters on all levels.
for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
State.Stack[i].BreakBeforeParameter = true;
unsigned ColumnsUsed =
- StartColumn +
- encoding::getCodePointCount(Text.substr(0, FirstLineBreak), Encoding);
+ State.Column - Current.CodePointCount + Current.CodePointsInFirstLine;
+ // We can only affect layout of the first and the last line, so the penalty
+ // for all other lines is constant, and we ignore it.
+ State.Column = Current.CodePointsInLastLine;
+
if (ColumnsUsed > getColumnLimit())
return Style.PenaltyExcessCharacter * (ColumnsUsed - getColumnLimit());
return 0;
// Don't break string literals with (in case of non-raw strings, escaped)
// newlines. As clang-format must not change the string's content, it is
// unlikely that we'll end up with a better format.
- if (Current.IsMultiline)
+ if (Current.isMultiline())
return addMultilineStringLiteral(Current, State);
// Only break up default narrow strings.
// FIXME: If we want to handle them correctly, we'll need to adjust
// leading whitespace in consecutive lines when changing indentation of
// the first line similar to what we do with block comments.
- if (Current.IsMultiline) {
- StringRef::size_type EscapedNewlinePos = Current.TokenText.find("\\\n");
- assert(EscapedNewlinePos != StringRef::npos);
- State.Column =
- StartColumn +
- encoding::getCodePointCount(
- Current.TokenText.substr(0, EscapedNewlinePos), Encoding) +
- 1;
+ if (Current.isMultiline()) {
+ State.Column = StartColumn + Current.CodePointsInFirstLine;
return 0;
}
// AlwaysBreakBeforeMultilineStrings implementation.
if (Current.TokenText.startswith("R\""))
return false;
- if (Current.IsMultiline)
+ if (Current.isMultiline())
return true;
if (Current.getNextNonComment() &&
Current.getNextNonComment()->is(tok::string_literal))
FormatTok->CodePointCount =
encoding::getCodePointCount(FormatTok->TokenText, Encoding);
- if (FormatTok->isOneOf(tok::string_literal, tok::comment) &&
- FormatTok->TokenText.find('\n') != StringRef::npos)
- FormatTok->IsMultiline = true;
-
+ if (FormatTok->isOneOf(tok::string_literal, tok::comment)) {
+ StringRef Text = FormatTok->TokenText;
+ size_t FirstNewlinePos = Text.find('\n');
+ if (FirstNewlinePos != StringRef::npos) {
+ FormatTok->CodePointsInFirstLine = encoding::getCodePointCount(
+ Text.substr(0, FirstNewlinePos), Encoding);
+ FormatTok->CodePointsInLastLine = encoding::getCodePointCount(
+ Text.substr(Text.find_last_of('\n') + 1), Encoding);
+ }
+ }
// FIXME: Add the CodePointCount to Column.
FormatTok->WhitespaceRange = SourceRange(
WhitespaceStart, WhitespaceStart.getLocWithOffset(WhitespaceLength));
/// whitespace characters preceeding it.
struct FormatToken {
FormatToken()
- : NewlinesBefore(0), HasUnescapedNewline(false), IsMultiline(false),
- LastNewlineOffset(0), CodePointCount(0), IsFirst(false),
- MustBreakBefore(false), IsUnterminatedLiteral(false),
+ : NewlinesBefore(0), HasUnescapedNewline(false), LastNewlineOffset(0),
+ CodePointCount(0), CodePointsInFirstLine(0), CodePointsInLastLine(0),
+ IsFirst(false), MustBreakBefore(false), IsUnterminatedLiteral(false),
BlockKind(BK_Unknown), Type(TT_Unknown), SpacesRequiredBefore(0),
CanBreakBefore(false), ClosesTemplateDeclaration(false),
ParameterCount(0), PackingKind(PPK_Inconclusive), TotalLength(0),
/// Token.
bool HasUnescapedNewline;
- /// \brief Whether the token text contains newlines (escaped or not).
- bool IsMultiline;
-
/// \brief The range of the whitespace immediately preceeding the \c Token.
SourceRange WhitespaceRange;
/// We need this to correctly measure number of columns a token spans.
unsigned CodePointCount;
+ /// \brief Contains the number of code points in the first line of a
+ /// multi-line string literal or comment. Zero if there's no newline in the
+ /// token.
+ unsigned CodePointsInFirstLine;
+
+ /// \brief Contains the number of code points in the last line of a
+ /// multi-line string literal or comment. Can be zero for line comments.
+ unsigned CodePointsInLastLine;
+
+ /// \brief Returns \c true if the token text contains newlines (escaped or
+ /// not).
+ bool isMultiline() const { return CodePointsInFirstLine != 0; }
+
/// \brief Indicates that this is the first token.
bool IsFirst;
Current->CanBreakBefore =
Current->MustBreakBefore || canBreakBefore(Line, *Current);
if (Current->MustBreakBefore ||
- (Current->is(tok::string_literal) && Current->IsMultiline))
+ (Current->is(tok::string_literal) && Current->isMultiline()))
Current->TotalLength = Current->Previous->TotalLength + Style.ColumnLimit;
else
Current->TotalLength = Current->Previous->TotalLength +