1 //===--- TokenAnnotator.h - Format C++ code ---------------------*- C++ -*-===// 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 a token annotator, i.e. creates 12 /// \c AnnotatedTokens out of \c FormatTokens with required extra information. 13 /// 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_CLANG_LIB_FORMAT_TOKENANNOTATOR_H 17 #define LLVM_CLANG_LIB_FORMAT_TOKENANNOTATOR_H 18 19 #include "UnwrappedLineParser.h" 20 #include "clang/Format/Format.h" 21 #include <string> 22 23 namespace clang { 24 class SourceManager; 25 26 namespace format { 27 28 enum LineType { 29 LT_Invalid, 30 LT_ImportStatement, 31 LT_ObjCDecl, // An @interface, @implementation, or @protocol line. 32 LT_ObjCMethodDecl, 33 LT_ObjCProperty, // An @property line. 34 LT_Other, 35 LT_PreprocessorDirective, 36 LT_VirtualFunctionDecl 37 }; 38 39 class AnnotatedLine { 40 public: AnnotatedLine(const UnwrappedLine & Line)41 AnnotatedLine(const UnwrappedLine &Line) 42 : First(Line.Tokens.front().Tok), Level(Line.Level), 43 InPPDirective(Line.InPPDirective), 44 MustBeDeclaration(Line.MustBeDeclaration), MightBeFunctionDecl(false), 45 IsMultiVariableDeclStmt(false), Affected(false), 46 LeadingEmptyLinesAffected(false), ChildrenAffected(false) { 47 assert(!Line.Tokens.empty()); 48 49 // Calculate Next and Previous for all tokens. Note that we must overwrite 50 // Next and Previous for every token, as previous formatting runs might have 51 // left them in a different state. 52 First->Previous = nullptr; 53 FormatToken *Current = First; 54 for (std::list<UnwrappedLineNode>::const_iterator I = ++Line.Tokens.begin(), 55 E = Line.Tokens.end(); 56 I != E; ++I) { 57 const UnwrappedLineNode &Node = *I; 58 Current->Next = I->Tok; 59 I->Tok->Previous = Current; 60 Current = Current->Next; 61 Current->Children.clear(); 62 for (const auto &Child : Node.Children) { 63 Children.push_back(new AnnotatedLine(Child)); 64 Current->Children.push_back(Children.back()); 65 } 66 } 67 Last = Current; 68 Last->Next = nullptr; 69 } 70 ~AnnotatedLine()71 ~AnnotatedLine() { 72 for (unsigned i = 0, e = Children.size(); i != e; ++i) { 73 delete Children[i]; 74 } 75 FormatToken *Current = First; 76 while (Current) { 77 Current->Children.clear(); 78 Current->Role.reset(); 79 Current = Current->Next; 80 } 81 } 82 83 /// \c true if this line starts with the given tokens in order, ignoring 84 /// comments. startsWith(Ts...Tokens)85 template <typename... Ts> bool startsWith(Ts... Tokens) const { 86 return startsWith(First, Tokens...); 87 } 88 89 FormatToken *First; 90 FormatToken *Last; 91 92 SmallVector<AnnotatedLine *, 0> Children; 93 94 LineType Type; 95 unsigned Level; 96 bool InPPDirective; 97 bool MustBeDeclaration; 98 bool MightBeFunctionDecl; 99 bool IsMultiVariableDeclStmt; 100 101 /// \c True if this line should be formatted, i.e. intersects directly or 102 /// indirectly with one of the input ranges. 103 bool Affected; 104 105 /// \c True if the leading empty lines of this line intersect with one of the 106 /// input ranges. 107 bool LeadingEmptyLinesAffected; 108 109 /// \c True if a one of this line's children intersects with an input range. 110 bool ChildrenAffected; 111 112 private: 113 // Disallow copying. 114 AnnotatedLine(const AnnotatedLine &) = delete; 115 void operator=(const AnnotatedLine &) = delete; 116 117 template <typename A, typename... Ts> startsWith(FormatToken * Tok,A K1)118 bool startsWith(FormatToken *Tok, A K1) const { 119 while (Tok && Tok->is(tok::comment)) 120 Tok = Tok->Next; 121 return Tok && Tok->is(K1); 122 } 123 124 template <typename A, typename... Ts> startsWith(FormatToken * Tok,A K1,Ts...Tokens)125 bool startsWith(FormatToken *Tok, A K1, Ts... Tokens) const { 126 return startsWith(Tok, K1) && startsWith(Tok->Next, Tokens...); 127 } 128 }; 129 130 /// \brief Determines extra information about the tokens comprising an 131 /// \c UnwrappedLine. 132 class TokenAnnotator { 133 public: TokenAnnotator(const FormatStyle & Style,const AdditionalKeywords & Keywords)134 TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords) 135 : Style(Style), Keywords(Keywords) {} 136 137 /// \brief Adapts the indent levels of comment lines to the indent of the 138 /// subsequent line. 139 // FIXME: Can/should this be done in the UnwrappedLineParser? 140 void setCommentLineLevels(SmallVectorImpl<AnnotatedLine *> &Lines); 141 142 void annotate(AnnotatedLine &Line); 143 void calculateFormattingInformation(AnnotatedLine &Line); 144 145 private: 146 /// \brief Calculate the penalty for splitting before \c Tok. 147 unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok, 148 bool InFunctionDecl); 149 150 bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left, 151 const FormatToken &Right); 152 153 bool spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Tok); 154 155 bool mustBreakBefore(const AnnotatedLine &Line, const FormatToken &Right); 156 157 bool canBreakBefore(const AnnotatedLine &Line, const FormatToken &Right); 158 159 void printDebugInfo(const AnnotatedLine &Line); 160 161 void calculateUnbreakableTailLengths(AnnotatedLine &Line); 162 163 const FormatStyle &Style; 164 165 const AdditionalKeywords &Keywords; 166 }; 167 168 } // end namespace format 169 } // end namespace clang 170 171 #endif 172