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

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

clang: lib/Format/UnwrappedLineFormatter.cpp Source File

startsExternCBlock(

AnnotatedLine &

) {

FormatToken *Next =

.First->getNextNonComment();

FormatToken *NextNext = Next ? Next->getNextNonComment() :

;

.startsWith(tok::kw_extern) && Next && Next->isStringLiteral() &&

NextNext && NextNext->is(tok::l_brace);

isRecordLBrace(

FormatToken &Tok) {

Tok.isOneOf(TT_ClassLBrace, TT_EnumLBrace, TT_RecordLBrace,

TT_StructLBrace, TT_UnionLBrace);

LevelIndentTracker {

LevelIndentTracker(

FormatStyle &Style,

AdditionalKeywords &Keywords,

StartLevel,

: Style(Style), Keywords(Keywords), AdditionalIndent(AdditionalIndent) {

(

i = 0; i != StartLevel; ++i)

IndentForLevel.push_back(Style.IndentWidth * i + AdditionalIndent);

getIndent()

{

Indent; }

nextLine(

AnnotatedLine &

) {

Offset = getIndentOffset(

);

(

.Level >= IndentForLevel.size())

IndentForLevel.resize(

.Level + 1, -1);

(

.InPPDirective ||

PPIndentWidth =

(Style.PPIndentWidth >= 0) ? Style.PPIndentWidth : Style.IndentWidth;

Indent =

.InMacroBody

?

.PPLevel * PPIndentWidth +

(

.Level -

.PPLevel) * Style.IndentWidth

:

.Level * PPIndentWidth;

Indent += AdditionalIndent;

(!

.InPPDirective) {

assert(

.Level <= IndentForLevel.size());

IndentForLevel.resize(

.Level + 1);

Indent = getIndent(

.Level);

(

(Indent) + Offset >= 0)

(

.IsContinuation)

Indent =

.Level * Style.IndentWidth + Style.ContinuationIndentWidth;

adjustToUnmodifiedLine(

AnnotatedLine &

) {

(

.InPPDirective ||

.IsContinuation)

assert(

.Level < IndentForLevel.size());

(

.First->is(tok::comment) && IndentForLevel[

.Level] != -1)

LevelIndent =

.First->OriginalColumn;

(

(LevelIndent) - Offset >= 0)

LevelIndent -= Offset;

IndentForLevel[

.Level] = LevelIndent;

getIndentOffset(

AnnotatedLine &

) {

IsAccessModifier = [&](

FormatToken &RootToken) {

*Next = RootToken.Next;

(RootToken.isOneOf(Keywords.kw_signals, Keywords.kw_qsignals) &&

Next && Next->is(tok::colon)) {

(Next && Next->isOneOf(Keywords.kw_slots, Keywords.kw_qslots) &&

Next->Next && Next->Next->is(tok::colon)) {

!Next && RootToken.isAccessSpecifier(

);

(IsAccessModifier(*

.First)) {

Style.IndentAccessModifiers ? -Style.IndentWidth

: Style.AccessModifierOffset;

getIndent(

Level)

{

assert(Level < IndentForLevel.size());

(IndentForLevel[Level] != -1)

IndentForLevel[Level];

getIndent(Level - 1) + Style.IndentWidth;

FormatStyle &Style;

AdditionalKeywords &Keywords;

AdditionalIndent;

SmallVector<int> IndentForLevel;

getMatchingNamespaceToken(

AnnotatedLine *

,

ArrayRef<AnnotatedLine *> &AnnotatedLines) {

(!

->startsWith(tok::r_brace))

StartLineIndex =

->MatchingOpeningBlockLineIndex;

assert(StartLineIndex < AnnotatedLines.size());

AnnotatedLines[StartLineIndex]->First->getNamespaceToken();

FormatToken *NamespaceToken =

->First->getNamespaceToken();

NamespaceToken ? NamespaceToken->TokenText : StringRef();

getMatchingNamespaceTokenText(

AnnotatedLine *

,

ArrayRef<AnnotatedLine *> &AnnotatedLines) {

FormatToken *NamespaceToken =

getMatchingNamespaceToken(

, AnnotatedLines);

NamespaceToken ? NamespaceToken->TokenText : StringRef();

LineJoiner(

FormatStyle &Style,

AdditionalKeywords &Keywords,

SmallVectorImpl<AnnotatedLine *> &Lines)

: Style(Style), Keywords(Keywords), End(Lines.end()), Next(Lines.begin()),

AnnotatedLines(Lines) {}

AnnotatedLine *getNextMergedLine(

DryRun,

LevelIndentTracker &IndentTracker) {

AnnotatedLine *Current = *Next;

IndentTracker.nextLine(*Current);

MergedLines = tryFitMultipleLinesInOne(IndentTracker, Next, End);

(MergedLines > 0 && Style.ColumnLimit == 0) {

(

i = 0; i < MergedLines; ++i)

(Next[i + 1]->

->NewlinesBefore > 0)

(

i = 0; i < MergedLines; ++i)

join(*Next[0], *Next[i + 1]);

Next = Next + MergedLines + 1;

tryFitMultipleLinesInOne(LevelIndentTracker &IndentTracker,

ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

) {

Indent = IndentTracker.getIndent();

AnnotatedLine *TheLine = *I;

(TheLine->Last->is(TT_LineComment))

&NextLine = *I[1];

(NextLine.Type ==

|| NextLine.First->MustBreakBefore)

(TheLine->InPPDirective &&

(!NextLine.InPPDirective || NextLine.First->HasUnescapedNewline)) {

(Style.ColumnLimit > 0 && Indent > Style.ColumnLimit)

Style.ColumnLimit == 0 ?

: Style.ColumnLimit - Indent;

Limit = TheLine->Last->TotalLength > Limit

: Limit - TheLine->Last->TotalLength;

(TheLine->Last->is(TT_FunctionLBrace) &&

TheLine->First == TheLine->Last &&

!Style.BraceWrapping.SplitEmptyFunction &&

NextLine.First->is(tok::r_brace)) {

tryMergeSimpleBlock(I,

, Limit);

*PreviousLine = I != AnnotatedLines.begin() ? I[-1] :

;

(PreviousLine && TheLine->Last->is(tok::l_brace) &&

TheLine->First == TheLine->Last) {

EmptyBlock = NextLine.First->is(tok::r_brace);

FormatToken *Tok = PreviousLine->First;

(Tok && Tok->is(tok::comment))

Tok = Tok->getNextNonComment();

(Tok && Tok->getNamespaceToken()) {

!Style.BraceWrapping.SplitEmptyNamespace && EmptyBlock

? tryMergeSimpleBlock(I,

, Limit)

(Tok && Tok->is(tok::kw_typedef))

Tok = Tok->getNextNonComment();

(Tok && Tok->isOneOf(tok::kw_class, tok::kw_struct, tok::kw_union,

tok::kw_extern, Keywords.kw_interface)) {

!Style.BraceWrapping.SplitEmptyRecord && EmptyBlock

? tryMergeSimpleBlock(I,

, Limit)

(Tok && Tok->is(tok::kw_template) &&

Style.BraceWrapping.SplitEmptyRecord && EmptyBlock) {

ShouldMergeShortFunctions = [

, &I, &NextLine, PreviousLine,

NextLine.First->is(tok::r_brace)) {

(Style.AllowShortFunctionsOnASingleLine &

(Style.isJavaScript() && TheLine->Last->is(TT_FunctionLBrace))

(TheLine->Level != 0) {

AnnotatedLine *

=

;

(

J = I - 1; J >= AnnotatedLines.begin(); --J) {

(!(*J)->InPPDirective && !(*J)->isComment() &&

(*J)->Level < TheLine->Level) {

*LastNonComment =

->getLastNonComment();

assert(LastNonComment);

isRecordLBrace(*LastNonComment);

MergeShortFunctions = ShouldMergeShortFunctions();

*FirstNonComment = TheLine->getFirstNonComment();

(!FirstNonComment)

(Style.AllowShortNamespacesOnASingleLine &&

TheLine->First->is(tok::kw_namespace) &&

TheLine->Last->is(tok::l_brace)) {

result = tryMergeNamespace(I,

, Limit);

(Style.CompactNamespaces) {

(

*NSToken = TheLine->First->getNamespaceToken()) {

assert(TheLine->MatchingClosingBlockLineIndex > 0);

(

ClosingLineIndex = TheLine->MatchingClosingBlockLineIndex - 1;

ClosingLineIndex == I[J]->MatchingClosingBlockLineIndex &&

I[J]->

->TotalLength < Limit;

++J, --ClosingLineIndex) {

Limit -= I[J]->Last->TotalLength + 1;

*ClosingLine = AnnotatedLines.begin() + ClosingLineIndex + 1;

OutdentBy = I[J]->Level - TheLine->Level;

assert(OutdentBy >= 0);

(

*CompactedLine = I + J; CompactedLine <= ClosingLine;

(!(*CompactedLine)->InPPDirective) {

Level = (*CompactedLine)->Level;

(*CompactedLine)->Level = std::max(Level - OutdentBy, 0);

(

nsToken = getMatchingNamespaceToken(TheLine, AnnotatedLines)) {

openingLine = TheLine->MatchingOpeningBlockLineIndex - 1;

(; I + 1 + i !=

&&

nsToken->TokenText ==

getMatchingNamespaceTokenText(I[i + 1], AnnotatedLines) &&

openingLine == I[i + 1]->MatchingOpeningBlockLineIndex;

i++, --openingLine) {

I[i + 1]->First->SpacesRequiredBefore =

I[i]->Last->isNot(tok::r_brace);

IndentTracker.nextLine(*I[i + 1]);

*LastNonComment = TheLine->getLastNonComment();

assert(LastNonComment);

(LastNonComment->is(TT_FunctionLBrace) &&

TheLine->First != LastNonComment) {

MergeShortFunctions ? tryMergeSimpleBlock(I,

, Limit) : 0;

(TheLine->Last->is(tok::l_brace) && FirstNonComment != TheLine->Last &&

(FirstNonComment->isOneOf(tok::kw_if, tok::kw_while, tok::kw_for,

TheLine->startsWithExportBlock())) {

? tryMergeSimpleBlock(I,

, Limit)

(NextLine.First->is(tok::l_brace)) {

((TheLine->First->isOneOf(tok::kw_if, tok::kw_else, tok::kw_while,

tok::kw_for, tok::kw_switch, tok::kw_try,

tok::kw_do, TT_ForEachMacro) ||

(TheLine->First->is(tok::r_brace) && TheLine->First->Next &&

TheLine->First->Next->isOneOf(tok::kw_else, tok::kw_catch))) &&

Style.BraceWrapping.AfterControlStatement ==

(Style.ColumnLimit == 0 || TheLine->Level * Style.IndentWidth +

TheLine->Last->TotalLength <=

(TheLine->First->isOneOf(tok::kw_if, tok::kw_else, tok::kw_while,

tok::kw_for, TT_ForEachMacro)) {

(Style.BraceWrapping.AfterControlStatement ==

? tryMergeSimpleBlock(I,

, Limit)

(TheLine->First->isOneOf(tok::kw_else, tok::kw_catch) &&

Style.BraceWrapping.AfterControlStatement ==

(Style.ColumnLimit == 0 ||

TheLine->Last->TotalLength <= Style.ColumnLimit)

(PreviousLine && TheLine->First->is(tok::l_brace)) {

(PreviousLine->First->Tok.getKind()) {

(PreviousLine->First->Next) {

PreviousLine->First->Next->Tok.getObjCKeywordID();

(kwId == tok::objc_autoreleasepool ||

kwId == tok::objc_synchronized) {

tok::kw_default:

(PreviousLine && Style.BraceWrapping.SplitEmptyRecord &&

TheLine->Last->is(tok::l_brace) && PreviousLine->Last) {

FormatToken *

= PreviousLine->Last;

(

->is(tok::greater) && !PreviousLine->InPPDirective)

(

->is(tok::identifier)) {

FormatToken *PreviousPrevious =

(PreviousPrevious &&

PreviousPrevious->isOneOf(tok::kw_class, tok::kw_struct)) {

(TheLine->First->is(TT_SwitchExpressionLabel)) {

Style.AllowShortCaseExpressionOnASingleLine

? tryMergeShortCaseLabels(I,

, Limit)

(TheLine->Last->is(tok::l_brace)) {

ShouldMerge =

;

(TheLine->Last->is(TT_EnumLBrace)) {

ShouldMerge = Style.AllowShortEnumsOnASingleLine;

}

(TheLine->Last->is(TT_CompoundRequirementLBrace)) {

ShouldMerge = Style.AllowShortCompoundRequirementOnASingleLine;

}

(TheLine->Last->isOneOf(TT_ClassLBrace, TT_StructLBrace)) {

ShouldMerge = !Style.BraceWrapping.AfterClass ||

(NextLine.First->is(tok::r_brace) &&

!Style.BraceWrapping.SplitEmptyRecord);

}

(TheLine->InPPDirective ||

!TheLine->First->isOneOf(tok::kw_class, tok::kw_enum,

ShouldMerge = !Style.BraceWrapping.AfterFunction ||

(NextLine.First->is(tok::r_brace) &&

!Style.BraceWrapping.SplitEmptyFunction);

ShouldMerge ? tryMergeSimpleBlock(I,

, Limit) : 0;

(NextLine.First->is(TT_FunctionLBrace) &&

Style.BraceWrapping.AfterFunction) {

(NextLine.Last->is(TT_LineComment))

(Limit <= 2 || (Style.ColumnLimit == 0 && containsMustBreak(TheLine)))

MergedLines = 0;

(MergeShortFunctions ||

NextLine.First == NextLine.Last && I + 2 !=

&&

I[2]->First->is(tok::r_brace))) {

MergedLines = tryMergeSimpleBlock(I + 1,

, Limit);

IsElseLine = [&TheLine]() ->

{

FormatToken *

= TheLine->First;

(

->is(tok::kw_else))

->is(tok::r_brace) &&

->Next &&

->Next->is(tok::kw_else);

(TheLine->First->is(tok::kw_if) ||

(IsElseLine() && (Style.AllowShortIfStatementsOnASingleLine ==

Style.AllowShortIfStatementsOnASingleLine

? tryMergeSimpleControlStatement(I,

, Limit)

(TheLine->First->isOneOf(tok::kw_for, tok::kw_while, tok::kw_do,

Style.AllowShortLoopsOnASingleLine

? tryMergeSimpleControlStatement(I,

, Limit)

(TheLine->First->isOneOf(tok::kw_case, tok::kw_default)) {

Style.AllowShortCaseLabelsOnASingleLine

? tryMergeShortCaseLabels(I,

, Limit)

(TheLine->InPPDirective &&

(TheLine->First->HasUnescapedNewline || TheLine->First->IsFirst)) {

tryMergeSimplePPDirective(I,

, Limit);

tryMergeSimplePPDirective(ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

,

(I + 2 !=

&& I[2]->InPPDirective && !I[2]->

->HasUnescapedNewline)

(1 + I[1]->

->TotalLength > Limit)

tryMergeNamespace(ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

,

&L1 = *I[1];

(L1.InPPDirective != (*I)->InPPDirective ||

(L1.InPPDirective && L1.First->HasUnescapedNewline)) {

(std::distance(I,

) <= 2)

&L2 = *I[2];

Limit = limitConsideringMacros(I + 1,

, Limit);

(!nextTwoLinesFitInto(I, Limit))

(L1.First->is(tok::kw_namespace)) {

(L1.Last->is(tok::comment) || !Style.CompactNamespaces)

assert(Limit >= L1.Last->TotalLength + 3);

InnerLimit = Limit - L1.Last->TotalLength - 3;

MergedLines = tryMergeNamespace(I + 1,

, InnerLimit);

(MergedLines == 0)

N = MergedLines + 2;

(std::distance(I,

) <= N)

(I[N]->

->is(tok::r_brace) && !I[N]->First->MustBreakBefore &&

I[MergedLines + 1]->Last->isNot(tok::comment) &&

nextNLinesFitInto(I, I + N + 1, Limit)) {

(L1.Last->isNot(tok::semi))

(L2.First->isNot(tok::r_brace) || L2.First->MustBreakBefore)

tryMergeSimpleControlStatement(ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

,

(Style.BraceWrapping.AfterControlStatement ==

I[1]->First->is(tok::l_brace) &&

(I[1]->InPPDirective != (*I)->InPPDirective ||

(I[1]->InPPDirective && I[1]->First->HasUnescapedNewline)) {

Limit = limitConsideringMacros(I + 1,

, Limit);

AnnotatedLine &

= **I;

(

.First->isNot(tok::kw_do) &&

.First->isNot(tok::kw_else) &&

.Last->isNot(tok::kw_else) &&

.Last->isNot(tok::r_paren)) {

(

.First->is(tok::kw_do) &&

.Last->isNot(tok::kw_do))

(1 + I[1]->

->TotalLength > Limit)

(I[1]->

->isOneOf(tok::semi, tok::kw_if, tok::kw_for, tok::kw_while,

TT_ForEachMacro, TT_LineComment)) {

(Style.AllowShortIfStatementsOnASingleLine ==

(I + 2 !=

&&

.startsWith(tok::kw_if) &&

I[2]->First->is(tok::kw_else)) {

tryMergeShortCaseLabels(ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

,

(Limit == 0 || I + 1 ==

||

I[1]->

->isOneOf(tok::kw_case, tok::kw_default)) {

(I[0]->

->is(tok::l_brace) || I[1]->First->is(tok::l_brace))

NumStmts = 0;

EndsWithComment =

;

InPPDirective = I[0]->InPPDirective;

InMacroBody = I[0]->InMacroBody;

Level = I[0]->Level;

(; NumStmts < 3; ++NumStmts) {

(I + 1 + NumStmts ==

)

AnnotatedLine *

= I[1 + NumStmts];

(

->InPPDirective != InPPDirective)

(

->InMacroBody != InMacroBody)

(

->First->isOneOf(tok::kw_case, tok::kw_default, tok::r_brace))

(

->First->isOneOf(tok::kw_if, tok::kw_for, tok::kw_switch,

(

->First->is(tok::comment)) {

(Level !=

->Level)

*J = I + 2 + NumStmts;

(; J !=

; ++J) {

(

->InPPDirective != InPPDirective)

(

->First->isOneOf(tok::kw_case, tok::kw_default, tok::r_brace))

(

->First->isNot(tok::comment) || Level !=

->Level)

(

->Last->is(tok::comment))

EndsWithComment =

;

Length += I[1 + NumStmts]->Last->TotalLength + 1;

(NumStmts == 0 || NumStmts == 3 || Length > Limit)

tryMergeSimpleBlock(ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

,

AnnotatedLine &

= **I;

.First->isOneOf(tok::at, tok::minus, tok::plus)) {

(

.First->is(tok::kw_case) ||

(

.First->Next &&

.First->Next->is(tok::kw_else))) {

(

.First->is(tok::kw_default)) {

FormatToken *Tok =

.First->getNextNonComment();

(Tok && Tok->is(tok::colon))

IsCtrlStmt = [](

&

) {

.First->isOneOf(tok::kw_if, tok::kw_else, tok::kw_while,

tok::kw_do, tok::kw_for, TT_ForEachMacro);

IsSplitBlock =

I[1]->First->isNot(tok::r_brace));

(IsCtrlStmt(

) ||

.First->isOneOf(tok::kw_try, tok::kw___try, tok::kw_catch,

tok::kw___finally, tok::r_brace,

Keywords.kw___except) ||

.startsWithExportBlock()) {

(!Style.AllowShortIfStatementsOnASingleLine &&

.First->isOneOf(tok::kw_if, tok::kw_else) &&

!Style.BraceWrapping.AfterControlStatement &&

I[1]->First->isNot(tok::r_brace)) {

(!Style.AllowShortIfStatementsOnASingleLine &&

.First->isOneOf(tok::kw_if, tok::kw_else) &&

Style.BraceWrapping.AfterControlStatement ==

I + 2 !=

&& I[2]->First->isNot(tok::r_brace)) {

(!Style.AllowShortLoopsOnASingleLine &&

.First->isOneOf(tok::kw_while, tok::kw_do, tok::kw_for,

!Style.BraceWrapping.AfterControlStatement &&

I[1]->First->isNot(tok::r_brace)) {

(!Style.AllowShortLoopsOnASingleLine &&

.First->isOneOf(tok::kw_while, tok::kw_do, tok::kw_for,

Style.BraceWrapping.AfterControlStatement ==

I + 2 !=

&& I[2]->First->isNot(tok::r_brace)) {

(

.First->isOneOf(tok::kw_try, tok::kw___try, tok::kw_catch,

Keywords.kw___except, tok::kw___finally)) {

(

.endsWith(tok::l_brace)) {

.First->is(TT_BlockLBrace)) {

(IsSplitBlock &&

.First ==

.Last &&

I > AnnotatedLines.begin() &&

(I[-1]->endsWith(tok::kw_else) || IsCtrlStmt(*I[-1]))) {

FormatToken *Tok = I[1]->First;

ShouldMerge = [Tok]() {

(Tok->isNot(tok::r_brace) || Tok->MustBreakBefore)

FormatToken *Next = Tok->getNextNonComment();

!Next || Next->is(tok::semi);

Tok->SpacesRequiredBefore =

(Style.SpaceInEmptyBlock ||

.Last->is(tok::comment)) ? 1 : 0;

Tok->CanBreakBefore =

;

}

(Limit != 0 && !

.startsWithNamespace() &&

!startsExternCBlock(

)) {

(isRecordLBrace(*

.Last))

Limit = limitConsideringMacros(I + 2,

, Limit);

(!nextTwoLinesFitInto(I, Limit))

(I[1]->

->is(TT_LineComment))

(Tok->isNot(tok::r_brace))

(Tok->Next && Tok->Next->is(tok::kw_else))

(

.First ==

.Last &&

.First->isNot(TT_FunctionLBrace) &&

Style.BraceWrapping.AfterControlStatement ==

}

(I[1]->

->is(tok::l_brace)) {

(I[1]->

->is(TT_LineComment))

(Limit <= 2 || (Style.ColumnLimit == 0 && containsMustBreak(*I)))

MergedLines = 0;

(I[1]->First == I[1]->Last && I + 2 !=

&&

I[2]->First->is(tok::r_brace))) {

MergedLines = tryMergeSimpleBlock(I + 1,

, Limit);

limitConsideringMacros(ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

,

(I[0]->InPPDirective && I + 1 !=

&&

!I[1]->

->HasUnescapedNewline && I[1]->First->isNot(tok::eof)) {

Limit < 2 ? 0 : Limit - 2;

nextTwoLinesFitInto(ArrayRef<AnnotatedLine *>::const_iterator I,

(I[1]->

->MustBreakBefore || I[2]->First->MustBreakBefore)

1 + I[1]->Last->TotalLength + 1 + I[2]->Last->TotalLength <= Limit;

nextNLinesFitInto(ArrayRef<AnnotatedLine *>::const_iterator I,

ArrayRef<AnnotatedLine *>::const_iterator

,

JoinedLength = 0;

(

*J = I + 1; J !=

; ++J) {

((*J)->First->MustBreakBefore)

JoinedLength += 1 + (*J)->Last->TotalLength;

(JoinedLength > Limit)

containsMustBreak(

AnnotatedLine *

) {

assert(

->First);

(

FormatToken *Tok =

->First->Next; Tok; Tok = Tok->Next)

(Tok->MustBreakBefore)

join(AnnotatedLine &A,

AnnotatedLine &B) {

assert(!A.Last->Next);

assert(!B.First->Previous);

A.Last->Next = B.First;

B.First->Previous = A.Last;

B.First->CanBreakBefore =

;

LengthA = A.Last->TotalLength + B.First->SpacesRequiredBefore;

(FormatToken *Tok = B.First; Tok; Tok = Tok->Next) {

Tok->TotalLength += LengthA;

FormatStyle &Style;

AdditionalKeywords &Keywords;

ArrayRef<AnnotatedLine *>::const_iterator End;

ArrayRef<AnnotatedLine *>::const_iterator Next;

SmallVectorImpl<AnnotatedLine *> &AnnotatedLines;

markFinalized(FormatToken *Tok) {

(Tok->is(tok::hash) && !Tok->Previous && Tok->Next &&

Tok->Next->isOneOf(tok::pp_if, tok::pp_ifdef, tok::pp_ifndef,

tok::pp_elif, tok::pp_elifdef, tok::pp_elifndef,

tok::pp_else, tok::pp_endif)) {

(; Tok; Tok = Tok->Next) {

Tok->SpacesRequiredBefore = 0;

(!Tok->MustBreakBeforeFinalized)

Tok->MustBreakBefore = 0;

Tok->Finalized =

;

printLineState(

LineState &State) {

llvm::dbgs() <<

;

(

ParenState &

: State.Stack) {

llvm::dbgs() << (

.Tok ?

.Tok->TokenText :

) <<

<<

.Indent <<

<<

.LastSpace <<

<<

.NestedBlockIndent <<

;

llvm::dbgs() << State.NextToken->TokenText <<

;

LineFormatter {

LineFormatter(ContinuationIndenter *

, WhitespaceManager *Whitespaces,

FormatStyle &Style,

UnwrappedLineFormatter *BlockFormatter)

BlockFormatter(BlockFormatter) {}

~LineFormatter() {}

formatLine(

AnnotatedLine &

,

FirstIndent,

FirstStartColumn,

DryRun) = 0;

formatChildren(LineState &State,

,

DryRun,

&Penalty) {

FormatToken *LBrace = State.NextToken->getPreviousNonComment();

HasLBrace = LBrace && LBrace->is(tok::l_brace) && LBrace->is(

);

FormatToken &

= *State.NextToken->Previous;

(

.Children.size() == 0 || (!HasLBrace && !LBrace->MacroParent)) {

ParenState &

= State.Stack.back();

AdditionalIndent =

.Indent -

.Children[0]->Level * Style.IndentWidth;

BlockFormatter->format(

.Children, DryRun, AdditionalIndent,

(

.Children[0]->First->MustBreakBefore)

(

.Children.size() > 1)

AnnotatedLine *Child =

.Children[0];

(Child->Last->isTrailingComment())

(Style.ColumnLimit > 0 &&

Child->Last->TotalLength + State.Column + 2 > Style.ColumnLimit) {

Whitespaces->replaceWhitespace(

*Child->First,

0,

1,

State.Column,

,

State.Line->InPPDirective);

formatLine(*Child, State.Column + 1,

0, DryRun);

markFinalized(Child->First);

State.Column += 1 + Child->Last->TotalLength;

WhitespaceManager *Whitespaces;

FormatStyle &Style;

UnwrappedLineFormatter *BlockFormatter;

NoColumnLimitLineFormatter :

LineFormatter {

NoColumnLimitLineFormatter(ContinuationIndenter *

,

WhitespaceManager *Whitespaces,

FormatStyle &Style,

UnwrappedLineFormatter *BlockFormatter)

: LineFormatter(

, Whitespaces, Style, BlockFormatter) {}

formatLine(

AnnotatedLine &

,

FirstIndent,

FirstStartColumn,

DryRun)

{

LineState State =

->getInitialState(FirstIndent, FirstStartColumn,

(State.NextToken) {

(

->canBreak(State) && State.NextToken->NewlinesBefore > 0);

Penalty = 0;

formatChildren(State, Newline,

, Penalty);

->addTokenToState(State, Newline,

);

NoLineBreakFormatter :

LineFormatter {

NoLineBreakFormatter(ContinuationIndenter *

,

WhitespaceManager *Whitespaces,

FormatStyle &Style,

UnwrappedLineFormatter *BlockFormatter)

: LineFormatter(

, Whitespaces, Style, BlockFormatter) {}

formatLine(

AnnotatedLine &

,

FirstIndent,

FirstStartColumn,

DryRun)

{

Penalty = 0;

->getInitialState(FirstIndent, FirstStartColumn, &

, DryRun);

(State.NextToken) {

formatChildren(State,

, DryRun, Penalty);

State,

State.NextToken->MustBreakBefore, DryRun);

OptimizingLineFormatter :

LineFormatter {

OptimizingLineFormatter(ContinuationIndenter *

,

WhitespaceManager *Whitespaces,

FormatStyle &Style,

UnwrappedLineFormatter *BlockFormatter)

: LineFormatter(

, Whitespaces, Style, BlockFormatter) {}

formatLine(

AnnotatedLine &

,

FirstIndent,

FirstStartColumn,

DryRun)

{

->getInitialState(FirstIndent, FirstStartColumn, &

, DryRun);

State.Stack.back().BreakBeforeParameter =

;

analyzeSolutionSpace(State, DryRun);

CompareLineStatePointers {

operator()(LineState *obj1, LineState *obj2)

{

*obj1 < *obj2;

std::pair<unsigned, unsigned> OrderedPenalty;

StateNode(

LineState &State,

NewLine, StateNode *Previous)

std::pair<OrderedPenalty, StateNode *> QueueItem;

std::priority_queue<QueueItem, SmallVector<QueueItem>,

std::greater<QueueItem>>

analyzeSolutionSpace(LineState &InitialState,

DryRun) {

std::set<LineState *, CompareLineStatePointers> Seen;

StateNode *RootNode =

(Allocator.Allocate()) StateNode(InitialState,

,

);

Queue.push(QueueItem(OrderedPenalty(0, Count), RootNode));

Penalty = 0;

(!Queue.empty()) {

(Count > 25'000'000)

Penalty = Queue.top().first.first;

StateNode *

= Queue.top().second;

(!

->State.NextToken) {

LLVM_DEBUG(llvm::dbgs()

<<

<< Penalty <<

);

->State.IgnoreStackForComparison =

;

(!Seen.insert(&

->State).second) {

addNextStateToQueue(Penalty,

,

, &Count, &Queue);

addNextStateToQueue(Penalty,

,

, &Count, &Queue);

(Queue.empty()) {

LLVM_DEBUG(llvm::dbgs() <<

);

reconstructPath(InitialState, Queue.top().second);

LLVM_DEBUG(llvm::dbgs()

<<

<< Count <<

);

LLVM_DEBUG(llvm::dbgs() <<

);

addNextStateToQueue(

Penalty, StateNode *PreviousNode,

,

*Count, QueueType *Queue) {

StateNode *

=

(Allocator.Allocate())

StateNode(PreviousNode->State,

, PreviousNode);

(!formatChildren(

->State,

,

, Penalty))

Queue->push(QueueItem(OrderedPenalty(Penalty, *Count),

));

reconstructPath(LineState &State, StateNode *Best) {

(Best->Previous) {

.push_back(Best);

Best = Best->Previous;

(

&

: llvm::reverse(

)) {

Penalty = 0;

formatChildren(State,

->NewLine,

, Penalty);

Penalty +=

->addTokenToState(State,

->NewLine,

);

printLineState(

->Previous->State);

(

->NewLine) {

llvm::dbgs() <<

<<

->Previous->State.NextToken->Tok.getName()

<<

<< Penalty <<

;

llvm::SpecificBumpPtrAllocator<StateNode> Allocator;

AdditionalIndent,

FixBadIndentation,

FirstStartColumn,

NextStartColumn,

LastStartColumn) {

LineJoiner Joiner(Style, Keywords, Lines);

std::pair<const SmallVectorImpl<AnnotatedLine *> *,

> CacheKey(

&Lines, AdditionalIndent);

CacheIt = PenaltyCache.find(CacheKey);

(DryRun && CacheIt != PenaltyCache.end())

CacheIt->second;

assert(!Lines.empty());

Penalty = 0;

LevelIndentTracker IndentTracker(Style, Keywords, Lines[0]->Level,

RangeMinLevel =

;

FirstLine =

;

Joiner.getNextMergedLine(DryRun, IndentTracker);

; PrevPrevLine = PreviousLine, PreviousLine =

,

= NextLine,

FirstLine =

) {

assert(

->First);

Indent = IndentTracker.getIndent();

PreviousRBrace =

PreviousLine && PreviousLine->

(tok::r_brace);

ContinueFormatting =

TheLine.

> RangeMinLevel ||

(TheLine.

== RangeMinLevel && !PreviousRBrace &&

FixIndentation = (FixBadIndentation || ContinueFormatting) &&

ShouldFormat = TheLine.

|| FixIndentation;

LastLine = TheLine.

->

(tok::eof);

formatFirstToken(TheLine, PreviousLine, PrevPrevLine, Lines, Indent,

LastLine ? LastStartColumn : NextStartColumn + Indent);

NextLine = Joiner.getNextMergedLine(DryRun, IndentTracker);

ColumnLimit = getColumnLimit(TheLine.

, NextLine);

FitsIntoOneLine =

(!Style.isJavaScript() || !Style.JavaScriptWrapImports)) ||

(Style.isCSharp() &&

(Style.ColumnLimit == 0) {

NoColumnLimitLineFormatter(

, Whitespaces, Style,

)

.formatLine(TheLine, NextStartColumn + Indent,

FirstLine ? FirstStartColumn : 0, DryRun);

}

(FitsIntoOneLine) {

Penalty += NoLineBreakFormatter(

, Whitespaces, Style,

)

.formatLine(TheLine, NextStartColumn + Indent,

FirstLine ? FirstStartColumn : 0, DryRun);

Penalty += OptimizingLineFormatter(

, Whitespaces, Style,

)

.formatLine(TheLine, NextStartColumn + Indent,

FirstLine ? FirstStartColumn : 0, DryRun);

RangeMinLevel = std::min(RangeMinLevel, TheLine.

);

(!Tok->Children.empty())

(Tok->Children, DryRun);

StartsNewLine =

IndentTracker.adjustToUnmodifiedLine(TheLine);

ReformatLeadingWhitespace =

StartsNewLine && ((PreviousLine && PreviousLine->

) ||

(ReformatLeadingWhitespace) {

formatFirstToken(TheLine, PreviousLine, PrevPrevLine, Lines,

Whitespaces->addUntouchableToken(*TheLine.

,

Whitespaces->addUntouchableToken(*Tok, TheLine.

);

NextLine = Joiner.getNextMergedLine(DryRun, IndentTracker);

markFinalized(TheLine.

);

PenaltyCache[CacheKey] = Penalty;

&RootToken = *

.First;

(RootToken.is(tok::r_brace) &&

(RootToken.Next->is(tok::semi) && !RootToken.Next->Next)) &&

Newlines = std::min(Newlines, 1u);

(!PreviousLine &&

.Level > 0)

Newlines = std::min(Newlines, 1u);

(Newlines == 0 && !RootToken.IsFirst)

(RootToken.IsFirst &&

PreviousLine->

->

(tok::l_brace) &&

!startsExternCBlock(*PreviousLine)) {

(PreviousLine && PreviousLine->

(TT_NamespaceLBrace)) {

(!

.startsWithNamespace())

Newlines = std::max(Newlines, 2u);

(

.startsWith(TT_NamespaceRBrace)) {

(!PreviousLine->

(TT_NamespaceRBrace))

Newlines = std::max(Newlines, 2u);

(PreviousLine && RootToken.isAccessSpecifier()) {

Newlines = std::max(RootToken.NewlinesBefore, 1u);

(PreviousLine->

->

(tok::semi, tok::r_brace) && Newlines <= 1)

(PreviousLine->

->

(tok::comment))

previousToken = PreviousLine->

;

((!previousToken || previousToken->

(tok::l_brace)) &&

(!PreviousLine->

|| !RootToken.HasUnescapedNewline)) {

(!RootToken.isAccessSpecifier()) {

Newlines = std::max(Newlines, 1u);

(RootToken.is(tok::r_brace))

Newlines = std::max(Newlines, 2u);

UnwrappedLineFormatter::formatFirstToken(

AnnotatedLine &

,

AnnotatedLine *PreviousLine,

AnnotatedLine *PrevPrevLine,

NewlineIndent) {

FormatToken &RootToken = *

.First;

(RootToken.is(tok::eof)) {

Newlines = std::min(

RootToken.NewlinesBefore,

Style.KeepEmptyLines.AtEndOfFile ? Style.MaxEmptyLinesToKeep + 1 : 1);

TokenIndent = Newlines ? NewlineIndent : 0;

Whitespaces->replaceWhitespace(RootToken, Newlines, TokenIndent,

(RootToken.Newlines < 0) {

RootToken.Newlines =

assert(RootToken.Newlines >= 0);

(RootToken.Newlines > 0)

Indent = NewlineIndent;

(!Style.isJavaScript() &&

Whitespaces->replaceWhitespace(RootToken, RootToken.Newlines, Indent, Indent,

.InPPDirective &&

!RootToken.HasUnescapedNewline);

UnwrappedLineFormatter::getColumnLimit(

InPPDirective,

AnnotatedLine *NextLine)

{

ContinuesPPDirective =

(NextLine->InPPDirective &&

!NextLine->First->HasUnescapedNewline));

Style.ColumnLimit - (ContinuesPPDirective ? 2 : 0);

This file contains the declaration of the FormatToken, a wrapper around Token with additional informa...

ContinuationIndenter * Indenter

Implements a combinatorial exploration of all the different linebreaks unwrapped lines can be formatt...

WhitespaceManager class manages whitespace around tokens and their replacements.

unsigned getSpellingLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

bool LeadingEmptyLinesAffected

True if the leading empty lines of this line intersect with one of the input ranges.

bool Affected

True if this line should be formatted, i.e.

bool ContainsMacroCall

True if this line contains a macro call for which an expansion exists.

bool ChildrenAffected

True if one of this line's children intersects with an input range.

bool startsWithNamespace() const

true if this line starts a namespace definition.

bool endsWith(Ts... Tokens) const

true if this line ends with the given tokens in reversed order, ignoring comments.

bool startsWith(Ts... Tokens) const

true if this line starts with the given tokens in order, ignoring comments.

unsigned format(const SmallVectorImpl< AnnotatedLine * > &Lines, bool DryRun=false, int AdditionalIndent=0, bool FixBadIndentation=false, unsigned FirstStartColumn=0, unsigned NextStartColumn=0, unsigned LastStartColumn=0)

Format the current block and return the penalty.

@ MR_UnexpandedArg

The token is part of a macro argument that was previously formatted as expansion when formatting the ...

@ MR_ExpandedArg

The token was expanded from a macro argument when formatting the expanded token sequence.

const FormatToken * getNamespaceToken(const AnnotatedLine *Line, const SmallVectorImpl< AnnotatedLine * > &AnnotatedLines)

static auto computeNewlines(const AnnotatedLine &Line, const AnnotatedLine *PreviousLine, const AnnotatedLine *PrevPrevLine, const SmallVectorImpl< AnnotatedLine * > &Lines, const FormatStyle &Style)

StringRef getNamespaceTokenText(const AnnotatedLine *Line, const SmallVectorImpl< AnnotatedLine * > &AnnotatedLines)

@ LT_CommentAbovePPDirective

@ LT_PreprocessorDirective

ObjCKeywordKind

Provides a namespace for Objective-C keywords which start with an '@'.

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

if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))

bool AtStartOfFile

Keep empty lines at start of file.

bool AtStartOfBlock

Keep empty lines at start of a block.

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

@ LK_Java

Should be used for Java.

@ ELBAMS_LogicalBlock

Add empty line only when access modifier starts a new logical block.

@ ELBAMS_Never

Remove all empty lines before access modifiers.

@ ELBAMS_Always

Always add empty line before access modifiers unless access modifier is at the start of struct or cla...

@ ELBAMS_Leave

Keep existing empty lines before access modifiers.

WrapNamespaceBodyWithEmptyLinesStyle WrapNamespaceBodyWithEmptyLines

Wrap namespace body with empty lines.

@ PPDIS_BeforeHash

Indents directives before the hash.

@ PPDIS_None

Does not indent any directives.

@ SBS_Empty

Only merge empty blocks.

@ SBS_Never

Never merge blocks into a single line.

@ SIS_WithoutElse

Put short ifs on the same line only if there is no else statement.

@ SIS_AllIfsAndElse

Always put short ifs, else ifs and else statements on the same line.

@ BWACS_Always

Always wrap braces after a control statement.

@ BWACS_MultiLine

Only wrap braces after a multi-line control statement.

@ WNBWELS_Leave

Keep existing newlines at the beginning and the end of namespace body.

@ WNBWELS_Never

Remove all empty lines at the beginning and the end of namespace body.

@ SFS_All

Merge all functions fitting on a single line.

@ SFS_Empty

Only merge empty functions.

@ SFS_InlineOnly

Only merge functions defined inside a class.

KeepEmptyLinesStyle KeepEmptyLines

Which empty lines are kept.

unsigned MaxEmptyLinesToKeep

The maximum number of consecutive empty lines to keep.

@ ELAAMS_Always

Always add empty line after access modifiers if there are none.

@ ELAAMS_Never

Remove all empty lines after access modifiers.

@ ELAAMS_Leave

Keep existing empty lines after access modifiers.

EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier

Defines in which cases to put empty line before access modifiers.

EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier

Defines when to put an empty line after access modifiers.

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

unsigned OriginalColumn

The original 0-based column of this token, including expanded tabs.

FormatToken * getPreviousNonComment() const

Returns the previous token ignoring comments.

FormatToken * Next

The next token in the unwrapped line.

unsigned NewlinesBefore

The number of newlines immediately before the Token.

bool is(tok::TokenKind Kind) const

unsigned TotalLength

The total length of the unwrapped line up to and including this token.

bool isOneOf(A K1, B K2) const

unsigned IsFirst

Indicates that this is the first token of the file.

bool isAccessSpecifier(bool ColonRequired=true) const

bool FormatComplete

A value of false means that any of the affected ranges were not formatted due to a non-recoverable sy...

unsigned Line

If FormatComplete is false, Line records a one-based original line number at which a syntax error mig...

static const size_t kInvalidIndex

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