1 //===--- TokenAnnotator.h - Format C++ code ---------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief This file implements a token annotator, i.e. creates
12 /// \c AnnotatedTokens out of \c FormatTokens with required extra information.
14 //===----------------------------------------------------------------------===//
16 #ifndef LLVM_CLANG_FORMAT_TOKEN_ANNOTATOR_H
17 #define LLVM_CLANG_FORMAT_TOKEN_ANNOTATOR_H
19 #include "UnwrappedLineParser.h"
20 #include "clang/Basic/OperatorPrecedence.h"
21 #include "clang/Format/Format.h"
35 TT_CtorInitializerColon,
36 TT_ImplicitStringLiteral,
45 TT_ObjCMethodSpecifier,
48 TT_OverloadedOperatorLParen,
49 TT_PointerOrReference,
50 TT_PureVirtualSpecifier,
51 TT_RangeBasedForLoopColon,
55 TT_TrailingUnaryOperator,
64 LT_PreprocessorDirective,
65 LT_VirtualFunctionDecl,
66 LT_ObjCDecl, // An @interface, @implementation, or @protocol line.
68 LT_ObjCProperty // An @property line.
71 class AnnotatedToken {
73 explicit AnnotatedToken(const FormatToken &FormatTok)
74 : FormatTok(FormatTok), Type(TT_Unknown), SpacesRequiredBefore(0),
75 CanBreakBefore(false), MustBreakBefore(false),
76 ClosesTemplateDeclaration(false), MatchingParen(NULL),
77 ParameterCount(0), BindingStrength(0), SplitPenalty(0),
78 LongestObjCSelectorName(0), Parent(NULL), FakeLParens(0),
79 FakeRParens(0), LastInChainOfCalls(false),
80 PartOfMultiVariableDeclStmt(false) {}
82 bool is(tok::TokenKind Kind) const { return FormatTok.Tok.is(Kind); }
84 bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const {
85 return is(K1) || is(K2);
88 bool isOneOf(tok::TokenKind K1, tok::TokenKind K2, tok::TokenKind K3) const {
89 return is(K1) || is(K2) || is(K3);
93 tok::TokenKind K1, tok::TokenKind K2, tok::TokenKind K3,
94 tok::TokenKind K4, tok::TokenKind K5 = tok::NUM_TOKENS,
95 tok::TokenKind K6 = tok::NUM_TOKENS, tok::TokenKind K7 = tok::NUM_TOKENS,
96 tok::TokenKind K8 = tok::NUM_TOKENS, tok::TokenKind K9 = tok::NUM_TOKENS,
97 tok::TokenKind K10 = tok::NUM_TOKENS,
98 tok::TokenKind K11 = tok::NUM_TOKENS,
99 tok::TokenKind K12 = tok::NUM_TOKENS) const {
100 return is(K1) || is(K2) || is(K3) || is(K4) || is(K5) || is(K6) || is(K7) ||
101 is(K8) || is(K9) || is(K10) || is(K11) || is(K12);
104 bool isNot(tok::TokenKind Kind) const { return FormatTok.Tok.isNot(Kind); }
106 bool isObjCAtKeyword(tok::ObjCKeywordKind Kind) const {
107 return FormatTok.Tok.isObjCAtKeyword(Kind);
110 bool isAccessSpecifier(bool ColonRequired = true) const {
111 return isOneOf(tok::kw_public, tok::kw_protected, tok::kw_private) &&
113 (!Children.empty() && Children[0].is(tok::colon)));
116 bool isObjCAccessSpecifier() const {
117 return is(tok::at) && !Children.empty() &&
118 (Children[0].isObjCAtKeyword(tok::objc_public) ||
119 Children[0].isObjCAtKeyword(tok::objc_protected) ||
120 Children[0].isObjCAtKeyword(tok::objc_package) ||
121 Children[0].isObjCAtKeyword(tok::objc_private));
124 FormatToken FormatTok;
128 unsigned SpacesRequiredBefore;
130 bool MustBreakBefore;
132 bool ClosesTemplateDeclaration;
134 AnnotatedToken *MatchingParen;
136 /// \brief Number of parameters, if this is "(", "[" or "<".
138 /// This is initialized to 1 as we don't need to distinguish functions with
139 /// 0 parameters from functions with 1 parameter. Thus, we can simply count
140 /// the number of commas.
141 unsigned ParameterCount;
143 /// \brief The total length of the line up to and including this token.
144 unsigned TotalLength;
146 // FIXME: Come up with a 'cleaner' concept.
147 /// \brief The binding strength of a token. This is a combined value of
148 /// operator precedence, parenthesis nesting, etc.
149 unsigned BindingStrength;
151 /// \brief Penalty for inserting a line break before this token.
152 unsigned SplitPenalty;
154 /// \brief If this is the first ObjC selector name in an ObjC method
155 /// definition or call, this contains the length of the longest name.
156 unsigned LongestObjCSelectorName;
158 std::vector<AnnotatedToken> Children;
159 AnnotatedToken *Parent;
161 /// \brief Insert this many fake ( before this token for correct indentation.
162 unsigned FakeLParens;
163 /// \brief Insert this many fake ) after this token for correct indentation.
164 unsigned FakeRParens;
166 /// \brief Is this the last "." or "->" in a builder-type call?
167 bool LastInChainOfCalls;
169 /// \brief Is this token part of a \c DeclStmt defining multiple variables?
171 /// Only set if \c Type == \c TT_StartOfName.
172 bool PartOfMultiVariableDeclStmt;
174 const AnnotatedToken *getPreviousNoneComment() const {
175 AnnotatedToken *Tok = Parent;
176 while (Tok != NULL && Tok->is(tok::comment))
182 class AnnotatedLine {
184 AnnotatedLine(const UnwrappedLine &Line)
185 : First(Line.Tokens.front()), Level(Line.Level),
186 InPPDirective(Line.InPPDirective),
187 MustBeDeclaration(Line.MustBeDeclaration),
188 MightBeFunctionDecl(false) {
189 assert(!Line.Tokens.empty());
190 AnnotatedToken *Current = &First;
191 for (std::list<FormatToken>::const_iterator I = ++Line.Tokens.begin(),
192 E = Line.Tokens.end();
194 Current->Children.push_back(AnnotatedToken(*I));
195 Current->Children[0].Parent = Current;
196 Current = &Current->Children[0];
200 AnnotatedLine(const AnnotatedLine &Other)
201 : First(Other.First), Type(Other.Type), Level(Other.Level),
202 InPPDirective(Other.InPPDirective),
203 MustBeDeclaration(Other.MustBeDeclaration),
204 MightBeFunctionDecl(Other.MightBeFunctionDecl) {
206 while (!Last->Children.empty()) {
207 Last->Children[0].Parent = Last;
208 Last = &Last->Children[0];
212 AnnotatedToken First;
213 AnnotatedToken *Last;
218 bool MustBeDeclaration;
219 bool MightBeFunctionDecl;
222 inline prec::Level getPrecedence(const AnnotatedToken &Tok) {
223 return getBinOpPrecedence(Tok.FormatTok.Tok.getKind(), true, true);
226 /// \brief Determines extra information about the tokens comprising an
227 /// \c UnwrappedLine.
228 class TokenAnnotator {
230 TokenAnnotator(const FormatStyle &Style, SourceManager &SourceMgr, Lexer &Lex,
231 IdentifierInfo &Ident_in)
232 : Style(Style), SourceMgr(SourceMgr), Lex(Lex), Ident_in(Ident_in) {
235 void annotate(AnnotatedLine &Line);
236 void calculateFormattingInformation(AnnotatedLine &Line);
239 /// \brief Calculate the penalty for splitting before \c Tok.
240 unsigned splitPenalty(const AnnotatedLine &Line, const AnnotatedToken &Tok);
242 bool spaceRequiredBetween(const AnnotatedLine &Line,
243 const AnnotatedToken &Left,
244 const AnnotatedToken &Right);
246 bool spaceRequiredBefore(const AnnotatedLine &Line,
247 const AnnotatedToken &Tok);
249 bool canBreakBefore(const AnnotatedLine &Line, const AnnotatedToken &Right);
251 const FormatStyle &Style;
252 SourceManager &SourceMgr;
255 // Contextual keywords:
256 IdentifierInfo &Ident_in;
259 } // end namespace format
260 } // end namespace clang
262 #endif // LLVM_CLANG_FORMAT_TOKEN_ANNOTATOR_H