head 1.1; branch 1.1.1; access; symbols perseant-exfatfs-base-20261102:1.1.1.10 netbsd-11-1-RELEASE:1.1.1.10 netbsd-10-2-RELEASE:1.1.1.10 netbsd-9-5-RELEASE:1.1.1.9 netbsd-11-0-RELEASE:1.1.1.10 netbsd-11-0-RC7:1.1.1.10 netbsd-11-0-RC6:1.1.1.10 netbsd-11-0-RC5:1.1.1.10 netbsd-11-0-RC4:1.1.1.10 netbsd-11-0-RC3:1.1.1.10 netbsd-11-0-RC2:1.1.1.10 netbsd-11-0-RC1:1.1.1.10 perseant-exfatfs-base-20250801:1.1.1.10 netbsd-11:1.1.1.10.0.10 netbsd-11-base:1.1.1.10 netbsd-10-1-RELEASE:1.1.1.10 perseant-exfatfs-base-20240630:1.1.1.10 perseant-exfatfs:1.1.1.10.0.8 perseant-exfatfs-base:1.1.1.10 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.9 netbsd-10-0-RELEASE:1.1.1.10 netbsd-10-0-RC6:1.1.1.10 netbsd-10-0-RC5:1.1.1.10 netbsd-10-0-RC4:1.1.1.10 netbsd-10-0-RC3:1.1.1.10 netbsd-10-0-RC2:1.1.1.10 netbsd-10-0-RC1:1.1.1.10 netbsd-10:1.1.1.10.0.6 netbsd-10-base:1.1.1.10 netbsd-9-3-RELEASE:1.1.1.9 cjep_sun2x:1.1.1.10.0.4 cjep_sun2x-base:1.1.1.10 cjep_staticlib_x-base1:1.1.1.10 netbsd-9-2-RELEASE:1.1.1.9 cjep_staticlib_x:1.1.1.10.0.2 cjep_staticlib_x-base:1.1.1.10 netbsd-9-1-RELEASE:1.1.1.9 phil-wifi-20200421:1.1.1.10 phil-wifi-20200411:1.1.1.10 phil-wifi-20200406:1.1.1.10 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.9 netbsd-9-0-RC2:1.1.1.9 netbsd-9-0-RC1:1.1.1.9 netbsd-9:1.1.1.9.0.2 netbsd-9-base:1.1.1.9 phil-wifi-20190609:1.1.1.9 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.8.12.1 pgoyette-compat-20190127:1.1.1.9 pgoyette-compat-20190118:1.1.1.9 pgoyette-compat-1226:1.1.1.9 pgoyette-compat-1126:1.1.1.9 pgoyette-compat-1020:1.1.1.9 pgoyette-compat-0930:1.1.1.9 pgoyette-compat-0906:1.1.1.9 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.9 clang-337282:1.1.1.9 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.8.0.14 phil-wifi-base:1.1.1.8 pgoyette-compat-0625:1.1.1.8 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.8 pgoyette-compat-0502:1.1.1.8 pgoyette-compat-0422:1.1.1.8 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.8 pgoyette-compat-0407:1.1.1.8 pgoyette-compat-0330:1.1.1.8 pgoyette-compat-0322:1.1.1.8 pgoyette-compat-0315:1.1.1.8 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.8.0.12 pgoyette-compat-base:1.1.1.8 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.8 matt-nb8-mediatek:1.1.1.8.0.10 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.8 perseant-stdc-iso10646:1.1.1.8.0.8 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.6 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.4 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.5 yamt-pagecache:1.1.1.4.0.4 yamt-pagecache-base9:1.1.1.4 tls-earlyentropy:1.1.1.4.0.2 tls-earlyentropy-base:1.1.1.5 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.4 riastradh-drm2-base3:1.1.1.4 clang-202566:1.1.1.4 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.39.24; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.24; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.24; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.05.30.18.14.41; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 8q0kdlBlCn09GACx; 1.1.1.6 date 2015.01.29.19.57.30; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.12.04; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.33.38; author joerg; state Exp; branches 1.1.1.8.12.1 1.1.1.8.14.1; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2018.07.17.18.30.57; author joerg; state Exp; branches; next 1.1.1.10; commitid wDzL46ALjrCZgwKA; 1.1.1.10 date 2019.11.13.22.19.23; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.4.2.1 date 2014.08.10.07.08.08; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.4.4.1 date 2014.02.14.20.07.24; author yamt; state dead; branches; next 1.1.1.4.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.4.2 date 2014.05.22.16.18.27; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.28; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.05.30.18.14.41; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.28; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.38; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.8.12.1 date 2018.07.28.04.33.19; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.8.14.1 date 2019.06.10.21.45.23; author christos; state Exp; branches; next 1.1.1.8.14.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.8.14.2 date 2020.04.13.07.46.33; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- FormatToken.cpp - Format C++ code --------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief This file implements specific functions of \c FormatTokens and their /// roles. /// //===----------------------------------------------------------------------===// #include "FormatToken.h" #include "ContinuationIndenter.h" #include "clang/Format/Format.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Debug.h" namespace clang { namespace format { TokenRole::~TokenRole() {} void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {} unsigned CommaSeparatedList::format(LineState &State, ContinuationIndenter *Indenter, bool DryRun) { if (!State.NextToken->Previous || !State.NextToken->Previous->Previous || Commas.size() <= 2) return 0; // Ensure that we start on the opening brace. const FormatToken *LBrace = State.NextToken->Previous->Previous; if (LBrace->isNot(tok::l_brace) || LBrace->BlockKind == BK_Block || LBrace->Type == TT_DictLiteral || LBrace->Next->Type == TT_DesignatedInitializerPeriod) return 0; // Calculate the number of code points we have to format this list. As the // first token is already placed, we have to subtract it. unsigned RemainingCodePoints = Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth; // Find the best ColumnFormat, i.e. the best number of columns to use. const ColumnFormat *Format = getColumnFormat(RemainingCodePoints); if (!Format) return 0; // Format the entire list. unsigned Penalty = 0; unsigned Column = 0; unsigned Item = 0; while (State.NextToken != LBrace->MatchingParen) { bool NewLine = false; unsigned ExtraSpaces = 0; // If the previous token was one of our commas, we are now on the next item. if (Item < Commas.size() && State.NextToken->Previous == Commas[Item]) { if (!State.NextToken->isTrailingComment()) { ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item]; ++Column; } ++Item; } if (Column == Format->Columns || State.NextToken->MustBreakBefore) { Column = 0; NewLine = true; } // Place token using the continuation indenter and store the penalty. Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces); } return Penalty; } // Returns the lengths in code points between Begin and End (both included), // assuming that the entire sequence is put on a single line. static unsigned CodePointsBetween(const FormatToken *Begin, const FormatToken *End) { assert(End->TotalLength >= Begin->TotalLength); return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth; } void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) { // FIXME: At some point we might want to do this for other lists, too. if (!Token->MatchingParen || Token->isNot(tok::l_brace)) return; FormatToken *ItemBegin = Token->Next; SmallVector MustBreakBeforeItem; // The lengths of an item if it is put at the end of the line. This includes // trailing comments which are otherwise ignored for column alignment. SmallVector EndOfLineItemLength; bool HasNestedBracedList = false; for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) { // Skip comments on their own line. while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment()) ItemBegin = ItemBegin->Next; MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore); if (ItemBegin->is(tok::l_brace)) HasNestedBracedList = true; const FormatToken *ItemEnd = NULL; if (i == Commas.size()) { ItemEnd = Token->MatchingParen; const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment(); ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd)); if (Style.Cpp11BracedListStyle) { // In Cpp11 braced list style, the } and possibly other subsequent // tokens will need to stay on a line with the last element. while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore) ItemEnd = ItemEnd->Next; } else { // In other braced lists styles, the "}" can be wrapped to the new line. ItemEnd = Token->MatchingParen->Previous; } } else { ItemEnd = Commas[i]; // The comma is counted as part of the item when calculating the length. ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd)); // Consume trailing comments so the are included in EndOfLineItemLength. if (ItemEnd->Next && !ItemEnd->Next->HasUnescapedNewline && ItemEnd->Next->isTrailingComment()) ItemEnd = ItemEnd->Next; } EndOfLineItemLength.push_back(CodePointsBetween(ItemBegin, ItemEnd)); // If there is a trailing comma in the list, the next item will start at the // closing brace. Don't create an extra item for this. if (ItemEnd->getNextNonComment() == Token->MatchingParen) break; ItemBegin = ItemEnd->Next; } // We can never place more than ColumnLimit / 3 items in a row (because of the // spaces and the comma). for (unsigned Columns = 1; Columns <= Style.ColumnLimit / 3; ++Columns) { ColumnFormat Format; Format.Columns = Columns; Format.ColumnSizes.resize(Columns); Format.LineCount = 1; bool HasRowWithSufficientColumns = false; unsigned Column = 0; for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) { assert(i < MustBreakBeforeItem.size()); if (MustBreakBeforeItem[i] || Column == Columns) { ++Format.LineCount; Column = 0; } if (Column == Columns - 1) HasRowWithSufficientColumns = true; unsigned length = (Column == Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i]; Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], length); ++Column; } // If all rows are terminated early (e.g. by trailing comments), we don't // need to look further. if (!HasRowWithSufficientColumns) break; Format.TotalWidth = Columns - 1; // Width of the N-1 spaces. for (unsigned i = 0; i < Columns; ++i) { Format.TotalWidth += Format.ColumnSizes[i]; } // Ignore layouts that are bound to violate the column limit. if (Format.TotalWidth > Style.ColumnLimit) continue; // If this braced list has nested braced list, we format it either with one // element per line or with all elements on one line. if (HasNestedBracedList && Columns > 1 && Format.LineCount > 1) continue; Formats.push_back(Format); } } const CommaSeparatedList::ColumnFormat * CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const { const ColumnFormat *BestFormat = NULL; for (SmallVector::const_reverse_iterator I = Formats.rbegin(), E = Formats.rend(); I != E; ++I) { if (I->TotalWidth <= RemainingCharacters) { if (BestFormat && I->LineCount > BestFormat->LineCount) break; BestFormat = &*I; } } return BestFormat; } } // namespace format } // namespace clang @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @a50 3 // If no ColumnFormat can be used, the braced list would generally be // bin-packed. Add a severe penalty to this so that column layouts are // preferred if possible. d52 1 a52 1 return 10000; d92 1 a92 2 if (!Token->MatchingParen || Token->isNot(tok::l_brace) || Token->NestingLevel != 0) @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @d29 5 a33 4 unsigned CommaSeparatedList::formatAfterToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) { if (!State.NextToken->Previous || !State.NextToken->Previous->Previous) a84 8 unsigned CommaSeparatedList::formatFromToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) { if (HasNestedBracedList) State.Stack.back().AvoidBinPacking = true; return 0; } d95 2 a96 1 if (!Token->MatchingParen || Token->isNot(tok::l_brace)) d106 1 a145 7 // If this doesn't have a nested list, we require at least 6 elements in order // create a column layout. If it has a nested list, column layout ensures one // list element per line. if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0) return; d182 5 @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @a24 30 // FIXME: This is copy&pasted from Sema. Put it in a common place and remove // duplication. bool FormatToken::isSimpleTypeSpecifier() const { switch (Tok.getKind()) { case tok::kw_short: case tok::kw_long: case tok::kw___int64: case tok::kw___int128: case tok::kw_signed: case tok::kw_unsigned: case tok::kw_void: case tok::kw_char: case tok::kw_int: case tok::kw_half: case tok::kw_float: case tok::kw_double: case tok::kw_wchar_t: case tok::kw_bool: case tok::kw___underlying_type: case tok::annot_typename: case tok::kw_char16_t: case tok::kw_char32_t: case tok::kw_typeof: case tok::kw_decltype: return true; default: return false; } } @ 1.1.1.4.2.1 log @Rebase. @ text @d67 2 a68 1 if (LBrace->isNot(tok::l_brace) || LBrace->BlockKind == BK_Block || d75 2 a76 2 unsigned RemainingCodePoints = Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth; a134 5 // In C++11 braced list style, we should not format in columns unless we allow // bin-packing of function parameters. if (Style.Cpp11BracedListStyle && !Style.BinPackParameters) return; d150 1 a150 1 const FormatToken *ItemEnd = nullptr; d184 2 a185 1 if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0) d207 2 a208 1 Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], length); d230 1 a230 1 const ColumnFormat *BestFormat = nullptr; @ 1.1.1.5 log @Import Clang 3.5svn r209886. @ text @d67 2 a68 1 if (LBrace->isNot(tok::l_brace) || LBrace->BlockKind == BK_Block || d75 2 a76 2 unsigned RemainingCodePoints = Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth; a134 5 // In C++11 braced list style, we should not format in columns unless we allow // bin-packing of function parameters. if (Style.Cpp11BracedListStyle && !Style.BinPackParameters) return; d150 1 a150 1 const FormatToken *ItemEnd = nullptr; d184 2 a185 1 if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0) d207 2 a208 1 Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], length); d230 1 a230 1 const ColumnFormat *BestFormat = nullptr; @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d134 3 a136 9 // In C++11 braced list style, we should not format in columns unless they // have many items (20 or more) or we allow bin-packing of function // parameters. if (Style.Cpp11BracedListStyle && !Style.BinPackParameters && Commas.size() < 19) return; // Column format doesn't really make sense if we don't align after brackets. if (!Style.AlignAfterOpenBracket) a145 3 unsigned MinItemLength = Style.ColumnLimit; unsigned MaxItemLength = 0; a171 3 MinItemLength = std::min(MinItemLength, ItemLengths.back()); MaxItemLength = std::max(MaxItemLength, ItemLengths.back()); d187 2 a188 4 // list element per line. If the difference between the shortest and longest // element is too large, column layout would create too much whitespace. if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0 || MaxItemLength - MinItemLength > 10) @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @d134 3 a136 9 // In C++11 braced list style, we should not format in columns unless they // have many items (20 or more) or we allow bin-packing of function // parameters. if (Style.Cpp11BracedListStyle && !Style.BinPackParameters && Commas.size() < 19) return; // Column format doesn't really make sense if we don't align after brackets. if (!Style.AlignAfterOpenBracket) a145 3 unsigned MinItemLength = Style.ColumnLimit; unsigned MaxItemLength = 0; a171 3 MinItemLength = std::min(MinItemLength, ItemLengths.back()); MaxItemLength = std::max(MaxItemLength, ItemLengths.back()); d187 2 a188 4 // list element per line. If the difference between the shortest and longest // element is too large, column layout would create too much whitespace. if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0 || MaxItemLength - MinItemLength > 10) @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d16 1 a17 1 #include "FormatToken.h" a20 1 #include a24 14 const char *getTokenTypeName(TokenType Type) { static const char *const TokNames[] = { #define TYPE(X) #X, LIST_TOKEN_TYPES #undef TYPE nullptr }; if (Type < NUM_TOKEN_TYPES) return TokNames[Type]; llvm_unreachable("unknown TokenType"); return nullptr; } d62 1 a62 1 if (State.NextToken == nullptr || !State.NextToken->Previous) d66 3 a68 4 const FormatToken *LBrace = State.NextToken->Previous->getPreviousNonComment(); if (!LBrace || !LBrace->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) || LBrace->BlockKind == BK_Block || LBrace->Type == TT_DictLiteral || d131 1 a131 2 if (!Token->MatchingParen || !Token->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare)) d135 3 a137 3 // have many items (20 or more) or we allow bin-packing of function call // arguments. if (Style.Cpp11BracedListStyle && !Style.BinPackArguments && a140 6 // Limit column layout for JavaScript array initializers to 20 or more items // for now to introduce it carefully. We can become more aggressive if this // necessary. if (Token->is(TT_ArrayInitializerLSquare) && Commas.size() < 19) return; d142 1 a142 1 if (Style.AlignAfterOpenBracket == FormatStyle::BAS_DontAlign) a145 2 while (ItemBegin->isTrailingComment()) ItemBegin = ItemBegin->Next; d152 3 a154 1 bool HasSeparatingComment = false; d157 1 a157 1 while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment()) { a158 2 HasSeparatingComment = i > 0; } d168 1 a168 2 if (Style.Cpp11BracedListStyle && !ItemEnd->Previous->isTrailingComment()) { d181 2 d197 6 a202 6 // Don't use column layout for lists with few elements and in presence of // separating comments. if (Commas.size() < 5 || HasSeparatingComment) return; if (Token->NestingLevel != 0 && Token->is(tok::l_brace) && Commas.size() < 19) d207 1 a207 4 unsigned MaxItems = Style.ColumnLimit / 3; std::vector MinSizeInColumn; MinSizeInColumn.reserve(MaxItems); for (unsigned Columns = 1; Columns <= MaxItems; ++Columns) { a210 1 MinSizeInColumn.assign(Columns, UINT_MAX); d222 1 a222 1 unsigned Length = d224 1 a224 2 Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], Length); MinSizeInColumn[Column] = std::min(MinSizeInColumn[Column], Length); d232 1 a232 2 for (unsigned i = 0; i < Columns; ++i) d234 1 a234 10 // Don't use this Format, if the difference between the longest and shortest // element in a column exceeds a threshold to avoid excessive spaces. if ([&] { for (unsigned i = 0; i < Columns - 1; ++i) if (Format.ColumnSizes[i] - MinSizeInColumn[i] > 10) return true; return false; }()) continue; @ 1.1.1.7.2.1 log @Sync with HEAD @ text @d16 1 d18 1 a18 1 #include "ContinuationIndenter.h" a55 1 case tok::kw___float128: a79 3 if (Formats.size() == 1) return 0; // Handled by formatFromToken a94 1 d132 1 a132 3 // Formatting with 1 Column isn't really a column layout, so we don't need the // special logic here. We can just avoid bin packing any of the parameters. if (Formats.size() == 1 || HasNestedBracedList) d276 1 a276 1 if (Format.TotalWidth > Style.ColumnLimit && Columns > 1) d290 1 a290 1 if (I->TotalWidth <= RemainingCharacters || I->Columns == 1) { @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @d16 1 d18 1 a18 1 #include "ContinuationIndenter.h" a55 1 case tok::kw___float128: a79 3 if (Formats.size() == 1) return 0; // Handled by formatFromToken a94 1 d132 1 a132 3 // Formatting with 1 Column isn't really a column layout, so we don't need the // special logic here. We can just avoid bin packing any of the parameters. if (Formats.size() == 1 || HasNestedBracedList) d276 1 a276 1 if (Format.TotalWidth > Style.ColumnLimit && Columns > 1) d290 1 a290 1 if (I->TotalWidth <= RemainingCharacters || I->Columns == 1) { @ 1.1.1.8.14.1 log @Sync with HEAD @ text @d11 1 a11 1 /// This file implements specific functions of \c FormatTokens and their d28 1 a28 1 LIST_TOKEN_TYPES d30 2 a31 1 nullptr}; a54 1 case tok::kw__Float16: a59 1 case tok::kw_char8_t: @ 1.1.1.8.14.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.8.12.1 log @Sync with HEAD @ text @d11 1 a11 1 /// This file implements specific functions of \c FormatTokens and their d28 1 a28 1 LIST_TOKEN_TYPES d30 2 a31 1 nullptr}; a54 1 case tok::kw__Float16: a59 1 case tok::kw_char8_t: @ 1.1.1.9 log @Import clang r337282 from trunk @ text @d11 1 a11 1 /// This file implements specific functions of \c FormatTokens and their d28 1 a28 1 LIST_TOKEN_TYPES d30 2 a31 1 nullptr}; a54 1 case tok::kw__Float16: a59 1 case tok::kw_char8_t: @ 1.1.1.10 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file FormatToken.cpp was added on branch tls-maxphys on 2014-08-19 23:47:28 +0000 @ text @d1 247 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 247 //===--- FormatToken.cpp - Format C++ code --------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief This file implements specific functions of \c FormatTokens and their /// roles. /// //===----------------------------------------------------------------------===// #include "FormatToken.h" #include "ContinuationIndenter.h" #include "clang/Format/Format.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Debug.h" namespace clang { namespace format { // FIXME: This is copy&pasted from Sema. Put it in a common place and remove // duplication. bool FormatToken::isSimpleTypeSpecifier() const { switch (Tok.getKind()) { case tok::kw_short: case tok::kw_long: case tok::kw___int64: case tok::kw___int128: case tok::kw_signed: case tok::kw_unsigned: case tok::kw_void: case tok::kw_char: case tok::kw_int: case tok::kw_half: case tok::kw_float: case tok::kw_double: case tok::kw_wchar_t: case tok::kw_bool: case tok::kw___underlying_type: case tok::annot_typename: case tok::kw_char16_t: case tok::kw_char32_t: case tok::kw_typeof: case tok::kw_decltype: return true; default: return false; } } TokenRole::~TokenRole() {} void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {} unsigned CommaSeparatedList::formatAfterToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) { if (!State.NextToken->Previous || !State.NextToken->Previous->Previous) return 0; // Ensure that we start on the opening brace. const FormatToken *LBrace = State.NextToken->Previous->Previous; if (LBrace->isNot(tok::l_brace) || LBrace->BlockKind == BK_Block || LBrace->Type == TT_DictLiteral || LBrace->Next->Type == TT_DesignatedInitializerPeriod) return 0; // Calculate the number of code points we have to format this list. As the // first token is already placed, we have to subtract it. unsigned RemainingCodePoints = Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth; // Find the best ColumnFormat, i.e. the best number of columns to use. const ColumnFormat *Format = getColumnFormat(RemainingCodePoints); // If no ColumnFormat can be used, the braced list would generally be // bin-packed. Add a severe penalty to this so that column layouts are // preferred if possible. if (!Format) return 10000; // Format the entire list. unsigned Penalty = 0; unsigned Column = 0; unsigned Item = 0; while (State.NextToken != LBrace->MatchingParen) { bool NewLine = false; unsigned ExtraSpaces = 0; // If the previous token was one of our commas, we are now on the next item. if (Item < Commas.size() && State.NextToken->Previous == Commas[Item]) { if (!State.NextToken->isTrailingComment()) { ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item]; ++Column; } ++Item; } if (Column == Format->Columns || State.NextToken->MustBreakBefore) { Column = 0; NewLine = true; } // Place token using the continuation indenter and store the penalty. Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces); } return Penalty; } unsigned CommaSeparatedList::formatFromToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) { if (HasNestedBracedList) State.Stack.back().AvoidBinPacking = true; return 0; } // Returns the lengths in code points between Begin and End (both included), // assuming that the entire sequence is put on a single line. static unsigned CodePointsBetween(const FormatToken *Begin, const FormatToken *End) { assert(End->TotalLength >= Begin->TotalLength); return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth; } void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) { // FIXME: At some point we might want to do this for other lists, too. if (!Token->MatchingParen || Token->isNot(tok::l_brace)) return; // In C++11 braced list style, we should not format in columns unless we allow // bin-packing of function parameters. if (Style.Cpp11BracedListStyle && !Style.BinPackParameters) return; FormatToken *ItemBegin = Token->Next; SmallVector MustBreakBeforeItem; // The lengths of an item if it is put at the end of the line. This includes // trailing comments which are otherwise ignored for column alignment. SmallVector EndOfLineItemLength; for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) { // Skip comments on their own line. while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment()) ItemBegin = ItemBegin->Next; MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore); if (ItemBegin->is(tok::l_brace)) HasNestedBracedList = true; const FormatToken *ItemEnd = nullptr; if (i == Commas.size()) { ItemEnd = Token->MatchingParen; const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment(); ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd)); if (Style.Cpp11BracedListStyle) { // In Cpp11 braced list style, the } and possibly other subsequent // tokens will need to stay on a line with the last element. while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore) ItemEnd = ItemEnd->Next; } else { // In other braced lists styles, the "}" can be wrapped to the new line. ItemEnd = Token->MatchingParen->Previous; } } else { ItemEnd = Commas[i]; // The comma is counted as part of the item when calculating the length. ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd)); // Consume trailing comments so the are included in EndOfLineItemLength. if (ItemEnd->Next && !ItemEnd->Next->HasUnescapedNewline && ItemEnd->Next->isTrailingComment()) ItemEnd = ItemEnd->Next; } EndOfLineItemLength.push_back(CodePointsBetween(ItemBegin, ItemEnd)); // If there is a trailing comma in the list, the next item will start at the // closing brace. Don't create an extra item for this. if (ItemEnd->getNextNonComment() == Token->MatchingParen) break; ItemBegin = ItemEnd->Next; } // If this doesn't have a nested list, we require at least 6 elements in order // create a column layout. If it has a nested list, column layout ensures one // list element per line. if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0) return; // We can never place more than ColumnLimit / 3 items in a row (because of the // spaces and the comma). for (unsigned Columns = 1; Columns <= Style.ColumnLimit / 3; ++Columns) { ColumnFormat Format; Format.Columns = Columns; Format.ColumnSizes.resize(Columns); Format.LineCount = 1; bool HasRowWithSufficientColumns = false; unsigned Column = 0; for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) { assert(i < MustBreakBeforeItem.size()); if (MustBreakBeforeItem[i] || Column == Columns) { ++Format.LineCount; Column = 0; } if (Column == Columns - 1) HasRowWithSufficientColumns = true; unsigned length = (Column == Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i]; Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], length); ++Column; } // If all rows are terminated early (e.g. by trailing comments), we don't // need to look further. if (!HasRowWithSufficientColumns) break; Format.TotalWidth = Columns - 1; // Width of the N-1 spaces. for (unsigned i = 0; i < Columns; ++i) { Format.TotalWidth += Format.ColumnSizes[i]; } // Ignore layouts that are bound to violate the column limit. if (Format.TotalWidth > Style.ColumnLimit) continue; Formats.push_back(Format); } } const CommaSeparatedList::ColumnFormat * CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const { const ColumnFormat *BestFormat = nullptr; for (SmallVector::const_reverse_iterator I = Formats.rbegin(), E = Formats.rend(); I != E; ++I) { if (I->TotalWidth <= RemainingCharacters) { if (BestFormat && I->LineCount > BestFormat->LineCount) break; BestFormat = &*I; } } return BestFormat; } } // namespace format } // namespace clang @ 1.1.1.4.4.1 log @file FormatToken.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:27 +0000 @ text @d1 245 @ 1.1.1.4.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 245 //===--- FormatToken.cpp - Format C++ code --------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief This file implements specific functions of \c FormatTokens and their /// roles. /// //===----------------------------------------------------------------------===// #include "FormatToken.h" #include "ContinuationIndenter.h" #include "clang/Format/Format.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Debug.h" namespace clang { namespace format { // FIXME: This is copy&pasted from Sema. Put it in a common place and remove // duplication. bool FormatToken::isSimpleTypeSpecifier() const { switch (Tok.getKind()) { case tok::kw_short: case tok::kw_long: case tok::kw___int64: case tok::kw___int128: case tok::kw_signed: case tok::kw_unsigned: case tok::kw_void: case tok::kw_char: case tok::kw_int: case tok::kw_half: case tok::kw_float: case tok::kw_double: case tok::kw_wchar_t: case tok::kw_bool: case tok::kw___underlying_type: case tok::annot_typename: case tok::kw_char16_t: case tok::kw_char32_t: case tok::kw_typeof: case tok::kw_decltype: return true; default: return false; } } TokenRole::~TokenRole() {} void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {} unsigned CommaSeparatedList::formatAfterToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) { if (!State.NextToken->Previous || !State.NextToken->Previous->Previous) return 0; // Ensure that we start on the opening brace. const FormatToken *LBrace = State.NextToken->Previous->Previous; if (LBrace->isNot(tok::l_brace) || LBrace->BlockKind == BK_Block || LBrace->Type == TT_DictLiteral || LBrace->Next->Type == TT_DesignatedInitializerPeriod) return 0; // Calculate the number of code points we have to format this list. As the // first token is already placed, we have to subtract it. unsigned RemainingCodePoints = Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth; // Find the best ColumnFormat, i.e. the best number of columns to use. const ColumnFormat *Format = getColumnFormat(RemainingCodePoints); // If no ColumnFormat can be used, the braced list would generally be // bin-packed. Add a severe penalty to this so that column layouts are // preferred if possible. if (!Format) return 10000; // Format the entire list. unsigned Penalty = 0; unsigned Column = 0; unsigned Item = 0; while (State.NextToken != LBrace->MatchingParen) { bool NewLine = false; unsigned ExtraSpaces = 0; // If the previous token was one of our commas, we are now on the next item. if (Item < Commas.size() && State.NextToken->Previous == Commas[Item]) { if (!State.NextToken->isTrailingComment()) { ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item]; ++Column; } ++Item; } if (Column == Format->Columns || State.NextToken->MustBreakBefore) { Column = 0; NewLine = true; } // Place token using the continuation indenter and store the penalty. Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces); } return Penalty; } unsigned CommaSeparatedList::formatFromToken(LineState &State, ContinuationIndenter *Indenter, bool DryRun) { if (HasNestedBracedList) State.Stack.back().AvoidBinPacking = true; return 0; } // Returns the lengths in code points between Begin and End (both included), // assuming that the entire sequence is put on a single line. static unsigned CodePointsBetween(const FormatToken *Begin, const FormatToken *End) { assert(End->TotalLength >= Begin->TotalLength); return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth; } void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) { // FIXME: At some point we might want to do this for other lists, too. if (!Token->MatchingParen || Token->isNot(tok::l_brace)) return; FormatToken *ItemBegin = Token->Next; SmallVector MustBreakBeforeItem; // The lengths of an item if it is put at the end of the line. This includes // trailing comments which are otherwise ignored for column alignment. SmallVector EndOfLineItemLength; for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) { // Skip comments on their own line. while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment()) ItemBegin = ItemBegin->Next; MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore); if (ItemBegin->is(tok::l_brace)) HasNestedBracedList = true; const FormatToken *ItemEnd = NULL; if (i == Commas.size()) { ItemEnd = Token->MatchingParen; const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment(); ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd)); if (Style.Cpp11BracedListStyle) { // In Cpp11 braced list style, the } and possibly other subsequent // tokens will need to stay on a line with the last element. while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore) ItemEnd = ItemEnd->Next; } else { // In other braced lists styles, the "}" can be wrapped to the new line. ItemEnd = Token->MatchingParen->Previous; } } else { ItemEnd = Commas[i]; // The comma is counted as part of the item when calculating the length. ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd)); // Consume trailing comments so the are included in EndOfLineItemLength. if (ItemEnd->Next && !ItemEnd->Next->HasUnescapedNewline && ItemEnd->Next->isTrailingComment()) ItemEnd = ItemEnd->Next; } EndOfLineItemLength.push_back(CodePointsBetween(ItemBegin, ItemEnd)); // If there is a trailing comma in the list, the next item will start at the // closing brace. Don't create an extra item for this. if (ItemEnd->getNextNonComment() == Token->MatchingParen) break; ItemBegin = ItemEnd->Next; } // If this doesn't have a nested list, we require at least 6 elements in order // create a column layout. If it has a nested list, column layout ensures one // list element per line. if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0) return; // We can never place more than ColumnLimit / 3 items in a row (because of the // spaces and the comma). for (unsigned Columns = 1; Columns <= Style.ColumnLimit / 3; ++Columns) { ColumnFormat Format; Format.Columns = Columns; Format.ColumnSizes.resize(Columns); Format.LineCount = 1; bool HasRowWithSufficientColumns = false; unsigned Column = 0; for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) { assert(i < MustBreakBeforeItem.size()); if (MustBreakBeforeItem[i] || Column == Columns) { ++Format.LineCount; Column = 0; } if (Column == Columns - 1) HasRowWithSufficientColumns = true; unsigned length = (Column == Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i]; Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], length); ++Column; } // If all rows are terminated early (e.g. by trailing comments), we don't // need to look further. if (!HasRowWithSufficientColumns) break; Format.TotalWidth = Columns - 1; // Width of the N-1 spaces. for (unsigned i = 0; i < Columns; ++i) { Format.TotalWidth += Format.ColumnSizes[i]; } // Ignore layouts that are bound to violate the column limit. if (Format.TotalWidth > Style.ColumnLimit) continue; Formats.push_back(Format); } } const CommaSeparatedList::ColumnFormat * CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const { const ColumnFormat *BestFormat = NULL; for (SmallVector::const_reverse_iterator I = Formats.rbegin(), E = Formats.rend(); I != E; ++I) { if (I->TotalWidth <= RemainingCharacters) { if (BestFormat && I->LineCount > BestFormat->LineCount) break; BestFormat = &*I; } } return BestFormat; } } // namespace format } // namespace clang @