| //===--- Format.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 functions declared in Format.h. This will be |
| /// split into separate files as we go. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/Format/Format.h" |
| #include "ContinuationIndenter.h" |
| #include "TokenAnnotator.h" |
| #include "UnwrappedLineFormatter.h" |
| #include "UnwrappedLineParser.h" |
| #include "WhitespaceManager.h" |
| #include "clang/Basic/Diagnostic.h" |
| #include "clang/Basic/DiagnosticOptions.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "clang/Lex/Lexer.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/Support/Allocator.h" |
| #include "llvm/Support/Debug.h" |
| #include "llvm/Support/Path.h" |
| #include "llvm/Support/Regex.h" |
| #include "llvm/Support/YAMLTraits.h" |
| #include <queue> |
| #include <string> |
| |
| #define DEBUG_TYPE "format-formatter" |
| |
| using clang::format::FormatStyle; |
| |
| LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string) |
| LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::IncludeCategory) |
| |
| namespace llvm { |
| namespace yaml { |
| template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> { |
| static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) { |
| IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp); |
| IO.enumCase(Value, "Java", FormatStyle::LK_Java); |
| IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript); |
| IO.enumCase(Value, "Proto", FormatStyle::LK_Proto); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> { |
| static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) { |
| IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03); |
| IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03); |
| IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11); |
| IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11); |
| IO.enumCase(Value, "Auto", FormatStyle::LS_Auto); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> { |
| static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) { |
| IO.enumCase(Value, "Never", FormatStyle::UT_Never); |
| IO.enumCase(Value, "false", FormatStyle::UT_Never); |
| IO.enumCase(Value, "Always", FormatStyle::UT_Always); |
| IO.enumCase(Value, "true", FormatStyle::UT_Always); |
| IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> { |
| static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) { |
| IO.enumCase(Value, "None", FormatStyle::SFS_None); |
| IO.enumCase(Value, "false", FormatStyle::SFS_None); |
| IO.enumCase(Value, "All", FormatStyle::SFS_All); |
| IO.enumCase(Value, "true", FormatStyle::SFS_All); |
| IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline); |
| IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> { |
| static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) { |
| IO.enumCase(Value, "All", FormatStyle::BOS_All); |
| IO.enumCase(Value, "true", FormatStyle::BOS_All); |
| IO.enumCase(Value, "None", FormatStyle::BOS_None); |
| IO.enumCase(Value, "false", FormatStyle::BOS_None); |
| IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> { |
| static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) { |
| IO.enumCase(Value, "Attach", FormatStyle::BS_Attach); |
| IO.enumCase(Value, "Linux", FormatStyle::BS_Linux); |
| IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla); |
| IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup); |
| IO.enumCase(Value, "Allman", FormatStyle::BS_Allman); |
| IO.enumCase(Value, "GNU", FormatStyle::BS_GNU); |
| IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit); |
| IO.enumCase(Value, "Custom", FormatStyle::BS_Custom); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> { |
| static void |
| enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) { |
| IO.enumCase(Value, "None", FormatStyle::DRTBS_None); |
| IO.enumCase(Value, "All", FormatStyle::DRTBS_All); |
| IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel); |
| |
| // For backward compatibility. |
| IO.enumCase(Value, "false", FormatStyle::DRTBS_None); |
| IO.enumCase(Value, "true", FormatStyle::DRTBS_All); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> { |
| static void enumeration(IO &IO, |
| FormatStyle::NamespaceIndentationKind &Value) { |
| IO.enumCase(Value, "None", FormatStyle::NI_None); |
| IO.enumCase(Value, "Inner", FormatStyle::NI_Inner); |
| IO.enumCase(Value, "All", FormatStyle::NI_All); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> { |
| static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) { |
| IO.enumCase(Value, "Align", FormatStyle::BAS_Align); |
| IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign); |
| IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak); |
| |
| // For backward compatibility. |
| IO.enumCase(Value, "true", FormatStyle::BAS_Align); |
| IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign); |
| } |
| }; |
| |
| template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> { |
| static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) { |
| IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle); |
| IO.enumCase(Value, "Left", FormatStyle::PAS_Left); |
| IO.enumCase(Value, "Right", FormatStyle::PAS_Right); |
| |
| // For backward compatibility. |
| IO.enumCase(Value, "true", FormatStyle::PAS_Left); |
| IO.enumCase(Value, "false", FormatStyle::PAS_Right); |
| } |
| }; |
| |
| template <> |
| struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> { |
| static void enumeration(IO &IO, |
| FormatStyle::SpaceBeforeParensOptions &Value) { |
| IO.enumCase(Value, "Never", FormatStyle::SBPO_Never); |
| IO.enumCase(Value, "ControlStatements", |
| FormatStyle::SBPO_ControlStatements); |
| IO.enumCase(Value, "Always", FormatStyle::SBPO_Always); |
| |
| // For backward compatibility. |
| IO.enumCase(Value, "false", FormatStyle::SBPO_Never); |
| IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements); |
| } |
| }; |
| |
| template <> struct MappingTraits<FormatStyle> { |
| static void mapping(IO &IO, FormatStyle &Style) { |
| // When reading, read the language first, we need it for getPredefinedStyle. |
| IO.mapOptional("Language", Style.Language); |
| |
| if (IO.outputting()) { |
| StringRef StylesArray[] = {"LLVM", "Google", "Chromium", |
| "Mozilla", "WebKit", "GNU"}; |
| ArrayRef<StringRef> Styles(StylesArray); |
| for (size_t i = 0, e = Styles.size(); i < e; ++i) { |
| StringRef StyleName(Styles[i]); |
| FormatStyle PredefinedStyle; |
| if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) && |
| Style == PredefinedStyle) { |
| IO.mapOptional("# BasedOnStyle", StyleName); |
| break; |
| } |
| } |
| } else { |
| StringRef BasedOnStyle; |
| IO.mapOptional("BasedOnStyle", BasedOnStyle); |
| if (!BasedOnStyle.empty()) { |
| FormatStyle::LanguageKind OldLanguage = Style.Language; |
| FormatStyle::LanguageKind Language = |
| ((FormatStyle *)IO.getContext())->Language; |
| if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) { |
| IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle)); |
| return; |
| } |
| Style.Language = OldLanguage; |
| } |
| } |
| |
| // For backward compatibility. |
| if (!IO.outputting()) { |
| IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment); |
| IO.mapOptional("IndentFunctionDeclarationAfterType", |
| Style.IndentWrappedFunctionNames); |
| IO.mapOptional("PointerBindsToType", Style.PointerAlignment); |
| IO.mapOptional("SpaceAfterControlStatementKeyword", |
| Style.SpaceBeforeParens); |
| } |
| |
| IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset); |
| IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket); |
| IO.mapOptional("AlignConsecutiveAssignments", |
| Style.AlignConsecutiveAssignments); |
| IO.mapOptional("AlignConsecutiveDeclarations", |
| Style.AlignConsecutiveDeclarations); |
| IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft); |
| IO.mapOptional("AlignOperands", Style.AlignOperands); |
| IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments); |
| IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine", |
| Style.AllowAllParametersOfDeclarationOnNextLine); |
| IO.mapOptional("AllowShortBlocksOnASingleLine", |
| Style.AllowShortBlocksOnASingleLine); |
| IO.mapOptional("AllowShortCaseLabelsOnASingleLine", |
| Style.AllowShortCaseLabelsOnASingleLine); |
| IO.mapOptional("AllowShortFunctionsOnASingleLine", |
| Style.AllowShortFunctionsOnASingleLine); |
| IO.mapOptional("AllowShortIfStatementsOnASingleLine", |
| Style.AllowShortIfStatementsOnASingleLine); |
| IO.mapOptional("AllowShortLoopsOnASingleLine", |
| Style.AllowShortLoopsOnASingleLine); |
| IO.mapOptional("AlwaysBreakAfterDefinitionReturnType", |
| Style.AlwaysBreakAfterDefinitionReturnType); |
| IO.mapOptional("AlwaysBreakBeforeMultilineStrings", |
| Style.AlwaysBreakBeforeMultilineStrings); |
| IO.mapOptional("AlwaysBreakTemplateDeclarations", |
| Style.AlwaysBreakTemplateDeclarations); |
| IO.mapOptional("BinPackArguments", Style.BinPackArguments); |
| IO.mapOptional("BinPackParameters", Style.BinPackParameters); |
| IO.mapOptional("BraceWrapping", Style.BraceWrapping); |
| IO.mapOptional("BreakBeforeBinaryOperators", |
| Style.BreakBeforeBinaryOperators); |
| IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces); |
| IO.mapOptional("BreakBeforeTernaryOperators", |
| Style.BreakBeforeTernaryOperators); |
| IO.mapOptional("BreakConstructorInitializersBeforeComma", |
| Style.BreakConstructorInitializersBeforeComma); |
| IO.mapOptional("ColumnLimit", Style.ColumnLimit); |
| IO.mapOptional("CommentPragmas", Style.CommentPragmas); |
| IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine", |
| Style.ConstructorInitializerAllOnOneLineOrOnePerLine); |
| IO.mapOptional("ConstructorInitializerIndentWidth", |
| Style.ConstructorInitializerIndentWidth); |
| IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth); |
| IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle); |
| IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment); |
| IO.mapOptional("DisableFormat", Style.DisableFormat); |
| IO.mapOptional("ExperimentalAutoDetectBinPacking", |
| Style.ExperimentalAutoDetectBinPacking); |
| IO.mapOptional("ForEachMacros", Style.ForEachMacros); |
| IO.mapOptional("IncludeCategories", Style.IncludeCategories); |
| IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels); |
| IO.mapOptional("IndentWidth", Style.IndentWidth); |
| IO.mapOptional("IndentWrappedFunctionNames", |
| Style.IndentWrappedFunctionNames); |
| IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks", |
| Style.KeepEmptyLinesAtTheStartOfBlocks); |
| IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin); |
| IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd); |
| IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep); |
| IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation); |
| IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth); |
| IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty); |
| IO.mapOptional("ObjCSpaceBeforeProtocolList", |
| Style.ObjCSpaceBeforeProtocolList); |
| IO.mapOptional("PenaltyBreakBeforeFirstCallParameter", |
| Style.PenaltyBreakBeforeFirstCallParameter); |
| IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment); |
| IO.mapOptional("PenaltyBreakFirstLessLess", |
| Style.PenaltyBreakFirstLessLess); |
| IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString); |
| IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter); |
| IO.mapOptional("PenaltyReturnTypeOnItsOwnLine", |
| Style.PenaltyReturnTypeOnItsOwnLine); |
| IO.mapOptional("PointerAlignment", Style.PointerAlignment); |
| IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast); |
| IO.mapOptional("SpaceBeforeAssignmentOperators", |
| Style.SpaceBeforeAssignmentOperators); |
| IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens); |
| IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses); |
| IO.mapOptional("SpacesBeforeTrailingComments", |
| Style.SpacesBeforeTrailingComments); |
| IO.mapOptional("SpacesInAngles", Style.SpacesInAngles); |
| IO.mapOptional("SpacesInContainerLiterals", |
| Style.SpacesInContainerLiterals); |
| IO.mapOptional("SpacesInCStyleCastParentheses", |
| Style.SpacesInCStyleCastParentheses); |
| IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses); |
| IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets); |
| IO.mapOptional("Standard", Style.Standard); |
| IO.mapOptional("TabWidth", Style.TabWidth); |
| IO.mapOptional("UseTab", Style.UseTab); |
| } |
| }; |
| |
| template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> { |
| static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) { |
| IO.mapOptional("AfterClass", Wrapping.AfterClass); |
| IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement); |
| IO.mapOptional("AfterEnum", Wrapping.AfterEnum); |
| IO.mapOptional("AfterFunction", Wrapping.AfterFunction); |
| IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace); |
| IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration); |
| IO.mapOptional("AfterStruct", Wrapping.AfterStruct); |
| IO.mapOptional("AfterUnion", Wrapping.AfterUnion); |
| IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch); |
| IO.mapOptional("BeforeElse", Wrapping.BeforeElse); |
| IO.mapOptional("IndentBraces", Wrapping.IndentBraces); |
| } |
| }; |
| |
| template <> struct MappingTraits<FormatStyle::IncludeCategory> { |
| static void mapping(IO &IO, FormatStyle::IncludeCategory &Category) { |
| IO.mapOptional("Regex", Category.Regex); |
| IO.mapOptional("Priority", Category.Priority); |
| } |
| }; |
| |
| // Allows to read vector<FormatStyle> while keeping default values. |
| // IO.getContext() should contain a pointer to the FormatStyle structure, that |
| // will be used to get default values for missing keys. |
| // If the first element has no Language specified, it will be treated as the |
| // default one for the following elements. |
| template <> struct DocumentListTraits<std::vector<FormatStyle>> { |
| static size_t size(IO &IO, std::vector<FormatStyle> &Seq) { |
| return Seq.size(); |
| } |
| static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq, |
| size_t Index) { |
| if (Index >= Seq.size()) { |
| assert(Index == Seq.size()); |
| FormatStyle Template; |
| if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) { |
| Template = Seq[0]; |
| } else { |
| Template = *((const FormatStyle *)IO.getContext()); |
| Template.Language = FormatStyle::LK_None; |
| } |
| Seq.resize(Index + 1, Template); |
| } |
| return Seq[Index]; |
| } |
| }; |
| } // namespace yaml |
| } // namespace llvm |
| |
| namespace clang { |
| namespace format { |
| |
| const std::error_category &getParseCategory() { |
| static ParseErrorCategory C; |
| return C; |
| } |
| std::error_code make_error_code(ParseError e) { |
| return std::error_code(static_cast<int>(e), getParseCategory()); |
| } |
| |
| const char *ParseErrorCategory::name() const LLVM_NOEXCEPT { |
| return "clang-format.parse_error"; |
| } |
| |
| std::string ParseErrorCategory::message(int EV) const { |
| switch (static_cast<ParseError>(EV)) { |
| case ParseError::Success: |
| return "Success"; |
| case ParseError::Error: |
| return "Invalid argument"; |
| case ParseError::Unsuitable: |
| return "Unsuitable"; |
| } |
| llvm_unreachable("unexpected parse error"); |
| } |
| |
| static FormatStyle expandPresets(const FormatStyle &Style) { |
| if (Style.BreakBeforeBraces == FormatStyle::BS_Custom) |
| return Style; |
| FormatStyle Expanded = Style; |
| Expanded.BraceWrapping = {false, false, false, false, false, false, |
| false, false, false, false, false}; |
| switch (Style.BreakBeforeBraces) { |
| case FormatStyle::BS_Linux: |
| Expanded.BraceWrapping.AfterClass = true; |
| Expanded.BraceWrapping.AfterFunction = true; |
| Expanded.BraceWrapping.AfterNamespace = true; |
| Expanded.BraceWrapping.BeforeElse = true; |
| break; |
| case FormatStyle::BS_Mozilla: |
| Expanded.BraceWrapping.AfterClass = true; |
| Expanded.BraceWrapping.AfterEnum = true; |
| Expanded.BraceWrapping.AfterFunction = true; |
| Expanded.BraceWrapping.AfterStruct = true; |
| Expanded.BraceWrapping.AfterUnion = true; |
| break; |
| case FormatStyle::BS_Stroustrup: |
| Expanded.BraceWrapping.AfterFunction = true; |
| Expanded.BraceWrapping.BeforeCatch = true; |
| Expanded.BraceWrapping.BeforeElse = true; |
| break; |
| case FormatStyle::BS_Allman: |
| Expanded.BraceWrapping.AfterClass = true; |
| Expanded.BraceWrapping.AfterControlStatement = true; |
| Expanded.BraceWrapping.AfterEnum = true; |
| Expanded.BraceWrapping.AfterFunction = true; |
| Expanded.BraceWrapping.AfterNamespace = true; |
| Expanded.BraceWrapping.AfterObjCDeclaration = true; |
| Expanded.BraceWrapping.AfterStruct = true; |
| Expanded.BraceWrapping.BeforeCatch = true; |
| Expanded.BraceWrapping.BeforeElse = true; |
| break; |
| case FormatStyle::BS_GNU: |
| Expanded.BraceWrapping = {true, true, true, true, true, true, |
| true, true, true, true, true}; |
| break; |
| case FormatStyle::BS_WebKit: |
| Expanded.BraceWrapping.AfterFunction = true; |
| Expanded.BraceWrapping.BeforeElse = true; |
| break; |
| default: |
| break; |
| } |
| return Expanded; |
| } |
| |
| FormatStyle getLLVMStyle() { |
| FormatStyle LLVMStyle; |
| LLVMStyle.Language = FormatStyle::LK_Cpp; |
| LLVMStyle.AccessModifierOffset = -2; |
| LLVMStyle.AlignEscapedNewlinesLeft = false; |
| LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align; |
| LLVMStyle.AlignOperands = true; |
| LLVMStyle.AlignTrailingComments = true; |
| LLVMStyle.AlignConsecutiveAssignments = false; |
| LLVMStyle.AlignConsecutiveDeclarations = false; |
| LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true; |
| LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; |
| LLVMStyle.AllowShortBlocksOnASingleLine = false; |
| LLVMStyle.AllowShortCaseLabelsOnASingleLine = false; |
| LLVMStyle.AllowShortIfStatementsOnASingleLine = false; |
| LLVMStyle.AllowShortLoopsOnASingleLine = false; |
| LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None; |
| LLVMStyle.AlwaysBreakBeforeMultilineStrings = false; |
| LLVMStyle.AlwaysBreakTemplateDeclarations = false; |
| LLVMStyle.BinPackParameters = true; |
| LLVMStyle.BinPackArguments = true; |
| LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None; |
| LLVMStyle.BreakBeforeTernaryOperators = true; |
| LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach; |
| LLVMStyle.BraceWrapping = {false, false, false, false, false, false, |
| false, false, false, false, false}; |
| LLVMStyle.BreakConstructorInitializersBeforeComma = false; |
| LLVMStyle.BreakAfterJavaFieldAnnotations = false; |
| LLVMStyle.ColumnLimit = 80; |
| LLVMStyle.CommentPragmas = "^ IWYU pragma:"; |
| LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false; |
| LLVMStyle.ConstructorInitializerIndentWidth = 4; |
| LLVMStyle.ContinuationIndentWidth = 4; |
| LLVMStyle.Cpp11BracedListStyle = true; |
| LLVMStyle.DerivePointerAlignment = false; |
| LLVMStyle.ExperimentalAutoDetectBinPacking = false; |
| LLVMStyle.ForEachMacros.push_back("foreach"); |
| LLVMStyle.ForEachMacros.push_back("Q_FOREACH"); |
| LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH"); |
| LLVMStyle.IncludeCategories = {{"^\"(llvm|llvm-c|clang|clang-c)/", 2}, |
| {"^(<|\"(gtest|isl|json)/)", 3}, |
| {".*", 1}}; |
| LLVMStyle.IndentCaseLabels = false; |
| LLVMStyle.IndentWrappedFunctionNames = false; |
| LLVMStyle.IndentWidth = 2; |
| LLVMStyle.TabWidth = 8; |
| LLVMStyle.MaxEmptyLinesToKeep = 1; |
| LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true; |
| LLVMStyle.NamespaceIndentation = FormatStyle::NI_None; |
| LLVMStyle.ObjCBlockIndentWidth = 2; |
| LLVMStyle.ObjCSpaceAfterProperty = false; |
| LLVMStyle.ObjCSpaceBeforeProtocolList = true; |
| LLVMStyle.PointerAlignment = FormatStyle::PAS_Right; |
| LLVMStyle.SpacesBeforeTrailingComments = 1; |
| LLVMStyle.Standard = FormatStyle::LS_Cpp11; |
| LLVMStyle.UseTab = FormatStyle::UT_Never; |
| LLVMStyle.SpacesInParentheses = false; |
| LLVMStyle.SpacesInSquareBrackets = false; |
| LLVMStyle.SpaceInEmptyParentheses = false; |
| LLVMStyle.SpacesInContainerLiterals = true; |
| LLVMStyle.SpacesInCStyleCastParentheses = false; |
| LLVMStyle.SpaceAfterCStyleCast = false; |
| LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements; |
| LLVMStyle.SpaceBeforeAssignmentOperators = true; |
| LLVMStyle.SpacesInAngles = false; |
| |
| LLVMStyle.PenaltyBreakComment = 300; |
| LLVMStyle.PenaltyBreakFirstLessLess = 120; |
| LLVMStyle.PenaltyBreakString = 1000; |
| LLVMStyle.PenaltyExcessCharacter = 1000000; |
| LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60; |
| LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19; |
| |
| LLVMStyle.DisableFormat = false; |
| |
| return LLVMStyle; |
| } |
| |
| FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) { |
| FormatStyle GoogleStyle = getLLVMStyle(); |
| GoogleStyle.Language = Language; |
| |
| GoogleStyle.AccessModifierOffset = -1; |
| GoogleStyle.AlignEscapedNewlinesLeft = true; |
| GoogleStyle.AllowShortIfStatementsOnASingleLine = true; |
| GoogleStyle.AllowShortLoopsOnASingleLine = true; |
| GoogleStyle.AlwaysBreakBeforeMultilineStrings = true; |
| GoogleStyle.AlwaysBreakTemplateDeclarations = true; |
| GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true; |
| GoogleStyle.DerivePointerAlignment = true; |
| GoogleStyle.IncludeCategories = {{"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}}; |
| GoogleStyle.IndentCaseLabels = true; |
| GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false; |
| GoogleStyle.ObjCSpaceAfterProperty = false; |
| GoogleStyle.ObjCSpaceBeforeProtocolList = false; |
| GoogleStyle.PointerAlignment = FormatStyle::PAS_Left; |
| GoogleStyle.SpacesBeforeTrailingComments = 2; |
| GoogleStyle.Standard = FormatStyle::LS_Auto; |
| |
| GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200; |
| GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1; |
| |
| if (Language == FormatStyle::LK_Java) { |
| GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; |
| GoogleStyle.AlignOperands = false; |
| GoogleStyle.AlignTrailingComments = false; |
| GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; |
| GoogleStyle.AllowShortIfStatementsOnASingleLine = false; |
| GoogleStyle.AlwaysBreakBeforeMultilineStrings = false; |
| GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; |
| GoogleStyle.ColumnLimit = 100; |
| GoogleStyle.SpaceAfterCStyleCast = true; |
| GoogleStyle.SpacesBeforeTrailingComments = 1; |
| } else if (Language == FormatStyle::LK_JavaScript) { |
| GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; |
| GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; |
| GoogleStyle.AlwaysBreakBeforeMultilineStrings = false; |
| GoogleStyle.BreakBeforeTernaryOperators = false; |
| GoogleStyle.MaxEmptyLinesToKeep = 3; |
| GoogleStyle.SpacesInContainerLiterals = false; |
| } else if (Language == FormatStyle::LK_Proto) { |
| GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; |
| GoogleStyle.SpacesInContainerLiterals = false; |
| } |
| |
| return GoogleStyle; |
| } |
| |
| FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) { |
| FormatStyle ChromiumStyle = getGoogleStyle(Language); |
| if (Language == FormatStyle::LK_Java) { |
| ChromiumStyle.AllowShortIfStatementsOnASingleLine = true; |
| ChromiumStyle.BreakAfterJavaFieldAnnotations = true; |
| ChromiumStyle.ContinuationIndentWidth = 8; |
| ChromiumStyle.IndentWidth = 4; |
| } else { |
| ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false; |
| ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; |
| ChromiumStyle.AllowShortIfStatementsOnASingleLine = false; |
| ChromiumStyle.AllowShortLoopsOnASingleLine = false; |
| ChromiumStyle.BinPackParameters = false; |
| ChromiumStyle.DerivePointerAlignment = false; |
| } |
| return ChromiumStyle; |
| } |
| |
| FormatStyle getMozillaStyle() { |
| FormatStyle MozillaStyle = getLLVMStyle(); |
| MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false; |
| MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; |
| MozillaStyle.AlwaysBreakAfterDefinitionReturnType = |
| FormatStyle::DRTBS_TopLevel; |
| MozillaStyle.AlwaysBreakTemplateDeclarations = true; |
| MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; |
| MozillaStyle.BreakConstructorInitializersBeforeComma = true; |
| MozillaStyle.ConstructorInitializerIndentWidth = 2; |
| MozillaStyle.ContinuationIndentWidth = 2; |
| MozillaStyle.Cpp11BracedListStyle = false; |
| MozillaStyle.IndentCaseLabels = true; |
| MozillaStyle.ObjCSpaceAfterProperty = true; |
| MozillaStyle.ObjCSpaceBeforeProtocolList = false; |
| MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200; |
| MozillaStyle.PointerAlignment = FormatStyle::PAS_Left; |
| return MozillaStyle; |
| } |
| |
| FormatStyle getWebKitStyle() { |
| FormatStyle Style = getLLVMStyle(); |
| Style.AccessModifierOffset = -4; |
| Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; |
| Style.AlignOperands = false; |
| Style.AlignTrailingComments = false; |
| Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; |
| Style.BreakBeforeBraces = FormatStyle::BS_WebKit; |
| Style.BreakConstructorInitializersBeforeComma = true; |
| Style.Cpp11BracedListStyle = false; |
| Style.ColumnLimit = 0; |
| Style.IndentWidth = 4; |
| Style.NamespaceIndentation = FormatStyle::NI_Inner; |
| Style.ObjCBlockIndentWidth = 4; |
| Style.ObjCSpaceAfterProperty = true; |
| Style.PointerAlignment = FormatStyle::PAS_Left; |
| Style.Standard = FormatStyle::LS_Cpp03; |
| return Style; |
| } |
| |
| FormatStyle getGNUStyle() { |
| FormatStyle Style = getLLVMStyle(); |
| Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; |
| Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; |
| Style.BreakBeforeBraces = FormatStyle::BS_GNU; |
| Style.BreakBeforeTernaryOperators = true; |
| Style.Cpp11BracedListStyle = false; |
| Style.ColumnLimit = 79; |
| Style.SpaceBeforeParens = FormatStyle::SBPO_Always; |
| Style.Standard = FormatStyle::LS_Cpp03; |
| return Style; |
| } |
| |
| FormatStyle getNoStyle() { |
| FormatStyle NoStyle = getLLVMStyle(); |
| NoStyle.DisableFormat = true; |
| return NoStyle; |
| } |
| |
| bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language, |
| FormatStyle *Style) { |
| if (Name.equals_lower("llvm")) { |
| *Style = getLLVMStyle(); |
| } else if (Name.equals_lower("chromium")) { |
| *Style = getChromiumStyle(Language); |
| } else if (Name.equals_lower("mozilla")) { |
| *Style = getMozillaStyle(); |
| } else if (Name.equals_lower("google")) { |
| *Style = getGoogleStyle(Language); |
| } else if (Name.equals_lower("webkit")) { |
| *Style = getWebKitStyle(); |
| } else if (Name.equals_lower("gnu")) { |
| *Style = getGNUStyle(); |
| } else if (Name.equals_lower("none")) { |
| *Style = getNoStyle(); |
| } else { |
| return false; |
| } |
| |
| Style->Language = Language; |
| return true; |
| } |
| |
| std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) { |
| assert(Style); |
| FormatStyle::LanguageKind Language = Style->Language; |
| assert(Language != FormatStyle::LK_None); |
| if (Text.trim().empty()) |
| return make_error_code(ParseError::Error); |
| |
| std::vector<FormatStyle> Styles; |
| llvm::yaml::Input Input(Text); |
| // DocumentListTraits<vector<FormatStyle>> uses the context to get default |
| // values for the fields, keys for which are missing from the configuration. |
| // Mapping also uses the context to get the language to find the correct |
| // base style. |
| Input.setContext(Style); |
| Input >> Styles; |
| if (Input.error()) |
| return Input.error(); |
| |
| for (unsigned i = 0; i < Styles.size(); ++i) { |
| // Ensures that only the first configuration can skip the Language option. |
| if (Styles[i].Language == FormatStyle::LK_None && i != 0) |
| return make_error_code(ParseError::Error); |
| // Ensure that each language is configured at most once. |
| for (unsigned j = 0; j < i; ++j) { |
| if (Styles[i].Language == Styles[j].Language) { |
| DEBUG(llvm::dbgs() |
| << "Duplicate languages in the config file on positions " << j |
| << " and " << i << "\n"); |
| return make_error_code(ParseError::Error); |
| } |
| } |
| } |
| // Look for a suitable configuration starting from the end, so we can |
| // find the configuration for the specific language first, and the default |
| // configuration (which can only be at slot 0) after it. |
| for (int i = Styles.size() - 1; i >= 0; --i) { |
| if (Styles[i].Language == Language || |
| Styles[i].Language == FormatStyle::LK_None) { |
| *Style = Styles[i]; |
| Style->Language = Language; |
| return make_error_code(ParseError::Success); |
| } |
| } |
| return make_error_code(ParseError::Unsuitable); |
| } |
| |
| std::string configurationAsText(const FormatStyle &Style) { |
| std::string Text; |
| llvm::raw_string_ostream Stream(Text); |
| llvm::yaml::Output Output(Stream); |
| // We use the same mapping method for input and output, so we need a non-const |
| // reference here. |
| FormatStyle NonConstStyle = expandPresets(Style); |
| Output << NonConstStyle; |
| return Stream.str(); |
| } |
| |
| namespace { |
| |
| class FormatTokenLexer { |
| public: |
| FormatTokenLexer(SourceManager &SourceMgr, FileID ID, FormatStyle &Style, |
| encoding::Encoding Encoding) |
| : FormatTok(nullptr), IsFirstToken(true), GreaterStashed(false), |
| LessStashed(false), Column(0), TrailingWhitespace(0), |
| SourceMgr(SourceMgr), ID(ID), Style(Style), |
| IdentTable(getFormattingLangOpts(Style)), Keywords(IdentTable), |
| Encoding(Encoding), FirstInLineIndex(0), FormattingDisabled(false), |
| MacroBlockBeginRegex(Style.MacroBlockBegin), |
| MacroBlockEndRegex(Style.MacroBlockEnd) { |
| Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr, |
| getFormattingLangOpts(Style))); |
| Lex->SetKeepWhitespaceMode(true); |
| |
| for (const std::string &ForEachMacro : Style.ForEachMacros) |
| ForEachMacros.push_back(&IdentTable.get(ForEachMacro)); |
| std::sort(ForEachMacros.begin(), ForEachMacros.end()); |
| } |
| |
| ArrayRef<FormatToken *> lex() { |
| assert(Tokens.empty()); |
| assert(FirstInLineIndex == 0); |
| do { |
| Tokens.push_back(getNextToken()); |
| if (Style.Language == FormatStyle::LK_JavaScript) |
| tryParseJSRegexLiteral(); |
| tryMergePreviousTokens(); |
| if (Tokens.back()->NewlinesBefore > 0 || Tokens.back()->IsMultiline) |
| FirstInLineIndex = Tokens.size() - 1; |
| } while (Tokens.back()->Tok.isNot(tok::eof)); |
| return Tokens; |
| } |
| |
| const AdditionalKeywords &getKeywords() { return Keywords; } |
| |
| private: |
| void tryMergePreviousTokens() { |
| if (tryMerge_TMacro()) |
| return; |
| if (tryMergeConflictMarkers()) |
| return; |
| if (tryMergeLessLess()) |
| return; |
| |
| if (Style.Language == FormatStyle::LK_JavaScript) { |
| if (tryMergeTemplateString()) |
| return; |
| |
| static const tok::TokenKind JSIdentity[] = {tok::equalequal, tok::equal}; |
| static const tok::TokenKind JSNotIdentity[] = {tok::exclaimequal, |
| tok::equal}; |
| static const tok::TokenKind JSShiftEqual[] = {tok::greater, tok::greater, |
| tok::greaterequal}; |
| static const tok::TokenKind JSRightArrow[] = {tok::equal, tok::greater}; |
| // FIXME: Investigate what token type gives the correct operator priority. |
| if (tryMergeTokens(JSIdentity, TT_BinaryOperator)) |
| return; |
| if (tryMergeTokens(JSNotIdentity, TT_BinaryOperator)) |
| return; |
| if (tryMergeTokens(JSShiftEqual, TT_BinaryOperator)) |
| return; |
| if (tryMergeTokens(JSRightArrow, TT_JsFatArrow)) |
| return; |
| } |
| } |
| |
| bool tryMergeLessLess() { |
| // Merge X,less,less,Y into X,lessless,Y unless X or Y is less. |
| if (Tokens.size() < 3) |
| return false; |
| |
| bool FourthTokenIsLess = false; |
| if (Tokens.size() > 3) |
| FourthTokenIsLess = (Tokens.end() - 4)[0]->is(tok::less); |
| |
| auto First = Tokens.end() - 3; |
| if (First[2]->is(tok::less) || First[1]->isNot(tok::less) || |
| First[0]->isNot(tok::less) || FourthTokenIsLess) |
| return false; |
| |
| // Only merge if there currently is no whitespace between the two "<". |
| if (First[1]->WhitespaceRange.getBegin() != |
| First[1]->WhitespaceRange.getEnd()) |
| return false; |
| |
| First[0]->Tok.setKind(tok::lessless); |
| First[0]->TokenText = "<<"; |
| First[0]->ColumnWidth += 1; |
| Tokens.erase(Tokens.end() - 2); |
| return true; |
| } |
| |
| bool tryMergeTokens(ArrayRef<tok::TokenKind> Kinds, TokenType NewType) { |
| if (Tokens.size() < Kinds.size()) |
| return false; |
| |
| SmallVectorImpl<FormatToken *>::const_iterator First = |
| Tokens.end() - Kinds.size(); |
| if (!First[0]->is(Kinds[0])) |
| return false; |
| unsigned AddLength = 0; |
| for (unsigned i = 1; i < Kinds.size(); ++i) { |
| if (!First[i]->is(Kinds[i]) || |
| First[i]->WhitespaceRange.getBegin() != |
| First[i]->WhitespaceRange.getEnd()) |
| return false; |
| AddLength += First[i]->TokenText.size(); |
| } |
| Tokens.resize(Tokens.size() - Kinds.size() + 1); |
| First[0]->TokenText = StringRef(First[0]->TokenText.data(), |
| First[0]->TokenText.size() + AddLength); |
| First[0]->ColumnWidth += AddLength; |
| First[0]->Type = NewType; |
| return true; |
| } |
| |
| // Returns \c true if \p Tok can only be followed by an operand in JavaScript. |
| bool precedesOperand(FormatToken *Tok) { |
| // NB: This is not entirely correct, as an r_paren can introduce an operand |
| // location in e.g. `if (foo) /bar/.exec(...);`. That is a rare enough |
| // corner case to not matter in practice, though. |
| return Tok->isOneOf(tok::period, tok::l_paren, tok::comma, tok::l_brace, |
| tok::r_brace, tok::l_square, tok::semi, tok::exclaim, |
| tok::colon, tok::question, tok::tilde) || |
| Tok->isOneOf(tok::kw_return, tok::kw_do, tok::kw_case, tok::kw_throw, |
| tok::kw_else, tok::kw_new, tok::kw_delete, tok::kw_void, |
| tok::kw_typeof, Keywords.kw_instanceof, |
| Keywords.kw_in) || |
| Tok->isBinaryOperator(); |
| } |
| |
| bool canPrecedeRegexLiteral(FormatToken *Prev) { |
| if (!Prev) |
| return true; |
| |
| // Regex literals can only follow after prefix unary operators, not after |
| // postfix unary operators. If the '++' is followed by a non-operand |
| // introducing token, the slash here is the operand and not the start of a |
| // regex. |
| if (Prev->isOneOf(tok::plusplus, tok::minusminus)) |
| return (Tokens.size() < 3 || precedesOperand(Tokens[Tokens.size() - 3])); |
| |
| // The previous token must introduce an operand location where regex |
| // literals can occur. |
| if (!precedesOperand(Prev)) |
| return false; |
| |
| return true; |
| } |
| |
| // Tries to parse a JavaScript Regex literal starting at the current token, |
| // if that begins with a slash and is in a location where JavaScript allows |
| // regex literals. Changes the current token to a regex literal and updates |
| // its text if successful. |
| void tryParseJSRegexLiteral() { |
| FormatToken *RegexToken = Tokens.back(); |
| if (!RegexToken->isOneOf(tok::slash, tok::slashequal)) |
| return; |
| |
| FormatToken *Prev = nullptr; |
| for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; ++I) { |
| // NB: Because previous pointers are not initialized yet, this cannot use |
| // Token.getPreviousNonComment. |
| if ((*I)->isNot(tok::comment)) { |
| Prev = *I; |
| break; |
| } |
| } |
| |
| if (!canPrecedeRegexLiteral(Prev)) |
| return; |
| |
| // 'Manually' lex ahead in the current file buffer. |
| const char *Offset = Lex->getBufferLocation(); |
| const char *RegexBegin = Offset - RegexToken->TokenText.size(); |
| StringRef Buffer = Lex->getBuffer(); |
| bool InCharacterClass = false; |
| bool HaveClosingSlash = false; |
| for (; !HaveClosingSlash && Offset != Buffer.end(); ++Offset) { |
| // Regular expressions are terminated with a '/', which can only be |
| // escaped using '\' or a character class between '[' and ']'. |
| // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.5. |
| switch (*Offset) { |
| case '\\': |
| // Skip the escaped character. |
| ++Offset; |
| break; |
| case '[': |
| InCharacterClass = true; |
| break; |
| case ']': |
| InCharacterClass = false; |
| break; |
| case '/': |
| if (!InCharacterClass) |
| HaveClosingSlash = true; |
| break; |
| } |
| } |
| |
| RegexToken->Type = TT_RegexLiteral; |
| // Treat regex literals like other string_literals. |
| RegexToken->Tok.setKind(tok::string_literal); |
| RegexToken->TokenText = StringRef(RegexBegin, Offset - RegexBegin); |
| RegexToken->ColumnWidth = RegexToken->TokenText.size(); |
| |
| resetLexer(SourceMgr.getFileOffset(Lex->getSourceLocation(Offset))); |
| } |
| |
| bool tryMergeTemplateString() { |
| if (Tokens.size() < 2) |
| return false; |
| |
| FormatToken *EndBacktick = Tokens.back(); |
| // Backticks get lexed as tok::unknown tokens. If a template string contains |
| // a comment start, it gets lexed as a tok::comment, or tok::unknown if |
| // unterminated. |
| if (!EndBacktick->isOneOf(tok::comment, tok::string_literal, |
| tok::char_constant, tok::unknown)) |
| return false; |
| size_t CommentBacktickPos = EndBacktick->TokenText.find('`'); |
| // Unknown token that's not actually a backtick, or a comment that doesn't |
| // contain a backtick. |
| if (CommentBacktickPos == StringRef::npos) |
| return false; |
| |
| unsigned TokenCount = 0; |
| bool IsMultiline = false; |
| unsigned EndColumnInFirstLine = |
| EndBacktick->OriginalColumn + EndBacktick->ColumnWidth; |
| for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; I++) { |
| ++TokenCount; |
| if (I[0]->IsMultiline) |
| IsMultiline = true; |
| |
| // If there was a preceding template string, this must be the start of a |
| // template string, not the end. |
| if (I[0]->is(TT_TemplateString)) |
| return false; |
| |
| if (I[0]->isNot(tok::unknown) || I[0]->TokenText != "`") { |
| // Keep track of the rhs offset of the last token to wrap across lines - |
| // its the rhs offset of the first line of the template string, used to |
| // determine its width. |
| if (I[0]->IsMultiline) |
| EndColumnInFirstLine = I[0]->OriginalColumn + I[0]->ColumnWidth; |
| // If the token has newlines, the token before it (if it exists) is the |
| // rhs end of the previous line. |
| if (I[0]->NewlinesBefore > 0 && (I + 1 != E)) { |
| EndColumnInFirstLine = I[1]->OriginalColumn + I[1]->ColumnWidth; |
| IsMultiline = true; |
| } |
| continue; |
| } |
| |
| Tokens.resize(Tokens.size() - TokenCount); |
| Tokens.back()->Type = TT_TemplateString; |
| const char *EndOffset = |
| EndBacktick->TokenText.data() + 1 + CommentBacktickPos; |
| if (CommentBacktickPos != 0) { |
| // If the backtick was not the first character (e.g. in a comment), |
| // re-lex after the backtick position. |
| SourceLocation Loc = EndBacktick->Tok.getLocation(); |
| resetLexer(SourceMgr.getFileOffset(Loc) + CommentBacktickPos + 1); |
| } |
| Tokens.back()->TokenText = |
| StringRef(Tokens.back()->TokenText.data(), |
| EndOffset - Tokens.back()->TokenText.data()); |
| |
| unsigned EndOriginalColumn = EndBacktick->OriginalColumn; |
| if (EndOriginalColumn == 0) { |
| SourceLocation Loc = EndBacktick->Tok.getLocation(); |
| EndOriginalColumn = SourceMgr.getSpellingColumnNumber(Loc); |
| } |
| // If the ` is further down within the token (e.g. in a comment). |
| EndOriginalColumn += CommentBacktickPos; |
| |
| if (IsMultiline) { |
| // ColumnWidth is from backtick to last token in line. |
| // LastLineColumnWidth is 0 to backtick. |
| // x = `some content |
| // until here`; |
| Tokens.back()->ColumnWidth = |
| EndColumnInFirstLine - Tokens.back()->OriginalColumn; |
| // +1 for the ` itself. |
| Tokens.back()->LastLineColumnWidth = EndOriginalColumn + 1; |
| Tokens.back()->IsMultiline = true; |
| } else { |
| // Token simply spans from start to end, +1 for the ` itself. |
| Tokens.back()->ColumnWidth = |
| EndOriginalColumn - Tokens.back()->OriginalColumn + 1; |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| bool tryMerge_TMacro() { |
| if (Tokens.size() < 4) |
| return false; |
| FormatToken *Last = Tokens.back(); |
| if (!Last->is(tok::r_paren)) |
| return false; |
| |
| FormatToken *String = Tokens[Tokens.size() - 2]; |
| if (!String->is(tok::string_literal) || String->IsMultiline) |
| return false; |
| |
| if (!Tokens[Tokens.size() - 3]->is(tok::l_paren)) |
| return false; |
| |
| FormatToken *Macro = Tokens[Tokens.size() - 4]; |
| if (Macro->TokenText != "_T") |
| return false; |
| |
| const char *Start = Macro->TokenText.data(); |
| const char *End = Last->TokenText.data() + Last->TokenText.size(); |
| String->TokenText = StringRef(Start, End - Start); |
| String->IsFirst = Macro->IsFirst; |
| String->LastNewlineOffset = Macro->LastNewlineOffset; |
| String->WhitespaceRange = Macro->WhitespaceRange; |
| String->OriginalColumn = Macro->OriginalColumn; |
| String->ColumnWidth = encoding::columnWidthWithTabs( |
| String->TokenText, String->OriginalColumn, Style.TabWidth, Encoding); |
| String->NewlinesBefore = Macro->NewlinesBefore; |
| String->HasUnescapedNewline = Macro->HasUnescapedNewline; |
| |
| Tokens.pop_back(); |
| Tokens.pop_back(); |
| Tokens.pop_back(); |
| Tokens.back() = String; |
| return true; |
| } |
| |
| bool tryMergeConflictMarkers() { |
| if (Tokens.back()->NewlinesBefore == 0 && Tokens.back()->isNot(tok::eof)) |
| return false; |
| |
| // Conflict lines look like: |
| // <marker> <text from the vcs> |
| // For example: |
| // >>>>>>> /file/in/file/system at revision 1234 |
| // |
| // We merge all tokens in a line that starts with a conflict marker |
| // into a single token with a special token type that the unwrapped line |
| // parser will use to correctly rebuild the underlying code. |
| |
| FileID ID; |
| // Get the position of the first token in the line. |
| unsigned FirstInLineOffset; |
| std::tie(ID, FirstInLineOffset) = SourceMgr.getDecomposedLoc( |
| Tokens[FirstInLineIndex]->getStartOfNonWhitespace()); |
| StringRef Buffer = SourceMgr.getBuffer(ID)->getBuffer(); |
| // Calculate the offset of the start of the current line. |
| auto LineOffset = Buffer.rfind('\n', FirstInLineOffset); |
| if (LineOffset == StringRef::npos) { |
| LineOffset = 0; |
| } else { |
| ++LineOffset; |
| } |
| |
| auto FirstSpace = Buffer.find_first_of(" \n", LineOffset); |
| StringRef LineStart; |
| if (FirstSpace == StringRef::npos) { |
| LineStart = Buffer.substr(LineOffset); |
| } else { |
| LineStart = Buffer.substr(LineOffset, FirstSpace - LineOffset); |
| } |
| |
| TokenType Type = TT_Unknown; |
| if (LineStart == "<<<<<<<" || LineStart == ">>>>") { |
| Type = TT_ConflictStart; |
| } else if (LineStart == "|||||||" || LineStart == "=======" || |
| LineStart == "====") { |
| Type = TT_ConflictAlternative; |
| } else if (LineStart == ">>>>>>>" || LineStart == "<<<<") { |
| Type = TT_ConflictEnd; |
| } |
| |
| if (Type != TT_Unknown) { |
| FormatToken *Next = Tokens.back(); |
| |
| Tokens.resize(FirstInLineIndex + 1); |
| // We do not need to build a complete token here, as we will skip it |
| // during parsing anyway (as we must not touch whitespace around conflict |
| // markers). |
| Tokens.back()->Type = Type; |
| Tokens.back()->Tok.setKind(tok::kw___unknown_anytype); |
| |
| Tokens.push_back(Next); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| FormatToken *getStashedToken() { |
| // Create a synthesized second '>' or '<' token. |
| Token Tok = FormatTok->Tok; |
| StringRef TokenText = FormatTok->TokenText; |
| |
| unsigned OriginalColumn = FormatTok->OriginalColumn; |
| FormatTok = new (Allocator.Allocate()) FormatToken; |
| FormatTok->Tok = Tok; |
| SourceLocation TokLocation = |
| FormatTok->Tok.getLocation().getLocWithOffset(Tok.getLength() - 1); |
| FormatTok->Tok.setLocation(TokLocation); |
| FormatTok->WhitespaceRange = SourceRange(TokLocation, TokLocation); |
| FormatTok->TokenText = TokenText; |
| FormatTok->ColumnWidth = 1; |
| FormatTok->OriginalColumn = OriginalColumn + 1; |
| |
| return FormatTok; |
| } |
| |
| FormatToken *getNextToken() { |
| if (GreaterStashed) { |
| GreaterStashed = false; |
| return getStashedToken(); |
| } |
| if (LessStashed) { |
| LessStashed = false; |
| return getStashedToken(); |
| } |
| |
| FormatTok = new (Allocator.Allocate()) FormatToken; |
| readRawToken(*FormatTok); |
| SourceLocation WhitespaceStart = |
| FormatTok->Tok.getLocation().getLocWithOffset(-TrailingWhitespace); |
| FormatTok->IsFirst = IsFirstToken; |
| IsFirstToken = false; |
| |
| // Consume and record whitespace until we find a significant token. |
| unsigned WhitespaceLength = TrailingWhitespace; |
| while (FormatTok->Tok.is(tok::unknown)) { |
| StringRef Text = FormatTok->TokenText; |
| auto EscapesNewline = [&](int pos) { |
| // A '\r' here is just part of '\r\n'. Skip it. |
| if (pos >= 0 && Text[pos] == '\r') |
| --pos; |
| // See whether there is an odd number of '\' before this. |
| unsigned count = 0; |
| for (; pos >= 0; --pos, ++count) |
| if (Text[pos] != '\\') |
| break; |
| return count & 1; |
| }; |
| // FIXME: This miscounts tok:unknown tokens that are not just |
| // whitespace, e.g. a '`' character. |
| for (int i = 0, e = Text.size(); i != e; ++i) { |
| switch (Text[i]) { |
| case '\n': |
| ++FormatTok->NewlinesBefore; |
| FormatTok->HasUnescapedNewline = !EscapesNewline(i - 1); |
| FormatTok->LastNewlineOffset = WhitespaceLength + i + 1; |
| Column = 0; |
| break; |
| case '\r': |
| FormatTok->LastNewlineOffset = WhitespaceLength + i + 1; |
| Column = 0; |
| break; |
| case '\f': |
| case '\v': |
| Column = 0; |
| break; |
| case ' ': |
| ++Column; |
| break; |
| case '\t': |
| Column += Style.TabWidth - Column % Style.TabWidth; |
| break; |
| case '\\': |
| if (i + 1 == e || (Text[i + 1] != '\r' && Text[i + 1] != '\n')) |
| FormatTok->Type = TT_ImplicitStringLiteral; |
| break; |
| default: |
| FormatTok->Type = TT_ImplicitStringLiteral; |
| break; |
| } |
| } |
| |
| if (FormatTok->is(TT_ImplicitStringLiteral)) |
| break; |
| WhitespaceLength += FormatTok->Tok.getLength(); |
| |
| readRawToken(*FormatTok); |
| } |
| |
| // In case the token starts with escaped newlines, we want to |
| // take them into account as whitespace - this pattern is quite frequent |
| // in macro definitions. |
| // FIXME: Add a more explicit test. |
| while (FormatTok->TokenText.size() > 1 && FormatTok->TokenText[0] == '\\' && |
| FormatTok->TokenText[1] == '\n') { |
| ++FormatTok->NewlinesBefore; |
| WhitespaceLength += 2; |
| FormatTok->LastNewlineOffset = 2; |
| Column = 0; |
| FormatTok->TokenText = FormatTok->TokenText.substr(2); |
| } |
| |
| FormatTok->WhitespaceRange = SourceRange( |
| WhitespaceStart, WhitespaceStart.getLocWithOffset(WhitespaceLength)); |
| |
| FormatTok->OriginalColumn = Column; |
| |
| TrailingWhitespace = 0; |
| if (FormatTok->Tok.is(tok::comment)) { |
| // FIXME: Add the trimmed whitespace to Column. |
| StringRef UntrimmedText = FormatTok->TokenText; |
| FormatTok->TokenText = FormatTok->TokenText.rtrim(" \t\v\f"); |
| TrailingWhitespace = UntrimmedText.size() - FormatTok->TokenText.size(); |
| } else if (FormatTok->Tok.is(tok::raw_identifier)) { |
| IdentifierInfo &Info = IdentTable.get(FormatTok->TokenText); |
| FormatTok->Tok.setIdentifierInfo(&Info); |
| FormatTok->Tok.setKind(Info.getTokenID()); |
| if (Style.Language == FormatStyle::LK_Java && |
| FormatTok->isOneOf(tok::kw_struct, tok::kw_union, tok::kw_delete)) { |
| FormatTok->Tok.setKind(tok::identifier); |
| FormatTok->Tok.setIdentifierInfo(nullptr); |
| } |
| } else if (FormatTok->Tok.is(tok::greatergreater)) { |
| FormatTok->Tok.setKind(tok::greater); |
| FormatTok->TokenText = FormatTok->TokenText.substr(0, 1); |
| GreaterStashed = true; |
| } else if (FormatTok->Tok.is(tok::lessless)) { |
| FormatTok->Tok.setKind(tok::less); |
| FormatTok->TokenText = FormatTok->TokenText.substr(0, 1); |
| LessStashed = true; |
| } |
| |
| // Now FormatTok is the next non-whitespace token. |
| |
| StringRef Text = FormatTok->TokenText; |
| size_t FirstNewlinePos = Text.find('\n'); |
| if (FirstNewlinePos == StringRef::npos) { |
| // FIXME: ColumnWidth actually depends on the start column, we need to |
| // take this into account when the token is moved. |
| FormatTok->ColumnWidth = |
| encoding::columnWidthWithTabs(Text, Column, Style.TabWidth, Encoding); |
| Column += FormatTok->ColumnWidth; |
| } else { |
| FormatTok->IsMultiline = true; |
| // FIXME: ColumnWidth actually depends on the start column, we need to |
| // take this into account when the token is moved. |
| FormatTok->ColumnWidth = encoding::columnWidthWithTabs( |
| Text.substr(0, FirstNewlinePos), Column, Style.TabWidth, Encoding); |
| |
| // The last line of the token always starts in column 0. |
| // Thus, the length can be precomputed even in the presence of tabs. |
| FormatTok->LastLineColumnWidth = encoding::columnWidthWithTabs( |
| Text.substr(Text.find_last_of('\n') + 1), 0, Style.TabWidth, |
| Encoding); |
| Column = FormatTok->LastLineColumnWidth; |
| } |
| |
| if (Style.Language == FormatStyle::LK_Cpp) { |
| if (!(Tokens.size() > 0 && Tokens.back()->Tok.getIdentifierInfo() && |
| Tokens.back()->Tok.getIdentifierInfo()->getPPKeywordID() == |
| tok::pp_define) && |
| std::find(ForEachMacros.begin(), ForEachMacros.end(), |
| FormatTok->Tok.getIdentifierInfo()) != ForEachMacros.end()) { |
| FormatTok->Type = TT_ForEachMacro; |
| } else if (FormatTok->is(tok::identifier)) { |
| if (MacroBlockBeginRegex.match(Text)) { |
| FormatTok->Type = TT_MacroBlockBegin; |
| } else if (MacroBlockEndRegex.match(Text)) { |
| FormatTok->Type = TT_MacroBlockEnd; |
| } |
| } |
| } |
| |
| return FormatTok; |
| } |
| |
| FormatToken *FormatTok; |
| bool IsFirstToken; |
| bool GreaterStashed, LessStashed; |
| unsigned Column; |
| unsigned TrailingWhitespace; |
| std::unique_ptr<Lexer> Lex; |
| SourceManager &SourceMgr; |
| FileID ID; |
| FormatStyle &Style; |
| IdentifierTable IdentTable; |
| AdditionalKeywords Keywords; |
| encoding::Encoding Encoding; |
| llvm::SpecificBumpPtrAllocator<FormatToken> Allocator; |
| // Index (in 'Tokens') of the last token that starts a new line. |
| unsigned FirstInLineIndex; |
| SmallVector<FormatToken *, 16> Tokens; |
| SmallVector<IdentifierInfo *, 8> ForEachMacros; |
| |
| bool FormattingDisabled; |
| |
| llvm::Regex MacroBlockBeginRegex; |
| llvm::Regex MacroBlockEndRegex; |
| |
| void readRawToken(FormatToken &Tok) { |
| Lex->LexFromRawLexer(Tok.Tok); |
| Tok.TokenText = StringRef(SourceMgr.getCharacterData(Tok.Tok.getLocation()), |
| Tok.Tok.getLength()); |
| // For formatting, treat unterminated string literals like normal string |
| // literals. |
| if (Tok.is(tok::unknown)) { |
| if (!Tok.TokenText.empty() && Tok.TokenText[0] == '"') { |
| Tok.Tok.setKind(tok::string_literal); |
| Tok.IsUnterminatedLiteral = true; |
| } else if (Style.Language == FormatStyle::LK_JavaScript && |
| Tok.TokenText == "''") { |
| Tok.Tok.setKind(tok::char_constant); |
| } |
| } |
| |
| if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format on" || |
| Tok.TokenText == "/* clang-format on */")) { |
| FormattingDisabled = false; |
| } |
| |
| Tok.Finalized = FormattingDisabled; |
| |
| if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" || |
| Tok.TokenText == "/* clang-format off */")) { |
| FormattingDisabled = true; |
| } |
| } |
| |
| void resetLexer(unsigned Offset) { |
| StringRef Buffer = SourceMgr.getBufferData(ID); |
| Lex.reset(new Lexer(SourceMgr.getLocForStartOfFile(ID), |
| getFormattingLangOpts(Style), Buffer.begin(), |
| Buffer.begin() + Offset, Buffer.end())); |
| Lex->SetKeepWhitespaceMode(true); |
| TrailingWhitespace = 0; |
| } |
| }; |
| |
| static StringRef getLanguageName(FormatStyle::LanguageKind Language) { |
| switch (Language) { |
| case FormatStyle::LK_Cpp: |
| return "C++"; |
| case FormatStyle::LK_Java: |
| return "Java"; |
| case FormatStyle::LK_JavaScript: |
| return "JavaScript"; |
| case FormatStyle::LK_Proto: |
| return "Proto"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| class Formatter : public UnwrappedLineConsumer { |
| public: |
| Formatter(const FormatStyle &Style, SourceManager &SourceMgr, FileID ID, |
| ArrayRef<CharSourceRange> Ranges) |
| : Style(Style), ID(ID), SourceMgr(SourceMgr), |
| Whitespaces(SourceMgr, Style, |
| inputUsesCRLF(SourceMgr.getBufferData(ID))), |
| Ranges(Ranges.begin(), Ranges.end()), UnwrappedLines(1), |
| Encoding(encoding::detectEncoding(SourceMgr.getBufferData(ID))) { |
| DEBUG(llvm::dbgs() << "File encoding: " |
| << (Encoding == encoding::Encoding_UTF8 ? "UTF8" |
| : "unknown") |
| << "\n"); |
| DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language) |
| << "\n"); |
| } |
| |
| tooling::Replacements format(bool *IncompleteFormat) { |
| tooling::Replacements Result; |
| FormatTokenLexer Tokens(SourceMgr, ID, Style, Encoding); |
| |
| UnwrappedLineParser Parser(Style, Tokens.getKeywords(), Tokens.lex(), |
| *this); |
| Parser.parse(); |
| assert(UnwrappedLines.rbegin()->empty()); |
| for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE; |
| ++Run) { |
| DEBUG(llvm::dbgs() << "Run " << Run << "...\n"); |
| SmallVector<AnnotatedLine *, 16> AnnotatedLines; |
| for (unsigned i = 0, e = UnwrappedLines[Run].size(); i != e; ++i) { |
| AnnotatedLines.push_back(new AnnotatedLine(UnwrappedLines[Run][i])); |
| } |
| tooling::Replacements RunResult = |
| format(AnnotatedLines, Tokens, IncompleteFormat); |
| DEBUG({ |
| llvm::dbgs() << "Replacements for run " << Run << ":\n"; |
| for (tooling::Replacements::iterator I = RunResult.begin(), |
| E = RunResult.end(); |
| I != E; ++I) { |
| llvm::dbgs() << I->toString() << "\n"; |
| } |
| }); |
| for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
| delete AnnotatedLines[i]; |
| } |
| Result.insert(RunResult.begin(), RunResult.end()); |
| Whitespaces.reset(); |
| } |
| return Result; |
| } |
| |
| tooling::Replacements format(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines, |
| FormatTokenLexer &Tokens, |
| bool *IncompleteFormat) { |
| TokenAnnotator Annotator(Style, Tokens.getKeywords()); |
| for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
| Annotator.annotate(*AnnotatedLines[i]); |
| } |
| deriveLocalStyle(AnnotatedLines); |
| for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
| Annotator.calculateFormattingInformation(*AnnotatedLines[i]); |
| } |
| computeAffectedLines(AnnotatedLines.begin(), AnnotatedLines.end()); |
| |
| Annotator.setCommentLineLevels(AnnotatedLines); |
| ContinuationIndenter Indenter(Style, Tokens.getKeywords(), SourceMgr, |
| Whitespaces, Encoding, |
| BinPackInconclusiveFunctions); |
| UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(), |
| IncompleteFormat) |
| .format(AnnotatedLines); |
| return Whitespaces.generateReplacements(); |
| } |
| |
| private: |
| // Determines which lines are affected by the SourceRanges given as input. |
| // Returns \c true if at least one line between I and E or one of their |
| // children is affected. |
| bool computeAffectedLines(SmallVectorImpl<AnnotatedLine *>::iterator I, |
| SmallVectorImpl<AnnotatedLine *>::iterator E) { |
| bool SomeLineAffected = false; |
| const AnnotatedLine *PreviousLine = nullptr; |
| while (I != E) { |
| AnnotatedLine *Line = *I; |
| Line->LeadingEmptyLinesAffected = affectsLeadingEmptyLines(*Line->First); |
| |
| // If a line is part of a preprocessor directive, it needs to be formatted |
| // if any token within the directive is affected. |
| if (Line->InPPDirective) { |
| FormatToken *Last = Line->Last; |
| SmallVectorImpl<AnnotatedLine *>::iterator PPEnd = I + 1; |
| while (PPEnd != E && !(*PPEnd)->First->HasUnescapedNewline) { |
| Last = (*PPEnd)->Last; |
| ++PPEnd; |
| } |
| |
| if (affectsTokenRange(*Line->First, *Last, |
| /*IncludeLeadingNewlines=*/false)) { |
| SomeLineAffected = true; |
| markAllAsAffected(I, PPEnd); |
| } |
| I = PPEnd; |
| continue; |
| } |
| |
| if (nonPPLineAffected(Line, PreviousLine)) |
| SomeLineAffected = true; |
| |
| PreviousLine = Line; |
| ++I; |
| } |
| return SomeLineAffected; |
| } |
| |
| // Determines whether 'Line' is affected by the SourceRanges given as input. |
| // Returns \c true if line or one if its children is affected. |
| bool nonPPLineAffected(AnnotatedLine *Line, |
| const AnnotatedLine *PreviousLine) { |
| bool SomeLineAffected = false; |
| Line->ChildrenAffected = |
| computeAffectedLines(Line->Children.begin(), Line->Children.end()); |
| if (Line->ChildrenAffected) |
| SomeLineAffected = true; |
| |
| // Stores whether one of the line's tokens is directly affected. |
| bool SomeTokenAffected = false; |
| // Stores whether we need to look at the leading newlines of the next token |
| // in order to determine whether it was affected. |
| bool IncludeLeadingNewlines = false; |
| |
| // Stores whether the first child line of any of this line's tokens is |
| // affected. |
| bool SomeFirstChildAffected = false; |
| |
| for (FormatToken *Tok = Line->First; Tok; Tok = Tok->Next) { |
| // Determine whether 'Tok' was affected. |
| if (affectsTokenRange(*Tok, *Tok, IncludeLeadingNewlines)) |
| SomeTokenAffected = true; |
| |
| // Determine whether the first child of 'Tok' was affected. |
| if (!Tok->Children.empty() && Tok->Children.front()->Affected) |
| SomeFirstChildAffected = true; |
| |
| IncludeLeadingNewlines = Tok->Children.empty(); |
| } |
| |
| // Was this line moved, i.e. has it previously been on the same line as an |
| // affected line? |
| bool LineMoved = PreviousLine && PreviousLine->Affected && |
| Line->First->NewlinesBefore == 0; |
| |
| bool IsContinuedComment = |
| Line->First->is(tok::comment) && Line->First->Next == nullptr && |
| Line->First->NewlinesBefore < 2 && PreviousLine && |
| PreviousLine->Affected && PreviousLine->Last->is(tok::comment); |
| |
| if (SomeTokenAffected || SomeFirstChildAffected || LineMoved || |
| IsContinuedComment) { |
| Line->Affected = true; |
| SomeLineAffected = true; |
| } |
| return SomeLineAffected; |
| } |
| |
| // Marks all lines between I and E as well as all their children as affected. |
| void markAllAsAffected(SmallVectorImpl<AnnotatedLine *>::iterator I, |
| SmallVectorImpl<AnnotatedLine *>::iterator E) { |
| while (I != E) { |
| (*I)->Affected = true; |
| markAllAsAffected((*I)->Children.begin(), (*I)->Children.end()); |
| ++I; |
| } |
| } |
| |
| // Returns true if the range from 'First' to 'Last' intersects with one of the |
| // input ranges. |
| bool affectsTokenRange(const FormatToken &First, const FormatToken &Last, |
| bool IncludeLeadingNewlines) { |
| SourceLocation Start = First.WhitespaceRange.getBegin(); |
| if (!IncludeLeadingNewlines) |
| Start = Start.getLocWithOffset(First.LastNewlineOffset); |
| SourceLocation End = Last.getStartOfNonWhitespace(); |
| End = End.getLocWithOffset(Last.TokenText.size()); |
| CharSourceRange Range = CharSourceRange::getCharRange(Start, End); |
| return affectsCharSourceRange(Range); |
| } |
| |
| // Returns true if one of the input ranges intersect the leading empty lines |
| // before 'Tok'. |
| bool affectsLeadingEmptyLines(const FormatToken &Tok) { |
| CharSourceRange EmptyLineRange = CharSourceRange::getCharRange( |
| Tok.WhitespaceRange.getBegin(), |
| Tok.WhitespaceRange.getBegin().getLocWithOffset(Tok.LastNewlineOffset)); |
| return affectsCharSourceRange(EmptyLineRange); |
| } |
| |
| // Returns true if 'Range' intersects with one of the input ranges. |
| bool affectsCharSourceRange(const CharSourceRange &Range) { |
| for (SmallVectorImpl<CharSourceRange>::const_iterator I = Ranges.begin(), |
| E = Ranges.end(); |
| I != E; ++I) { |
| if (!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(), I->getBegin()) && |
| !SourceMgr.isBeforeInTranslationUnit(I->getEnd(), Range.getBegin())) |
| return true; |
| } |
| return false; |
| } |
| |
| static bool inputUsesCRLF(StringRef Text) { |
| return Text.count('\r') * 2 > Text.count('\n'); |
| } |
| |
| bool |
| hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) { |
| for (const AnnotatedLine* Line : Lines) { |
| if (hasCpp03IncompatibleFormat(Line->Children)) |
| return true; |
| for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) { |
| if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) { |
| if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener)) |
| return true; |
| if (Tok->is(TT_TemplateCloser) && |
| Tok->Previous->is(TT_TemplateCloser)) |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) { |
| int AlignmentDiff = 0; |
| for (const AnnotatedLine* Line : Lines) { |
| AlignmentDiff += countVariableAlignments(Line->Children); |
| for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) { |
| if (!Tok->is(TT_PointerOrReference)) |
| continue; |
| bool SpaceBefore = |
| Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd(); |
| bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() != |
| Tok->Next->WhitespaceRange.getEnd(); |
| if (SpaceBefore && !SpaceAfter) |
| ++AlignmentDiff; |
| if (!SpaceBefore && SpaceAfter) |
| --AlignmentDiff; |
| } |
| } |
| return AlignmentDiff; |
| } |
| |
| void |
| deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) { |
| bool HasBinPackedFunction = false; |
| bool HasOnePerLineFunction = false; |
| for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
| if (!AnnotatedLines[i]->First->Next) |
| continue; |
| FormatToken *Tok = AnnotatedLines[i]->First->Next; |
| while (Tok->Next) { |
| if (Tok->PackingKind == PPK_BinPacked) |
| HasBinPackedFunction = true; |
| if (Tok->PackingKind == PPK_OnePerLine) |
| HasOnePerLineFunction = true; |
| |
| Tok = Tok->Next; |
| } |
| } |
| if (Style.DerivePointerAlignment) |
| Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0 |
| ? FormatStyle::PAS_Left |
| : FormatStyle::PAS_Right; |
| if (Style.Standard == FormatStyle::LS_Auto) |
| Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines) |
| ? FormatStyle::LS_Cpp11 |
| : FormatStyle::LS_Cpp03; |
| BinPackInconclusiveFunctions = |
| HasBinPackedFunction || !HasOnePerLineFunction; |
| } |
| |
| void consumeUnwrappedLine(const UnwrappedLine &TheLine) override { |
| assert(!UnwrappedLines.empty()); |
| UnwrappedLines.back().push_back(TheLine); |
| } |
| |
| void finishRun() override { |
| UnwrappedLines.push_back(SmallVector<UnwrappedLine, 16>()); |
| } |
| |
| FormatStyle Style; |
| FileID ID; |
| SourceManager &SourceMgr; |
| WhitespaceManager Whitespaces; |
| SmallVector<CharSourceRange, 8> Ranges; |
| SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines; |
| |
| encoding::Encoding Encoding; |
| bool BinPackInconclusiveFunctions; |
| }; |
| |
| struct IncludeDirective { |
| StringRef Filename; |
| StringRef Text; |
| unsigned Offset; |
| unsigned Category; |
| }; |
| |
| } // end anonymous namespace |
| |
| // Determines whether 'Ranges' intersects with ('Start', 'End'). |
| static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start, |
| unsigned End) { |
| for (auto Range : Ranges) { |
| if (Range.getOffset() < End && |
| Range.getOffset() + Range.getLength() > Start) |
| return true; |
| } |
| return false; |
| } |
| |
| // Sorts a block of includes given by 'Includes' alphabetically adding the |
| // necessary replacement to 'Replaces'. 'Includes' must be in strict source |
| // order. |
| static void sortIncludes(const FormatStyle &Style, |
| const SmallVectorImpl<IncludeDirective> &Includes, |
| ArrayRef<tooling::Range> Ranges, StringRef FileName, |
| tooling::Replacements &Replaces) { |
| if (!affectsRange(Ranges, Includes.front().Offset, |
| Includes.back().Offset + Includes.back().Text.size())) |
| return; |
| SmallVector<unsigned, 16> Indices; |
| for (unsigned i = 0, e = Includes.size(); i != e; ++i) |
| Indices.push_back(i); |
| std::sort(Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) { |
| return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) < |
| std::tie(Includes[RHSI].Category, Includes[RHSI].Filename); |
| }); |
| |
| // If the #includes are out of order, we generate a single replacement fixing |
| // the entire block. Otherwise, no replacement is generated. |
| bool OutOfOrder = false; |
| for (unsigned i = 1, e = Indices.size(); i != e; ++i) { |
| if (Indices[i] != i) { |
| OutOfOrder = true; |
| break; |
| } |
| } |
| if (!OutOfOrder) |
| return; |
| |
| std::string result = Includes[Indices[0]].Text; |
| for (unsigned i = 1, e = Indices.size(); i != e; ++i) { |
| result += "\n"; |
| result += Includes[Indices[i]].Text; |
| } |
| |
| // Sorting #includes shouldn't change their total number of characters. |
| // This would otherwise mess up 'Ranges'. |
| assert(result.size() == |
| Includes.back().Offset + Includes.back().Text.size() - |
| Includes.front().Offset); |
| |
| Replaces.insert(tooling::Replacement(FileName, Includes.front().Offset, |
| result.size(), result)); |
| } |
| |
| tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code, |
| ArrayRef<tooling::Range> Ranges, |
| StringRef FileName) { |
| tooling::Replacements Replaces; |
| unsigned Prev = 0; |
| unsigned SearchFrom = 0; |
| llvm::Regex IncludeRegex( |
| R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))"); |
| SmallVector<StringRef, 4> Matches; |
| SmallVector<IncludeDirective, 16> IncludesInBlock; |
| |
| // In compiled files, consider the first #include to be the main #include of |
| // the file if it is not a system #include. This ensures that the header |
| // doesn't have hidden dependencies |
| // (http://llvm.org/docs/CodingStandards.html#include-style). |
| // |
| // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix |
| // cases where the first #include is unlikely to be the main header. |
| bool LookForMainHeader = FileName.endswith(".c") || |
| FileName.endswith(".cc") || |
| FileName.endswith(".cpp")|| |
| FileName.endswith(".c++")|| |
| FileName.endswith(".cxx") || |
| FileName.endswith(".m")|| |
| FileName.endswith(".mm"); |
| |
| // Create pre-compiled regular expressions for the #include categories. |
| SmallVector<llvm::Regex, 4> CategoryRegexs; |
| for (const auto &Category : Style.IncludeCategories) |
| CategoryRegexs.emplace_back(Category.Regex); |
| |
| for (;;) { |
| auto Pos = Code.find('\n', SearchFrom); |
| StringRef Line = |
| Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev); |
| if (!Line.endswith("\\")) { |
| if (IncludeRegex.match(Line, &Matches)) { |
| StringRef IncludeName = Matches[2]; |
| unsigned Category; |
| if (LookForMainHeader && !IncludeName.startswith("<")) { |
| Category = 0; |
| } else { |
| Category = UINT_MAX; |
| for (unsigned i = 0, e = CategoryRegexs.size(); i != e; ++i) { |
| if (CategoryRegexs[i].match(IncludeName)) { |
| Category = Style.IncludeCategories[i].Priority; |
| break; |
| } |
| } |
| } |
| LookForMainHeader = false; |
| IncludesInBlock.push_back({IncludeName, Line, Prev, Category}); |
| } else if (!IncludesInBlock.empty()) { |
| sortIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces); |
| IncludesInBlock.clear(); |
| } |
| Prev = Pos + 1; |
| } |
| if (Pos == StringRef::npos || Pos + 1 == Code.size()) |
| break; |
| SearchFrom = Pos + 1; |
| } |
| if (!IncludesInBlock.empty()) |
| sortIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces); |
| return Replaces; |
| } |
| |
| tooling::Replacements reformat(const FormatStyle &Style, |
| SourceManager &SourceMgr, FileID ID, |
| ArrayRef<CharSourceRange> Ranges, |
| bool *IncompleteFormat) { |
| FormatStyle Expanded = expandPresets(Style); |
| if (Expanded.DisableFormat) |
| return tooling::Replacements(); |
| Formatter formatter(Expanded, SourceMgr, ID, Ranges); |
| return formatter.format(IncompleteFormat); |
| } |
| |
| tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, |
| ArrayRef<tooling::Range> Ranges, |
| StringRef FileName, bool *IncompleteFormat) { |
| if (Style.DisableFormat) |
| return tooling::Replacements(); |
| |
| IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem( |
| new vfs::InMemoryFileSystem); |
| FileManager Files(FileSystemOptions(), InMemoryFileSystem); |
| DiagnosticsEngine Diagnostics( |
| IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), |
| new DiagnosticOptions); |
| SourceManager SourceMgr(Diagnostics, Files); |
| InMemoryFileSystem->addFile(FileName, 0, |
| llvm::MemoryBuffer::getMemBuffer(Code, FileName)); |
| FileID ID = SourceMgr.createFileID(Files.getFile(FileName), SourceLocation(), |
| clang::SrcMgr::C_User); |
| SourceLocation StartOfFile = SourceMgr.getLocForStartOfFile(ID); |
| std::vector<CharSourceRange> CharRanges; |
| for (const tooling::Range &Range : Ranges) { |
| SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset()); |
| SourceLocation End = Start.getLocWithOffset(Range.getLength()); |
| CharRanges.push_back(CharSourceRange::getCharRange(Start, End)); |
| } |
| return reformat(Style, SourceMgr, ID, CharRanges, IncompleteFormat); |
| } |
| |
| LangOptions getFormattingLangOpts(const FormatStyle &Style) { |
| LangOptions LangOpts; |
| LangOpts.CPlusPlus = 1; |
| LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1; |
| LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1; |
| LangOpts.LineComment = 1; |
| bool AlternativeOperators = Style.Language == FormatStyle::LK_Cpp; |
| LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0; |
| LangOpts.Bool = 1; |
| LangOpts.ObjC1 = 1; |
| LangOpts.ObjC2 = 1; |
| LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally. |
| LangOpts.DeclSpecKeyword = 1; // To get __declspec. |
| return LangOpts; |
| } |
| |
| const char *StyleOptionHelpDescription = |
| "Coding style, currently supports:\n" |
| " LLVM, Google, Chromium, Mozilla, WebKit.\n" |
| "Use -style=file to load style configuration from\n" |
| ".clang-format file located in one of the parent\n" |
| "directories of the source file (or current\n" |
| "directory for stdin).\n" |
| "Use -style=\"{key: value, ...}\" to set specific\n" |
| "parameters, e.g.:\n" |
| " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\""; |
| |
| static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) { |
| if (FileName.endswith(".java")) { |
| return FormatStyle::LK_Java; |
| } else if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts")) { |
| // JavaScript or TypeScript. |
| return FormatStyle::LK_JavaScript; |
| } else if (FileName.endswith_lower(".proto") || |
| FileName.endswith_lower(".protodevel")) { |
| return FormatStyle::LK_Proto; |
| } |
| return FormatStyle::LK_Cpp; |
| } |
| |
| FormatStyle getStyle(StringRef StyleName, StringRef FileName, |
| StringRef FallbackStyle) { |
| FormatStyle Style = getLLVMStyle(); |
| Style.Language = getLanguageByFileName(FileName); |
| if (!getPredefinedStyle(FallbackStyle, Style.Language, &Style)) { |
| llvm::errs() << "Invalid fallback style \"" << FallbackStyle |
| << "\" using LLVM style\n"; |
| return Style; |
| } |
| |
| if (StyleName.startswith("{")) { |
| // Parse YAML/JSON style from the command line. |
| if (std::error_code ec = parseConfiguration(StyleName, &Style)) { |
| llvm::errs() << "Error parsing -style: " << ec.message() << ", using " |
| << FallbackStyle << " style\n"; |
| } |
| return Style; |
| } |
| |
| if (!StyleName.equals_lower("file")) { |
| if (!getPredefinedStyle(StyleName, Style.Language, &Style)) |
| llvm::errs() << "Invalid value for -style, using " << FallbackStyle |
| << " style\n"; |
| return Style; |
| } |
| |
| // Look for .clang-format/_clang-format file in the file's parent directories. |
| SmallString<128> UnsuitableConfigFiles; |
| SmallString<128> Path(FileName); |
| llvm::sys::fs::make_absolute(Path); |
| for (StringRef Directory = Path; !Directory.empty(); |
| Directory = llvm::sys::path::parent_path(Directory)) { |
| if (!llvm::sys::fs::is_directory(Directory)) |
| continue; |
| SmallString<128> ConfigFile(Directory); |
| |
| llvm::sys::path::append(ConfigFile, ".clang-format"); |
| DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n"); |
| bool IsFile = false; |
| // Ignore errors from is_regular_file: we only need to know if we can read |
| // the file or not. |
| llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile); |
| |
| if (!IsFile) { |
| // Try _clang-format too, since dotfiles are not commonly used on Windows. |
| ConfigFile = Directory; |
| llvm::sys::path::append(ConfigFile, "_clang-format"); |
| DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n"); |
| llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile); |
| } |
| |
| if (IsFile) { |
| llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text = |
| llvm::MemoryBuffer::getFile(ConfigFile.c_str()); |
| if (std::error_code EC = Text.getError()) { |
| llvm::errs() << EC.message() << "\n"; |
| break; |
| } |
| if (std::error_code ec = |
| parseConfiguration(Text.get()->getBuffer(), &Style)) { |
| if (ec == ParseError::Unsuitable) { |
| if (!UnsuitableConfigFiles.empty()) |
| UnsuitableConfigFiles.append(", "); |
| UnsuitableConfigFiles.append(ConfigFile); |
| continue; |
| } |
| llvm::errs() << "Error reading " << ConfigFile << ": " << ec.message() |
| << "\n"; |
| break; |
| } |
| DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n"); |
| return Style; |
| } |
| } |
| if (!UnsuitableConfigFiles.empty()) { |
| llvm::errs() << "Configuration file(s) do(es) not support " |
| << getLanguageName(Style.Language) << ": " |
| << UnsuitableConfigFiles << "\n"; |
| } |
| return Style; |
| } |
| |
| } // namespace format |
| } // namespace clang |