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

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

clang: lib/Format/FormatToken.cpp Source File

*

[] = {

llvm_unreachable(

);

,

,

,

,

,

,

,

,

,

,

,

,

,

,

IsCpp = LangOpts.CXXOperatorNames;

IsCpp &&

(tok::identifier) &&

assert(

(tok::r_brace));

(!Style.Cpp11BracedListStyle ||

assert(LBrace && LBrace->is(tok::l_brace));

(LBrace->Previous && LBrace->Previous->is(tok::equal))

(TT_ArrayInitializerLSquare) ||

(TT_ProtoExtensionLSquare) ||

(

(tok::l_brace) &&

(

(tok::less) && Style.isProto());

(!State.NextToken || !State.NextToken->Previous)

(Formats.size() <= 1)

State.NextToken->Previous->getPreviousNonComment();

(!LBrace || !LBrace->

(tok::l_brace, TT_ArrayInitializerLSquare) ||

LBrace->

(

) || LBrace->

(TT_DictLiteral) ||

LBrace->

->

(TT_DesignatedInitializerPeriod)) {

RemainingCodePoints =

.

- State.Column + State.NextToken->Previous->ColumnWidth;

ColumnFormat *Format = getColumnFormat(RemainingCodePoints);

Penalty = 0;

ExtraSpaces = 0;

(Item < Commas.size() && State.NextToken->Previous == Commas[Item]) {

(!State.NextToken->isTrailingComment()) {

ExtraSpaces += Format->ColumnSizes[

] - ItemLengths[Item];

(

== Format->Columns || State.NextToken->MustBreakBefore) {

Penalty +=

->addTokenToState(State,

, DryRun, ExtraSpaces);

(Formats.size() == 1 || HasNestedBracedList)

State.Stack.back().AvoidBinPacking =

;

assert(End->TotalLength >=

->TotalLength);

End->TotalLength -

->TotalLength +

->ColumnWidth;

(!

->MatchingParen ||

!

->

(tok::l_brace, TT_ArrayInitializerLSquare)) {

Commas.size() < 19) {

(

->

(TT_ArrayInitializerLSquare) && Commas.size() < 19)

ItemBegin = ItemBegin->

;

MustBreakBeforeItem.reserve(Commas.size() + 1);

EndOfLineItemLength.reserve(Commas.size() + 1);

ItemLengths.reserve(Commas.size() + 1);

HasSeparatingComment =

;

(

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

ItemBegin = ItemBegin->

;

HasSeparatingComment = i > 0;

(ItemBegin->

(tok::l_brace))

HasNestedBracedList =

;

(i == Commas.size()) {

ItemEnd =

->MatchingParen;

ItemEnd = ItemEnd->

;

ItemEnd =

->MatchingParen->Previous;

ItemEnd = ItemEnd->

;

ItemBegin = ItemEnd->

;

(Commas.size() < 5 || HasSeparatingComment)

(

->NestingLevel != 0 &&

->

(tok::l_brace) && Commas.size() < 19)

MinSizeInColumn.reserve(MaxItems);

(

Columns = 1; Columns <= MaxItems; ++Columns) {

Format.Columns = Columns;

Format.ColumnSizes.resize(Columns);

MinSizeInColumn.assign(Columns,

);

Format.LineCount = 1;

HasRowWithSufficientColumns =

;

(

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

assert(i < MustBreakBeforeItem.size());

(MustBreakBeforeItem[i] ||

== Columns) {

(

== Columns - 1)

HasRowWithSufficientColumns =

;

(

== Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i];

Format.ColumnSizes[

] = std::max(Format.ColumnSizes[

], Length);

MinSizeInColumn[

] = std::min(MinSizeInColumn[

], Length);

(!HasRowWithSufficientColumns)

Format.TotalWidth = Columns - 1;

(

i = 0; i < Columns; ++i)

Format.TotalWidth += Format.ColumnSizes[i];

(

i = 0; i < Columns - 1; ++i)

(Format.ColumnSizes[i] - MinSizeInColumn[i] > 10)

Formats.push_back(Format);

CommaSeparatedList::ColumnFormat *

CommaSeparatedList::getColumnFormat(

RemainingCharacters)

{

ColumnFormat *BestFormat =

;

(

ColumnFormat &Format : llvm::reverse(Formats)) {

(Format.TotalWidth <= RemainingCharacters || Format.Columns == 1) {

(BestFormat && Format.LineCount > BestFormat->LineCount)

BestFormat = &Format;

(Current.

(TT_CtorInitializerComma) &&

((

.isNot(TT_CtorInitializerComma) ||

(

.isNot(TT_InheritanceComma) ||

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

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

static constexpr bool isOneOf()

static const char *const TokNames[]

ContinuationIndenter * Indenter

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

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)) {....

bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const

bool isSimpleTypeSpecifier(const LangOptions &LangOpts) const

Determine whether the token kind starts a simple-type-specifier.

The base class of the type hierarchy.

unsigned formatFromToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) override

Apply the special formatting that the given role demands.

unsigned formatAfterToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) override

Same as formatFromToken, but assumes that the first token has already been set thereby deciding on th...

void precomputeFormattingInfos(const FormatToken *Token) override

After the TokenAnnotator has finished annotating all the tokens, this function precomputes required i...

virtual void precomputeFormattingInfos(const FormatToken *Token)

After the TokenAnnotator has finished annotating all the tokens, this function precomputes required i...

const FormatStyle & Style

const char * getTokenTypeName(TokenType Type)

Determines the name of a token type.

static SmallVector< StringRef > CppNonKeywordTypes

static unsigned CodePointsBetween(const FormatToken *Begin, const FormatToken *End)

TokenType

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

bool startsNextParameter(const FormatToken &Current, const FormatStyle &Style)

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

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

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

@ LK_Proto

Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).

bool Cpp11BracedListStyle

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

BreakInheritanceListStyle BreakInheritanceList

The inheritance list style to use.

@ BCIS_BeforeComma

Break constructor initializers before the colon and commas, and align the commas with the colon.

LanguageKind Language

Language, this format style is targeted at.

@ BAS_DontAlign

Don't align, instead use ContinuationIndentWidth, e.g.:

@ BAS_BlockIndent

Always break after an open bracket, if the parameters don't fit on a single line.

BreakConstructorInitializersStyle BreakConstructorInitializers

The break constructor initializers style to use.

@ BILS_BeforeComma

Break inheritance list before the colon and commas, and align the commas with the colon.

bool BinPackArguments

If false, a function call's arguments will either be all on the same line or will have one line each.

BracketAlignmentStyle AlignAfterOpenBracket

If true, horizontally aligns arguments after an open bracket.

unsigned ColumnLimit

The column limit.

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

unsigned NestingLevel

The nesting level of this token, i.e.

bool isTypeName(const LangOptions &LangOpts) const

unsigned CanBreakBefore

true if it is allowed to break before this token.

StringRef TokenText

The raw text of the token.

bool opensScope() const

Returns whether Tok is ([{ or an opening < of a template or in protos.

FormatToken * getNextNonComment() const

Returns the next token ignoring comments.

FormatToken * getPreviousNonComment() const

Returns the previous token ignoring comments.

BraceBlockKind getBlockKind() const

FormatToken * Next

The next token in the unwrapped line.

unsigned MustBreakBefore

Whether there must be a line break before this token.

unsigned HasUnescapedNewline

Whether there is at least one unescaped newline before the Token.

bool isBlockIndentedInitRBrace(const FormatStyle &Style) const

Returns true if this token ends a block indented initializer list.

bool is(tok::TokenKind Kind) const

bool opensBlockOrBlockTypeList(const FormatStyle &Style) const

Returns true if this tokens starts a block-type list, i.e.

bool isOneOf(A K1, B K2) const

bool isTrailingComment() const

bool isTypeOrIdentifier(const LangOptions &LangOpts) const

FormatToken * MatchingParen

If this is a bracket, this points to the matching one.

FormatToken * Previous

The previous token in the unwrapped line.

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