1//===--- UnwrappedLineParser.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 contains the declaration of the UnwrappedLineParser, 12/// which turns a stream of tokens into UnwrappedLines. 13/// 14//===----------------------------------------------------------------------===// 15 16#ifndef LLVM_CLANG_LIB_FORMAT_UNWRAPPEDLINEPARSER_H 17#define LLVM_CLANG_LIB_FORMAT_UNWRAPPEDLINEPARSER_H 18 19#include "FormatToken.h" 20#include "clang/Basic/IdentifierTable.h" 21#include "clang/Format/Format.h" 22#include <list> 23#include <stack> 24 25namespace clang { 26namespace format { 27 28struct UnwrappedLineNode; 29 30/// \brief An unwrapped line is a sequence of \c Token, that we would like to 31/// put on a single line if there was no column limit. 32/// 33/// This is used as a main interface between the \c UnwrappedLineParser and the 34/// \c UnwrappedLineFormatter. The key property is that changing the formatting 35/// within an unwrapped line does not affect any other unwrapped lines. 36struct UnwrappedLine { 37 UnwrappedLine(); 38 39 // FIXME: Don't use std::list here. 40 /// \brief The \c Tokens comprising this \c UnwrappedLine. 41 std::list<UnwrappedLineNode> Tokens; 42 43 /// \brief The indent level of the \c UnwrappedLine. 44 unsigned Level; 45 46 /// \brief Whether this \c UnwrappedLine is part of a preprocessor directive. 47 bool InPPDirective; 48 49 bool MustBeDeclaration; 50}; 51 52class UnwrappedLineConsumer { 53public: 54 virtual ~UnwrappedLineConsumer() {} 55 virtual void consumeUnwrappedLine(const UnwrappedLine &Line) = 0; 56 virtual void finishRun() = 0; 57}; 58 59class FormatTokenSource; 60 61class UnwrappedLineParser { 62public: 63 UnwrappedLineParser(const FormatStyle &Style, 64 const AdditionalKeywords &Keywords, 65 ArrayRef<FormatToken *> Tokens, 66 UnwrappedLineConsumer &Callback); 67 68 void parse(); 69 70private: 71 void reset(); 72 void parseFile(); 73 void parseLevel(bool HasOpeningBrace); 74 void parseBlock(bool MustBeDeclaration, bool AddLevel = true, 75 bool MunchSemi = true); 76 void parseChildBlock(); 77 void parsePPDirective(); 78 void parsePPDefine(); 79 void parsePPIf(bool IfDef); 80 void parsePPElIf(); 81 void parsePPElse(); 82 void parsePPEndIf(); 83 void parsePPUnknown(); 84 void parseStructuralElement(); 85 bool tryToParseBracedList(); 86 bool parseBracedList(bool ContinueOnSemicolons = false); 87 void parseParens(); 88 void parseSquare(); 89 void parseIfThenElse(); 90 void parseTryCatch(); 91 void parseForOrWhileLoop(); 92 void parseDoWhile(); 93 void parseLabel(); 94 void parseCaseLabel(); 95 void parseSwitch(); 96 void parseNamespace(); 97 void parseNew(); 98 void parseAccessSpecifier(); 99 bool parseEnum(); 100 void parseJavaEnumBody(); 101 void parseRecord(); 102 void parseObjCProtocolList(); 103 void parseObjCUntilAtEnd(); 104 void parseObjCInterfaceOrImplementation(); 105 void parseObjCProtocol(); 106 void parseJavaScriptEs6ImportExport(); 107 bool tryToParseLambda(); 108 bool tryToParseLambdaIntroducer(); 109 void tryToParseJSFunction(); 110 void addUnwrappedLine(); 111 bool eof() const; 112 void nextToken(); 113 const FormatToken *getPreviousToken(); 114 void readToken(); 115 void flushComments(bool NewlineBeforeNext); 116 void pushToken(FormatToken *Tok); 117 void calculateBraceTypes(bool ExpectClassBody = false); 118 119 // Marks a conditional compilation edge (for example, an '#if', '#ifdef', 120 // '#else' or merge conflict marker). If 'Unreachable' is true, assumes 121 // this branch either cannot be taken (for example '#if false'), or should 122 // not be taken in this round. 123 void conditionalCompilationCondition(bool Unreachable); 124 void conditionalCompilationStart(bool Unreachable); 125 void conditionalCompilationAlternative(); 126 void conditionalCompilationEnd(); 127 128 bool isOnNewLine(const FormatToken &FormatTok); 129 130 // FIXME: We are constantly running into bugs where Line.Level is incorrectly 131 // subtracted from beyond 0. Introduce a method to subtract from Line.Level 132 // and use that everywhere in the Parser. 133 std::unique_ptr<UnwrappedLine> Line; 134 135 // Comments are sorted into unwrapped lines by whether they are in the same 136 // line as the previous token, or not. If not, they belong to the next token. 137 // Since the next token might already be in a new unwrapped line, we need to 138 // store the comments belonging to that token. 139 SmallVector<FormatToken *, 1> CommentsBeforeNextToken; 140 FormatToken *FormatTok; 141 bool MustBreakBeforeNextToken; 142 143 // The parsed lines. Only added to through \c CurrentLines. 144 SmallVector<UnwrappedLine, 8> Lines; 145 146 // Preprocessor directives are parsed out-of-order from other unwrapped lines. 147 // Thus, we need to keep a list of preprocessor directives to be reported 148 // after an unwarpped line that has been started was finished. 149 SmallVector<UnwrappedLine, 4> PreprocessorDirectives; 150 151 // New unwrapped lines are added via CurrentLines. 152 // Usually points to \c &Lines. While parsing a preprocessor directive when 153 // there is an unfinished previous unwrapped line, will point to 154 // \c &PreprocessorDirectives. 155 SmallVectorImpl<UnwrappedLine> *CurrentLines; 156 157 // We store for each line whether it must be a declaration depending on 158 // whether we are in a compound statement or not. 159 std::vector<bool> DeclarationScopeStack; 160 161 const FormatStyle &Style; 162 const AdditionalKeywords &Keywords; 163 164 FormatTokenSource *Tokens; 165 UnwrappedLineConsumer &Callback; 166 167 // FIXME: This is a temporary measure until we have reworked the ownership 168 // of the format tokens. The goal is to have the actual tokens created and 169 // owned outside of and handed into the UnwrappedLineParser. 170 ArrayRef<FormatToken *> AllTokens; 171 172 // Represents preprocessor branch type, so we can find matching 173 // #if/#else/#endif directives. 174 enum PPBranchKind { 175 PP_Conditional, // Any #if, #ifdef, #ifndef, #elif, block outside #if 0 176 PP_Unreachable // #if 0 or a conditional preprocessor block inside #if 0 177 }; 178 179 // Keeps a stack of currently active preprocessor branching directives. 180 SmallVector<PPBranchKind, 16> PPStack; 181 182 // The \c UnwrappedLineParser re-parses the code for each combination 183 // of preprocessor branches that can be taken. 184 // To that end, we take the same branch (#if, #else, or one of the #elif 185 // branches) for each nesting level of preprocessor branches. 186 // \c PPBranchLevel stores the current nesting level of preprocessor 187 // branches during one pass over the code. 188 int PPBranchLevel; 189 190 // Contains the current branch (#if, #else or one of the #elif branches) 191 // for each nesting level. 192 SmallVector<int, 8> PPLevelBranchIndex; 193 194 // Contains the maximum number of branches at each nesting level. 195 SmallVector<int, 8> PPLevelBranchCount; 196 197 // Contains the number of branches per nesting level we are currently 198 // in while parsing a preprocessor branch sequence. 199 // This is used to update PPLevelBranchCount at the end of a branch 200 // sequence. 201 std::stack<int> PPChainBranchIndex; 202 203 friend class ScopedLineState; 204 friend class CompoundStatementIndenter; 205}; 206 207struct UnwrappedLineNode { 208 UnwrappedLineNode() : Tok(nullptr) {} 209 UnwrappedLineNode(FormatToken *Tok) : Tok(Tok) {} 210 211 FormatToken *Tok; 212 SmallVector<UnwrappedLine, 0> Children; 213}; 214 215inline UnwrappedLine::UnwrappedLine() 216 : Level(0), InPPDirective(false), MustBeDeclaration(false) {} 217 218} // end namespace format 219} // end namespace clang 220 221#endif 222