Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 1 | //===--- Format.cpp - Format C++ code -------------------------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | /// |
| 10 | /// \file |
| 11 | /// \brief This file implements functions declared in Format.h. This will be |
| 12 | /// split into separate files as we go. |
| 13 | /// |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 14 | //===----------------------------------------------------------------------===// |
| 15 | |
Manuel Klimek | ca547db | 2013-01-16 14:55:28 +0000 | [diff] [blame] | 16 | #define DEBUG_TYPE "format-formatter" |
| 17 | |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 18 | #include "ContinuationIndenter.h" |
Daniel Jasper | 32d28ee | 2013-01-29 21:01:14 +0000 | [diff] [blame] | 19 | #include "TokenAnnotator.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 20 | #include "UnwrappedLineParser.h" |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 21 | #include "WhitespaceManager.h" |
Daniel Jasper | 8a99945 | 2013-05-16 10:40:07 +0000 | [diff] [blame] | 22 | #include "clang/Basic/Diagnostic.h" |
Chandler Carruth | b99083e | 2013-01-02 10:28:36 +0000 | [diff] [blame] | 23 | #include "clang/Basic/SourceManager.h" |
Manuel Klimek | ca547db | 2013-01-16 14:55:28 +0000 | [diff] [blame] | 24 | #include "clang/Format/Format.h" |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 25 | #include "clang/Lex/Lexer.h" |
Alexander Kornienko | 5262dd9 | 2013-03-27 11:52:18 +0000 | [diff] [blame] | 26 | #include "llvm/ADT/STLExtras.h" |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 27 | #include "llvm/Support/Allocator.h" |
Manuel Klimek | ca547db | 2013-01-16 14:55:28 +0000 | [diff] [blame] | 28 | #include "llvm/Support/Debug.h" |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 29 | #include "llvm/Support/YAMLTraits.h" |
Edwin Vane | f4e12c8 | 2013-09-30 13:31:48 +0000 | [diff] [blame] | 30 | #include "llvm/Support/Path.h" |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 31 | #include <queue> |
Daniel Jasper | 8822d3a | 2012-12-04 13:02:32 +0000 | [diff] [blame] | 32 | #include <string> |
| 33 | |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 34 | namespace llvm { |
| 35 | namespace yaml { |
| 36 | template <> |
| 37 | struct ScalarEnumerationTraits<clang::format::FormatStyle::LanguageStandard> { |
Manuel Klimek | 44135b8 | 2013-05-13 12:51:40 +0000 | [diff] [blame] | 38 | static void enumeration(IO &IO, |
| 39 | clang::format::FormatStyle::LanguageStandard &Value) { |
Alexander Kornienko | 9321e87 | 2013-09-04 14:09:13 +0000 | [diff] [blame] | 40 | IO.enumCase(Value, "Cpp03", clang::format::FormatStyle::LS_Cpp03); |
Manuel Klimek | 44135b8 | 2013-05-13 12:51:40 +0000 | [diff] [blame] | 41 | IO.enumCase(Value, "C++03", clang::format::FormatStyle::LS_Cpp03); |
Alexander Kornienko | 9321e87 | 2013-09-04 14:09:13 +0000 | [diff] [blame] | 42 | IO.enumCase(Value, "Cpp11", clang::format::FormatStyle::LS_Cpp11); |
Manuel Klimek | 44135b8 | 2013-05-13 12:51:40 +0000 | [diff] [blame] | 43 | IO.enumCase(Value, "C++11", clang::format::FormatStyle::LS_Cpp11); |
| 44 | IO.enumCase(Value, "Auto", clang::format::FormatStyle::LS_Auto); |
| 45 | } |
| 46 | }; |
| 47 | |
Daniel Jasper | 1fb8d88 | 2013-05-14 09:30:02 +0000 | [diff] [blame] | 48 | template <> |
Alexander Kornienko | 3d9ffcf | 2013-09-27 16:14:22 +0000 | [diff] [blame] | 49 | struct ScalarEnumerationTraits<clang::format::FormatStyle::UseTabStyle> { |
| 50 | static void |
| 51 | enumeration(IO &IO, clang::format::FormatStyle::UseTabStyle &Value) { |
| 52 | IO.enumCase(Value, "Never", clang::format::FormatStyle::UT_Never); |
| 53 | IO.enumCase(Value, "false", clang::format::FormatStyle::UT_Never); |
| 54 | IO.enumCase(Value, "Always", clang::format::FormatStyle::UT_Always); |
| 55 | IO.enumCase(Value, "true", clang::format::FormatStyle::UT_Always); |
| 56 | IO.enumCase(Value, "ForIndentation", |
| 57 | clang::format::FormatStyle::UT_ForIndentation); |
| 58 | } |
| 59 | }; |
| 60 | |
| 61 | template <> |
Manuel Klimek | 44135b8 | 2013-05-13 12:51:40 +0000 | [diff] [blame] | 62 | struct ScalarEnumerationTraits<clang::format::FormatStyle::BraceBreakingStyle> { |
| 63 | static void |
| 64 | enumeration(IO &IO, clang::format::FormatStyle::BraceBreakingStyle &Value) { |
| 65 | IO.enumCase(Value, "Attach", clang::format::FormatStyle::BS_Attach); |
| 66 | IO.enumCase(Value, "Linux", clang::format::FormatStyle::BS_Linux); |
| 67 | IO.enumCase(Value, "Stroustrup", clang::format::FormatStyle::BS_Stroustrup); |
Manuel Klimek | e490705 | 2013-08-02 21:31:59 +0000 | [diff] [blame] | 68 | IO.enumCase(Value, "Allman", clang::format::FormatStyle::BS_Allman); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 69 | } |
| 70 | }; |
| 71 | |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 72 | template <> |
| 73 | struct ScalarEnumerationTraits< |
| 74 | clang::format::FormatStyle::NamespaceIndentationKind> { |
| 75 | static void |
| 76 | enumeration(IO &IO, |
| 77 | clang::format::FormatStyle::NamespaceIndentationKind &Value) { |
| 78 | IO.enumCase(Value, "None", clang::format::FormatStyle::NI_None); |
| 79 | IO.enumCase(Value, "Inner", clang::format::FormatStyle::NI_Inner); |
| 80 | IO.enumCase(Value, "All", clang::format::FormatStyle::NI_All); |
| 81 | } |
| 82 | }; |
| 83 | |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 84 | template <> struct MappingTraits<clang::format::FormatStyle> { |
| 85 | static void mapping(llvm::yaml::IO &IO, clang::format::FormatStyle &Style) { |
Alexander Kornienko | dd25631 | 2013-05-10 11:56:10 +0000 | [diff] [blame] | 86 | if (IO.outputting()) { |
Alexander Kornienko | 4e65c98 | 2013-09-02 16:39:23 +0000 | [diff] [blame] | 87 | StringRef StylesArray[] = { "LLVM", "Google", "Chromium", |
| 88 | "Mozilla", "WebKit" }; |
Alexander Kornienko | dd25631 | 2013-05-10 11:56:10 +0000 | [diff] [blame] | 89 | ArrayRef<StringRef> Styles(StylesArray); |
| 90 | for (size_t i = 0, e = Styles.size(); i < e; ++i) { |
| 91 | StringRef StyleName(Styles[i]); |
Alexander Kornienko | 885f87b | 2013-05-19 00:53:30 +0000 | [diff] [blame] | 92 | clang::format::FormatStyle PredefinedStyle; |
| 93 | if (clang::format::getPredefinedStyle(StyleName, &PredefinedStyle) && |
| 94 | Style == PredefinedStyle) { |
Alexander Kornienko | dd25631 | 2013-05-10 11:56:10 +0000 | [diff] [blame] | 95 | IO.mapOptional("# BasedOnStyle", StyleName); |
| 96 | break; |
| 97 | } |
| 98 | } |
| 99 | } else { |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 100 | StringRef BasedOnStyle; |
| 101 | IO.mapOptional("BasedOnStyle", BasedOnStyle); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 102 | if (!BasedOnStyle.empty()) |
Alexander Kornienko | 885f87b | 2013-05-19 00:53:30 +0000 | [diff] [blame] | 103 | if (!clang::format::getPredefinedStyle(BasedOnStyle, &Style)) { |
| 104 | IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle)); |
| 105 | return; |
| 106 | } |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset); |
Daniel Jasper | 6315fec | 2013-08-13 10:58:30 +0000 | [diff] [blame] | 110 | IO.mapOptional("ConstructorInitializerIndentWidth", |
| 111 | Style.ConstructorInitializerIndentWidth); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 112 | IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft); |
Daniel Jasper | 893ea8d | 2013-07-31 23:55:15 +0000 | [diff] [blame] | 113 | IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 114 | IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine", |
| 115 | Style.AllowAllParametersOfDeclarationOnNextLine); |
| 116 | IO.mapOptional("AllowShortIfStatementsOnASingleLine", |
| 117 | Style.AllowShortIfStatementsOnASingleLine); |
Daniel Jasper | f11bbb9 | 2013-05-16 12:12:21 +0000 | [diff] [blame] | 118 | IO.mapOptional("AllowShortLoopsOnASingleLine", |
| 119 | Style.AllowShortLoopsOnASingleLine); |
Daniel Jasper | bbc8776 | 2013-05-29 12:07:31 +0000 | [diff] [blame] | 120 | IO.mapOptional("AlwaysBreakTemplateDeclarations", |
| 121 | Style.AlwaysBreakTemplateDeclarations); |
Alexander Kornienko | 5631202 | 2013-07-04 12:02:44 +0000 | [diff] [blame] | 122 | IO.mapOptional("AlwaysBreakBeforeMultilineStrings", |
| 123 | Style.AlwaysBreakBeforeMultilineStrings); |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 124 | IO.mapOptional("BreakBeforeBinaryOperators", |
| 125 | Style.BreakBeforeBinaryOperators); |
| 126 | IO.mapOptional("BreakConstructorInitializersBeforeComma", |
| 127 | Style.BreakConstructorInitializersBeforeComma); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 128 | IO.mapOptional("BinPackParameters", Style.BinPackParameters); |
| 129 | IO.mapOptional("ColumnLimit", Style.ColumnLimit); |
| 130 | IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine", |
| 131 | Style.ConstructorInitializerAllOnOneLineOrOnePerLine); |
| 132 | IO.mapOptional("DerivePointerBinding", Style.DerivePointerBinding); |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 133 | IO.mapOptional("ExperimentalAutoDetectBinPacking", |
| 134 | Style.ExperimentalAutoDetectBinPacking); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 135 | IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels); |
| 136 | IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep); |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 137 | IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 138 | IO.mapOptional("ObjCSpaceBeforeProtocolList", |
| 139 | Style.ObjCSpaceBeforeProtocolList); |
Alexander Kornienko | 2785b9a | 2013-06-07 16:02:52 +0000 | [diff] [blame] | 140 | IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment); |
| 141 | IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString); |
Daniel Jasper | faec47b | 2013-07-11 20:41:21 +0000 | [diff] [blame] | 142 | IO.mapOptional("PenaltyBreakFirstLessLess", |
| 143 | Style.PenaltyBreakFirstLessLess); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 144 | IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter); |
| 145 | IO.mapOptional("PenaltyReturnTypeOnItsOwnLine", |
| 146 | Style.PenaltyReturnTypeOnItsOwnLine); |
| 147 | IO.mapOptional("PointerBindsToType", Style.PointerBindsToType); |
| 148 | IO.mapOptional("SpacesBeforeTrailingComments", |
| 149 | Style.SpacesBeforeTrailingComments); |
Daniel Jasper | b5dc3f4 | 2013-07-16 18:22:10 +0000 | [diff] [blame] | 150 | IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 151 | IO.mapOptional("Standard", Style.Standard); |
Manuel Klimek | 07a64ec | 2013-05-13 08:42:42 +0000 | [diff] [blame] | 152 | IO.mapOptional("IndentWidth", Style.IndentWidth); |
Alexander Kornienko | 0b62cc3 | 2013-09-05 14:08:34 +0000 | [diff] [blame] | 153 | IO.mapOptional("TabWidth", Style.TabWidth); |
Manuel Klimek | 7c9a93e | 2013-05-13 09:22:11 +0000 | [diff] [blame] | 154 | IO.mapOptional("UseTab", Style.UseTab); |
Manuel Klimek | 44135b8 | 2013-05-13 12:51:40 +0000 | [diff] [blame] | 155 | IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces); |
Manuel Klimek | a9a7f10 | 2013-06-21 17:25:42 +0000 | [diff] [blame] | 156 | IO.mapOptional("IndentFunctionDeclarationAfterType", |
| 157 | Style.IndentFunctionDeclarationAfterType); |
Daniel Jasper | 7df56bf | 2013-08-20 12:36:34 +0000 | [diff] [blame] | 158 | IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses); |
Daniel Jasper | 34f3d05 | 2013-08-21 08:39:01 +0000 | [diff] [blame] | 159 | IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses); |
Daniel Jasper | 7df56bf | 2013-08-20 12:36:34 +0000 | [diff] [blame] | 160 | IO.mapOptional("SpacesInCStyleCastParentheses", |
| 161 | Style.SpacesInCStyleCastParentheses); |
| 162 | IO.mapOptional("SpaceAfterControlStatementKeyword", |
| 163 | Style.SpaceAfterControlStatementKeyword); |
Daniel Jasper | 9b4de85 | 2013-09-25 15:15:02 +0000 | [diff] [blame] | 164 | IO.mapOptional("SpaceBeforeAssignmentOperators", |
| 165 | Style.SpaceBeforeAssignmentOperators); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 166 | } |
| 167 | }; |
| 168 | } |
| 169 | } |
| 170 | |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 171 | namespace clang { |
| 172 | namespace format { |
| 173 | |
Daniel Jasper | faec47b | 2013-07-11 20:41:21 +0000 | [diff] [blame] | 174 | void setDefaultPenalties(FormatStyle &Style) { |
Daniel Jasper | f546178 | 2013-08-28 10:03:58 +0000 | [diff] [blame] | 175 | Style.PenaltyBreakComment = 60; |
Daniel Jasper | 9637dda | 2013-07-15 14:33:14 +0000 | [diff] [blame] | 176 | Style.PenaltyBreakFirstLessLess = 120; |
Daniel Jasper | faec47b | 2013-07-11 20:41:21 +0000 | [diff] [blame] | 177 | Style.PenaltyBreakString = 1000; |
| 178 | Style.PenaltyExcessCharacter = 1000000; |
| 179 | } |
| 180 | |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 181 | FormatStyle getLLVMStyle() { |
| 182 | FormatStyle LLVMStyle; |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 183 | LLVMStyle.AccessModifierOffset = -2; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 184 | LLVMStyle.AlignEscapedNewlinesLeft = false; |
Daniel Jasper | 893ea8d | 2013-07-31 23:55:15 +0000 | [diff] [blame] | 185 | LLVMStyle.AlignTrailingComments = true; |
Daniel Jasper | f157960 | 2013-01-29 16:03:49 +0000 | [diff] [blame] | 186 | LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true; |
Daniel Jasper | 6f5bb2c | 2013-01-14 16:24:39 +0000 | [diff] [blame] | 187 | LLVMStyle.AllowShortIfStatementsOnASingleLine = false; |
Daniel Jasper | f11bbb9 | 2013-05-16 12:12:21 +0000 | [diff] [blame] | 188 | LLVMStyle.AllowShortLoopsOnASingleLine = false; |
Alexander Kornienko | 5631202 | 2013-07-04 12:02:44 +0000 | [diff] [blame] | 189 | LLVMStyle.AlwaysBreakBeforeMultilineStrings = false; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 190 | LLVMStyle.AlwaysBreakTemplateDeclarations = false; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 191 | LLVMStyle.BinPackParameters = true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 192 | LLVMStyle.BreakBeforeBinaryOperators = false; |
| 193 | LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach; |
| 194 | LLVMStyle.BreakConstructorInitializersBeforeComma = false; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 195 | LLVMStyle.ColumnLimit = 80; |
| 196 | LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false; |
Daniel Jasper | 6315fec | 2013-08-13 10:58:30 +0000 | [diff] [blame] | 197 | LLVMStyle.ConstructorInitializerIndentWidth = 4; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 198 | LLVMStyle.Cpp11BracedListStyle = false; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 199 | LLVMStyle.DerivePointerBinding = false; |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 200 | LLVMStyle.ExperimentalAutoDetectBinPacking = false; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 201 | LLVMStyle.IndentCaseLabels = false; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 202 | LLVMStyle.IndentFunctionDeclarationAfterType = false; |
| 203 | LLVMStyle.IndentWidth = 2; |
Alexander Kornienko | 0b62cc3 | 2013-09-05 14:08:34 +0000 | [diff] [blame] | 204 | LLVMStyle.TabWidth = 8; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 205 | LLVMStyle.MaxEmptyLinesToKeep = 1; |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 206 | LLVMStyle.NamespaceIndentation = FormatStyle::NI_None; |
Nico Weber | 5f500df | 2013-01-10 20:12:55 +0000 | [diff] [blame] | 207 | LLVMStyle.ObjCSpaceBeforeProtocolList = true; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 208 | LLVMStyle.PointerBindsToType = false; |
| 209 | LLVMStyle.SpacesBeforeTrailingComments = 1; |
| 210 | LLVMStyle.Standard = FormatStyle::LS_Cpp03; |
Alexander Kornienko | 3d9ffcf | 2013-09-27 16:14:22 +0000 | [diff] [blame] | 211 | LLVMStyle.UseTab = FormatStyle::UT_Never; |
Daniel Jasper | 7df56bf | 2013-08-20 12:36:34 +0000 | [diff] [blame] | 212 | LLVMStyle.SpacesInParentheses = false; |
| 213 | LLVMStyle.SpaceInEmptyParentheses = false; |
| 214 | LLVMStyle.SpacesInCStyleCastParentheses = false; |
| 215 | LLVMStyle.SpaceAfterControlStatementKeyword = true; |
Daniel Jasper | 9b4de85 | 2013-09-25 15:15:02 +0000 | [diff] [blame] | 216 | LLVMStyle.SpaceBeforeAssignmentOperators = true; |
Daniel Jasper | faec47b | 2013-07-11 20:41:21 +0000 | [diff] [blame] | 217 | |
| 218 | setDefaultPenalties(LLVMStyle); |
| 219 | LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60; |
| 220 | |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 221 | return LLVMStyle; |
| 222 | } |
| 223 | |
| 224 | FormatStyle getGoogleStyle() { |
| 225 | FormatStyle GoogleStyle; |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 226 | GoogleStyle.AccessModifierOffset = -1; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 227 | GoogleStyle.AlignEscapedNewlinesLeft = true; |
Daniel Jasper | 893ea8d | 2013-07-31 23:55:15 +0000 | [diff] [blame] | 228 | GoogleStyle.AlignTrailingComments = true; |
Daniel Jasper | f157960 | 2013-01-29 16:03:49 +0000 | [diff] [blame] | 229 | GoogleStyle.AllowAllParametersOfDeclarationOnNextLine = true; |
Daniel Jasper | 94d6ad7 | 2013-04-24 13:46:00 +0000 | [diff] [blame] | 230 | GoogleStyle.AllowShortIfStatementsOnASingleLine = true; |
Daniel Jasper | 1bee073 | 2013-05-23 18:05:18 +0000 | [diff] [blame] | 231 | GoogleStyle.AllowShortLoopsOnASingleLine = true; |
Alexander Kornienko | 5631202 | 2013-07-04 12:02:44 +0000 | [diff] [blame] | 232 | GoogleStyle.AlwaysBreakBeforeMultilineStrings = true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 233 | GoogleStyle.AlwaysBreakTemplateDeclarations = true; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 234 | GoogleStyle.BinPackParameters = true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 235 | GoogleStyle.BreakBeforeBinaryOperators = false; |
| 236 | GoogleStyle.BreakBeforeBraces = FormatStyle::BS_Attach; |
| 237 | GoogleStyle.BreakConstructorInitializersBeforeComma = false; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 238 | GoogleStyle.ColumnLimit = 80; |
| 239 | GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true; |
Daniel Jasper | 6315fec | 2013-08-13 10:58:30 +0000 | [diff] [blame] | 240 | GoogleStyle.ConstructorInitializerIndentWidth = 4; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 241 | GoogleStyle.Cpp11BracedListStyle = true; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 242 | GoogleStyle.DerivePointerBinding = true; |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 243 | GoogleStyle.ExperimentalAutoDetectBinPacking = false; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 244 | GoogleStyle.IndentCaseLabels = true; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 245 | GoogleStyle.IndentFunctionDeclarationAfterType = true; |
| 246 | GoogleStyle.IndentWidth = 2; |
Alexander Kornienko | 0b62cc3 | 2013-09-05 14:08:34 +0000 | [diff] [blame] | 247 | GoogleStyle.TabWidth = 8; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 248 | GoogleStyle.MaxEmptyLinesToKeep = 1; |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 249 | GoogleStyle.NamespaceIndentation = FormatStyle::NI_None; |
Nico Weber | 5f500df | 2013-01-10 20:12:55 +0000 | [diff] [blame] | 250 | GoogleStyle.ObjCSpaceBeforeProtocolList = false; |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 251 | GoogleStyle.PointerBindsToType = true; |
| 252 | GoogleStyle.SpacesBeforeTrailingComments = 2; |
| 253 | GoogleStyle.Standard = FormatStyle::LS_Auto; |
Alexander Kornienko | 3d9ffcf | 2013-09-27 16:14:22 +0000 | [diff] [blame] | 254 | GoogleStyle.UseTab = FormatStyle::UT_Never; |
Daniel Jasper | 7df56bf | 2013-08-20 12:36:34 +0000 | [diff] [blame] | 255 | GoogleStyle.SpacesInParentheses = false; |
| 256 | GoogleStyle.SpaceInEmptyParentheses = false; |
| 257 | GoogleStyle.SpacesInCStyleCastParentheses = false; |
| 258 | GoogleStyle.SpaceAfterControlStatementKeyword = true; |
Daniel Jasper | 9b4de85 | 2013-09-25 15:15:02 +0000 | [diff] [blame] | 259 | GoogleStyle.SpaceBeforeAssignmentOperators = true; |
Daniel Jasper | faec47b | 2013-07-11 20:41:21 +0000 | [diff] [blame] | 260 | |
| 261 | setDefaultPenalties(GoogleStyle); |
| 262 | GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200; |
| 263 | |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 264 | return GoogleStyle; |
| 265 | } |
| 266 | |
Daniel Jasper | 6f5bb2c | 2013-01-14 16:24:39 +0000 | [diff] [blame] | 267 | FormatStyle getChromiumStyle() { |
| 268 | FormatStyle ChromiumStyle = getGoogleStyle(); |
Daniel Jasper | f157960 | 2013-01-29 16:03:49 +0000 | [diff] [blame] | 269 | ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false; |
Daniel Jasper | 94d6ad7 | 2013-04-24 13:46:00 +0000 | [diff] [blame] | 270 | ChromiumStyle.AllowShortIfStatementsOnASingleLine = false; |
Daniel Jasper | f11bbb9 | 2013-05-16 12:12:21 +0000 | [diff] [blame] | 271 | ChromiumStyle.AllowShortLoopsOnASingleLine = false; |
Daniel Jasper | faab0d3 | 2013-02-27 09:47:53 +0000 | [diff] [blame] | 272 | ChromiumStyle.BinPackParameters = false; |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 273 | ChromiumStyle.DerivePointerBinding = false; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 274 | ChromiumStyle.Standard = FormatStyle::LS_Cpp03; |
Daniel Jasper | 6f5bb2c | 2013-01-14 16:24:39 +0000 | [diff] [blame] | 275 | return ChromiumStyle; |
| 276 | } |
| 277 | |
Alexander Kornienko | fb59486 | 2013-05-06 14:11:27 +0000 | [diff] [blame] | 278 | FormatStyle getMozillaStyle() { |
| 279 | FormatStyle MozillaStyle = getLLVMStyle(); |
| 280 | MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false; |
| 281 | MozillaStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true; |
| 282 | MozillaStyle.DerivePointerBinding = true; |
| 283 | MozillaStyle.IndentCaseLabels = true; |
| 284 | MozillaStyle.ObjCSpaceBeforeProtocolList = false; |
| 285 | MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200; |
| 286 | MozillaStyle.PointerBindsToType = true; |
| 287 | return MozillaStyle; |
| 288 | } |
| 289 | |
Daniel Jasper | e05dc6d | 2013-07-24 13:10:59 +0000 | [diff] [blame] | 290 | FormatStyle getWebKitStyle() { |
| 291 | FormatStyle Style = getLLVMStyle(); |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 292 | Style.AccessModifierOffset = -4; |
Daniel Jasper | 893ea8d | 2013-07-31 23:55:15 +0000 | [diff] [blame] | 293 | Style.AlignTrailingComments = false; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 294 | Style.BreakBeforeBinaryOperators = true; |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 295 | Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 296 | Style.BreakConstructorInitializersBeforeComma = true; |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 297 | Style.ColumnLimit = 0; |
Daniel Jasper | e8b10d3 | 2013-07-26 16:56:36 +0000 | [diff] [blame] | 298 | Style.IndentWidth = 4; |
Daniel Jasper | eff18b9 | 2013-07-31 23:16:02 +0000 | [diff] [blame] | 299 | Style.NamespaceIndentation = FormatStyle::NI_Inner; |
Daniel Jasper | e05dc6d | 2013-07-24 13:10:59 +0000 | [diff] [blame] | 300 | Style.PointerBindsToType = true; |
| 301 | return Style; |
| 302 | } |
| 303 | |
Alexander Kornienko | 885f87b | 2013-05-19 00:53:30 +0000 | [diff] [blame] | 304 | bool getPredefinedStyle(StringRef Name, FormatStyle *Style) { |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 305 | if (Name.equals_lower("llvm")) |
Alexander Kornienko | 885f87b | 2013-05-19 00:53:30 +0000 | [diff] [blame] | 306 | *Style = getLLVMStyle(); |
| 307 | else if (Name.equals_lower("chromium")) |
| 308 | *Style = getChromiumStyle(); |
| 309 | else if (Name.equals_lower("mozilla")) |
| 310 | *Style = getMozillaStyle(); |
| 311 | else if (Name.equals_lower("google")) |
| 312 | *Style = getGoogleStyle(); |
Daniel Jasper | e05dc6d | 2013-07-24 13:10:59 +0000 | [diff] [blame] | 313 | else if (Name.equals_lower("webkit")) |
| 314 | *Style = getWebKitStyle(); |
Alexander Kornienko | 885f87b | 2013-05-19 00:53:30 +0000 | [diff] [blame] | 315 | else |
| 316 | return false; |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 317 | |
Alexander Kornienko | 885f87b | 2013-05-19 00:53:30 +0000 | [diff] [blame] | 318 | return true; |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | llvm::error_code parseConfiguration(StringRef Text, FormatStyle *Style) { |
Alexander Kornienko | 107db3c | 2013-05-20 15:18:01 +0000 | [diff] [blame] | 322 | if (Text.trim().empty()) |
| 323 | return llvm::make_error_code(llvm::errc::invalid_argument); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 324 | llvm::yaml::Input Input(Text); |
| 325 | Input >> *Style; |
| 326 | return Input.error(); |
| 327 | } |
| 328 | |
| 329 | std::string configurationAsText(const FormatStyle &Style) { |
| 330 | std::string Text; |
| 331 | llvm::raw_string_ostream Stream(Text); |
| 332 | llvm::yaml::Output Output(Stream); |
| 333 | // We use the same mapping method for input and output, so we need a non-const |
| 334 | // reference here. |
| 335 | FormatStyle NonConstStyle = Style; |
| 336 | Output << NonConstStyle; |
Alexander Kornienko | 2b6acb6 | 2013-05-13 12:56:35 +0000 | [diff] [blame] | 337 | return Stream.str(); |
Alexander Kornienko | d71ec16 | 2013-05-07 15:32:14 +0000 | [diff] [blame] | 338 | } |
| 339 | |
Craig Topper | 83f81d7 | 2013-06-30 22:29:28 +0000 | [diff] [blame] | 340 | namespace { |
| 341 | |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 342 | class NoColumnLimitFormatter { |
| 343 | public: |
Daniel Jasper | 34f3d05 | 2013-08-21 08:39:01 +0000 | [diff] [blame] | 344 | NoColumnLimitFormatter(ContinuationIndenter *Indenter) : Indenter(Indenter) {} |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 345 | |
| 346 | /// \brief Formats the line starting at \p State, simply keeping all of the |
| 347 | /// input's line breaking decisions. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 348 | void format(unsigned FirstIndent, const AnnotatedLine *Line) { |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 349 | LineState State = |
| 350 | Indenter->getInitialState(FirstIndent, Line, /*DryRun=*/false); |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 351 | while (State.NextToken != NULL) { |
| 352 | bool Newline = |
| 353 | Indenter->mustBreak(State) || |
| 354 | (Indenter->canBreak(State) && State.NextToken->NewlinesBefore > 0); |
| 355 | Indenter->addTokenToState(State, Newline, /*DryRun=*/false); |
| 356 | } |
| 357 | } |
Daniel Jasper | 34f3d05 | 2013-08-21 08:39:01 +0000 | [diff] [blame] | 358 | |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 359 | private: |
| 360 | ContinuationIndenter *Indenter; |
| 361 | }; |
| 362 | |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 363 | class UnwrappedLineFormatter { |
| 364 | public: |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 365 | UnwrappedLineFormatter(ContinuationIndenter *Indenter, |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 366 | WhitespaceManager *Whitespaces, |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 367 | const FormatStyle &Style, const AnnotatedLine &Line) |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 368 | : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style), Line(Line), |
| 369 | Count(0) {} |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 370 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 371 | /// \brief Formats an \c UnwrappedLine and returns the penalty. |
| 372 | /// |
| 373 | /// If \p DryRun is \c false, directly applies the changes. |
| 374 | unsigned format(unsigned FirstIndent, bool DryRun = false) { |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 375 | LineState State = Indenter->getInitialState(FirstIndent, &Line, DryRun); |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 376 | |
Daniel Jasper | ce3d1a6 | 2013-02-08 08:22:00 +0000 | [diff] [blame] | 377 | // If the ObjC method declaration does not fit on a line, we should format |
| 378 | // it with one arg per line. |
| 379 | if (Line.Type == LT_ObjCMethodDecl) |
| 380 | State.Stack.back().BreakBeforeParameter = true; |
| 381 | |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 382 | // Find best solution in solution space. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 383 | return analyzeSolutionSpace(State, DryRun); |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 384 | } |
| 385 | |
| 386 | private: |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 387 | /// \brief An edge in the solution space from \c Previous->State to \c State, |
| 388 | /// inserting a newline dependent on the \c NewLine. |
| 389 | struct StateNode { |
| 390 | StateNode(const LineState &State, bool NewLine, StateNode *Previous) |
Daniel Jasper | f11a705 | 2013-02-21 21:33:55 +0000 | [diff] [blame] | 391 | : State(State), NewLine(NewLine), Previous(Previous) {} |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 392 | LineState State; |
| 393 | bool NewLine; |
| 394 | StateNode *Previous; |
| 395 | }; |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 396 | |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 397 | /// \brief A pair of <penalty, count> that is used to prioritize the BFS on. |
| 398 | /// |
| 399 | /// In case of equal penalties, we want to prefer states that were inserted |
| 400 | /// first. During state generation we make sure that we insert states first |
| 401 | /// that break the line as late as possible. |
| 402 | typedef std::pair<unsigned, unsigned> OrderedPenalty; |
| 403 | |
| 404 | /// \brief An item in the prioritized BFS search queue. The \c StateNode's |
| 405 | /// \c State has the given \c OrderedPenalty. |
| 406 | typedef std::pair<OrderedPenalty, StateNode *> QueueItem; |
| 407 | |
| 408 | /// \brief The BFS queue type. |
| 409 | typedef std::priority_queue<QueueItem, std::vector<QueueItem>, |
| 410 | std::greater<QueueItem> > QueueType; |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 411 | |
| 412 | /// \brief Analyze the entire solution space starting from \p InitialState. |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 413 | /// |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 414 | /// This implements a variant of Dijkstra's algorithm on the graph that spans |
| 415 | /// the solution space (\c LineStates are the nodes). The algorithm tries to |
| 416 | /// find the shortest path (the one with lowest penalty) from \p InitialState |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 417 | /// to a state where all tokens are placed. Returns the penalty. |
| 418 | /// |
| 419 | /// If \p DryRun is \c false, directly applies the changes. |
| 420 | unsigned analyzeSolutionSpace(LineState &InitialState, bool DryRun = false) { |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 421 | std::set<LineState> Seen; |
| 422 | |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 423 | // Insert start element into queue. |
Daniel Jasper | fc75908 | 2013-02-14 14:26:07 +0000 | [diff] [blame] | 424 | StateNode *Node = |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 425 | new (Allocator.Allocate()) StateNode(InitialState, false, NULL); |
| 426 | Queue.push(QueueItem(OrderedPenalty(0, Count), Node)); |
| 427 | ++Count; |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 428 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 429 | unsigned Penalty = 0; |
| 430 | |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 431 | // While not empty, take first element and follow edges. |
| 432 | while (!Queue.empty()) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 433 | Penalty = Queue.top().first.first; |
Daniel Jasper | fc75908 | 2013-02-14 14:26:07 +0000 | [diff] [blame] | 434 | StateNode *Node = Queue.top().second; |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 435 | if (Node->State.NextToken == NULL) { |
Alexander Kornienko | dd25631 | 2013-05-10 11:56:10 +0000 | [diff] [blame] | 436 | DEBUG(llvm::dbgs() << "\n---\nPenalty for line: " << Penalty << "\n"); |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 437 | break; |
Daniel Jasper | 0178673 | 2013-02-04 07:21:18 +0000 | [diff] [blame] | 438 | } |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 439 | Queue.pop(); |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 440 | |
Daniel Jasper | 54b4e44 | 2013-05-22 05:27:42 +0000 | [diff] [blame] | 441 | // Cut off the analysis of certain solutions if the analysis gets too |
| 442 | // complex. See description of IgnoreStackForComparison. |
| 443 | if (Count > 10000) |
| 444 | Node->State.IgnoreStackForComparison = true; |
| 445 | |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 446 | if (!Seen.insert(Node->State).second) |
| 447 | // State already examined with lower penalty. |
| 448 | continue; |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 449 | |
Nico Weber | 2726877 | 2013-06-26 00:30:14 +0000 | [diff] [blame] | 450 | addNextStateToQueue(Penalty, Node, /*NewLine=*/false); |
| 451 | addNextStateToQueue(Penalty, Node, /*NewLine=*/true); |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | if (Queue.empty()) |
| 455 | // We were unable to find a solution, do nothing. |
| 456 | // FIXME: Add diagnostic? |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 457 | return 0; |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 458 | |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 459 | // Reconstruct the solution. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 460 | if (!DryRun) |
| 461 | reconstructPath(InitialState, Queue.top().second); |
| 462 | |
Alexander Kornienko | dd25631 | 2013-05-10 11:56:10 +0000 | [diff] [blame] | 463 | DEBUG(llvm::dbgs() << "Total number of analyzed states: " << Count << "\n"); |
| 464 | DEBUG(llvm::dbgs() << "---\n"); |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 465 | |
| 466 | return Penalty; |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 467 | } |
| 468 | |
| 469 | void reconstructPath(LineState &State, StateNode *Current) { |
Manuel Klimek | 9c333b9 | 2013-05-29 15:10:11 +0000 | [diff] [blame] | 470 | std::deque<StateNode *> Path; |
| 471 | // We do not need a break before the initial token. |
| 472 | while (Current->Previous) { |
| 473 | Path.push_front(Current); |
| 474 | Current = Current->Previous; |
| 475 | } |
| 476 | for (std::deque<StateNode *>::iterator I = Path.begin(), E = Path.end(); |
| 477 | I != E; ++I) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 478 | unsigned Penalty = 0; |
| 479 | formatChildren(State, (*I)->NewLine, /*DryRun=*/false, Penalty); |
| 480 | Penalty += Indenter->addTokenToState(State, (*I)->NewLine, false); |
| 481 | |
Manuel Klimek | 9c333b9 | 2013-05-29 15:10:11 +0000 | [diff] [blame] | 482 | DEBUG({ |
| 483 | if ((*I)->NewLine) { |
Daniel Jasper | d4a03db | 2013-08-22 15:00:41 +0000 | [diff] [blame] | 484 | llvm::dbgs() << "Penalty for placing " |
Manuel Klimek | 9c333b9 | 2013-05-29 15:10:11 +0000 | [diff] [blame] | 485 | << (*I)->Previous->State.NextToken->Tok.getName() << ": " |
Daniel Jasper | d4a03db | 2013-08-22 15:00:41 +0000 | [diff] [blame] | 486 | << Penalty << "\n"; |
Manuel Klimek | 9c333b9 | 2013-05-29 15:10:11 +0000 | [diff] [blame] | 487 | } |
| 488 | }); |
Manuel Klimek | 9c333b9 | 2013-05-29 15:10:11 +0000 | [diff] [blame] | 489 | } |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 490 | } |
| 491 | |
Manuel Klimek | 62a48fb | 2013-02-13 10:54:19 +0000 | [diff] [blame] | 492 | /// \brief Add the following state to the analysis queue \c Queue. |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 493 | /// |
Manuel Klimek | 62a48fb | 2013-02-13 10:54:19 +0000 | [diff] [blame] | 494 | /// Assume the current state is \p PreviousNode and has been reached with a |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 495 | /// penalty of \p Penalty. Insert a line break if \p NewLine is \c true. |
Manuel Klimek | 62a48fb | 2013-02-13 10:54:19 +0000 | [diff] [blame] | 496 | void addNextStateToQueue(unsigned Penalty, StateNode *PreviousNode, |
| 497 | bool NewLine) { |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 498 | if (NewLine && !Indenter->canBreak(PreviousNode->State)) |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 499 | return; |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 500 | if (!NewLine && Indenter->mustBreak(PreviousNode->State)) |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 501 | return; |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 502 | |
| 503 | StateNode *Node = new (Allocator.Allocate()) |
| 504 | StateNode(PreviousNode->State, NewLine, PreviousNode); |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 505 | if (!formatChildren(Node->State, NewLine, /*DryRun=*/true, Penalty)) |
| 506 | return; |
| 507 | |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 508 | Penalty += Indenter->addTokenToState(Node->State, NewLine, true); |
Manuel Klimek | 32a2fd7 | 2013-02-13 10:46:36 +0000 | [diff] [blame] | 509 | |
| 510 | Queue.push(QueueItem(OrderedPenalty(Penalty, Count), Node)); |
| 511 | ++Count; |
Daniel Jasper | 68ef0df | 2013-02-01 11:00:45 +0000 | [diff] [blame] | 512 | } |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 513 | |
Daniel Jasper | 1a925bc | 2013-09-05 10:48:50 +0000 | [diff] [blame] | 514 | /// \brief If the \p State's next token is an r_brace closing a nested block, |
| 515 | /// format the nested block before it. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 516 | /// |
| 517 | /// Returns \c true if all children could be placed successfully and adapts |
| 518 | /// \p Penalty as well as \p State. If \p DryRun is false, also directly |
| 519 | /// creates changes using \c Whitespaces. |
| 520 | /// |
| 521 | /// The crucial idea here is that children always get formatted upon |
| 522 | /// encountering the closing brace right after the nested block. Now, if we |
| 523 | /// are currently trying to keep the "}" on the same line (i.e. \p NewLine is |
| 524 | /// \c false), the entire block has to be kept on the same line (which is only |
| 525 | /// possible if it fits on the line, only contains a single statement, etc. |
| 526 | /// |
| 527 | /// If \p NewLine is true, we format the nested block on separate lines, i.e. |
| 528 | /// break after the "{", format all lines with correct indentation and the put |
| 529 | /// the closing "}" on yet another new line. |
| 530 | /// |
| 531 | /// This enables us to keep the simple structure of the |
| 532 | /// \c UnwrappedLineFormatter, where we only have two options for each token: |
| 533 | /// break or don't break. |
| 534 | bool formatChildren(LineState &State, bool NewLine, bool DryRun, |
| 535 | unsigned &Penalty) { |
| 536 | const FormatToken &LBrace = *State.NextToken->Previous; |
| 537 | if (LBrace.isNot(tok::l_brace) || LBrace.BlockKind != BK_Block || |
| 538 | LBrace.Children.size() == 0) |
Daniel Jasper | 1a925bc | 2013-09-05 10:48:50 +0000 | [diff] [blame] | 539 | // The previous token does not open a block. Nothing to do. We don't |
| 540 | // assert so that we can simply call this function for all tokens. |
Daniel Jasper | 2f0a020 | 2013-09-06 08:54:24 +0000 | [diff] [blame] | 541 | return true; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 542 | |
| 543 | if (NewLine) { |
| 544 | unsigned ParentIndent = State.Stack.back().Indent; |
| 545 | for (SmallVector<AnnotatedLine *, 1>::const_iterator |
| 546 | I = LBrace.Children.begin(), |
| 547 | E = LBrace.Children.end(); |
| 548 | I != E; ++I) { |
| 549 | unsigned Indent = |
Daniel Jasper | 5798120 | 2013-09-13 09:20:45 +0000 | [diff] [blame] | 550 | ParentIndent + ((*I)->Level - Line.Level - 1) * Style.IndentWidth; |
Daniel Jasper | 14e25c0 | 2013-09-08 14:07:57 +0000 | [diff] [blame] | 551 | if (!DryRun) { |
| 552 | unsigned Newlines = std::min((*I)->First->NewlinesBefore, |
| 553 | Style.MaxEmptyLinesToKeep + 1); |
| 554 | Newlines = std::max(1u, Newlines); |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 555 | Whitespaces->replaceWhitespace( |
Alexander Kornienko | 3d9ffcf | 2013-09-27 16:14:22 +0000 | [diff] [blame] | 556 | *(*I)->First, Newlines, (*I)->Level, /*Spaces=*/Indent, |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 557 | /*StartOfTokenColumn=*/Indent, Line.InPPDirective); |
Daniel Jasper | 14e25c0 | 2013-09-08 14:07:57 +0000 | [diff] [blame] | 558 | } |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 559 | UnwrappedLineFormatter Formatter(Indenter, Whitespaces, Style, **I); |
| 560 | Penalty += Formatter.format(Indent, DryRun); |
| 561 | } |
| 562 | return true; |
| 563 | } |
| 564 | |
| 565 | if (LBrace.Children.size() > 1) |
| 566 | return false; // Cannot merge multiple statements into a single line. |
| 567 | |
| 568 | // We can't put the closing "}" on a line with a trailing comment. |
| 569 | if (LBrace.Children[0]->Last->isTrailingComment()) |
| 570 | return false; |
| 571 | |
| 572 | if (!DryRun) { |
Alexander Kornienko | 3d9ffcf | 2013-09-27 16:14:22 +0000 | [diff] [blame] | 573 | Whitespaces->replaceWhitespace( |
| 574 | *LBrace.Children[0]->First, |
| 575 | /*Newlines=*/0, /*IndentLevel=*/1, /*Spaces=*/1, |
| 576 | /*StartOfTokenColumn=*/State.Column, State.Line->InPPDirective); |
Daniel Jasper | 14e25c0 | 2013-09-08 14:07:57 +0000 | [diff] [blame] | 577 | UnwrappedLineFormatter Formatter(Indenter, Whitespaces, Style, |
| 578 | *LBrace.Children[0]); |
| 579 | Penalty += Formatter.format(State.Column + 1, DryRun); |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 580 | } |
| 581 | |
| 582 | State.Column += 1 + LBrace.Children[0]->Last->TotalLength; |
| 583 | return true; |
| 584 | } |
| 585 | |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 586 | ContinuationIndenter *Indenter; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 587 | WhitespaceManager *Whitespaces; |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 588 | FormatStyle Style; |
Daniel Jasper | 995e820 | 2013-01-14 13:08:07 +0000 | [diff] [blame] | 589 | const AnnotatedLine &Line; |
Manuel Klimek | 62a48fb | 2013-02-13 10:54:19 +0000 | [diff] [blame] | 590 | |
| 591 | llvm::SpecificBumpPtrAllocator<StateNode> Allocator; |
| 592 | QueueType Queue; |
| 593 | // Increasing count of \c StateNode items we have created. This is used |
| 594 | // to create a deterministic order independent of the container. |
| 595 | unsigned Count; |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 596 | }; |
| 597 | |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 598 | class FormatTokenLexer { |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 599 | public: |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 600 | FormatTokenLexer(Lexer &Lex, SourceManager &SourceMgr, FormatStyle &Style, |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 601 | encoding::Encoding Encoding) |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 602 | : FormatTok(NULL), GreaterStashed(false), Column(0), |
| 603 | TrailingWhitespace(0), Lex(Lex), SourceMgr(SourceMgr), Style(Style), |
| 604 | IdentTable(getFormattingLangOpts()), Encoding(Encoding) { |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 605 | Lex.SetKeepWhitespaceMode(true); |
| 606 | } |
| 607 | |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 608 | ArrayRef<FormatToken *> lex() { |
| 609 | assert(Tokens.empty()); |
| 610 | do { |
| 611 | Tokens.push_back(getNextToken()); |
Alexander Kornienko | 2c2f729 | 2013-09-16 20:20:49 +0000 | [diff] [blame] | 612 | maybeJoinPreviousTokens(); |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 613 | } while (Tokens.back()->Tok.isNot(tok::eof)); |
| 614 | return Tokens; |
| 615 | } |
| 616 | |
| 617 | IdentifierTable &getIdentTable() { return IdentTable; } |
| 618 | |
| 619 | private: |
Alexander Kornienko | 2c2f729 | 2013-09-16 20:20:49 +0000 | [diff] [blame] | 620 | void maybeJoinPreviousTokens() { |
| 621 | if (Tokens.size() < 4) |
| 622 | return; |
| 623 | FormatToken *Last = Tokens.back(); |
| 624 | if (!Last->is(tok::r_paren)) |
| 625 | return; |
| 626 | |
| 627 | FormatToken *String = Tokens[Tokens.size() - 2]; |
| 628 | if (!String->is(tok::string_literal) || String->IsMultiline) |
| 629 | return; |
| 630 | |
| 631 | if (!Tokens[Tokens.size() - 3]->is(tok::l_paren)) |
| 632 | return; |
| 633 | |
| 634 | FormatToken *Macro = Tokens[Tokens.size() - 4]; |
| 635 | if (Macro->TokenText != "_T") |
| 636 | return; |
| 637 | |
| 638 | const char *Start = Macro->TokenText.data(); |
| 639 | const char *End = Last->TokenText.data() + Last->TokenText.size(); |
| 640 | String->TokenText = StringRef(Start, End - Start); |
| 641 | String->IsFirst = Macro->IsFirst; |
| 642 | String->LastNewlineOffset = Macro->LastNewlineOffset; |
| 643 | String->WhitespaceRange = Macro->WhitespaceRange; |
| 644 | String->OriginalColumn = Macro->OriginalColumn; |
| 645 | String->ColumnWidth = encoding::columnWidthWithTabs( |
| 646 | String->TokenText, String->OriginalColumn, Style.TabWidth, Encoding); |
| 647 | |
| 648 | Tokens.pop_back(); |
| 649 | Tokens.pop_back(); |
| 650 | Tokens.pop_back(); |
| 651 | Tokens.back() = String; |
| 652 | } |
| 653 | |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 654 | FormatToken *getNextToken() { |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 655 | if (GreaterStashed) { |
Manuel Klimek | dcb3f2a | 2013-05-28 13:42:28 +0000 | [diff] [blame] | 656 | // Create a synthesized second '>' token. |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 657 | // FIXME: Increment Column and set OriginalColumn. |
Manuel Klimek | dcb3f2a | 2013-05-28 13:42:28 +0000 | [diff] [blame] | 658 | Token Greater = FormatTok->Tok; |
| 659 | FormatTok = new (Allocator.Allocate()) FormatToken; |
| 660 | FormatTok->Tok = Greater; |
Manuel Klimek | ad3094b | 2013-05-23 10:56:37 +0000 | [diff] [blame] | 661 | SourceLocation GreaterLocation = |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 662 | FormatTok->Tok.getLocation().getLocWithOffset(1); |
| 663 | FormatTok->WhitespaceRange = |
| 664 | SourceRange(GreaterLocation, GreaterLocation); |
Alexander Kornienko | 54e6c9d | 2013-06-07 17:45:07 +0000 | [diff] [blame] | 665 | FormatTok->TokenText = ">"; |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 666 | FormatTok->ColumnWidth = 1; |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 667 | GreaterStashed = false; |
| 668 | return FormatTok; |
| 669 | } |
| 670 | |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 671 | FormatTok = new (Allocator.Allocate()) FormatToken; |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 672 | readRawToken(*FormatTok); |
Manuel Klimek | de008c0 | 2013-05-27 15:23:34 +0000 | [diff] [blame] | 673 | SourceLocation WhitespaceStart = |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 674 | FormatTok->Tok.getLocation().getLocWithOffset(-TrailingWhitespace); |
Manuel Klimek | ad3094b | 2013-05-23 10:56:37 +0000 | [diff] [blame] | 675 | if (SourceMgr.getFileOffset(WhitespaceStart) == 0) |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 676 | FormatTok->IsFirst = true; |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 677 | |
| 678 | // Consume and record whitespace until we find a significant token. |
Manuel Klimek | de008c0 | 2013-05-27 15:23:34 +0000 | [diff] [blame] | 679 | unsigned WhitespaceLength = TrailingWhitespace; |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 680 | while (FormatTok->Tok.is(tok::unknown)) { |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 681 | for (int i = 0, e = FormatTok->TokenText.size(); i != e; ++i) { |
| 682 | switch (FormatTok->TokenText[i]) { |
| 683 | case '\n': |
| 684 | ++FormatTok->NewlinesBefore; |
| 685 | // FIXME: This is technically incorrect, as it could also |
| 686 | // be a literal backslash at the end of the line. |
Alexander Kornienko | 73d845c | 2013-09-11 12:25:57 +0000 | [diff] [blame] | 687 | if (i == 0 || (FormatTok->TokenText[i - 1] != '\\' && |
| 688 | (FormatTok->TokenText[i - 1] != '\r' || i == 1 || |
| 689 | FormatTok->TokenText[i - 2] != '\\'))) |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 690 | FormatTok->HasUnescapedNewline = true; |
| 691 | FormatTok->LastNewlineOffset = WhitespaceLength + i + 1; |
| 692 | Column = 0; |
| 693 | break; |
| 694 | case ' ': |
| 695 | ++Column; |
| 696 | break; |
| 697 | case '\t': |
Alexander Kornienko | 0b62cc3 | 2013-09-05 14:08:34 +0000 | [diff] [blame] | 698 | Column += Style.TabWidth - Column % Style.TabWidth; |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 699 | break; |
| 700 | default: |
| 701 | ++Column; |
| 702 | break; |
| 703 | } |
| 704 | } |
| 705 | |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 706 | WhitespaceLength += FormatTok->Tok.getLength(); |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 707 | |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 708 | readRawToken(*FormatTok); |
Manuel Klimek | d4397b9 | 2013-01-04 23:34:14 +0000 | [diff] [blame] | 709 | } |
Manuel Klimek | 9541938 | 2013-01-07 07:56:50 +0000 | [diff] [blame] | 710 | |
Manuel Klimek | d4397b9 | 2013-01-04 23:34:14 +0000 | [diff] [blame] | 711 | // In case the token starts with escaped newlines, we want to |
| 712 | // take them into account as whitespace - this pattern is quite frequent |
| 713 | // in macro definitions. |
Manuel Klimek | d4397b9 | 2013-01-04 23:34:14 +0000 | [diff] [blame] | 714 | // FIXME: Add a more explicit test. |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 715 | while (FormatTok->TokenText.size() > 1 && FormatTok->TokenText[0] == '\\' && |
| 716 | FormatTok->TokenText[1] == '\n') { |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 717 | // FIXME: ++FormatTok->NewlinesBefore is missing... |
Manuel Klimek | ad3094b | 2013-05-23 10:56:37 +0000 | [diff] [blame] | 718 | WhitespaceLength += 2; |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 719 | Column = 0; |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 720 | FormatTok->TokenText = FormatTok->TokenText.substr(2); |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 721 | } |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 722 | |
| 723 | FormatTok->WhitespaceRange = SourceRange( |
| 724 | WhitespaceStart, WhitespaceStart.getLocWithOffset(WhitespaceLength)); |
| 725 | |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 726 | FormatTok->OriginalColumn = Column; |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 727 | |
Alexander Kornienko | 54e6c9d | 2013-06-07 17:45:07 +0000 | [diff] [blame] | 728 | TrailingWhitespace = 0; |
| 729 | if (FormatTok->Tok.is(tok::comment)) { |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 730 | // FIXME: Add the trimmed whitespace to Column. |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 731 | StringRef UntrimmedText = FormatTok->TokenText; |
Alexander Kornienko | 51bb5d9 | 2013-09-06 17:24:54 +0000 | [diff] [blame] | 732 | FormatTok->TokenText = FormatTok->TokenText.rtrim(" \t\v\f"); |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 733 | TrailingWhitespace = UntrimmedText.size() - FormatTok->TokenText.size(); |
Alexander Kornienko | 54e6c9d | 2013-06-07 17:45:07 +0000 | [diff] [blame] | 734 | } else if (FormatTok->Tok.is(tok::raw_identifier)) { |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 735 | IdentifierInfo &Info = IdentTable.get(FormatTok->TokenText); |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 736 | FormatTok->Tok.setIdentifierInfo(&Info); |
| 737 | FormatTok->Tok.setKind(Info.getTokenID()); |
Alexander Kornienko | 54e6c9d | 2013-06-07 17:45:07 +0000 | [diff] [blame] | 738 | } else if (FormatTok->Tok.is(tok::greatergreater)) { |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 739 | FormatTok->Tok.setKind(tok::greater); |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 740 | FormatTok->TokenText = FormatTok->TokenText.substr(0, 1); |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 741 | GreaterStashed = true; |
| 742 | } |
| 743 | |
Alexander Kornienko | 54e6c9d | 2013-06-07 17:45:07 +0000 | [diff] [blame] | 744 | // Now FormatTok is the next non-whitespace token. |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 745 | |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 746 | StringRef Text = FormatTok->TokenText; |
| 747 | size_t FirstNewlinePos = Text.find('\n'); |
Alexander Kornienko | 6f6154c | 2013-09-10 12:29:48 +0000 | [diff] [blame] | 748 | if (FirstNewlinePos == StringRef::npos) { |
| 749 | // FIXME: ColumnWidth actually depends on the start column, we need to |
| 750 | // take this into account when the token is moved. |
| 751 | FormatTok->ColumnWidth = |
| 752 | encoding::columnWidthWithTabs(Text, Column, Style.TabWidth, Encoding); |
| 753 | Column += FormatTok->ColumnWidth; |
| 754 | } else { |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 755 | FormatTok->IsMultiline = true; |
Alexander Kornienko | 6f6154c | 2013-09-10 12:29:48 +0000 | [diff] [blame] | 756 | // FIXME: ColumnWidth actually depends on the start column, we need to |
| 757 | // take this into account when the token is moved. |
| 758 | FormatTok->ColumnWidth = encoding::columnWidthWithTabs( |
| 759 | Text.substr(0, FirstNewlinePos), Column, Style.TabWidth, Encoding); |
| 760 | |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 761 | // The last line of the token always starts in column 0. |
| 762 | // Thus, the length can be precomputed even in the presence of tabs. |
| 763 | FormatTok->LastLineColumnWidth = encoding::columnWidthWithTabs( |
| 764 | Text.substr(Text.find_last_of('\n') + 1), 0, Style.TabWidth, |
| 765 | Encoding); |
Alexander Kornienko | 6f6154c | 2013-09-10 12:29:48 +0000 | [diff] [blame] | 766 | Column = FormatTok->LastLineColumnWidth; |
Alexander Kornienko | 4b762a9 | 2013-09-02 13:58:14 +0000 | [diff] [blame] | 767 | } |
Alexander Kornienko | 83a7dcd | 2013-09-10 09:38:25 +0000 | [diff] [blame] | 768 | |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 769 | return FormatTok; |
| 770 | } |
| 771 | |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 772 | FormatToken *FormatTok; |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 773 | bool GreaterStashed; |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 774 | unsigned Column; |
Manuel Klimek | de008c0 | 2013-05-27 15:23:34 +0000 | [diff] [blame] | 775 | unsigned TrailingWhitespace; |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 776 | Lexer &Lex; |
| 777 | SourceManager &SourceMgr; |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 778 | FormatStyle &Style; |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 779 | IdentifierTable IdentTable; |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 780 | encoding::Encoding Encoding; |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 781 | llvm::SpecificBumpPtrAllocator<FormatToken> Allocator; |
| 782 | SmallVector<FormatToken *, 16> Tokens; |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 783 | |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 784 | void readRawToken(FormatToken &Tok) { |
| 785 | Lex.LexFromRawLexer(Tok.Tok); |
| 786 | Tok.TokenText = StringRef(SourceMgr.getCharacterData(Tok.Tok.getLocation()), |
| 787 | Tok.Tok.getLength()); |
Daniel Jasper | 561211d | 2013-07-16 20:28:33 +0000 | [diff] [blame] | 788 | // For formatting, treat unterminated string literals like normal string |
| 789 | // literals. |
| 790 | if (Tok.is(tok::unknown) && !Tok.TokenText.empty() && |
| 791 | Tok.TokenText[0] == '"') { |
| 792 | Tok.Tok.setKind(tok::string_literal); |
| 793 | Tok.IsUnterminatedLiteral = true; |
| 794 | } |
Alexander Kornienko | 469a21b | 2012-12-07 16:15:44 +0000 | [diff] [blame] | 795 | } |
| 796 | }; |
| 797 | |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 798 | class Formatter : public UnwrappedLineConsumer { |
| 799 | public: |
Daniel Jasper | caf42a3 | 2013-05-15 08:14:19 +0000 | [diff] [blame] | 800 | Formatter(const FormatStyle &Style, Lexer &Lex, SourceManager &SourceMgr, |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 801 | const std::vector<CharSourceRange> &Ranges) |
Daniel Jasper | caf42a3 | 2013-05-15 08:14:19 +0000 | [diff] [blame] | 802 | : Style(Style), Lex(Lex), SourceMgr(SourceMgr), |
Alexander Kornienko | 73d845c | 2013-09-11 12:25:57 +0000 | [diff] [blame] | 803 | Whitespaces(SourceMgr, Style, inputUsesCRLF(Lex.getBuffer())), |
| 804 | Ranges(Ranges), Encoding(encoding::detectEncoding(Lex.getBuffer())) { |
Daniel Jasper | 9637dda | 2013-07-15 14:33:14 +0000 | [diff] [blame] | 805 | DEBUG(llvm::dbgs() << "File encoding: " |
| 806 | << (Encoding == encoding::Encoding_UTF8 ? "UTF8" |
| 807 | : "unknown") |
| 808 | << "\n"); |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 809 | } |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 810 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 811 | virtual ~Formatter() { |
| 812 | for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
| 813 | delete AnnotatedLines[i]; |
| 814 | } |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 815 | } |
Daniel Jasper | accb0b0 | 2012-12-04 21:05:31 +0000 | [diff] [blame] | 816 | |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 817 | tooling::Replacements format() { |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 818 | FormatTokenLexer Tokens(Lex, SourceMgr, Style, Encoding); |
Manuel Klimek | 96e888b | 2013-05-28 11:55:06 +0000 | [diff] [blame] | 819 | |
| 820 | UnwrappedLineParser Parser(Style, Tokens.lex(), *this); |
Manuel Klimek | 67d080d | 2013-04-12 14:13:36 +0000 | [diff] [blame] | 821 | bool StructuralError = Parser.parse(); |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 822 | TokenAnnotator Annotator(Style, Tokens.getIdentTable().get("in")); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 823 | for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 824 | Annotator.annotate(*AnnotatedLines[i]); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 825 | } |
| 826 | deriveLocalStyle(); |
| 827 | for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 828 | Annotator.calculateFormattingInformation(*AnnotatedLines[i]); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 829 | } |
Daniel Jasper | 5999f76 | 2013-04-09 17:46:55 +0000 | [diff] [blame] | 830 | |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 831 | Annotator.setCommentLineLevels(AnnotatedLines); |
Daniel Jasper | 5999f76 | 2013-04-09 17:46:55 +0000 | [diff] [blame] | 832 | |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 833 | std::vector<int> IndentForLevel; |
| 834 | bool PreviousLineWasTouched = false; |
Daniel Jasper | 63cfb89 | 2013-10-06 11:40:08 +0000 | [diff] [blame] | 835 | const AnnotatedLine *PreviousLine = NULL; |
Daniel Jasper | 89b3a7f | 2013-05-10 13:00:49 +0000 | [diff] [blame] | 836 | bool FormatPPDirective = false; |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 837 | for (SmallVectorImpl<AnnotatedLine *>::iterator I = AnnotatedLines.begin(), |
| 838 | E = AnnotatedLines.end(); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 839 | I != E; ++I) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 840 | const AnnotatedLine &TheLine = **I; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 841 | const FormatToken *FirstTok = TheLine.First; |
| 842 | int Offset = getIndentOffset(*TheLine.First); |
Daniel Jasper | 89b3a7f | 2013-05-10 13:00:49 +0000 | [diff] [blame] | 843 | |
| 844 | // Check whether this line is part of a formatted preprocessor directive. |
Manuel Klimek | dcb3f2a | 2013-05-28 13:42:28 +0000 | [diff] [blame] | 845 | if (FirstTok->HasUnescapedNewline) |
Daniel Jasper | 89b3a7f | 2013-05-10 13:00:49 +0000 | [diff] [blame] | 846 | FormatPPDirective = false; |
| 847 | if (!FormatPPDirective && TheLine.InPPDirective && |
| 848 | (touchesLine(TheLine) || touchesPPDirective(I + 1, E))) |
| 849 | FormatPPDirective = true; |
| 850 | |
Daniel Jasper | 1fb8d88 | 2013-05-14 09:30:02 +0000 | [diff] [blame] | 851 | // Determine indent and try to merge multiple unwrapped lines. |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 852 | while (IndentForLevel.size() <= TheLine.Level) |
| 853 | IndentForLevel.push_back(-1); |
| 854 | IndentForLevel.resize(TheLine.Level + 1); |
Daniel Jasper | 1fb8d88 | 2013-05-14 09:30:02 +0000 | [diff] [blame] | 855 | unsigned Indent = getIndent(IndentForLevel, TheLine.Level); |
| 856 | if (static_cast<int>(Indent) + Offset >= 0) |
| 857 | Indent += Offset; |
| 858 | tryFitMultipleLinesInOne(Indent, I, E); |
| 859 | |
Manuel Klimek | dcb3f2a | 2013-05-28 13:42:28 +0000 | [diff] [blame] | 860 | bool WasMoved = PreviousLineWasTouched && FirstTok->NewlinesBefore == 0; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 861 | if (TheLine.First->is(tok::eof)) { |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 862 | if (PreviousLineWasTouched) { |
Manuel Klimek | dcb3f2a | 2013-05-28 13:42:28 +0000 | [diff] [blame] | 863 | unsigned NewLines = std::min(FirstTok->NewlinesBefore, 1u); |
Alexander Kornienko | 3d9ffcf | 2013-09-27 16:14:22 +0000 | [diff] [blame] | 864 | Whitespaces.replaceWhitespace(*TheLine.First, NewLines, |
| 865 | /*IndentLevel=*/0, /*Spaces=*/0, |
| 866 | /*TargetColumn=*/0); |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 867 | } |
| 868 | } else if (TheLine.Type != LT_Invalid && |
Daniel Jasper | 89b3a7f | 2013-05-10 13:00:49 +0000 | [diff] [blame] | 869 | (WasMoved || FormatPPDirective || touchesLine(TheLine))) { |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 870 | unsigned LevelIndent = getIndent(IndentForLevel, TheLine.Level); |
Manuel Klimek | dcb3f2a | 2013-05-28 13:42:28 +0000 | [diff] [blame] | 871 | if (FirstTok->WhitespaceRange.isValid() && |
Manuel Klimek | 67d080d | 2013-04-12 14:13:36 +0000 | [diff] [blame] | 872 | // Insert a break even if there is a structural error in case where |
| 873 | // we break apart a line consisting of multiple unwrapped lines. |
Manuel Klimek | dcb3f2a | 2013-05-28 13:42:28 +0000 | [diff] [blame] | 874 | (FirstTok->NewlinesBefore == 0 || !StructuralError)) { |
Daniel Jasper | 63cfb89 | 2013-10-06 11:40:08 +0000 | [diff] [blame] | 875 | formatFirstToken(*TheLine.First, PreviousLine, Indent, |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 876 | TheLine.InPPDirective); |
Manuel Klimek | 67d080d | 2013-04-12 14:13:36 +0000 | [diff] [blame] | 877 | } else { |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 878 | Indent = LevelIndent = FirstTok->OriginalColumn; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 879 | } |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 880 | ContinuationIndenter Indenter(Style, SourceMgr, Whitespaces, Encoding, |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 881 | BinPackInconclusiveFunctions); |
| 882 | |
| 883 | // If everything fits on a single line, just put it there. |
| 884 | unsigned ColumnLimit = Style.ColumnLimit; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 885 | AnnotatedLine *NextLine = *(I + 1); |
| 886 | if ((I + 1) != E && NextLine->InPPDirective && |
| 887 | !NextLine->First->HasUnescapedNewline) |
| 888 | ColumnLimit = getColumnLimit(TheLine.InPPDirective); |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 889 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 890 | if (TheLine.Last->TotalLength + Indent <= ColumnLimit) { |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 891 | LineState State = |
| 892 | Indenter.getInitialState(Indent, &TheLine, /*DryRun=*/false); |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 893 | while (State.NextToken != NULL) |
| 894 | Indenter.addTokenToState(State, false, false); |
| 895 | } else if (Style.ColumnLimit == 0) { |
| 896 | NoColumnLimitFormatter Formatter(&Indenter); |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 897 | Formatter.format(Indent, &TheLine); |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 898 | } else { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 899 | UnwrappedLineFormatter Formatter(&Indenter, &Whitespaces, Style, |
| 900 | TheLine); |
| 901 | Formatter.format(Indent); |
Daniel Jasper | 6b2afe4 | 2013-08-16 11:20:30 +0000 | [diff] [blame] | 902 | } |
| 903 | |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 904 | IndentForLevel[TheLine.Level] = LevelIndent; |
| 905 | PreviousLineWasTouched = true; |
| 906 | } else { |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 907 | // Format the first token if necessary, and notify the WhitespaceManager |
| 908 | // about the unchanged whitespace. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 909 | for (const FormatToken *Tok = TheLine.First; Tok != NULL; |
| 910 | Tok = Tok->Next) { |
| 911 | if (Tok == TheLine.First && |
| 912 | (Tok->NewlinesBefore > 0 || Tok->IsFirst)) { |
Manuel Klimek | c41e819 | 2013-08-29 15:21:40 +0000 | [diff] [blame] | 913 | unsigned LevelIndent = Tok->OriginalColumn; |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 914 | // Remove trailing whitespace of the previous line if it was |
| 915 | // touched. |
| 916 | if (PreviousLineWasTouched || touchesEmptyLineBefore(TheLine)) { |
Daniel Jasper | 63cfb89 | 2013-10-06 11:40:08 +0000 | [diff] [blame] | 917 | formatFirstToken(*Tok, PreviousLine, LevelIndent, |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 918 | TheLine.InPPDirective); |
| 919 | } else { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 920 | Whitespaces.addUntouchableToken(*Tok, TheLine.InPPDirective); |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 921 | } |
Daniel Jasper | 1fb8d88 | 2013-05-14 09:30:02 +0000 | [diff] [blame] | 922 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 923 | if (static_cast<int>(LevelIndent) - Offset >= 0) |
| 924 | LevelIndent -= Offset; |
| 925 | if (Tok->isNot(tok::comment)) |
| 926 | IndentForLevel[TheLine.Level] = LevelIndent; |
| 927 | } else { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 928 | Whitespaces.addUntouchableToken(*Tok, TheLine.InPPDirective); |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 929 | } |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 930 | } |
| 931 | // If we did not reformat this unwrapped line, the column at the end of |
| 932 | // the last token is unchanged - thus, we can calculate the end of the |
| 933 | // last token. |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 934 | PreviousLineWasTouched = false; |
| 935 | } |
Daniel Jasper | 63cfb89 | 2013-10-06 11:40:08 +0000 | [diff] [blame] | 936 | PreviousLine = *I; |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 937 | } |
| 938 | return Whitespaces.generateReplacements(); |
| 939 | } |
| 940 | |
| 941 | private: |
Alexander Kornienko | 73d845c | 2013-09-11 12:25:57 +0000 | [diff] [blame] | 942 | static bool inputUsesCRLF(StringRef Text) { |
| 943 | return Text.count('\r') * 2 > Text.count('\n'); |
| 944 | } |
| 945 | |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 946 | void deriveLocalStyle() { |
| 947 | unsigned CountBoundToVariable = 0; |
| 948 | unsigned CountBoundToType = 0; |
| 949 | bool HasCpp03IncompatibleFormat = false; |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 950 | bool HasBinPackedFunction = false; |
| 951 | bool HasOnePerLineFunction = false; |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 952 | for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 953 | if (!AnnotatedLines[i]->First->Next) |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 954 | continue; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 955 | FormatToken *Tok = AnnotatedLines[i]->First->Next; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 956 | while (Tok->Next) { |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 957 | if (Tok->Type == TT_PointerOrReference) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 958 | bool SpacesBefore = |
| 959 | Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd(); |
| 960 | bool SpacesAfter = Tok->Next->WhitespaceRange.getBegin() != |
| 961 | Tok->Next->WhitespaceRange.getEnd(); |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 962 | if (SpacesBefore && !SpacesAfter) |
| 963 | ++CountBoundToVariable; |
| 964 | else if (!SpacesBefore && SpacesAfter) |
| 965 | ++CountBoundToType; |
| 966 | } |
| 967 | |
Daniel Jasper | 29f123b | 2013-02-08 15:28:42 +0000 | [diff] [blame] | 968 | if (Tok->Type == TT_TemplateCloser && |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 969 | Tok->Previous->Type == TT_TemplateCloser && |
| 970 | Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 971 | HasCpp03IncompatibleFormat = true; |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 972 | |
| 973 | if (Tok->PackingKind == PPK_BinPacked) |
| 974 | HasBinPackedFunction = true; |
| 975 | if (Tok->PackingKind == PPK_OnePerLine) |
| 976 | HasOnePerLineFunction = true; |
| 977 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 978 | Tok = Tok->Next; |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 979 | } |
| 980 | } |
| 981 | if (Style.DerivePointerBinding) { |
| 982 | if (CountBoundToType > CountBoundToVariable) |
| 983 | Style.PointerBindsToType = true; |
| 984 | else if (CountBoundToType < CountBoundToVariable) |
| 985 | Style.PointerBindsToType = false; |
| 986 | } |
| 987 | if (Style.Standard == FormatStyle::LS_Auto) { |
| 988 | Style.Standard = HasCpp03IncompatibleFormat ? FormatStyle::LS_Cpp11 |
| 989 | : FormatStyle::LS_Cpp03; |
| 990 | } |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 991 | BinPackInconclusiveFunctions = |
| 992 | HasBinPackedFunction || !HasOnePerLineFunction; |
Daniel Jasper | 8ff690a | 2013-02-06 14:22:40 +0000 | [diff] [blame] | 993 | } |
| 994 | |
Manuel Klimek | 547d5db | 2013-02-08 17:38:27 +0000 | [diff] [blame] | 995 | /// \brief Get the indent of \p Level from \p IndentForLevel. |
| 996 | /// |
| 997 | /// \p IndentForLevel must contain the indent for the level \c l |
| 998 | /// at \p IndentForLevel[l], or a value < 0 if the indent for |
| 999 | /// that level is unknown. |
Daniel Jasper | fc75908 | 2013-02-14 14:26:07 +0000 | [diff] [blame] | 1000 | unsigned getIndent(const std::vector<int> IndentForLevel, unsigned Level) { |
Manuel Klimek | 547d5db | 2013-02-08 17:38:27 +0000 | [diff] [blame] | 1001 | if (IndentForLevel[Level] != -1) |
| 1002 | return IndentForLevel[Level]; |
Manuel Klimek | 52635ff | 2013-02-08 19:53:32 +0000 | [diff] [blame] | 1003 | if (Level == 0) |
| 1004 | return 0; |
Manuel Klimek | 07a64ec | 2013-05-13 08:42:42 +0000 | [diff] [blame] | 1005 | return getIndent(IndentForLevel, Level - 1) + Style.IndentWidth; |
Manuel Klimek | 547d5db | 2013-02-08 17:38:27 +0000 | [diff] [blame] | 1006 | } |
| 1007 | |
| 1008 | /// \brief Get the offset of the line relatively to the level. |
| 1009 | /// |
| 1010 | /// For example, 'public:' labels in classes are offset by 1 or 2 |
| 1011 | /// characters to the left from their level. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1012 | int getIndentOffset(const FormatToken &RootToken) { |
Alexander Kornienko | 94b748f | 2013-03-27 17:08:02 +0000 | [diff] [blame] | 1013 | if (RootToken.isAccessSpecifier(false) || RootToken.isObjCAccessSpecifier()) |
Manuel Klimek | 547d5db | 2013-02-08 17:38:27 +0000 | [diff] [blame] | 1014 | return Style.AccessModifierOffset; |
| 1015 | return 0; |
| 1016 | } |
| 1017 | |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1018 | /// \brief Tries to merge lines into one. |
| 1019 | /// |
| 1020 | /// This will change \c Line and \c AnnotatedLine to contain the merged line, |
| 1021 | /// if possible; note that \c I will be incremented when lines are merged. |
Daniel Jasper | 3f8cdbf | 2013-01-16 10:41:46 +0000 | [diff] [blame] | 1022 | void tryFitMultipleLinesInOne(unsigned Indent, |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1023 | SmallVectorImpl<AnnotatedLine *>::iterator &I, |
| 1024 | SmallVectorImpl<AnnotatedLine *>::iterator E) { |
Daniel Jasper | 3f8cdbf | 2013-01-16 10:41:46 +0000 | [diff] [blame] | 1025 | // We can never merge stuff if there are trailing line comments. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1026 | AnnotatedLine *TheLine = *I; |
| 1027 | if (TheLine->Last->Type == TT_LineComment) |
Daniel Jasper | 3f8cdbf | 2013-01-16 10:41:46 +0000 | [diff] [blame] | 1028 | return; |
| 1029 | |
Daniel Jasper | e05dc6d | 2013-07-24 13:10:59 +0000 | [diff] [blame] | 1030 | if (Indent > Style.ColumnLimit) |
| 1031 | return; |
| 1032 | |
Daniel Jasper | a4d4621 | 2013-02-28 11:05:57 +0000 | [diff] [blame] | 1033 | unsigned Limit = Style.ColumnLimit - Indent; |
Daniel Jasper | f11a705 | 2013-02-21 21:33:55 +0000 | [diff] [blame] | 1034 | // If we already exceed the column limit, we set 'Limit' to 0. The different |
| 1035 | // tryMerge..() functions can then decide whether to still do merging. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1036 | Limit = TheLine->Last->TotalLength > Limit |
| 1037 | ? 0 |
| 1038 | : Limit - TheLine->Last->TotalLength; |
Daniel Jasper | 55b08e7 | 2013-01-16 07:02:34 +0000 | [diff] [blame] | 1039 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1040 | if (I + 1 == E || (*(I + 1))->Type == LT_Invalid) |
Daniel Jasper | 3f8cdbf | 2013-01-16 10:41:46 +0000 | [diff] [blame] | 1041 | return; |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1042 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1043 | if (TheLine->Last->is(tok::l_brace)) { |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1044 | tryMergeSimpleBlock(I, E, Limit); |
Daniel Jasper | f11bbb9 | 2013-05-16 12:12:21 +0000 | [diff] [blame] | 1045 | } else if (Style.AllowShortIfStatementsOnASingleLine && |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1046 | TheLine->First->is(tok::kw_if)) { |
Daniel Jasper | f11bbb9 | 2013-05-16 12:12:21 +0000 | [diff] [blame] | 1047 | tryMergeSimpleControlStatement(I, E, Limit); |
| 1048 | } else if (Style.AllowShortLoopsOnASingleLine && |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1049 | TheLine->First->isOneOf(tok::kw_for, tok::kw_while)) { |
Daniel Jasper | f11bbb9 | 2013-05-16 12:12:21 +0000 | [diff] [blame] | 1050 | tryMergeSimpleControlStatement(I, E, Limit); |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1051 | } else if (TheLine->InPPDirective && (TheLine->First->HasUnescapedNewline || |
| 1052 | TheLine->First->IsFirst)) { |
Daniel Jasper | e0b15ea | 2013-01-14 15:40:57 +0000 | [diff] [blame] | 1053 | tryMergeSimplePPDirective(I, E, Limit); |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1054 | } |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1055 | } |
| 1056 | |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1057 | void tryMergeSimplePPDirective(SmallVectorImpl<AnnotatedLine *>::iterator &I, |
| 1058 | SmallVectorImpl<AnnotatedLine *>::iterator E, |
Daniel Jasper | e0b15ea | 2013-01-14 15:40:57 +0000 | [diff] [blame] | 1059 | unsigned Limit) { |
Daniel Jasper | f11a705 | 2013-02-21 21:33:55 +0000 | [diff] [blame] | 1060 | if (Limit == 0) |
| 1061 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1062 | AnnotatedLine &Line = **I; |
| 1063 | if (!(*(I + 1))->InPPDirective || (*(I + 1))->First->HasUnescapedNewline) |
Daniel Jasper | 2b9c10b | 2013-01-14 15:52:06 +0000 | [diff] [blame] | 1064 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1065 | if (I + 2 != E && (*(I + 2))->InPPDirective && |
| 1066 | !(*(I + 2))->First->HasUnescapedNewline) |
Daniel Jasper | e0b15ea | 2013-01-14 15:40:57 +0000 | [diff] [blame] | 1067 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1068 | if (1 + (*(I + 1))->Last->TotalLength > Limit) |
Daniel Jasper | 3f8cdbf | 2013-01-16 10:41:46 +0000 | [diff] [blame] | 1069 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1070 | join(Line, **(++I)); |
Daniel Jasper | e0b15ea | 2013-01-14 15:40:57 +0000 | [diff] [blame] | 1071 | } |
| 1072 | |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1073 | void |
| 1074 | tryMergeSimpleControlStatement(SmallVectorImpl<AnnotatedLine *>::iterator &I, |
| 1075 | SmallVectorImpl<AnnotatedLine *>::iterator E, |
| 1076 | unsigned Limit) { |
Daniel Jasper | f11a705 | 2013-02-21 21:33:55 +0000 | [diff] [blame] | 1077 | if (Limit == 0) |
| 1078 | return; |
Manuel Klimek | d3a247c | 2013-08-07 19:20:45 +0000 | [diff] [blame] | 1079 | if (Style.BreakBeforeBraces == FormatStyle::BS_Allman && |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1080 | (*(I + 1))->First->is(tok::l_brace)) |
Manuel Klimek | d3a247c | 2013-08-07 19:20:45 +0000 | [diff] [blame] | 1081 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1082 | if ((*(I + 1))->InPPDirective != (*I)->InPPDirective || |
| 1083 | ((*(I + 1))->InPPDirective && (*(I + 1))->First->HasUnescapedNewline)) |
Manuel Klimek | 4c12812 | 2013-01-18 14:46:43 +0000 | [diff] [blame] | 1084 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1085 | AnnotatedLine &Line = **I; |
Daniel Jasper | 55b08e7 | 2013-01-16 07:02:34 +0000 | [diff] [blame] | 1086 | if (Line.Last->isNot(tok::r_paren)) |
| 1087 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1088 | if (1 + (*(I + 1))->Last->TotalLength > Limit) |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1089 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1090 | if ((*(I + 1))->First->isOneOf(tok::semi, tok::kw_if, tok::kw_for, |
| 1091 | tok::kw_while) || |
| 1092 | (*(I + 1))->First->Type == TT_LineComment) |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1093 | return; |
| 1094 | // Only inline simple if's (no nested if or else). |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1095 | if (I + 2 != E && Line.First->is(tok::kw_if) && |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1096 | (*(I + 2))->First->is(tok::kw_else)) |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1097 | return; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1098 | join(Line, **(++I)); |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1099 | } |
| 1100 | |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1101 | void tryMergeSimpleBlock(SmallVectorImpl<AnnotatedLine *>::iterator &I, |
| 1102 | SmallVectorImpl<AnnotatedLine *>::iterator E, |
Daniel Jasper | 1a1ce83 | 2013-01-29 11:27:30 +0000 | [diff] [blame] | 1103 | unsigned Limit) { |
Daniel Jasper | 5be59ba | 2013-05-15 14:09:55 +0000 | [diff] [blame] | 1104 | // No merging if the brace already is on the next line. |
| 1105 | if (Style.BreakBeforeBraces != FormatStyle::BS_Attach) |
| 1106 | return; |
| 1107 | |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1108 | // First, check that the current line allows merging. This is the case if |
| 1109 | // we're not in a control flow statement and the last token is an opening |
| 1110 | // brace. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1111 | AnnotatedLine &Line = **I; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1112 | if (Line.First->isOneOf(tok::kw_if, tok::kw_while, tok::kw_do, tok::r_brace, |
| 1113 | tok::kw_else, tok::kw_try, tok::kw_catch, |
Daniel Jasper | 8893b8a | 2013-05-31 14:56:20 +0000 | [diff] [blame] | 1114 | tok::kw_for, |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1115 | // This gets rid of all ObjC @ keywords and methods. |
| 1116 | tok::at, tok::minus, tok::plus)) |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1117 | return; |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1118 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1119 | FormatToken *Tok = (*(I + 1))->First; |
Daniel Jasper | 8893b8a | 2013-05-31 14:56:20 +0000 | [diff] [blame] | 1120 | if (Tok->is(tok::r_brace) && !Tok->MustBreakBefore && |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 1121 | (Tok->getNextNonComment() == NULL || |
| 1122 | Tok->getNextNonComment()->is(tok::semi))) { |
Daniel Jasper | f11a705 | 2013-02-21 21:33:55 +0000 | [diff] [blame] | 1123 | // We merge empty blocks even if the line exceeds the column limit. |
Daniel Jasper | 729a743 | 2013-02-11 12:36:37 +0000 | [diff] [blame] | 1124 | Tok->SpacesRequiredBefore = 0; |
Daniel Jasper | f11a705 | 2013-02-21 21:33:55 +0000 | [diff] [blame] | 1125 | Tok->CanBreakBefore = true; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1126 | join(Line, **(I + 1)); |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1127 | I += 1; |
Daniel Jasper | 8893b8a | 2013-05-31 14:56:20 +0000 | [diff] [blame] | 1128 | } else if (Limit != 0 && Line.First->isNot(tok::kw_namespace)) { |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1129 | // Check that we still have three lines and they fit into the limit. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1130 | if (I + 2 == E || (*(I + 2))->Type == LT_Invalid || |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1131 | !nextTwoLinesFitInto(I, Limit)) |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1132 | return; |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1133 | |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1134 | // Second, check that the next line does not contain any braces - if it |
| 1135 | // does, readability declines when putting it into a single line. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1136 | if ((*(I + 1))->Last->Type == TT_LineComment || Tok->MustBreakBefore) |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1137 | return; |
| 1138 | do { |
Alexander Kornienko | e74de28 | 2013-03-13 14:41:29 +0000 | [diff] [blame] | 1139 | if (Tok->isOneOf(tok::l_brace, tok::r_brace)) |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1140 | return; |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1141 | Tok = Tok->Next; |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1142 | } while (Tok != NULL); |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1143 | |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1144 | // Last, check that the third line contains a single closing brace. |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1145 | Tok = (*(I + 2))->First; |
Alexander Kornienko | 0bdc643 | 2013-07-04 14:47:51 +0000 | [diff] [blame] | 1146 | if (Tok->getNextNonComment() != NULL || Tok->isNot(tok::r_brace) || |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1147 | Tok->MustBreakBefore) |
| 1148 | return; |
| 1149 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1150 | join(Line, **(I + 1)); |
| 1151 | join(Line, **(I + 2)); |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1152 | I += 2; |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1153 | } |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1154 | } |
| 1155 | |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1156 | bool nextTwoLinesFitInto(SmallVectorImpl<AnnotatedLine *>::iterator I, |
Daniel Jasper | feb18f5 | 2013-01-14 14:14:23 +0000 | [diff] [blame] | 1157 | unsigned Limit) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1158 | return 1 + (*(I + 1))->Last->TotalLength + 1 + |
| 1159 | (*(I + 2))->Last->TotalLength <= |
Manuel Klimek | 2f1ac41 | 2013-01-21 16:42:44 +0000 | [diff] [blame] | 1160 | Limit; |
Manuel Klimek | 517e894 | 2013-01-11 17:54:10 +0000 | [diff] [blame] | 1161 | } |
| 1162 | |
Daniel Jasper | 995e820 | 2013-01-14 13:08:07 +0000 | [diff] [blame] | 1163 | void join(AnnotatedLine &A, const AnnotatedLine &B) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1164 | assert(!A.Last->Next); |
| 1165 | assert(!B.First->Previous); |
| 1166 | A.Last->Next = B.First; |
| 1167 | B.First->Previous = A.Last; |
| 1168 | unsigned LengthA = A.Last->TotalLength + B.First->SpacesRequiredBefore; |
| 1169 | for (FormatToken *Tok = B.First; Tok; Tok = Tok->Next) { |
| 1170 | Tok->TotalLength += LengthA; |
| 1171 | A.Last = Tok; |
Daniel Jasper | 995e820 | 2013-01-14 13:08:07 +0000 | [diff] [blame] | 1172 | } |
Manuel Klimek | f9ea2ed | 2013-01-10 19:49:59 +0000 | [diff] [blame] | 1173 | } |
| 1174 | |
Daniel Jasper | 6f21a98 | 2013-03-13 07:49:51 +0000 | [diff] [blame] | 1175 | bool touchesRanges(const CharSourceRange &Range) { |
Daniel Jasper | f302354 | 2013-03-07 20:50:00 +0000 | [diff] [blame] | 1176 | for (unsigned i = 0, e = Ranges.size(); i != e; ++i) { |
| 1177 | if (!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(), |
| 1178 | Ranges[i].getBegin()) && |
| 1179 | !SourceMgr.isBeforeInTranslationUnit(Ranges[i].getEnd(), |
| 1180 | Range.getBegin())) |
| 1181 | return true; |
| 1182 | } |
| 1183 | return false; |
| 1184 | } |
| 1185 | |
| 1186 | bool touchesLine(const AnnotatedLine &TheLine) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1187 | const FormatToken *First = TheLine.First; |
| 1188 | const FormatToken *Last = TheLine.Last; |
Daniel Jasper | 84f5ddf | 2013-05-14 10:31:09 +0000 | [diff] [blame] | 1189 | CharSourceRange LineRange = CharSourceRange::getCharRange( |
Manuel Klimek | ad3094b | 2013-05-23 10:56:37 +0000 | [diff] [blame] | 1190 | First->WhitespaceRange.getBegin().getLocWithOffset( |
| 1191 | First->LastNewlineOffset), |
Alexander Kornienko | 2c2f729 | 2013-09-16 20:20:49 +0000 | [diff] [blame] | 1192 | Last->getStartOfNonWhitespace().getLocWithOffset( |
| 1193 | Last->TokenText.size() - 1)); |
Daniel Jasper | f302354 | 2013-03-07 20:50:00 +0000 | [diff] [blame] | 1194 | return touchesRanges(LineRange); |
| 1195 | } |
| 1196 | |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1197 | bool touchesPPDirective(SmallVectorImpl<AnnotatedLine *>::iterator I, |
| 1198 | SmallVectorImpl<AnnotatedLine *>::iterator E) { |
Daniel Jasper | 89b3a7f | 2013-05-10 13:00:49 +0000 | [diff] [blame] | 1199 | for (; I != E; ++I) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1200 | if ((*I)->First->HasUnescapedNewline) |
Daniel Jasper | 89b3a7f | 2013-05-10 13:00:49 +0000 | [diff] [blame] | 1201 | return false; |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1202 | if (touchesLine(**I)) |
Daniel Jasper | 89b3a7f | 2013-05-10 13:00:49 +0000 | [diff] [blame] | 1203 | return true; |
| 1204 | } |
| 1205 | return false; |
| 1206 | } |
| 1207 | |
Daniel Jasper | f302354 | 2013-03-07 20:50:00 +0000 | [diff] [blame] | 1208 | bool touchesEmptyLineBefore(const AnnotatedLine &TheLine) { |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1209 | const FormatToken *First = TheLine.First; |
Daniel Jasper | f302354 | 2013-03-07 20:50:00 +0000 | [diff] [blame] | 1210 | CharSourceRange LineRange = CharSourceRange::getCharRange( |
Manuel Klimek | ad3094b | 2013-05-23 10:56:37 +0000 | [diff] [blame] | 1211 | First->WhitespaceRange.getBegin(), |
| 1212 | First->WhitespaceRange.getBegin().getLocWithOffset( |
| 1213 | First->LastNewlineOffset)); |
Daniel Jasper | f302354 | 2013-03-07 20:50:00 +0000 | [diff] [blame] | 1214 | return touchesRanges(LineRange); |
Manuel Klimek | f9ea2ed | 2013-01-10 19:49:59 +0000 | [diff] [blame] | 1215 | } |
| 1216 | |
| 1217 | virtual void consumeUnwrappedLine(const UnwrappedLine &TheLine) { |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1218 | AnnotatedLines.push_back(new AnnotatedLine(TheLine)); |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 1219 | } |
| 1220 | |
Manuel Klimek | 3f8c7f3 | 2013-01-10 18:45:26 +0000 | [diff] [blame] | 1221 | /// \brief Add a new line and the required indent before the first Token |
| 1222 | /// of the \c UnwrappedLine if there was no structural parsing error. |
| 1223 | /// Returns the indent level of the \c UnwrappedLine. |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1224 | void formatFirstToken(const FormatToken &RootToken, |
Daniel Jasper | 63cfb89 | 2013-10-06 11:40:08 +0000 | [diff] [blame] | 1225 | const AnnotatedLine *PreviousLine, unsigned Indent, |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1226 | bool InPPDirective) { |
Daniel Jasper | 1a1ce83 | 2013-01-29 11:27:30 +0000 | [diff] [blame] | 1227 | unsigned Newlines = |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1228 | std::min(RootToken.NewlinesBefore, Style.MaxEmptyLinesToKeep + 1); |
Daniel Jasper | 15f33f0 | 2013-06-03 16:16:41 +0000 | [diff] [blame] | 1229 | // Remove empty lines before "}" where applicable. |
| 1230 | if (RootToken.is(tok::r_brace) && |
| 1231 | (!RootToken.Next || |
| 1232 | (RootToken.Next->is(tok::semi) && !RootToken.Next->Next))) |
| 1233 | Newlines = std::min(Newlines, 1u); |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1234 | if (Newlines == 0 && !RootToken.IsFirst) |
Manuel Klimek | 3f8c7f3 | 2013-01-10 18:45:26 +0000 | [diff] [blame] | 1235 | Newlines = 1; |
Manuel Klimek | 3f8c7f3 | 2013-01-10 18:45:26 +0000 | [diff] [blame] | 1236 | |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1237 | // Insert extra new line before access specifiers. |
Daniel Jasper | 63cfb89 | 2013-10-06 11:40:08 +0000 | [diff] [blame] | 1238 | if (PreviousLine && PreviousLine->Last->isOneOf(tok::semi, tok::r_brace) && |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1239 | RootToken.isAccessSpecifier() && RootToken.NewlinesBefore == 1) |
Manuel Klimek | e573c3f | 2013-05-22 12:51:29 +0000 | [diff] [blame] | 1240 | ++Newlines; |
Alexander Kornienko | 94b748f | 2013-03-27 17:08:02 +0000 | [diff] [blame] | 1241 | |
Daniel Jasper | 63cfb89 | 2013-10-06 11:40:08 +0000 | [diff] [blame] | 1242 | // Remove empty lines after access specifiers. |
| 1243 | if (PreviousLine && PreviousLine->First->isAccessSpecifier()) |
| 1244 | Newlines = std::min(1u, Newlines); |
| 1245 | |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1246 | Whitespaces.replaceWhitespace( |
Alexander Kornienko | 3d9ffcf | 2013-09-27 16:14:22 +0000 | [diff] [blame] | 1247 | RootToken, Newlines, Indent / Style.IndentWidth, Indent, Indent, |
Manuel Klimek | b398701 | 2013-05-29 14:47:47 +0000 | [diff] [blame] | 1248 | InPPDirective && !RootToken.HasUnescapedNewline); |
Manuel Klimek | 3f8c7f3 | 2013-01-10 18:45:26 +0000 | [diff] [blame] | 1249 | } |
| 1250 | |
Daniel Jasper | 567dcf9 | 2013-09-05 09:29:45 +0000 | [diff] [blame] | 1251 | unsigned getColumnLimit(bool InPPDirective) const { |
| 1252 | // In preprocessor directives reserve two chars for trailing " \" |
| 1253 | return Style.ColumnLimit - (InPPDirective ? 2 : 0); |
| 1254 | } |
| 1255 | |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 1256 | FormatStyle Style; |
| 1257 | Lexer &Lex; |
| 1258 | SourceManager &SourceMgr; |
Daniel Jasper | dcc2a62 | 2013-01-18 08:44:07 +0000 | [diff] [blame] | 1259 | WhitespaceManager Whitespaces; |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 1260 | std::vector<CharSourceRange> Ranges; |
Daniel Jasper | b77d741 | 2013-09-06 07:54:20 +0000 | [diff] [blame] | 1261 | SmallVector<AnnotatedLine *, 16> AnnotatedLines; |
Alexander Kornienko | 0089510 | 2013-06-05 14:09:10 +0000 | [diff] [blame] | 1262 | |
| 1263 | encoding::Encoding Encoding; |
Daniel Jasper | c7bd68f | 2013-07-10 14:02:49 +0000 | [diff] [blame] | 1264 | bool BinPackInconclusiveFunctions; |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 1265 | }; |
| 1266 | |
Craig Topper | 83f81d7 | 2013-06-30 22:29:28 +0000 | [diff] [blame] | 1267 | } // end anonymous namespace |
| 1268 | |
Alexander Kornienko | 70ce788 | 2013-04-15 14:28:00 +0000 | [diff] [blame] | 1269 | tooling::Replacements reformat(const FormatStyle &Style, Lexer &Lex, |
| 1270 | SourceManager &SourceMgr, |
Daniel Jasper | caf42a3 | 2013-05-15 08:14:19 +0000 | [diff] [blame] | 1271 | std::vector<CharSourceRange> Ranges) { |
| 1272 | Formatter formatter(Style, Lex, SourceMgr, Ranges); |
Daniel Jasper | bac016b | 2012-12-03 18:12:45 +0000 | [diff] [blame] | 1273 | return formatter.format(); |
| 1274 | } |
| 1275 | |
Daniel Jasper | 8a99945 | 2013-05-16 10:40:07 +0000 | [diff] [blame] | 1276 | tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, |
| 1277 | std::vector<tooling::Range> Ranges, |
| 1278 | StringRef FileName) { |
| 1279 | FileManager Files((FileSystemOptions())); |
| 1280 | DiagnosticsEngine Diagnostics( |
| 1281 | IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), |
| 1282 | new DiagnosticOptions); |
| 1283 | SourceManager SourceMgr(Diagnostics, Files); |
| 1284 | llvm::MemoryBuffer *Buf = llvm::MemoryBuffer::getMemBuffer(Code, FileName); |
| 1285 | const clang::FileEntry *Entry = |
| 1286 | Files.getVirtualFile(FileName, Buf->getBufferSize(), 0); |
| 1287 | SourceMgr.overrideFileContents(Entry, Buf); |
| 1288 | FileID ID = |
| 1289 | SourceMgr.createFileID(Entry, SourceLocation(), clang::SrcMgr::C_User); |
Alexander Kornienko | a1753f4 | 2013-06-28 12:51:24 +0000 | [diff] [blame] | 1290 | Lexer Lex(ID, SourceMgr.getBuffer(ID), SourceMgr, |
| 1291 | getFormattingLangOpts(Style.Standard)); |
Daniel Jasper | 8a99945 | 2013-05-16 10:40:07 +0000 | [diff] [blame] | 1292 | SourceLocation StartOfFile = SourceMgr.getLocForStartOfFile(ID); |
| 1293 | std::vector<CharSourceRange> CharRanges; |
| 1294 | for (unsigned i = 0, e = Ranges.size(); i != e; ++i) { |
| 1295 | SourceLocation Start = StartOfFile.getLocWithOffset(Ranges[i].getOffset()); |
| 1296 | SourceLocation End = Start.getLocWithOffset(Ranges[i].getLength()); |
| 1297 | CharRanges.push_back(CharSourceRange::getCharRange(Start, End)); |
| 1298 | } |
| 1299 | return reformat(Style, Lex, SourceMgr, CharRanges); |
| 1300 | } |
| 1301 | |
Alexander Kornienko | a1753f4 | 2013-06-28 12:51:24 +0000 | [diff] [blame] | 1302 | LangOptions getFormattingLangOpts(FormatStyle::LanguageStandard Standard) { |
Daniel Jasper | 46ef852 | 2013-01-10 13:08:12 +0000 | [diff] [blame] | 1303 | LangOptions LangOpts; |
| 1304 | LangOpts.CPlusPlus = 1; |
Alexander Kornienko | a1753f4 | 2013-06-28 12:51:24 +0000 | [diff] [blame] | 1305 | LangOpts.CPlusPlus11 = Standard == FormatStyle::LS_Cpp03 ? 0 : 1; |
Daniel Jasper | b64eca0 | 2013-03-22 10:01:29 +0000 | [diff] [blame] | 1306 | LangOpts.LineComment = 1; |
Daniel Jasper | 46ef852 | 2013-01-10 13:08:12 +0000 | [diff] [blame] | 1307 | LangOpts.Bool = 1; |
| 1308 | LangOpts.ObjC1 = 1; |
| 1309 | LangOpts.ObjC2 = 1; |
| 1310 | return LangOpts; |
| 1311 | } |
| 1312 | |
Edwin Vane | f4e12c8 | 2013-09-30 13:31:48 +0000 | [diff] [blame] | 1313 | const char *StyleOptionHelpDescription = |
| 1314 | "Coding style, currently supports:\n" |
| 1315 | " LLVM, Google, Chromium, Mozilla, WebKit.\n" |
| 1316 | "Use -style=file to load style configuration from\n" |
| 1317 | ".clang-format file located in one of the parent\n" |
| 1318 | "directories of the source file (or current\n" |
| 1319 | "directory for stdin).\n" |
| 1320 | "Use -style=\"{key: value, ...}\" to set specific\n" |
| 1321 | "parameters, e.g.:\n" |
| 1322 | " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\""; |
| 1323 | |
| 1324 | FormatStyle getStyle(StringRef StyleName, StringRef FileName) { |
| 1325 | // Fallback style in case the rest of this function can't determine a style. |
| 1326 | StringRef FallbackStyle = "LLVM"; |
| 1327 | FormatStyle Style; |
| 1328 | getPredefinedStyle(FallbackStyle, &Style); |
| 1329 | |
| 1330 | if (StyleName.startswith("{")) { |
| 1331 | // Parse YAML/JSON style from the command line. |
| 1332 | if (llvm::error_code ec = parseConfiguration(StyleName, &Style)) { |
| 1333 | llvm::errs() << "Error parsing -style: " << ec.message() |
| 1334 | << ", using " << FallbackStyle << " style\n"; |
| 1335 | } |
| 1336 | return Style; |
| 1337 | } |
| 1338 | |
| 1339 | if (!StyleName.equals_lower("file")) { |
| 1340 | if (!getPredefinedStyle(StyleName, &Style)) |
| 1341 | llvm::errs() << "Invalid value for -style, using " << FallbackStyle |
| 1342 | << " style\n"; |
| 1343 | return Style; |
| 1344 | } |
| 1345 | |
| 1346 | SmallString<128> Path(FileName); |
| 1347 | llvm::sys::fs::make_absolute(Path); |
| 1348 | for (StringRef Directory = Path; |
| 1349 | !Directory.empty(); |
| 1350 | Directory = llvm::sys::path::parent_path(Directory)) { |
| 1351 | if (!llvm::sys::fs::is_directory(Directory)) |
| 1352 | continue; |
| 1353 | SmallString<128> ConfigFile(Directory); |
| 1354 | |
| 1355 | llvm::sys::path::append(ConfigFile, ".clang-format"); |
| 1356 | DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n"); |
| 1357 | bool IsFile = false; |
| 1358 | // Ignore errors from is_regular_file: we only need to know if we can read |
| 1359 | // the file or not. |
| 1360 | llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile); |
| 1361 | |
| 1362 | if (!IsFile) { |
| 1363 | // Try _clang-format too, since dotfiles are not commonly used on Windows. |
| 1364 | ConfigFile = Directory; |
| 1365 | llvm::sys::path::append(ConfigFile, "_clang-format"); |
| 1366 | DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n"); |
| 1367 | llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile); |
| 1368 | } |
| 1369 | |
| 1370 | if (IsFile) { |
| 1371 | OwningPtr<llvm::MemoryBuffer> Text; |
| 1372 | if (llvm::error_code ec = llvm::MemoryBuffer::getFile(ConfigFile, Text)) { |
| 1373 | llvm::errs() << ec.message() << "\n"; |
| 1374 | continue; |
| 1375 | } |
| 1376 | if (llvm::error_code ec = parseConfiguration(Text->getBuffer(), &Style)) { |
| 1377 | llvm::errs() << "Error reading " << ConfigFile << ": " << ec.message() |
| 1378 | << "\n"; |
| 1379 | continue; |
| 1380 | } |
| 1381 | DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n"); |
| 1382 | return Style; |
| 1383 | } |
| 1384 | } |
| 1385 | llvm::errs() << "Can't find usable .clang-format, using " << FallbackStyle |
| 1386 | << " style\n"; |
| 1387 | return Style; |
| 1388 | } |
| 1389 | |
Daniel Jasper | cd16238 | 2013-01-07 13:26:07 +0000 | [diff] [blame] | 1390 | } // namespace format |
| 1391 | } // namespace clang |