Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/BreakableToken_8cpp_source.html below:

clang: lib/Format/BreakableToken.cpp Source File

StringRef

=

;

StringRef KnownCStylePrefixes[] = {

,

,

,

,

,

};

StringRef KnownTextProtoPrefixes[] = {

,

,

,

KnownPrefixes = KnownTextProtoPrefixes;

llvm::is_sorted(KnownPrefixes, [](StringRef Lhs, StringRef Rhs)

{

Lhs.size() > Rhs.size();

(StringRef KnownPrefix : KnownPrefixes) {

(Comment.starts_with(KnownPrefix)) {

PrefixLength =

Comment.find_first_not_of(

, KnownPrefix.size());

Comment.substr(0, PrefixLength);

ColumnLimit,

TabWidth,

DecorationEndsWithStar =

) {

LLVM_DEBUG(llvm::dbgs() <<

<<

<<

<< ColumnLimit

<<

<< ContentStartColumn <<

);

(ColumnLimit <= ContentStartColumn + 1)

MaxSplit = ColumnLimit - ContentStartColumn + 1;

MaxSplitBytes = 0;

(

NumChars = 0;

NumChars < MaxSplit && MaxSplitBytes <

.size();) {

BytesInChar =

.substr(MaxSplitBytes, BytesInChar), ContentStartColumn + NumChars,

MaxSplitBytes += BytesInChar;

StringRef::size_type SpaceOffset =

(SpaceOffset != StringRef::npos && SpaceOffset + 1 <

.size() &&

[SpaceOffset + 1] ==

) {

MaxSplitBytes = SpaceOffset + 1;

StringRef::size_type SpaceOffset =

.find_last_of(

, MaxSplitBytes);

kNumberedListRegexp = llvm::Regex(

);

(SpaceOffset != StringRef::npos) {

(Style.

()) {

StringRef::size_type LastNonBlank =

.find_last_not_of(

, SpaceOffset);

(LastNonBlank != StringRef::npos &&

[LastNonBlank] ==

) {

SpaceOffset =

.find_last_of(

, LastNonBlank);

(kNumberedListRegexp.match(

.substr(SpaceOffset).ltrim(

))) {

SpaceOffset =

.find_last_of(

, SpaceOffset);

(

[SpaceOffset + 1] ==

||

[SpaceOffset + 1] ==

)) {

SpaceOffset =

.find_last_of(

, SpaceOffset);

(SpaceOffset == StringRef::npos ||

.find_last_not_of(

, SpaceOffset) == StringRef::npos) {

StringRef::size_type FirstNonWhitespace =

.find_first_not_of(

);

(FirstNonWhitespace == StringRef::npos) {

SpaceOffset =

.find_first_of(

, std::max<unsigned>(MaxSplitBytes, FirstNonWhitespace));

(SpaceOffset != StringRef::npos && SpaceOffset != 0) {

(SpaceOffset == 1 &&

[SpaceOffset - 1] ==

)

StringRef BeforeCut =

.substr(0, SpaceOffset).rtrim(

);

StringRef AfterCut =

.substr(SpaceOffset);

(!DecorationEndsWithStar || AfterCut.size() <= 1 || AfterCut[1] !=

)

AfterCut = AfterCut.ltrim(

);

AfterCut.begin() - BeforeCut.end());

(ColumnLimit <= UsedColumns)

MaxSplit = ColumnLimit - UsedColumns;

StringRef::size_type SpaceOffset = 0;

StringRef::size_type SlashOffset = 0;

StringRef::size_type WordStartOffset = 0;

StringRef::size_type SplitPoint = 0;

(

Chars = 0;;) {

(

[0] ==

) {

.substr(0, Advance), UsedColumns + Chars, TabWidth, Encoding);

(Chars > MaxSplit ||

.size() <= Advance)

SpaceOffset = SplitPoint;

(

[0] ==

)

SlashOffset = SplitPoint;

WordStartOffset = SplitPoint;

SplitPoint += Advance;

(SpaceOffset != 0)

(SlashOffset != 0)

(WordStartOffset != 0)

assert((

.

(TT_BlockComment) ||

.

(TT_LineComment)) &&

);

StringRef Content =

.TokenText.substr(2).ltrim();

Content.starts_with(

) ||

Content.starts_with(

);

RemainingTokenColumns + 1 -

.second;

StringRef::size_type Length,

StartColumn)

{

llvm_unreachable(

);

StartColumn)

{

&Tok,

StartColumn, StringRef Prefix,

StringRef Postfix,

UnbreakableTailLength,

InPPDirective,

StartColumn(StartColumn), Prefix(Prefix), Postfix(Postfix),

UnbreakableTailLength(UnbreakableTailLength) {

LineIndex,

TailOffset,

ColumnLimit,

ContentStartColumn,

llvm::Regex &CommentPragmasRegex)

{

ContentIndent,

Whitespaces.replaceWhitespaceInToken(

StartColumn,

UnbreakableTailLength,

InPPDirective,

Tok, StartColumn,

QuoteStyle == SingleQuotes ?

: QuoteStyle == AtDoubleQuotes ?

QuoteStyle == SingleQuotes ?

:

,

UnbreakableTailLength, InPPDirective, Encoding, Style),

BracesNeeded(Tok.isNot(TT_StringInConcatenation)),

QuoteStyle(QuoteStyle) {

= SignOnNewLine ?

:

;

= SignOnNewLine ?

:

;

= SignOnNewLine ?

:

;

= SignOnNewLine ?

:

;

= SignOnNewLine ?

:

;

LineIndex,

Offset,

StartColumn)

{

LineIndex,

TailOffset,

,

Whitespaces.replaceWhitespaceInToken(

Whitespaces.replaceWhitespaceInToken(

Whitespaces.replaceWhitespaceInToken(

StartColumn,

InPPDirective,

StartColumn(StartColumn) {}

ColumnLimit,

ContentStartColumn,

llvm::Regex &CommentPragmasRegex)

{

(StringRef::npos, 0);

LineIndex,

TailOffset,

,

StringRef

=

[LineIndex].substr(TailOffset);

BreakOffsetInToken =

CharsToRemove =

.second;

Whitespaces.replaceWhitespaceInToken(

(LineIndex), BreakOffsetInToken, CharsToRemove,

,

,

Content = Content.trim(

);

hasSpecialMeaningPrefix =

;

(StringRef Prefix :

{

,

,

,

,

,

,

,

,

}) {

(Content.starts_with(Prefix)) {

hasSpecialMeaningPrefix =

;

kNumberedListRegexp = llvm::Regex(

);

hasSpecialMeaningPrefix =

hasSpecialMeaningPrefix || kNumberedListRegexp.match(Content);

Content.size() >= 2 && !hasSpecialMeaningPrefix &&

!Content.ends_with(

) &&

OriginalStartColumn,

FirstInLine,

InPPDirective,

DelimitersOnNewline(

),

UnbreakableTailLength(

.UnbreakableTailLength) {

assert(

.

(TT_BlockComment) &&

);

assert(TokenText.starts_with(

) && TokenText.ends_with(

));

TokenText.substr(2, TokenText.size() - 4)

.split(

, UseCRLF ?

:

);

IndentDelta =

- OriginalStartColumn;

(

i = 1; i <

.size(); ++i)

adjustWhitespace(i, IndentDelta);

(

.size() >= 2 &&

[1].starts_with(

) &&

(

.size() == 1 && !FirstInLine) {

(

i = 1, e =

.size(); i < e && !Decoration.empty(); ++i) {

}

(!

.empty() && Decoration.starts_with(

)) {

(!

.starts_with(Decoration))

Decoration = Decoration.drop_back(1);

LastLineNeedsDecoration =

;

(

i = 1, e =

.size(); i < e; ++i) {

LastLineNeedsDecoration =

;

(e >= 2 && !Decoration.empty())

}

(Decoration.empty()) {

DecorationSize = Decoration.starts_with(

[i])

(!Decoration.starts_with(

[i])) {

std::min<int>(IndentAtLineBreak, std::max(0,

[i]));

IndentAtLineBreak = std::max<unsigned>(IndentAtLineBreak, Decoration.size());

((

[0] ==

||

[0].starts_with(

)) &&

.size() > 1) {

DelimitersOnNewline =

;

}

(

[0].starts_with(

) &&

.size() == 1) {

llvm::dbgs() <<

<< IndentAtLineBreak <<

;

llvm::dbgs() <<

<< DelimitersOnNewline <<

;

(

i = 0; i <

.size(); ++i) {

llvm::dbgs() << i <<

<<

[i] <<

<<

<< (

[i].data() -

[i].data()) <<

;

LineIndex,

TailOffset,

ColumnLimit,

ContentStartColumn,

llvm::Regex &CommentPragmasRegex)

{

(StringRef::npos, 0);

BreakableBlockComment::adjustWhitespace(

LineIndex,

EndOfPreviousLine =

[LineIndex - 1].size();

[LineIndex - 1].find_last_not_of(

, EndOfPreviousLine);

(EndOfPreviousLine == StringRef::npos)

EndOfPreviousLine = 0;

StartOfLine =

[LineIndex].find_first_not_of(

);

(StartOfLine == StringRef::npos)

StartOfLine =

[LineIndex].size();

StringRef Whitespace =

[LineIndex].substr(0, StartOfLine);

PreviousContentOffset =

[LineIndex - 1].data() -

[LineIndex - 1].data();

PreviousContentOffset, EndOfPreviousLine - PreviousContentOffset);

[LineIndex] =

[LineIndex].substr(StartOfLine);

StringRef::size_type Length,

StartColumn)

{

StartColumn)

{

LineLength =

UnbreakableTailLength +

(LineIndex + 1 ==

.size()) {

HasRemainingText = Offset <

[LineIndex].size();

(!HasRemainingText) {

HasDecoration =

[LineIndex].ltrim().starts_with(Decoration);

LineLength -= Decoration.size();

IndentAtLineBreak;

llvm::StringSet<>

,

,

,

,

,

,

,

,

,

,

,

,

StringRef ContentWithNoDecoration =

[LineIndex];

(LineIndex == 0 && ContentWithNoDecoration.starts_with(

))

ContentWithNoDecoration = ContentWithNoDecoration.substr(1).ltrim(

);

StringRef FirstWord = ContentWithNoDecoration.substr(

0, ContentWithNoDecoration.find_first_of(

));

StringRef

=

[LineIndex].substr(TailOffset);

StringRef Prefix = Decoration;

LocalIndentAtLineBreak = IndentAtLineBreak;

(LineIndex + 1 ==

.size() &&

(LocalIndentAtLineBreak >= 2)

LocalIndentAtLineBreak -= 2;

BreakOffsetInToken =

CharsToRemove =

.second;

assert(LocalIndentAtLineBreak >= Prefix.size());

std::string PrefixWithTrailingIndent = std::string(Prefix);

PrefixWithTrailingIndent.append(ContentIndent,

);

Whitespaces.replaceWhitespaceInToken(

(LineIndex), BreakOffsetInToken, CharsToRemove,

,

LocalIndentAtLineBreak + ContentIndent -

PrefixWithTrailingIndent.size());

LineIndex,

llvm::Regex &CommentPragmasRegex)

{

(!

(LineIndex, CommentPragmasRegex))

(StringRef::npos, 0);

Trimmed =

[LineIndex].find_first_not_of(

);

(PreviousContentIndent && Trimmed != StringRef::npos &&

Trimmed != PreviousContentIndent) {

(StringRef::npos, 0);

(0, Trimmed != StringRef::npos ? Trimmed : 0);

DelimitersOnNewline &&

[0].substr(1).find_first_not_of(

) != StringRef::npos;

StringRef TrimmedContent =

[LineIndex].ltrim(

);

);

WhitespaceOffsetInToken =

[LineIndex - 1].data() +

[LineIndex - 1].size() -

WhitespaceLength = TrimmedContent.data() -

WhitespaceOffsetInToken;

Whitespaces.replaceWhitespaceInToken(

(LineIndex), WhitespaceOffsetInToken,

WhitespaceLength,

,

(LineIndex == 0) {

(DelimitersOnNewline) {

BreakLength =

[0].substr(1).find_first_not_of(

);

(BreakLength != StringRef::npos) {

StringRef Prefix = Decoration;

(

[LineIndex].empty()) {

(LineIndex + 1 ==

.size()) {

(!LastLineNeedsDecoration) {

}

(!Decoration.empty()) {

Prefix = Prefix.substr(0, 1);

Prefix = Prefix.substr(0, 1);

WhitespaceOffsetInToken =

[LineIndex - 1].data() +

[LineIndex - 1].size() -

WhitespaceLength =

[LineIndex].data() -

WhitespaceOffsetInToken;

Whitespaces.replaceWhitespaceInToken(

(LineIndex), WhitespaceOffsetInToken, WhitespaceLength,

, Prefix,

(DelimitersOnNewline) {

StringRef

=

.back().substr(TailOffset);

StringRef TrimmedLine =

.rtrim(

);

(!TrimmedLine.empty())

(TrimmedLine.size(),

.size() - TrimmedLine.size());

(StringRef::npos, 0);

LineIndex,

llvm::Regex &CommentPragmasRegex)

{

StringRef IndentContent =

[LineIndex];

(

[LineIndex].ltrim(

).starts_with(

))

IndentContent =

[LineIndex].ltrim(

).substr(1);

!CommentPragmasRegex.match(IndentContent) &&

assert(

.

(TT_LineComment) &&

);

FirstLineSpaceChange = 0;

CurrentTok && CurrentTok->

(TT_LineComment);

CurrentTok = CurrentTok->Next) {

LastLineTok = LineTok;

StringRef TokenText(CurrentTok->TokenText);

assert((TokenText.starts_with(

) || TokenText.starts_with(

)) &&

);

FirstLineIndex =

.size();

TokenText.split(

,

);

PrefixSpaceChange.resize(

.size());

Prefix.resize(

.size());

OriginalPrefix.resize(

.size());

(

i = FirstLineIndex, e =

.size(); i < e; ++i) {

OriginalPrefix[i] = IndentPrefix;

SpacesInPrefix = llvm::count(IndentPrefix,

);

NoSpaceBeforeFirstCommentChar = [&]() {

assert(

[i].size() > IndentPrefix.size());

FirstCommentChar =

[i][IndentPrefix.size()];

FirstCharByteSize =

[i].substr(IndentPrefix.size(), FirstCharByteSize),

(FirstCommentChar ==

&& !TokenText.starts_with(

))

FirstCommentChar ==

||

(FirstCommentChar) ||

(i == 0 || OriginalPrefix[i].rtrim(

) !=

OriginalPrefix[i - 1].rtrim(

)) {

(SpacesInPrefix < Minimum &&

[i].size() > IndentPrefix.size() &&

!NoSpaceBeforeFirstCommentChar()) {

FirstLineSpaceChange = Minimum - SpacesInPrefix;

}

(

(SpacesInPrefix) >

FirstLineSpaceChange =

FirstLineSpaceChange = 0;

(

[i].size() != IndentPrefix.size()) {

PrefixSpaceChange[i] = FirstLineSpaceChange;

(SpacesInPrefix + PrefixSpaceChange[i] < Minimum) {

PrefixSpaceChange[i] +=

Minimum - (SpacesInPrefix + PrefixSpaceChange[i]);

assert(

[i].size() > IndentPrefix.size());

FirstNonSpace =

[i][IndentPrefix.size()];

LineRequiresLeadingSpace =

!NoSpaceBeforeFirstCommentChar() ||

(FirstNonSpace ==

&& FirstLineSpaceChange != 0);

AllowsSpaceChange =

(SpacesInPrefix != 0 || LineRequiresLeadingSpace);

(PrefixSpaceChange[i] > 0 && AllowsSpaceChange) {

Prefix[i] = IndentPrefix.str();

Prefix[i].append(PrefixSpaceChange[i],

);

}

(PrefixSpaceChange[i] < 0 && AllowsSpaceChange) {

Prefix[i] = IndentPrefix

.drop_back(std::min<std::size_t>(

-PrefixSpaceChange[i], SpacesInPrefix))

Prefix[i] = IndentPrefix.str();

Prefix[i] = IndentPrefix.drop_back(SpacesInPrefix).str();

(EndOfLine == StringRef::npos)

EndOfLine =

[i].size();

LineTok = CurrentTok->

;

(CurrentTok->Next && !CurrentTok->Next->ContinuesLineCommentSection) {

StringRef::size_type Length,

StartColumn)

{

LineIndex,

TailOffset,

,

StringRef

=

[LineIndex].substr(TailOffset);

BreakOffsetInToken =

CharsToRemove =

.second;

Whitespaces.replaceWhitespaceInToken(

(LineIndex), BreakOffsetInToken, CharsToRemove,

,

LineIndex,

llvm::Regex &CommentPragmasRegex)

{

(!

(LineIndex, CommentPragmasRegex))

(StringRef::npos, 0);

Trimmed =

[LineIndex].find_first_not_of(

);

(0, Trimmed != StringRef::npos ? Trimmed : 0);

(LineIndex > 0 &&

[LineIndex] !=

[LineIndex - 1]) {

Whitespaces.replaceWhitespace(

*

[LineIndex],

0,

0,

}

(LineIndex > 0) {

Offset =

[LineIndex - 1].data() +

[LineIndex - 1].size() -

WhitespaceLength =

Whitespaces.replaceWhitespaceInToken(*

[LineIndex], Offset,

WhitespaceLength =

Whitespaces.replaceWhitespaceInToken(*

[LineIndex], Offset,

(LineIndex > 0 &&

[LineIndex] !=

[LineIndex - 1]) {

LineColumn =

(

[LineIndex].data() -

[LineIndex].data()) +

(OriginalPrefix[LineIndex].size() - Prefix[LineIndex].size());

Whitespaces.replaceWhitespace(*

[LineIndex],

(OriginalPrefix[LineIndex] != Prefix[LineIndex]) {

SpacesToRemove = -std::min(PrefixSpaceChange[LineIndex], 0);

SpacesToAdd = std::max(PrefixSpaceChange[LineIndex], 0);

Whitespaces.replaceWhitespaceInToken(

(LineIndex), OriginalPrefix[LineIndex].size() - SpacesToRemove,

SpacesToRemove,

,

,

,

State.NextToken = LastLineTok->

;

LineIndex,

llvm::Regex &CommentPragmasRegex)

{

StringRef IndentContent =

[LineIndex];

(

[LineIndex].starts_with(

))

IndentContent =

[LineIndex].substr(2);

!CommentPragmasRegex.match(IndentContent) &&

OriginalPrefix[LineIndex] == OriginalPrefix[LineIndex - 1];

Declares BreakableToken, BreakableStringLiteral, BreakableComment, BreakableBlockComment and Breakabl...

This file implements an indenter that manages the indentation of continuations.

Various functions to configurably format source code.

Token - This structure provides full information about a lexed token.

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

BreakableStringLiteralUsingOperators(const FormatToken &Tok, QuoteStyleType QuoteStyle, bool UnindentPlus, unsigned StartColumn, unsigned UnbreakableTailLength, bool InPPDirective, encoding::Encoding Encoding, const FormatStyle &Style)

Creates a breakable token for a single line string literal for C#, Java, JavaScript,...

QuoteStyleType QuoteStyle

void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split, unsigned ContentIndent, WhitespaceManager &Whitespaces) const override

Emits the previously retrieved Split via Whitespaces.

StringRef RightBraceQuote

unsigned getContentStartColumn(unsigned LineIndex, bool Break) const override

Returns the column at which content in line LineIndex starts, assuming no reflow.

void updateAfterBroken(WhitespaceManager &Whitespaces) const override

Adds replacements that are needed when the token is broken.

unsigned getRemainingLength(unsigned LineIndex, unsigned Offset, unsigned StartColumn) const override

Returns the number of columns required to format the text following the byte Offset in the line LineI...

Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit, unsigned ContentStartColumn, const llvm::Regex &CommentPragmasRegex) const override

Returns a range (offset, length) at which to break the line at LineIndex, if previously broken at Tai...

unsigned UnbreakableTailLength

unsigned getRangeLength(unsigned LineIndex, unsigned Offset, StringRef::size_type Length, unsigned StartColumn) const override

Returns the number of columns required to format the text in the byte range [Offset,...

unsigned getContentStartColumn(unsigned LineIndex, bool Break) const override

Returns the column at which content in line LineIndex starts, assuming no reflow.

unsigned getLineCount() const override

Returns the number of lines in this token in the original code.

unsigned getRemainingLength(unsigned LineIndex, unsigned Offset, unsigned StartColumn) const override

Returns the number of columns required to format the text following the byte Offset in the line LineI...

BreakableStringLiteral(const FormatToken &Tok, unsigned StartColumn, StringRef Prefix, StringRef Postfix, unsigned UnbreakableTailLength, bool InPPDirective, encoding::Encoding Encoding, const FormatStyle &Style)

Creates a breakable token for a single line string literal.

void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split, unsigned ContentIndent, WhitespaceManager &Whitespaces) const override

Emits the previously retrieved Split via Whitespaces.

Base class for tokens / ranges of tokens that can allow breaking within the tokens - for example,...

std::pair< StringRef::size_type, unsigned > Split

Contains starting character index and length of split.

const FormatStyle & Style

unsigned getLengthAfterCompression(unsigned RemainingTokenColumns, Split Split) const

Returns the number of columns needed to format RemainingTokenColumns, assuming that Split is within t...

const encoding::Encoding Encoding

Manages the whitespaces around tokens and their replacements.

unsigned columnWidthWithTabs(StringRef Text, unsigned StartColumn, unsigned TabWidth, Encoding Encoding)

Returns the number of columns required to display the Text, starting from the StartColumn on a termin...

unsigned getEscapeSequenceLength(StringRef Text)

Gets the length of an escape sequence inside a C++ string literal.

unsigned getCodePointNumBytes(char FirstChar, Encoding Encoding)

Gets the number of bytes in a sequence representing a single codepoint and starting with FirstChar in...

unsigned columnWidth(StringRef Text, Encoding Encoding)

Returns the number of columns required to display the Text on a generic Unicode-capable terminal.

static constexpr StringRef Blanks

bool switchesFormatting(const FormatToken &Token)

Checks if Token switches formatting, like /* clang-format off *‍/.

static bool IsBlank(char C)

static BreakableToken::Split getStringSplit(StringRef Text, unsigned UsedColumns, unsigned ColumnLimit, unsigned TabWidth, encoding::Encoding Encoding)

static StringRef getLineCommentIndentPrefix(StringRef Comment, const FormatStyle &Style)

static bool mayReflowContent(StringRef Content)

static BreakableToken::Split getCommentSplit(StringRef Text, unsigned ContentStartColumn, unsigned ColumnLimit, unsigned TabWidth, encoding::Encoding Encoding, const FormatStyle &Style, bool DecorationEndsWithStar=false)

The JSON file list parser is used to communicate input to InstallAPI.

LLVM_READONLY bool isAlphanumeric(unsigned char c)

Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].

LLVM_READONLY bool isHorizontalWhitespace(unsigned char c)

Returns true if this character is horizontal ASCII whitespace: ' ', '\t', '\f', '\v'.

LLVM_READONLY bool isPunctuation(unsigned char c)

Return true if this character is an ASCII punctuation character.

bool Other

Put a space in parentheses not covered by preceding options.

The FormatStyle is used to configure the formatting to follow specific guidelines.

unsigned ContinuationIndentWidth

Indent width for line continuations.

@ LK_Java

Should be used for Java.

@ LK_TextProto

Should be used for Protocol Buffer messages in text format (https://developers.google....

bool Cpp11BracedListStyle

If true, format braced lists as best suited for C++11 braced lists.

BinaryOperatorStyle BreakBeforeBinaryOperators

The way to wrap binary operators.

@ BOS_None

Break after operators.

LanguageKind Language

Language, this format style is targeted at.

unsigned TabWidth

The number of columns used for tab stops.

OperandAlignmentStyle AlignOperands

If true, horizontally align operands of binary and ternary expressions.

SpacesInParensCustom SpacesInParensOptions

Control of individual spaces in parentheses.

SpacesInLineComment SpacesInLineCommentPrefix

How many spaces are allowed at the start of a line comment.

bool isJavaScript() const

@ OAS_AlignAfterOperator

Horizontally align operands of binary and ternary expressions.

unsigned ColumnLimit

The column limit.

A wrapper around a Token storing information about the whitespace characters preceding it.

StringRef TokenText

The raw text of the token.

unsigned Finalized

If true, this token has been fully formatted (indented and potentially re-formatted inside),...

FormatToken * Next

The next token in the unwrapped line.

bool is(tok::TokenKind Kind) const

The current state when indenting a unwrapped line.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4