1 //===--- StmtObjC.h - Classes for representing ObjC 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 /// \file 11 /// \brief Defines the Objective-C statement AST node classes. 12 13 #ifndef LLVM_CLANG_AST_STMTOBJC_H 14 #define LLVM_CLANG_AST_STMTOBJC_H 15 16 #include "clang/AST/Stmt.h" 17 #include "llvm/Support/Compiler.h" 18 19 namespace clang { 20 21 /// \brief Represents Objective-C's collection statement. 22 /// 23 /// This is represented as 'for (element 'in' collection-expression)' stmt. 24 class ObjCForCollectionStmt : public Stmt { 25 enum { ELEM, COLLECTION, BODY, END_EXPR }; 26 Stmt* SubExprs[END_EXPR]; // SubExprs[ELEM] is an expression or declstmt. 27 SourceLocation ForLoc; 28 SourceLocation RParenLoc; 29 public: 30 ObjCForCollectionStmt(Stmt *Elem, Expr *Collect, Stmt *Body, 31 SourceLocation FCL, SourceLocation RPL); 32 explicit ObjCForCollectionStmt(EmptyShell Empty) : 33 Stmt(ObjCForCollectionStmtClass, Empty) { } 34 35 Stmt *getElement() { return SubExprs[ELEM]; } 36 Expr *getCollection() { 37 return reinterpret_cast<Expr*>(SubExprs[COLLECTION]); 38 } 39 Stmt *getBody() { return SubExprs[BODY]; } 40 41 const Stmt *getElement() const { return SubExprs[ELEM]; } 42 const Expr *getCollection() const { 43 return reinterpret_cast<Expr*>(SubExprs[COLLECTION]); 44 } 45 const Stmt *getBody() const { return SubExprs[BODY]; } 46 47 void setElement(Stmt *S) { SubExprs[ELEM] = S; } 48 void setCollection(Expr *E) { 49 SubExprs[COLLECTION] = reinterpret_cast<Stmt*>(E); 50 } 51 void setBody(Stmt *S) { SubExprs[BODY] = S; } 52 53 SourceLocation getForLoc() const { return ForLoc; } 54 void setForLoc(SourceLocation Loc) { ForLoc = Loc; } 55 SourceLocation getRParenLoc() const { return RParenLoc; } 56 void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; } 57 58 SourceLocation getLocStart() const LLVM_READONLY { return ForLoc; } 59 SourceLocation getLocEnd() const LLVM_READONLY { 60 return SubExprs[BODY]->getLocEnd(); 61 } 62 63 static bool classof(const Stmt *T) { 64 return T->getStmtClass() == ObjCForCollectionStmtClass; 65 } 66 67 // Iterators 68 child_range children() { 69 return child_range(&SubExprs[0], &SubExprs[END_EXPR]); 70 } 71 }; 72 73 /// \brief Represents Objective-C's \@catch statement. 74 class ObjCAtCatchStmt : public Stmt { 75 private: 76 VarDecl *ExceptionDecl; 77 Stmt *Body; 78 SourceLocation AtCatchLoc, RParenLoc; 79 80 public: 81 ObjCAtCatchStmt(SourceLocation atCatchLoc, SourceLocation rparenloc, 82 VarDecl *catchVarDecl, 83 Stmt *atCatchStmt) 84 : Stmt(ObjCAtCatchStmtClass), ExceptionDecl(catchVarDecl), 85 Body(atCatchStmt), AtCatchLoc(atCatchLoc), RParenLoc(rparenloc) { } 86 87 explicit ObjCAtCatchStmt(EmptyShell Empty) : 88 Stmt(ObjCAtCatchStmtClass, Empty) { } 89 90 const Stmt *getCatchBody() const { return Body; } 91 Stmt *getCatchBody() { return Body; } 92 void setCatchBody(Stmt *S) { Body = S; } 93 94 const VarDecl *getCatchParamDecl() const { 95 return ExceptionDecl; 96 } 97 VarDecl *getCatchParamDecl() { 98 return ExceptionDecl; 99 } 100 void setCatchParamDecl(VarDecl *D) { ExceptionDecl = D; } 101 102 SourceLocation getAtCatchLoc() const { return AtCatchLoc; } 103 void setAtCatchLoc(SourceLocation Loc) { AtCatchLoc = Loc; } 104 SourceLocation getRParenLoc() const { return RParenLoc; } 105 void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; } 106 107 SourceLocation getLocStart() const LLVM_READONLY { return AtCatchLoc; } 108 SourceLocation getLocEnd() const LLVM_READONLY { return Body->getLocEnd(); } 109 110 bool hasEllipsis() const { return getCatchParamDecl() == nullptr; } 111 112 static bool classof(const Stmt *T) { 113 return T->getStmtClass() == ObjCAtCatchStmtClass; 114 } 115 116 child_range children() { return child_range(&Body, &Body + 1); } 117 }; 118 119 /// \brief Represents Objective-C's \@finally statement 120 class ObjCAtFinallyStmt : public Stmt { 121 SourceLocation AtFinallyLoc; 122 Stmt *AtFinallyStmt; 123 124 public: 125 ObjCAtFinallyStmt(SourceLocation atFinallyLoc, Stmt *atFinallyStmt) 126 : Stmt(ObjCAtFinallyStmtClass), AtFinallyLoc(atFinallyLoc), 127 AtFinallyStmt(atFinallyStmt) {} 128 129 explicit ObjCAtFinallyStmt(EmptyShell Empty) : 130 Stmt(ObjCAtFinallyStmtClass, Empty) { } 131 132 const Stmt *getFinallyBody() const { return AtFinallyStmt; } 133 Stmt *getFinallyBody() { return AtFinallyStmt; } 134 void setFinallyBody(Stmt *S) { AtFinallyStmt = S; } 135 136 SourceLocation getLocStart() const LLVM_READONLY { return AtFinallyLoc; } 137 SourceLocation getLocEnd() const LLVM_READONLY { 138 return AtFinallyStmt->getLocEnd(); 139 } 140 141 SourceLocation getAtFinallyLoc() const { return AtFinallyLoc; } 142 void setAtFinallyLoc(SourceLocation Loc) { AtFinallyLoc = Loc; } 143 144 static bool classof(const Stmt *T) { 145 return T->getStmtClass() == ObjCAtFinallyStmtClass; 146 } 147 148 child_range children() { 149 return child_range(&AtFinallyStmt, &AtFinallyStmt+1); 150 } 151 }; 152 153 /// \brief Represents Objective-C's \@try ... \@catch ... \@finally statement. 154 class ObjCAtTryStmt : public Stmt { 155 private: 156 // The location of the @ in the \@try. 157 SourceLocation AtTryLoc; 158 159 // The number of catch blocks in this statement. 160 unsigned NumCatchStmts : 16; 161 162 // Whether this statement has a \@finally statement. 163 bool HasFinally : 1; 164 165 /// \brief Retrieve the statements that are stored after this \@try statement. 166 /// 167 /// The order of the statements in memory follows the order in the source, 168 /// with the \@try body first, followed by the \@catch statements (if any) 169 /// and, finally, the \@finally (if it exists). 170 Stmt **getStmts() { return reinterpret_cast<Stmt **> (this + 1); } 171 const Stmt* const *getStmts() const { 172 return reinterpret_cast<const Stmt * const*> (this + 1); 173 } 174 175 ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt, 176 Stmt **CatchStmts, unsigned NumCatchStmts, 177 Stmt *atFinallyStmt); 178 179 explicit ObjCAtTryStmt(EmptyShell Empty, unsigned NumCatchStmts, 180 bool HasFinally) 181 : Stmt(ObjCAtTryStmtClass, Empty), NumCatchStmts(NumCatchStmts), 182 HasFinally(HasFinally) { } 183 184 public: 185 static ObjCAtTryStmt *Create(const ASTContext &Context, 186 SourceLocation atTryLoc, Stmt *atTryStmt, 187 Stmt **CatchStmts, unsigned NumCatchStmts, 188 Stmt *atFinallyStmt); 189 static ObjCAtTryStmt *CreateEmpty(const ASTContext &Context, 190 unsigned NumCatchStmts, bool HasFinally); 191 192 /// \brief Retrieve the location of the @ in the \@try. 193 SourceLocation getAtTryLoc() const { return AtTryLoc; } 194 void setAtTryLoc(SourceLocation Loc) { AtTryLoc = Loc; } 195 196 /// \brief Retrieve the \@try body. 197 const Stmt *getTryBody() const { return getStmts()[0]; } 198 Stmt *getTryBody() { return getStmts()[0]; } 199 void setTryBody(Stmt *S) { getStmts()[0] = S; } 200 201 /// \brief Retrieve the number of \@catch statements in this try-catch-finally 202 /// block. 203 unsigned getNumCatchStmts() const { return NumCatchStmts; } 204 205 /// \brief Retrieve a \@catch statement. 206 const ObjCAtCatchStmt *getCatchStmt(unsigned I) const { 207 assert(I < NumCatchStmts && "Out-of-bounds @catch index"); 208 return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]); 209 } 210 211 /// \brief Retrieve a \@catch statement. 212 ObjCAtCatchStmt *getCatchStmt(unsigned I) { 213 assert(I < NumCatchStmts && "Out-of-bounds @catch index"); 214 return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]); 215 } 216 217 /// \brief Set a particular catch statement. 218 void setCatchStmt(unsigned I, ObjCAtCatchStmt *S) { 219 assert(I < NumCatchStmts && "Out-of-bounds @catch index"); 220 getStmts()[I + 1] = S; 221 } 222 223 /// \brief Retrieve the \@finally statement, if any. 224 const ObjCAtFinallyStmt *getFinallyStmt() const { 225 if (!HasFinally) 226 return nullptr; 227 228 return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]); 229 } 230 ObjCAtFinallyStmt *getFinallyStmt() { 231 if (!HasFinally) 232 return nullptr; 233 234 return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]); 235 } 236 void setFinallyStmt(Stmt *S) { 237 assert(HasFinally && "@try does not have a @finally slot!"); 238 getStmts()[1 + NumCatchStmts] = S; 239 } 240 241 SourceLocation getLocStart() const LLVM_READONLY { return AtTryLoc; } 242 SourceLocation getLocEnd() const LLVM_READONLY; 243 244 static bool classof(const Stmt *T) { 245 return T->getStmtClass() == ObjCAtTryStmtClass; 246 } 247 248 child_range children() { 249 return child_range(getStmts(), 250 getStmts() + 1 + NumCatchStmts + HasFinally); 251 } 252 }; 253 254 /// \brief Represents Objective-C's \@synchronized statement. 255 /// 256 /// Example: 257 /// \code 258 /// @synchronized (sem) { 259 /// do-something; 260 /// } 261 /// \endcode 262 class ObjCAtSynchronizedStmt : public Stmt { 263 private: 264 SourceLocation AtSynchronizedLoc; 265 enum { SYNC_EXPR, SYNC_BODY, END_EXPR }; 266 Stmt* SubStmts[END_EXPR]; 267 268 public: 269 ObjCAtSynchronizedStmt(SourceLocation atSynchronizedLoc, Stmt *synchExpr, 270 Stmt *synchBody) 271 : Stmt(ObjCAtSynchronizedStmtClass) { 272 SubStmts[SYNC_EXPR] = synchExpr; 273 SubStmts[SYNC_BODY] = synchBody; 274 AtSynchronizedLoc = atSynchronizedLoc; 275 } 276 explicit ObjCAtSynchronizedStmt(EmptyShell Empty) : 277 Stmt(ObjCAtSynchronizedStmtClass, Empty) { } 278 279 SourceLocation getAtSynchronizedLoc() const { return AtSynchronizedLoc; } 280 void setAtSynchronizedLoc(SourceLocation Loc) { AtSynchronizedLoc = Loc; } 281 282 const CompoundStmt *getSynchBody() const { 283 return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]); 284 } 285 CompoundStmt *getSynchBody() { 286 return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]); 287 } 288 void setSynchBody(Stmt *S) { SubStmts[SYNC_BODY] = S; } 289 290 const Expr *getSynchExpr() const { 291 return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]); 292 } 293 Expr *getSynchExpr() { 294 return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]); 295 } 296 void setSynchExpr(Stmt *S) { SubStmts[SYNC_EXPR] = S; } 297 298 SourceLocation getLocStart() const LLVM_READONLY { return AtSynchronizedLoc; } 299 SourceLocation getLocEnd() const LLVM_READONLY { 300 return getSynchBody()->getLocEnd(); 301 } 302 303 static bool classof(const Stmt *T) { 304 return T->getStmtClass() == ObjCAtSynchronizedStmtClass; 305 } 306 307 child_range children() { 308 return child_range(&SubStmts[0], &SubStmts[0]+END_EXPR); 309 } 310 }; 311 312 /// \brief Represents Objective-C's \@throw statement. 313 class ObjCAtThrowStmt : public Stmt { 314 SourceLocation AtThrowLoc; 315 Stmt *Throw; 316 317 public: 318 ObjCAtThrowStmt(SourceLocation atThrowLoc, Stmt *throwExpr) 319 : Stmt(ObjCAtThrowStmtClass), Throw(throwExpr) { 320 AtThrowLoc = atThrowLoc; 321 } 322 explicit ObjCAtThrowStmt(EmptyShell Empty) : 323 Stmt(ObjCAtThrowStmtClass, Empty) { } 324 325 const Expr *getThrowExpr() const { return reinterpret_cast<Expr*>(Throw); } 326 Expr *getThrowExpr() { return reinterpret_cast<Expr*>(Throw); } 327 void setThrowExpr(Stmt *S) { Throw = S; } 328 329 SourceLocation getThrowLoc() { return AtThrowLoc; } 330 void setThrowLoc(SourceLocation Loc) { AtThrowLoc = Loc; } 331 332 SourceLocation getLocStart() const LLVM_READONLY { return AtThrowLoc; } 333 SourceLocation getLocEnd() const LLVM_READONLY { 334 return Throw ? Throw->getLocEnd() : AtThrowLoc; 335 } 336 337 static bool classof(const Stmt *T) { 338 return T->getStmtClass() == ObjCAtThrowStmtClass; 339 } 340 341 child_range children() { return child_range(&Throw, &Throw+1); } 342 }; 343 344 /// \brief Represents Objective-C's \@autoreleasepool Statement 345 class ObjCAutoreleasePoolStmt : public Stmt { 346 SourceLocation AtLoc; 347 Stmt *SubStmt; 348 349 public: 350 ObjCAutoreleasePoolStmt(SourceLocation atLoc, Stmt *subStmt) 351 : Stmt(ObjCAutoreleasePoolStmtClass), AtLoc(atLoc), SubStmt(subStmt) {} 352 353 explicit ObjCAutoreleasePoolStmt(EmptyShell Empty) : 354 Stmt(ObjCAutoreleasePoolStmtClass, Empty) { } 355 356 const Stmt *getSubStmt() const { return SubStmt; } 357 Stmt *getSubStmt() { return SubStmt; } 358 void setSubStmt(Stmt *S) { SubStmt = S; } 359 360 SourceLocation getLocStart() const LLVM_READONLY { return AtLoc; } 361 SourceLocation getLocEnd() const LLVM_READONLY { return SubStmt->getLocEnd();} 362 363 SourceLocation getAtLoc() const { return AtLoc; } 364 void setAtLoc(SourceLocation Loc) { AtLoc = Loc; } 365 366 static bool classof(const Stmt *T) { 367 return T->getStmtClass() == ObjCAutoreleasePoolStmtClass; 368 } 369 370 child_range children() { return child_range(&SubStmt, &SubStmt + 1); } 371 }; 372 373 } // end namespace clang 374 375 #endif 376
