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

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

clang: lib/Format/WhitespaceManager.cpp Source File

StartOfTokenColumn,

IsAligned,

InPPDirective) {

Spaces, StartOfTokenColumn, Newlines,

,

,

IsAligned, InPPDirective && !Tok.

,

Changes.push_back(

(Tok,

,

, InPPDirective && !Tok.

,

Replaces.

(Replacement);

LF =

.count(

);

CR =

.count(

) * 2;

LF == CR ? DefaultToCRLF : CR > LF;

&Tok,

Offset,

ReplaceChars,

StringRef PreviousPostfix, StringRef CurrentPrefix,

InPPDirective,

Newlines,

Spaces) {

std::max(0, Spaces), Newlines, PreviousPostfix, CurrentPrefix,

, InPPDirective && !Tok.

,

calculateLineBreakInformation();

alignConsecutiveMacros();

alignConsecutiveShortCaseStatements(

);

alignConsecutiveShortCaseStatements(

);

alignConsecutiveDeclarations();

alignConsecutiveBitFields();

alignConsecutiveAssignments();

alignConsecutiveTableGenBreakingDAGArgColons();

alignConsecutiveTableGenCondOperatorColons();

alignConsecutiveTableGenDefinitions();

alignChainedConditionals();

alignTrailingComments();

alignEscapedNewlines();

alignArrayInitializers();

WhitespaceManager::calculateLineBreakInformation() {

Changes[0].PreviousEndOfTokenColumn = 0;

Change *LastOutsideTokenChange = &Changes[0];

(

I = 1, e = Changes.size(); I != e; ++I) {

&

= Changes[I];

&

= Changes[I - 1];

&PrevTokLength =

.TokenLength;

.OriginalWhitespaceRange.getBegin();

.OriginalWhitespaceRange.getEnd();

OriginalWhitespaceStartOffset =

PreviousOriginalWhitespaceEndOffset =

assert(PreviousOriginalWhitespaceEndOffset <=

OriginalWhitespaceStartOffset);

*

PreviousOriginalWhitespaceEndData =

StringRef

(PreviousOriginalWhitespaceEndData,

PreviousOriginalWhitespaceEndData);

NewlinePos =

.find_first_of(

);

(NewlinePos == StringRef::npos) {

PrevTokLength = OriginalWhitespaceStartOffset -

PreviousOriginalWhitespaceEndOffset +

.PreviousLinePostfix.size() +

.CurrentLinePrefix.size();

(!

.IsInsideToken)

PrevTokLength = std::min(PrevTokLength,

.Tok->ColumnWidth);

PrevTokLength = NewlinePos +

.CurrentLinePrefix.size();

(

.IsInsideToken &&

.NewlinesBefore == 0)

LastOutsideTokenChange->TokenLength += PrevTokLength +

.Spaces;

LastOutsideTokenChange = &

;

.PreviousEndOfTokenColumn =

.StartOfTokenColumn + PrevTokLength;

.IsTrailingComment =

(

.NewlinesBefore > 0 ||

.Tok->is(tok::eof) ||

(

.IsInsideToken &&

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

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

OriginalWhitespaceStart != PreviousOriginalWhitespaceEnd;

Changes.back().TokenLength = 0;

Changes.back().IsTrailingComment = Changes.back().Tok->is(tok::comment);

WhitespaceManager::Change *LastBlockComment =

;

(

&Change : Changes) {

(Change.IsInsideToken && Change.NewlinesBefore == 0)

Change.IsTrailingComment =

;

Change.StartOfBlockComment =

;

Change.IndentationOffset = 0;

(Change.Tok->is(tok::comment)) {

(Change.Tok->is(TT_LineComment) || !Change.IsInsideToken) {

LastBlockComment = &Change;

}

((Change.StartOfBlockComment = LastBlockComment)) {

Change.IndentationOffset =

Change.StartOfTokenColumn -

Change.StartOfBlockComment->StartOfTokenColumn;

LastBlockComment =

;

SmallVector<bool, 16> ScopeStack;

ConditionalsLevel = 0;

(

&Change : Changes) {

(

i = 0, e = Change.Tok->FakeLParens.size(); i != e; ++i) {

isNestedConditional =

!(i == 0 && Change.Tok->Previous &&

Change.Tok->Previous->is(TT_ConditionalExpr) &&

Change.Tok->Previous->is(tok::colon));

(isNestedConditional)

ScopeStack.push_back(isNestedConditional);

Change.ConditionalsLevel = ConditionalsLevel;

(

i = Change.Tok->FakeRParens; i > 0 && ScopeStack.size(); --i)

(ScopeStack.pop_back_val())

<

F>

,

RightJustify, F &&Matches,

FoundMatchOnLine =

;

(

i = Start; i != End; ++i) {

&CurrentChange = Changes[i];

(ScopeStack.size() != 0 &&

CurrentChange.indentAndNestingLevel() <

Changes[ScopeStack.back()].indentAndNestingLevel()) {

ScopeStack.pop_back();

PreviousNonComment = i - 1;

(PreviousNonComment > Start &&

Changes[PreviousNonComment].Tok->is(tok::comment)) {

--PreviousNonComment;

(i != Start && CurrentChange.indentAndNestingLevel() >

Changes[PreviousNonComment].indentAndNestingLevel()) {

ScopeStack.push_back(i);

InsideNestedScope = ScopeStack.size() != 0;

ContinuedStringLiteral = i > Start &&

CurrentChange.Tok->is(tok::string_literal) &&

Changes[i - 1].Tok->is(tok::string_literal);

SkipMatchCheck = InsideNestedScope || ContinuedStringLiteral;

(CurrentChange.NewlinesBefore > 0 && !SkipMatchCheck) {

FoundMatchOnLine =

;

(!FoundMatchOnLine && !SkipMatchCheck && Matches(CurrentChange)) {

FoundMatchOnLine =

;

Shift =

- (RightJustify ? CurrentChange.TokenLength : 0) -

CurrentChange.StartOfTokenColumn;

CurrentChange.Spaces += Shift;

(CurrentChange.NewlinesBefore == 0) {

CurrentChange.Spaces =

std::max(CurrentChange.Spaces,

(CurrentChange.Tok->SpacesRequiredBefore));

(InsideNestedScope && CurrentChange.NewlinesBefore > 0) {

ScopeStart = ScopeStack.back();

ShouldShiftBeAdded = [&] {

(Changes[ScopeStart - 1].Tok->is(TT_FunctionDeclarationName))

(Changes[ScopeStart - 1].Tok->is(TT_LambdaLBrace))

(ScopeStart > Start + 1 &&

Changes[ScopeStart - 2].Tok->is(TT_FunctionDeclarationName)) {

(ScopeStart > Start + 1 &&

Changes[ScopeStart - 2].Tok->isOneOf(tok::identifier,

TT_TemplateCloser) &&

Changes[ScopeStart - 1].Tok->is(tok::l_paren) &&

Changes[ScopeStart].Tok->isNot(TT_LambdaLSquare)) {

(CurrentChange.Tok->MatchingParen &&

CurrentChange.Tok->MatchingParen->is(TT_LambdaLBrace)) {

(Changes[ScopeStart].NewlinesBefore > 0)

(CurrentChange.Tok->is(tok::l_brace) &&

Style.BinPackArguments;

(CurrentChange.Tok->is(TT_ConditionalExpr))

(CurrentChange.Tok->is(TT_DesignatedInitializerPeriod))

(CurrentChange.Tok->Previous &&

CurrentChange.Tok->Previous->is(TT_ConditionalExpr)) {

(ScopeStart > Start + 1 &&

Changes[ScopeStart - 2].Tok->is(tok::identifier) &&

Changes[ScopeStart - 1].Tok->is(tok::l_brace) &&

CurrentChange.Tok->is(tok::l_brace) &&

(ScopeStart > Start + 1 &&

Changes[ScopeStart - 2].Tok->isNot(tok::identifier) &&

Changes[ScopeStart - 1].Tok->is(tok::l_brace) &&

CurrentChange.Tok->isNot(tok::r_brace)) {

(

OuterScopeStart : llvm::reverse(ScopeStack)) {

(OuterScopeStart > Start &&

Changes[OuterScopeStart - 1].Tok->is(TT_LambdaLBrace)) {

(Changes[ScopeStart].NewlinesBefore > 0)

(Changes[ScopeStart - 1].Tok->is(TT_TemplateOpener))

(ShouldShiftBeAdded())

CurrentChange.Spaces += Shift;

(ContinuedStringLiteral)

CurrentChange.Spaces += Shift;

assert(Shift > 0 || Changes[i].NewlinesBefore > 0 ||

CurrentChange.Spaces >=

(Changes[i].Tok->SpacesRequiredBefore) ||

CurrentChange.Tok->is(tok::eof));

CurrentChange.StartOfTokenColumn += Shift;

(i + 1 != Changes.size())

Changes[i + 1].PreviousEndOfTokenColumn += Shift;

CurrentChange.Spaces != 0 &&

!CurrentChange.Tok->isOneOf(tok::equal, tok::r_paren,

TT_TemplateCloser)) {

ReferenceNotRightAligned =

assert(Changes[

].Tok->isPointerOrReference());

(Changes[

].Tok->isNot(tok::star)) {

(ReferenceNotRightAligned)

Changes[

+ 1].Spaces -= Shift;

Changes[

].Spaces += Shift;

Changes[

].StartOfTokenColumn += Shift;

<

F>

RightJustify =

) {

WidthLeft = 0;

WidthAnchor = 0;

WidthRight = 0;

StartOfSequence = 0;

EndOfSequence = 0;

IndentAndNestingLevel = StartAt < Changes.size()

? Changes[StartAt].indentAndNestingLevel()

: std::tuple<unsigned, unsigned, unsigned>();

CommasBeforeLastMatch = 0;

CommasBeforeMatch = 0;

FoundMatchOnLine =

;

LineIsComment =

;

AlignCurrentSequence = [&] {

(StartOfSequence > 0 && StartOfSequence < EndOfSequence) {

WidthLeft + WidthAnchor, RightJustify, Matches,

i = StartAt;

(

e = Changes.size(); i != e; ++i) {

&CurrentChange = Changes[i];

(CurrentChange.indentAndNestingLevel() < IndentAndNestingLevel)

(CurrentChange.NewlinesBefore != 0) {

CommasBeforeMatch = 0;

EmptyLineBreak =

(CurrentChange.NewlinesBefore > 1) && !ACS.AcrossEmptyLines;

!FoundMatchOnLine && !(LineIsComment && ACS.AcrossComments);

(EmptyLineBreak || NoMatchBreak)

AlignCurrentSequence();

(i == 0 || CurrentChange.Tok->isNot(tok::string_literal) ||

Changes[i - 1].Tok->isNot(tok::string_literal)) {

FoundMatchOnLine =

;

LineIsComment =

;

(CurrentChange.Tok->isNot(tok::comment))

LineIsComment =

;

(CurrentChange.Tok->is(tok::comma)) {

}

(CurrentChange.indentAndNestingLevel() > IndentAndNestingLevel) {

(Style, Matches, Changes, i, ACS, RightJustify);

(!Matches(CurrentChange))

(FoundMatchOnLine || CommasBeforeMatch != CommasBeforeLastMatch)

AlignCurrentSequence();

CommasBeforeLastMatch = CommasBeforeMatch;

FoundMatchOnLine =

;

(StartOfSequence == 0)

ChangeWidthLeft = CurrentChange.StartOfTokenColumn;

ChangeWidthAnchor = 0;

ChangeWidthRight = 0;

(ACS.PadOperators)

ChangeWidthAnchor = CurrentChange.TokenLength;

ChangeWidthLeft += CurrentChange.TokenLength;

ChangeWidthRight = CurrentChange.TokenLength;

(

j = i + 1; j != e && Changes[j].NewlinesBefore == 0; ++j) {

ChangeWidthRight += Changes[j].Spaces;

(!Changes[j].IsInsideToken)

ChangeWidthRight += Changes[j].TokenLength;

NewLeft = std::max(ChangeWidthLeft, WidthLeft);

NewAnchor = std::max(ChangeWidthAnchor, WidthAnchor);

NewRight = std::max(ChangeWidthRight, WidthRight);

(Style.ColumnLimit != 0 &&

Style.ColumnLimit < NewLeft + NewAnchor + NewRight) {

AlignCurrentSequence();

WidthLeft = ChangeWidthLeft;

WidthAnchor = ChangeWidthAnchor;

WidthRight = ChangeWidthRight;

WidthAnchor = NewAnchor;

WidthRight = NewRight;

AlignCurrentSequence();

&StartOfSequence,

&EndOfSequence,

&MinColumn,

(StartOfSequence > 0 && StartOfSequence < EndOfSequence) {

FoundMatchOnLine =

;

(

I = StartOfSequence; I != EndOfSequence; ++I) {

(Changes[I].NewlinesBefore > 0) {

FoundMatchOnLine =

;

(!FoundMatchOnLine && Matches(Changes[I])) {

FoundMatchOnLine =

;

Shift = MinColumn - Changes[I].StartOfTokenColumn;

Changes[I].Spaces += Shift;

Changes[I].StartOfTokenColumn += Shift;

(I + 1 != Changes.size())

Changes[I + 1].PreviousEndOfTokenColumn += Shift;

WhitespaceManager::alignConsecutiveMacros() {

(!Style.AlignConsecutiveMacros.Enabled)

AlignMacrosMatches = [](

Change &

) {

FormatToken *Current =

.Tok;

SpacesRequiredBefore = 1;

(Current->SpacesRequiredBefore == 0 || !Current->Previous)

Current = Current->Previous;

(Current->is(tok::r_paren) && Current->MatchingParen) {

Current = Current->MatchingParen->Previous;

SpacesRequiredBefore = 0;

(!Current || Current->isNot(tok::identifier))

(!Current->Previous || Current->Previous->isNot(tok::pp_define))

Current->Next->SpacesRequiredBefore == SpacesRequiredBefore;

MinColumn = 0;

StartOfSequence = 0;

EndOfSequence = 0;

FoundMatchOnLine =

;

LineIsComment =

;

(

= Changes.size(); I !=

; ++I) {

(Changes[I].NewlinesBefore != 0) {

EmptyLineBreak = (Changes[I].NewlinesBefore > 1) &&

!Style.AlignConsecutiveMacros.AcrossEmptyLines;

!(LineIsComment && Style.AlignConsecutiveMacros.AcrossComments);

(EmptyLineBreak || NoMatchBreak) {

AlignMacrosMatches, Changes);

FoundMatchOnLine =

;

LineIsComment =

;

(Changes[I].Tok->isNot(tok::comment))

LineIsComment =

;

(!AlignMacrosMatches(Changes[I]))

FoundMatchOnLine =

;

(StartOfSequence == 0)

ChangeMinColumn = Changes[I].StartOfTokenColumn;

MinColumn = std::max(MinColumn, ChangeMinColumn);

AlignMacrosMatches, Changes);

WhitespaceManager::alignConsecutiveAssignments() {

(!Style.AlignConsecutiveAssignments.Enabled)

[&](

Change &

) {

(

.NewlinesBefore > 0)

(&

!= &Changes.back() && (&

+ 1)->NewlinesBefore > 0)

FormatToken *

=

.Tok->getPreviousNonComment();

Style.AlignConsecutiveAssignments.AlignCompound

: (

.Tok->is(tok::equal) ||

(Style.isVerilog() &&

.Tok->is(tok::lessequal) &&

Changes,

0, Style.AlignConsecutiveAssignments,

WhitespaceManager::alignConsecutiveBitFields() {

alignConsecutiveColons(Style.AlignConsecutiveBitFields, TT_BitFieldColon);

WhitespaceManager::alignConsecutiveColons(

FormatStyle::AlignConsecutiveStyle &AlignStyle,

Type) {

(!AlignStyle.Enabled)

[&](Change

&

) {

(

.NewlinesBefore > 0)

(&

!= &Changes.back() && (&

+ 1)->NewlinesBefore > 0)

.Tok->is(Type);

Changes,

0, AlignStyle);

WhitespaceManager::alignConsecutiveShortCaseStatements(

IsExpr) {

(!Style.AlignConsecutiveShortCaseStatements.Enabled ||

!(IsExpr ? Style.AllowShortCaseExpressionOnASingleLine

: Style.AllowShortCaseLabelsOnASingleLine)) {

= IsExpr ? TT_CaseLabelArrow : TT_CaseLabelColon;

&Option = Style.AlignConsecutiveShortCaseStatements;

AlignArrowOrColon =

IsExpr ? Option.AlignCaseArrows : Option.AlignCaseColons;

Matches = [&](

Change &

) {

(AlignArrowOrColon)

.Tok->is(Type);

!

.IsInsideToken &&

.Tok->Previous &&

.Tok->Previous->is(Type);

MinColumn = 0;

MinEmptyCaseColumn = 0;

StartOfSequence = 0;

EndOfSequence = 0;

FoundMatchOnLine =

;

LineIsComment =

;

LineIsEmptyCase =

;

(

= Changes.size(); I !=

; ++I) {

(Changes[I].NewlinesBefore != 0) {

EmptyLineBreak =

(Changes[I].NewlinesBefore > 1) &&

!Style.AlignConsecutiveShortCaseStatements.AcrossEmptyLines;

Style.AlignConsecutiveShortCaseStatements.AcrossComments) &&

(EmptyLineBreak || NoMatchBreak) {

MinEmptyCaseColumn = 0;

FoundMatchOnLine =

;

LineIsComment =

;

LineIsEmptyCase =

;

(Changes[I].Tok->isNot(tok::comment))

LineIsComment =

;

(Changes[I].Tok->is(Type)) {

!Changes[I].Tok->Next || Changes[I].Tok->Next->isTrailingComment();

(LineIsEmptyCase) {

(Style.AlignConsecutiveShortCaseStatements.AlignCaseColons) {

std::max(MinEmptyCaseColumn, Changes[I].StartOfTokenColumn);

std::max(MinEmptyCaseColumn, Changes[I].StartOfTokenColumn + 2);

(!Matches(Changes[I]))

FoundMatchOnLine =

;

(StartOfSequence == 0)

EndOfSequence = I + 1;

MinColumn = std::max(MinColumn, Changes[I].StartOfTokenColumn);

MinColumn = std::max(MinColumn, MinEmptyCaseColumn);

WhitespaceManager::alignConsecutiveTableGenBreakingDAGArgColons() {

alignConsecutiveColons(Style.AlignConsecutiveTableGenBreakingDAGArgColons,

TT_TableGenDAGArgListColonToAlign);

WhitespaceManager::alignConsecutiveTableGenCondOperatorColons() {

alignConsecutiveColons(Style.AlignConsecutiveTableGenCondOperatorColons,

TT_TableGenCondOperatorColon);

WhitespaceManager::alignConsecutiveTableGenDefinitions() {

alignConsecutiveColons(Style.AlignConsecutiveTableGenDefinitionColons,

TT_InheritanceColon);

WhitespaceManager::alignConsecutiveDeclarations() {

(!Style.AlignConsecutiveDeclarations.Enabled)

[&](Change

&

) {

(Style.AlignConsecutiveDeclarations.AlignFunctionPointers) {

for (const auto *Prev = C.Tok->Previous; Prev; Prev = Prev->Previous)

if (Prev->is(tok::equal))

if (C.Tok->is(TT_FunctionTypeLParen))

(

.Tok->is(TT_FunctionDeclarationName))

Style.AlignConsecutiveDeclarations.AlignFunctionDeclarations;

(

.Tok->isNot(TT_StartOfName))

(

.Tok->Previous &&

.Tok->Previous->is(TT_StatementAttributeLikeMacro))

(FormatToken *Next =

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

if (Next->is(tok::comment))

if (Next->is(TT_PointerOrReference))

if (!Next->Tok.getIdentifierInfo())

if (Next->isOneOf(TT_StartOfName, TT_FunctionDeclarationName,

tok::kw_operator)) {

Changes,

0, Style.AlignConsecutiveDeclarations);

WhitespaceManager::alignChainedConditionals() {

(Style.BreakBeforeTernaryOperators) {

[](Change

&

) {

.Tok->is(TT_ConditionalExpr) &&

((

.Tok->is(tok::question) && !

.NewlinesBefore) ||

(

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

.Tok->Next &&

(

.Tok->Next->FakeLParens.size() == 0 ||

AlignWrappedOperand = [](Change

&

) {

FormatToken *

=

.Tok->getPreviousNonComment();

(

.Tok->FakeLParens.size() == 0 ||

(Change &

: Changes)

(AlignWrappedOperand(

))

.StartOfTokenColumn -= 2;

[

](Change

&

) {

(

.Tok->is(TT_ConditionalExpr) &&

.Tok->is(tok::question) &&

&

!= &Changes.back() && (&

+ 1)->NewlinesBefore == 0 &&

!(&

+ 1)->IsTrailingComment) ||

AlignWrappedOperand(

);

WhitespaceManager::alignTrailingComments() {

= Changes.size();

StartOfSequence = 0;

BreakBeforeNext =

;

NewLineThreshold = 1;

NewLineThreshold = Style.AlignTrailingComments.OverEmptyLines + 1;

(

I = 0, MaxColumn =

, Newlines = 0; I <

; ++I) {

&

= Changes[I];

(

.StartOfBlockComment)

Newlines +=

.NewlinesBefore;

(!

.IsTrailingComment)

OriginalSpaces =

.OriginalWhitespaceRange.getEnd().getRawEncoding() -

.OriginalWhitespaceRange.getBegin().getRawEncoding() -

.Tok->LastNewlineOffset;

assert(OriginalSpaces >= 0);

RestoredLineLength =

.StartOfTokenColumn +

.TokenLength + OriginalSpaces;

(RestoredLineLength >= Style.ColumnLimit && Style.ColumnLimit > 0)

.Spaces =

.NewlinesBefore > 0 ?

.Tok->OriginalColumn : OriginalSpaces;

ChangeMinColumn =

.StartOfTokenColumn;

ChangeMaxColumn;

(!

.CreateReplacement)

ChangeMaxColumn = ChangeMinColumn;

(Style.ColumnLimit == 0)

(Style.ColumnLimit >=

.TokenLength)

ChangeMaxColumn = Style.ColumnLimit -

.TokenLength;

ChangeMaxColumn = ChangeMinColumn;

(I + 1 < Size && Changes[I + 1].ContinuesPPDirective &&

ChangeMaxColumn >= 2) {

ChangeMaxColumn -= 2;

WasAlignedWithStartOfNextLine =

;

(

.NewlinesBefore >= 1) {

CommentColumn =

(

J = I + 1; J <

; ++J) {

(Changes[J].Tok->is(tok::comment))

Changes[J].OriginalWhitespaceRange.getEnd());

WasAlignedWithStartOfNextLine =

CommentColumn == NextColumn ||

CommentColumn == NextColumn + Style.IndentWidth;

DontAlignThisComment = [](

*Tok) {

(Tok->is(tok::semi)) {

Tok = Tok->getPreviousNonComment();

(Tok->is(tok::r_paren)) {

Tok = Tok->MatchingParen;

Tok = Tok->getPreviousNonComment();

(Tok->is(TT_DoWhile)) {

*Prev = Tok->getPreviousNonComment();

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

(Tok->Previous && Tok->Previous->is(tok::r_brace))

Tok = Tok->Previous;

Tok->NewlinesBefore > 0;

(I > 0 &&

.NewlinesBefore == 0 &&

DontAlignThisComment(Changes[I - 1].Tok)) {

alignTrailingComments(StartOfSequence, I, MinColumn);

StartOfSequence = I + 1;

}

(BreakBeforeNext || Newlines > NewLineThreshold ||

(ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) ||

(

.NewlinesBefore == 1 && I > 0 &&

!Changes[I - 1].IsTrailingComment) ||

WasAlignedWithStartOfNextLine) {

alignTrailingComments(StartOfSequence, I, MinColumn);

MinColumn = ChangeMinColumn;

MaxColumn = ChangeMaxColumn;

StartOfSequence = I;

MinColumn = std::max(MinColumn, ChangeMinColumn);

MaxColumn = std::min(MaxColumn, ChangeMaxColumn);

BreakBeforeNext = (I == 0) || (

.NewlinesBefore > 1) ||

(

.NewlinesBefore == 1 && StartOfSequence == I);

alignTrailingComments(StartOfSequence, Size, MinColumn);

WhitespaceManager::alignTrailingComments(

Start,

End,

(

i = Start; i != End; ++i) {

(Changes[i].IsTrailingComment)

(Changes[i].StartOfBlockComment) {

= Changes[i].IndentationOffset +

Changes[i].StartOfBlockComment->StartOfTokenColumn -

Changes[i].StartOfTokenColumn;

Changes[i].Spaces +=

;

(i + 1 != Changes.size())

Changes[i + 1].PreviousEndOfTokenColumn +=

;

Changes[i].StartOfTokenColumn +=

;

WhitespaceManager::alignEscapedNewlines() {

Align = Style.AlignEscapedNewlines;

MaxColumn = Style.ColumnLimit;

MaxEndOfLine = AlignLeft ? 0 : MaxColumn;

StartOfMacro = 0;

(

i = 1, e = Changes.size(); i < e; ++i) {

Change &

= Changes[i];

(

.NewlinesBefore == 0 && (!WithLastLine ||

.Tok->isNot(tok::eof)))

InPPDirective =

.ContinuesPPDirective;

BackslashColumn =

.PreviousEndOfTokenColumn + 2;

(InPPDirective ||

(WithLastLine && (MaxColumn == 0 || BackslashColumn <= MaxColumn))) {

MaxEndOfLine = std::max(BackslashColumn, MaxEndOfLine);

(!InPPDirective) {

alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine);

MaxEndOfLine = AlignLeft ? 0 : MaxColumn;

alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine);

WhitespaceManager::alignEscapedNewlines(

Start,

End,

(

i = Start; i < End; ++i) {

Change &

= Changes[i];

(

.NewlinesBefore > 0) {

assert(

.ContinuesPPDirective);

(

.PreviousEndOfTokenColumn + 1 >

)

.EscapedNewlineColumn = 0;

.EscapedNewlineColumn =

;

WhitespaceManager::alignArrayInitializers() {

(

ChangeIndex = 1U, ChangeEnd = Changes.size();

ChangeIndex < ChangeEnd; ++ChangeIndex) {

&

= Changes[ChangeIndex];

(

.Tok->IsArrayInitializer) {

FoundComplete =

;

(

InsideIndex = ChangeIndex + 1; InsideIndex < ChangeEnd;

(Changes[InsideIndex].Tok ==

.Tok->MatchingParen) {

alignArrayInitializers(ChangeIndex, InsideIndex + 1);

ChangeIndex = InsideIndex + 1;

FoundComplete =

;

ChangeIndex = ChangeEnd;

WhitespaceManager::alignArrayInitializers(

Start,

End) {

alignArrayInitializersRightJustified(getCells(Start, End));

alignArrayInitializersLeftJustified(getCells(Start, End));

WhitespaceManager::alignArrayInitializersRightJustified(

CellDescriptions &&CellDescs) {

(!CellDescs.isRectangular())

BracePadding = Style.Cpp11BracedListStyle ? 0 : 1;

&Cells = CellDescs.Cells;

*CellIter = Cells.begin();

(

i = 0

; i < CellDescs.CellCounts[0]; ++i, ++CellIter) {

NetWidth = 0

;

(isSplitCell(*CellIter))

NetWidth = getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);

CellWidth = getMaximumCellWidth(CellIter, NetWidth);

(Changes[CellIter->Index].Tok->is(tok::r_brace)) {

*Next = CellIter;

FormatToken *

= Changes[Next->Index].Tok->Previous;

Changes[Next->Index].Spaces = BracePadding;

Changes[Next->Index].NewlinesBefore = 0;

Next = Next->NextColumnElement;

(CellIter != Cells.begin()) {

getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);

MaxNetWidth = getMaximumNetWidth(

Cells.begin(), CellIter, CellDescs.InitialSpaces,

CellDescs.CellCounts[0], CellDescs.CellCounts.size());

(ThisNetWidth < MaxNetWidth)

Changes[CellIter->Index].Spaces = (MaxNetWidth - ThisNetWidth);

Offset = std::distance(Cells.begin(), CellIter);

(

*Next = CellIter->NextColumnElement; Next;

Next = Next->NextColumnElement) {

(RowCount >= CellDescs.CellCounts.size())

*Start = (Cells.begin() + RowCount * CellDescs.CellCounts[0]);

*End = Start + Offset;

ThisNetWidth = getNetWidth(Start, End, CellDescs.InitialSpaces);

(ThisNetWidth < MaxNetWidth)

Changes[Next->Index].Spaces = (MaxNetWidth - ThisNetWidth);

calculateCellWidth(CellIter->Index, CellIter->EndIndex,

) +

(Changes[CellIter->Index].NewlinesBefore == 0) {

Changes[CellIter->Index].Spaces = (CellWidth - (ThisWidth + NetWidth));

Changes[CellIter->Index].Spaces += (i > 0) ? 1 : BracePadding;

alignToStartOfCell(CellIter->Index, CellIter->EndIndex);

(

*Next = CellIter->NextColumnElement; Next;

Next = Next->NextColumnElement) {

calculateCellWidth(Next->Index, Next->EndIndex,

) + NetWidth;

(Changes[Next->Index].NewlinesBefore == 0) {

Changes[Next->Index].Spaces = (CellWidth - ThisWidth);

Changes[Next->Index].Spaces += (i > 0) ? 1 : BracePadding;

alignToStartOfCell(Next->Index, Next->EndIndex);

WhitespaceManager::alignArrayInitializersLeftJustified(

CellDescriptions &&CellDescs) {

(!CellDescs.isRectangular())

BracePadding = Style.Cpp11BracedListStyle ? 0 : 1;

&Cells = CellDescs.Cells;

*CellIter = Cells.begin();

(

*Next = CellIter; Next; Next = Next->NextColumnElement) {

&Change = Changes[Next->Index];

Change.NewlinesBefore == 0 ? BracePadding : CellDescs.InitialSpaces;

(

i = 1U; i < CellDescs.CellCounts[0]; i++, ++CellIter) {

MaxNetWidth = getMaximumNetWidth(

Cells.begin(), CellIter, CellDescs.InitialSpaces,

CellDescs.CellCounts[0], CellDescs.CellCounts.size());

getNetWidth(Cells.begin(), CellIter, CellDescs.InitialSpaces);

(Changes[CellIter->Index].NewlinesBefore == 0) {

Changes[CellIter->Index].Spaces =

MaxNetWidth - ThisNetWidth +

(Changes[CellIter->Index].Tok->isNot(tok::r_brace) ? 1

Offset = std::distance(Cells.begin(), CellIter);

(

*Next = CellIter->NextColumnElement; Next;

Next = Next->NextColumnElement) {

(RowCount >= CellDescs.CellCounts.size())

*Start = (Cells.begin() + RowCount * CellDescs.CellCounts[0]);

*End = Start + Offset;

ThisNetWidth = getNetWidth(Start, End, CellDescs.InitialSpaces);

(Changes[Next->Index].NewlinesBefore == 0) {

Changes[Next->Index].Spaces =

MaxNetWidth - ThisNetWidth +

(Changes[Next->Index].Tok->isNot(tok::r_brace) ? 1 : BracePadding);

WhitespaceManager::isSplitCell(

CellDescription &Cell) {

(

*Next = Cell.NextColumnElement; Next;

Next = Next->NextColumnElement) {

WhitespaceManager::CellDescriptions WhitespaceManager::getCells(

Start,

SmallVector<unsigned> CellCounts;

InitialSpaces = 0;

InitialTokenLength = 0;

EndSpaces = 0;

SmallVector<CellDescription> Cells;

FormatToken *MatchingParen =

;

(

i = Start; i < End; ++i) {

&

= Changes[i];

(

.Tok->is(tok::l_brace))

(

.Tok->is(tok::r_brace))

(

.Tok->is(tok::l_brace)) {

MatchingParen =

.Tok->MatchingParen;

(InitialSpaces == 0) {

InitialSpaces =

.Spaces +

.TokenLength;

InitialTokenLength =

.TokenLength;

(; Changes[j].NewlinesBefore == 0 && j > Start; --j) {

InitialSpaces += Changes[j].Spaces + Changes[j].TokenLength;

InitialTokenLength += Changes[j].TokenLength;

(

.NewlinesBefore == 0) {

InitialSpaces += Changes[j].Spaces + Changes[j].TokenLength;

InitialTokenLength += Changes[j].TokenLength;

}

(

.Tok->is(tok::comma)) {

Cells.back().EndIndex = i;

(

*Next =

.Tok->getNextNonComment();

Next && Next->isNot(tok::r_brace)) {

}

(Depth == 1) {

(

.Tok == MatchingParen) {

Cells.back().EndIndex = i;

Cells.push_back(CellDescription{i, ++Cell, i + 1,

,

});

CellCounts.push_back(

.Tok->Previous->isNot(tok::comma) ? Cell + 1

*NextNonComment =

.Tok->getNextNonComment();

(NextNonComment && NextNonComment->is(tok::comma))

NextNonComment = NextNonComment->getNextNonComment();

(j < End && Changes[j].Tok != NextNonComment)

(j < End && Changes[j].NewlinesBefore == 0 &&

Changes[j].Tok->isNot(tok::r_brace)) {

Changes[j].NewlinesBefore = 1;

Changes[j].Spaces = InitialSpaces - InitialTokenLength;

}

(

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

.Tok->NewlinesBefore == 0) {

.Spaces = Changes[i - 1].Tok->is(tok::comma) ? 1 : 2;

}

(

.Tok->is(tok::l_brace)) {

(; j > 0 && !Changes[j].Tok->ArrayInitializerLineStart; --j)

EndSpaces = Changes[j].Spaces;

}

(Depth == 0 &&

.Tok->is(tok::r_brace)) {

.NewlinesBefore = 1;

.Spaces = EndSpaces;

(

.Tok->StartsColumn) {

HasSplit =

;

(Changes[i].NewlinesBefore > 0) {

((j - 1) > Start && Changes[j].Tok->is(tok::comma) &&

Changes[j - 1].NewlinesBefore > 0) {

LineLimit = Changes[j].Spaces + Changes[j].TokenLength;

(LineLimit < Style.ColumnLimit) {

Changes[i].NewlinesBefore = 0;

Changes[i].Spaces = 1;

(Changes[i].NewlinesBefore > 0 && Changes[i].Tok ==

.Tok) {

Changes[i].Spaces = InitialSpaces;

(Changes[i].Tok !=

.Tok)

Cells.push_back(CellDescription{i, Cell, i, HasSplit,

});

linkCells({Cells, CellCounts, InitialSpaces});

WhitespaceManager::calculateCellWidth(

Start,

End,

WithSpaces)

{

CellWidth = 0;

(

i = Start; i < End; i++) {

(Changes[i].NewlinesBefore > 0)

CellWidth += Changes[i].TokenLength;

CellWidth += (WithSpaces ? Changes[i].Spaces : 0);

WhitespaceManager::alignToStartOfCell(

Start,

End) {

((End - Start) <= 1)

(

i = Start + 1; i < End; i++)

(Changes[i].NewlinesBefore > 0)

Changes[i].Spaces = Changes[Start].Spaces;

WhitespaceManager::CellDescriptions

WhitespaceManager::linkCells(CellDescriptions &&CellDesc) {

&Cells = CellDesc.Cells;

(

*CellIter = Cells.begin(); CellIter != Cells.end(); ++CellIter) {

(!CellIter->NextColumnElement && (CellIter + 1) != Cells.end()) {

(

*NextIter = CellIter + 1; NextIter != Cells.end(); ++NextIter) {

(NextIter->Cell == CellIter->Cell) {

CellIter->NextColumnElement = &(*NextIter);

std::move(CellDesc);

WhitespaceManager::generateChanges() {

(

i = 0, e = Changes.size(); i != e; ++i) {

Change &

= Changes[i];

= Changes[i - 1].OriginalWhitespaceRange;

New = Changes[i].OriginalWhitespaceRange;

(

.getBegin() == New.getBegin() &&

(

.getEnd() !=

.getBegin() ||

New.getEnd() == New.getBegin())) {

(

.CreateReplacement) {

std::string ReplacementText =

.PreviousLinePostfix;

(

.ContinuesPPDirective) {

appendEscapedNewlineText(ReplacementText,

.NewlinesBefore,

.PreviousEndOfTokenColumn,

.EscapedNewlineColumn);

appendNewlineText(ReplacementText,

);

ReplacementText,

.Tok->IndentLevel, std::max(0,

.Spaces),

std::max((

)

.StartOfTokenColumn,

.Spaces) - std::max(0,

.Spaces),

ReplacementText.append(

.CurrentLinePrefix);

storeReplacement(

.OriginalWhitespaceRange, ReplacementText);

WhitespaceManager::storeReplacement(SourceRange

, StringRef

) {

WhitespaceLength) ==

) {

Err = Replaces.

(tooling::Replacement(

llvm::errs() << llvm::toString(std::move(Err)) <<

;

WhitespaceManager::appendNewlineText(std::string &

,

Change &

) {

(

.NewlinesBefore <= 0)

StringRef Newline = UseCRLF ?

:

;

.append(Newline);

(

.Tok->HasFormFeedBefore)

.append(

);

(

I = 1; I <

.NewlinesBefore; ++I)

.append(Newline);

WhitespaceManager::appendEscapedNewlineText(

std::string &

,

Newlines,

PreviousEndOfTokenColumn,

EscapedNewlineColumn) {

std::max<int>(1, EscapedNewlineColumn - PreviousEndOfTokenColumn - 1);

(

i = 0; i < Newlines; ++i) {

.append(Spaces,

);

.append(UseCRLF ?

:

);

Spaces = std::max<int>(0, EscapedNewlineColumn - 1);

WhitespaceManager::appendIndentText(std::string &

,

IndentLevel,

Spaces,

WhitespaceStartColumn,

(Style.UseTab) {

.append(Spaces,

);

(Style.TabWidth) {

FirstTabWidth =

Style.TabWidth - WhitespaceStartColumn % Style.TabWidth;

(Spaces < FirstTabWidth || Spaces == 1) {

.append(Spaces,

);

Spaces -= FirstTabWidth;

.append(

);

.append(Spaces / Style.TabWidth,

);

.append(Spaces % Style.TabWidth,

);

}

(Spaces == 1) {

.append(Spaces,

);

(WhitespaceStartColumn == 0) {

Indentation = IndentLevel * Style.IndentWidth;

Spaces = appendTabIndent(

, Spaces, Indentation);

.append(Spaces,

);

(WhitespaceStartColumn == 0)

Spaces = appendTabIndent(

, Spaces, Spaces);

.append(Spaces,

);

(WhitespaceStartColumn == 0) {

Indentation =

IsAligned ? IndentLevel * Style.IndentWidth : Spaces;

Spaces = appendTabIndent(

, Spaces, Indentation);

.append(Spaces,

);

WhitespaceManager::appendTabIndent(std::string &

,

Spaces,

Indentation) {

(Indentation > Spaces)

Indentation = Spaces;

(Style.TabWidth) {

Tabs = Indentation / Style.TabWidth;

.append(Tabs,

);

Spaces -= Tabs * Style.TabWidth;

WhitespaceManager class manages whitespace around tokens and their replacements.

static CharSourceRange getCharRange(SourceRange R)

Encodes a location in the source.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

unsigned getFileOffset(SourceLocation SpellingLoc) const

Returns the offset from the start of the file that the specified SourceLocation represents.

const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const

Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.

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

bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const

Determines the order of 2 source locations in the translation unit.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

Functor to sort changes in original source order.

bool operator()(const Change &C1, const Change &C2) const

void replaceWhitespaceInToken(const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars, StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective, unsigned Newlines, int Spaces)

Inserts or replaces whitespace in the middle of a token.

void addUntouchableToken(const FormatToken &Tok, bool InPPDirective)

Adds information about an unchangeable token's whitespace.

static bool inputUsesCRLF(StringRef Text, bool DefaultToCRLF)

Infers whether the input is using CRLF.

llvm::Error addReplacement(const tooling::Replacement &Replacement)

const tooling::Replacements & generateReplacements()

Returns all the Replacements created during formatting.

void replaceWhitespace(FormatToken &Tok, unsigned Newlines, unsigned Spaces, unsigned StartOfTokenColumn, bool IsAligned=false, bool InPPDirective=false)

Replaces the whitespace in front of Tok.

@ MR_ExpandedArg

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

static void AlignMatchingTokenSequence(unsigned &StartOfSequence, unsigned &EndOfSequence, unsigned &MinColumn, std::function< bool(const WhitespaceManager::Change &C)> Matches, SmallVector< WhitespaceManager::Change, 16 > &Changes)

static unsigned AlignTokens(const FormatStyle &Style, F &&Matches, SmallVector< WhitespaceManager::Change, 16 > &Changes, unsigned StartAt, const FormatStyle::AlignConsecutiveStyle &ACS={}, bool RightJustify=false)

static void AlignTokenSequence(const FormatStyle &Style, unsigned Start, unsigned End, unsigned Column, bool RightJustify, F &&Matches, SmallVector< WhitespaceManager::Change, 16 > &Changes)

TokenType

Determines the semantic type of a syntactic token, e.g.

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

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

for(const auto &A :T->param_types())

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

@ UT_AlignWithSpaces

Use tabs for line continuation and indentation, and spaces for alignment.

@ UT_ForContinuationAndIndentation

Fill all leading whitespace with tabs, and use spaces for alignment that appears within a line (e....

@ UT_ForIndentation

Use tabs only for indentation.

@ UT_Always

Use tabs whenever we need to fill whitespace that spans at least from one tab stop to the next one.

@ UT_Never

Never use tab.

@ TCAS_Never

Don't align trailing comments but other formatter applies.

@ TCAS_Leave

Leave trailing comments as they are.

@ TCAS_Always

Align trailing comments.

@ AIAS_Left

Align array column and left justify the columns e.g.:

@ AIAS_Right

Align array column and right justify the columns e.g.:

@ AIAS_None

Don't align array initializer columns.

@ ENAS_DontAlign

Don't align escaped newlines.

@ ENAS_Left

Align escaped newlines as far left as possible.

@ ENAS_LeftWithLastLine

Align escaped newlines as far left as possible, using the last line of the preprocessor directive as ...

@ PAS_Right

Align pointer to the right.

@ RAS_Right

Align reference to the right.

@ RAS_Pointer

Align reference like PointerAlignment.

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.

SourceLocation getStartOfNonWhitespace() const

Returns actual token start location without leading escaped newlines and whitespace.

void setDecision(FormatDecision D)

unsigned Finalized

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

std::optional< MacroExpansion > MacroCtx

unsigned NewlinesBefore

The number of newlines immediately before the Token.

unsigned IsFirst

Indicates that this is the first token of the file.

SourceRange WhitespaceRange

The range of the whitespace immediately preceding the Token.

Represents a change before a token, a break inside a token, or the layout of an unchanged token (or w...

Change(const FormatToken &Tok, bool CreateReplacement, SourceRange OriginalWhitespaceRange, int Spaces, unsigned StartOfTokenColumn, unsigned NewlinesBefore, StringRef PreviousLinePostfix, StringRef CurrentLinePrefix, bool IsAligned, bool ContinuesPPDirective, bool IsInsideToken)

Creates a Change.

const Change * StartOfBlockComment

SourceRange OriginalWhitespaceRange

std::string PreviousLinePostfix

std::string CurrentLinePrefix

unsigned StartOfTokenColumn

unsigned PreviousEndOfTokenColumn

unsigned EscapedNewlineColumn

bool ContinuesPPDirective

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