1 //===--- StmtCXX.h - Classes for representing C++ statements ----*- 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 // This file defines the C++ statement AST node classes. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_AST_STMTCXX_H 15 #define LLVM_CLANG_AST_STMTCXX_H 16 17 #include "clang/AST/DeclarationName.h" 18 #include "clang/AST/Expr.h" 19 #include "clang/AST/NestedNameSpecifier.h" 20 #include "clang/AST/Stmt.h" 21 #include "llvm/Support/Compiler.h" 22 23 namespace clang { 24 25 class VarDecl; 26 27 /// CXXCatchStmt - This represents a C++ catch block. 28 /// 29 class CXXCatchStmt : public Stmt { 30 SourceLocation CatchLoc; 31 /// The exception-declaration of the type. 32 VarDecl *ExceptionDecl; 33 /// The handler block. 34 Stmt *HandlerBlock; 35 36 public: CXXCatchStmt(SourceLocation catchLoc,VarDecl * exDecl,Stmt * handlerBlock)37 CXXCatchStmt(SourceLocation catchLoc, VarDecl *exDecl, Stmt *handlerBlock) 38 : Stmt(CXXCatchStmtClass), CatchLoc(catchLoc), ExceptionDecl(exDecl), 39 HandlerBlock(handlerBlock) {} 40 CXXCatchStmt(EmptyShell Empty)41 CXXCatchStmt(EmptyShell Empty) 42 : Stmt(CXXCatchStmtClass), ExceptionDecl(nullptr), HandlerBlock(nullptr) {} 43 getLocStart()44 SourceLocation getLocStart() const LLVM_READONLY { return CatchLoc; } getLocEnd()45 SourceLocation getLocEnd() const LLVM_READONLY { 46 return HandlerBlock->getLocEnd(); 47 } 48 getCatchLoc()49 SourceLocation getCatchLoc() const { return CatchLoc; } getExceptionDecl()50 VarDecl *getExceptionDecl() const { return ExceptionDecl; } 51 QualType getCaughtType() const; getHandlerBlock()52 Stmt *getHandlerBlock() const { return HandlerBlock; } 53 classof(const Stmt * T)54 static bool classof(const Stmt *T) { 55 return T->getStmtClass() == CXXCatchStmtClass; 56 } 57 children()58 child_range children() { return child_range(&HandlerBlock, &HandlerBlock+1); } 59 60 friend class ASTStmtReader; 61 }; 62 63 /// CXXTryStmt - A C++ try block, including all handlers. 64 /// 65 class CXXTryStmt : public Stmt { 66 SourceLocation TryLoc; 67 unsigned NumHandlers; 68 69 CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock, ArrayRef<Stmt*> handlers); 70 CXXTryStmt(EmptyShell Empty,unsigned numHandlers)71 CXXTryStmt(EmptyShell Empty, unsigned numHandlers) 72 : Stmt(CXXTryStmtClass), NumHandlers(numHandlers) { } 73 getStmts()74 Stmt const * const *getStmts() const { 75 return reinterpret_cast<Stmt const * const*>(this + 1); 76 } getStmts()77 Stmt **getStmts() { 78 return reinterpret_cast<Stmt **>(this + 1); 79 } 80 81 public: 82 static CXXTryStmt *Create(const ASTContext &C, SourceLocation tryLoc, 83 Stmt *tryBlock, ArrayRef<Stmt*> handlers); 84 85 static CXXTryStmt *Create(const ASTContext &C, EmptyShell Empty, 86 unsigned numHandlers); 87 getLocStart()88 SourceLocation getLocStart() const LLVM_READONLY { return getTryLoc(); } getLocEnd()89 SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); } 90 getTryLoc()91 SourceLocation getTryLoc() const { return TryLoc; } getEndLoc()92 SourceLocation getEndLoc() const { 93 return getStmts()[NumHandlers]->getLocEnd(); 94 } 95 getTryBlock()96 CompoundStmt *getTryBlock() { 97 return cast<CompoundStmt>(getStmts()[0]); 98 } getTryBlock()99 const CompoundStmt *getTryBlock() const { 100 return cast<CompoundStmt>(getStmts()[0]); 101 } 102 getNumHandlers()103 unsigned getNumHandlers() const { return NumHandlers; } getHandler(unsigned i)104 CXXCatchStmt *getHandler(unsigned i) { 105 return cast<CXXCatchStmt>(getStmts()[i + 1]); 106 } getHandler(unsigned i)107 const CXXCatchStmt *getHandler(unsigned i) const { 108 return cast<CXXCatchStmt>(getStmts()[i + 1]); 109 } 110 classof(const Stmt * T)111 static bool classof(const Stmt *T) { 112 return T->getStmtClass() == CXXTryStmtClass; 113 } 114 children()115 child_range children() { 116 return child_range(getStmts(), getStmts() + getNumHandlers() + 1); 117 } 118 119 friend class ASTStmtReader; 120 }; 121 122 /// CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for 123 /// statement, represented as 'for (range-declarator : range-expression)'. 124 /// 125 /// This is stored in a partially-desugared form to allow full semantic 126 /// analysis of the constituent components. The original syntactic components 127 /// can be extracted using getLoopVariable and getRangeInit. 128 class CXXForRangeStmt : public Stmt { 129 SourceLocation ForLoc; 130 enum { RANGE, BEGINEND, COND, INC, LOOPVAR, BODY, END }; 131 // SubExprs[RANGE] is an expression or declstmt. 132 // SubExprs[COND] and SubExprs[INC] are expressions. 133 Stmt *SubExprs[END]; 134 SourceLocation ColonLoc; 135 SourceLocation RParenLoc; 136 public: 137 CXXForRangeStmt(DeclStmt *Range, DeclStmt *BeginEnd, 138 Expr *Cond, Expr *Inc, DeclStmt *LoopVar, Stmt *Body, 139 SourceLocation FL, SourceLocation CL, SourceLocation RPL); CXXForRangeStmt(EmptyShell Empty)140 CXXForRangeStmt(EmptyShell Empty) : Stmt(CXXForRangeStmtClass, Empty) { } 141 142 143 VarDecl *getLoopVariable(); 144 Expr *getRangeInit(); 145 146 const VarDecl *getLoopVariable() const; 147 const Expr *getRangeInit() const; 148 149 getRangeStmt()150 DeclStmt *getRangeStmt() { return cast<DeclStmt>(SubExprs[RANGE]); } getBeginEndStmt()151 DeclStmt *getBeginEndStmt() { 152 return cast_or_null<DeclStmt>(SubExprs[BEGINEND]); 153 } getCond()154 Expr *getCond() { return cast_or_null<Expr>(SubExprs[COND]); } getInc()155 Expr *getInc() { return cast_or_null<Expr>(SubExprs[INC]); } getLoopVarStmt()156 DeclStmt *getLoopVarStmt() { return cast<DeclStmt>(SubExprs[LOOPVAR]); } getBody()157 Stmt *getBody() { return SubExprs[BODY]; } 158 getRangeStmt()159 const DeclStmt *getRangeStmt() const { 160 return cast<DeclStmt>(SubExprs[RANGE]); 161 } getBeginEndStmt()162 const DeclStmt *getBeginEndStmt() const { 163 return cast_or_null<DeclStmt>(SubExprs[BEGINEND]); 164 } getCond()165 const Expr *getCond() const { 166 return cast_or_null<Expr>(SubExprs[COND]); 167 } getInc()168 const Expr *getInc() const { 169 return cast_or_null<Expr>(SubExprs[INC]); 170 } getLoopVarStmt()171 const DeclStmt *getLoopVarStmt() const { 172 return cast<DeclStmt>(SubExprs[LOOPVAR]); 173 } getBody()174 const Stmt *getBody() const { return SubExprs[BODY]; } 175 setRangeInit(Expr * E)176 void setRangeInit(Expr *E) { SubExprs[RANGE] = reinterpret_cast<Stmt*>(E); } setRangeStmt(Stmt * S)177 void setRangeStmt(Stmt *S) { SubExprs[RANGE] = S; } setBeginEndStmt(Stmt * S)178 void setBeginEndStmt(Stmt *S) { SubExprs[BEGINEND] = S; } setCond(Expr * E)179 void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); } setInc(Expr * E)180 void setInc(Expr *E) { SubExprs[INC] = reinterpret_cast<Stmt*>(E); } setLoopVarStmt(Stmt * S)181 void setLoopVarStmt(Stmt *S) { SubExprs[LOOPVAR] = S; } setBody(Stmt * S)182 void setBody(Stmt *S) { SubExprs[BODY] = S; } 183 184 getForLoc()185 SourceLocation getForLoc() const { return ForLoc; } setForLoc(SourceLocation Loc)186 void setForLoc(SourceLocation Loc) { ForLoc = Loc; } getColonLoc()187 SourceLocation getColonLoc() const { return ColonLoc; } setColonLoc(SourceLocation Loc)188 void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; } getRParenLoc()189 SourceLocation getRParenLoc() const { return RParenLoc; } setRParenLoc(SourceLocation Loc)190 void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; } 191 getLocStart()192 SourceLocation getLocStart() const LLVM_READONLY { return ForLoc; } getLocEnd()193 SourceLocation getLocEnd() const LLVM_READONLY { 194 return SubExprs[BODY]->getLocEnd(); 195 } 196 classof(const Stmt * T)197 static bool classof(const Stmt *T) { 198 return T->getStmtClass() == CXXForRangeStmtClass; 199 } 200 201 // Iterators children()202 child_range children() { 203 return child_range(&SubExprs[0], &SubExprs[END]); 204 } 205 }; 206 207 /// \brief Representation of a Microsoft __if_exists or __if_not_exists 208 /// statement with a dependent name. 209 /// 210 /// The __if_exists statement can be used to include a sequence of statements 211 /// in the program only when a particular dependent name does not exist. For 212 /// example: 213 /// 214 /// \code 215 /// template<typename T> 216 /// void call_foo(T &t) { 217 /// __if_exists (T::foo) { 218 /// t.foo(); // okay: only called when T::foo exists. 219 /// } 220 /// } 221 /// \endcode 222 /// 223 /// Similarly, the __if_not_exists statement can be used to include the 224 /// statements when a particular name does not exist. 225 /// 226 /// Note that this statement only captures __if_exists and __if_not_exists 227 /// statements whose name is dependent. All non-dependent cases are handled 228 /// directly in the parser, so that they don't introduce a new scope. Clang 229 /// introduces scopes in the dependent case to keep names inside the compound 230 /// statement from leaking out into the surround statements, which would 231 /// compromise the template instantiation model. This behavior differs from 232 /// Visual C++ (which never introduces a scope), but is a fairly reasonable 233 /// approximation of the VC++ behavior. 234 class MSDependentExistsStmt : public Stmt { 235 SourceLocation KeywordLoc; 236 bool IsIfExists; 237 NestedNameSpecifierLoc QualifierLoc; 238 DeclarationNameInfo NameInfo; 239 Stmt *SubStmt; 240 241 friend class ASTReader; 242 friend class ASTStmtReader; 243 244 public: MSDependentExistsStmt(SourceLocation KeywordLoc,bool IsIfExists,NestedNameSpecifierLoc QualifierLoc,DeclarationNameInfo NameInfo,CompoundStmt * SubStmt)245 MSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, 246 NestedNameSpecifierLoc QualifierLoc, 247 DeclarationNameInfo NameInfo, 248 CompoundStmt *SubStmt) 249 : Stmt(MSDependentExistsStmtClass), 250 KeywordLoc(KeywordLoc), IsIfExists(IsIfExists), 251 QualifierLoc(QualifierLoc), NameInfo(NameInfo), 252 SubStmt(reinterpret_cast<Stmt *>(SubStmt)) { } 253 254 /// \brief Retrieve the location of the __if_exists or __if_not_exists 255 /// keyword. getKeywordLoc()256 SourceLocation getKeywordLoc() const { return KeywordLoc; } 257 258 /// \brief Determine whether this is an __if_exists statement. isIfExists()259 bool isIfExists() const { return IsIfExists; } 260 261 /// \brief Determine whether this is an __if_exists statement. isIfNotExists()262 bool isIfNotExists() const { return !IsIfExists; } 263 264 /// \brief Retrieve the nested-name-specifier that qualifies this name, if 265 /// any. getQualifierLoc()266 NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; } 267 268 /// \brief Retrieve the name of the entity we're testing for, along with 269 /// location information getNameInfo()270 DeclarationNameInfo getNameInfo() const { return NameInfo; } 271 272 /// \brief Retrieve the compound statement that will be included in the 273 /// program only if the existence of the symbol matches the initial keyword. getSubStmt()274 CompoundStmt *getSubStmt() const { 275 return reinterpret_cast<CompoundStmt *>(SubStmt); 276 } 277 getLocStart()278 SourceLocation getLocStart() const LLVM_READONLY { return KeywordLoc; } getLocEnd()279 SourceLocation getLocEnd() const LLVM_READONLY { return SubStmt->getLocEnd();} 280 children()281 child_range children() { 282 return child_range(&SubStmt, &SubStmt+1); 283 } 284 classof(const Stmt * T)285 static bool classof(const Stmt *T) { 286 return T->getStmtClass() == MSDependentExistsStmtClass; 287 } 288 }; 289 290 } // end namespace clang 291 292 #endif 293