• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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);
ObjCForCollectionStmt(EmptyShell Empty)32   explicit ObjCForCollectionStmt(EmptyShell Empty) :
33     Stmt(ObjCForCollectionStmtClass, Empty) { }
34 
getElement()35   Stmt *getElement() { return SubExprs[ELEM]; }
getCollection()36   Expr *getCollection() {
37     return reinterpret_cast<Expr*>(SubExprs[COLLECTION]);
38   }
getBody()39   Stmt *getBody() { return SubExprs[BODY]; }
40 
getElement()41   const Stmt *getElement() const { return SubExprs[ELEM]; }
getCollection()42   const Expr *getCollection() const {
43     return reinterpret_cast<Expr*>(SubExprs[COLLECTION]);
44   }
getBody()45   const Stmt *getBody() const { return SubExprs[BODY]; }
46 
setElement(Stmt * S)47   void setElement(Stmt *S) { SubExprs[ELEM] = S; }
setCollection(Expr * E)48   void setCollection(Expr *E) {
49     SubExprs[COLLECTION] = reinterpret_cast<Stmt*>(E);
50   }
setBody(Stmt * S)51   void setBody(Stmt *S) { SubExprs[BODY] = S; }
52 
getForLoc()53   SourceLocation getForLoc() const { return ForLoc; }
setForLoc(SourceLocation Loc)54   void setForLoc(SourceLocation Loc) { ForLoc = Loc; }
getRParenLoc()55   SourceLocation getRParenLoc() const { return RParenLoc; }
setRParenLoc(SourceLocation Loc)56   void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; }
57 
getLocStart()58   SourceLocation getLocStart() const LLVM_READONLY { return ForLoc; }
getLocEnd()59   SourceLocation getLocEnd() const LLVM_READONLY {
60     return SubExprs[BODY]->getLocEnd();
61   }
62 
classof(const Stmt * T)63   static bool classof(const Stmt *T) {
64     return T->getStmtClass() == ObjCForCollectionStmtClass;
65   }
66 
67   // Iterators
children()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:
ObjCAtCatchStmt(SourceLocation atCatchLoc,SourceLocation rparenloc,VarDecl * catchVarDecl,Stmt * atCatchStmt)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 
ObjCAtCatchStmt(EmptyShell Empty)87   explicit ObjCAtCatchStmt(EmptyShell Empty) :
88     Stmt(ObjCAtCatchStmtClass, Empty) { }
89 
getCatchBody()90   const Stmt *getCatchBody() const { return Body; }
getCatchBody()91   Stmt *getCatchBody() { return Body; }
setCatchBody(Stmt * S)92   void setCatchBody(Stmt *S) { Body = S; }
93 
getCatchParamDecl()94   const VarDecl *getCatchParamDecl() const {
95     return ExceptionDecl;
96   }
getCatchParamDecl()97   VarDecl *getCatchParamDecl() {
98     return ExceptionDecl;
99   }
setCatchParamDecl(VarDecl * D)100   void setCatchParamDecl(VarDecl *D) { ExceptionDecl = D; }
101 
getAtCatchLoc()102   SourceLocation getAtCatchLoc() const { return AtCatchLoc; }
setAtCatchLoc(SourceLocation Loc)103   void setAtCatchLoc(SourceLocation Loc) { AtCatchLoc = Loc; }
getRParenLoc()104   SourceLocation getRParenLoc() const { return RParenLoc; }
setRParenLoc(SourceLocation Loc)105   void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; }
106 
getLocStart()107   SourceLocation getLocStart() const LLVM_READONLY { return AtCatchLoc; }
getLocEnd()108   SourceLocation getLocEnd() const LLVM_READONLY { return Body->getLocEnd(); }
109 
hasEllipsis()110   bool hasEllipsis() const { return getCatchParamDecl() == nullptr; }
111 
classof(const Stmt * T)112   static bool classof(const Stmt *T) {
113     return T->getStmtClass() == ObjCAtCatchStmtClass;
114   }
115 
children()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:
ObjCAtFinallyStmt(SourceLocation atFinallyLoc,Stmt * atFinallyStmt)125   ObjCAtFinallyStmt(SourceLocation atFinallyLoc, Stmt *atFinallyStmt)
126       : Stmt(ObjCAtFinallyStmtClass), AtFinallyLoc(atFinallyLoc),
127         AtFinallyStmt(atFinallyStmt) {}
128 
ObjCAtFinallyStmt(EmptyShell Empty)129   explicit ObjCAtFinallyStmt(EmptyShell Empty) :
130     Stmt(ObjCAtFinallyStmtClass, Empty) { }
131 
getFinallyBody()132   const Stmt *getFinallyBody() const { return AtFinallyStmt; }
getFinallyBody()133   Stmt *getFinallyBody() { return AtFinallyStmt; }
setFinallyBody(Stmt * S)134   void setFinallyBody(Stmt *S) { AtFinallyStmt = S; }
135 
getLocStart()136   SourceLocation getLocStart() const LLVM_READONLY { return AtFinallyLoc; }
getLocEnd()137   SourceLocation getLocEnd() const LLVM_READONLY {
138     return AtFinallyStmt->getLocEnd();
139   }
140 
getAtFinallyLoc()141   SourceLocation getAtFinallyLoc() const { return AtFinallyLoc; }
setAtFinallyLoc(SourceLocation Loc)142   void setAtFinallyLoc(SourceLocation Loc) { AtFinallyLoc = Loc; }
143 
classof(const Stmt * T)144   static bool classof(const Stmt *T) {
145     return T->getStmtClass() == ObjCAtFinallyStmtClass;
146   }
147 
children()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).
getStmts()170   Stmt **getStmts() { return reinterpret_cast<Stmt **> (this + 1); }
getStmts()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 
ObjCAtTryStmt(EmptyShell Empty,unsigned NumCatchStmts,bool HasFinally)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.
getAtTryLoc()193   SourceLocation getAtTryLoc() const { return AtTryLoc; }
setAtTryLoc(SourceLocation Loc)194   void setAtTryLoc(SourceLocation Loc) { AtTryLoc = Loc; }
195 
196   /// \brief Retrieve the \@try body.
getTryBody()197   const Stmt *getTryBody() const { return getStmts()[0]; }
getTryBody()198   Stmt *getTryBody() { return getStmts()[0]; }
setTryBody(Stmt * S)199   void setTryBody(Stmt *S) { getStmts()[0] = S; }
200 
201   /// \brief Retrieve the number of \@catch statements in this try-catch-finally
202   /// block.
getNumCatchStmts()203   unsigned getNumCatchStmts() const { return NumCatchStmts; }
204 
205   /// \brief Retrieve a \@catch statement.
getCatchStmt(unsigned I)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.
getCatchStmt(unsigned I)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.
setCatchStmt(unsigned I,ObjCAtCatchStmt * S)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.
getFinallyStmt()224   const ObjCAtFinallyStmt *getFinallyStmt() const {
225     if (!HasFinally)
226       return nullptr;
227 
228     return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
229   }
getFinallyStmt()230   ObjCAtFinallyStmt *getFinallyStmt() {
231     if (!HasFinally)
232       return nullptr;
233 
234     return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
235   }
setFinallyStmt(Stmt * S)236   void setFinallyStmt(Stmt *S) {
237     assert(HasFinally && "@try does not have a @finally slot!");
238     getStmts()[1 + NumCatchStmts] = S;
239   }
240 
getLocStart()241   SourceLocation getLocStart() const LLVM_READONLY { return AtTryLoc; }
242   SourceLocation getLocEnd() const LLVM_READONLY;
243 
classof(const Stmt * T)244   static bool classof(const Stmt *T) {
245     return T->getStmtClass() == ObjCAtTryStmtClass;
246   }
247 
children()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:
ObjCAtSynchronizedStmt(SourceLocation atSynchronizedLoc,Stmt * synchExpr,Stmt * synchBody)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   }
ObjCAtSynchronizedStmt(EmptyShell Empty)276   explicit ObjCAtSynchronizedStmt(EmptyShell Empty) :
277     Stmt(ObjCAtSynchronizedStmtClass, Empty) { }
278 
getAtSynchronizedLoc()279   SourceLocation getAtSynchronizedLoc() const { return AtSynchronizedLoc; }
setAtSynchronizedLoc(SourceLocation Loc)280   void setAtSynchronizedLoc(SourceLocation Loc) { AtSynchronizedLoc = Loc; }
281 
getSynchBody()282   const CompoundStmt *getSynchBody() const {
283     return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
284   }
getSynchBody()285   CompoundStmt *getSynchBody() {
286     return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
287   }
setSynchBody(Stmt * S)288   void setSynchBody(Stmt *S) { SubStmts[SYNC_BODY] = S; }
289 
getSynchExpr()290   const Expr *getSynchExpr() const {
291     return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
292   }
getSynchExpr()293   Expr *getSynchExpr() {
294     return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
295   }
setSynchExpr(Stmt * S)296   void setSynchExpr(Stmt *S) { SubStmts[SYNC_EXPR] = S; }
297 
getLocStart()298   SourceLocation getLocStart() const LLVM_READONLY { return AtSynchronizedLoc; }
getLocEnd()299   SourceLocation getLocEnd() const LLVM_READONLY {
300     return getSynchBody()->getLocEnd();
301   }
302 
classof(const Stmt * T)303   static bool classof(const Stmt *T) {
304     return T->getStmtClass() == ObjCAtSynchronizedStmtClass;
305   }
306 
children()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:
ObjCAtThrowStmt(SourceLocation atThrowLoc,Stmt * throwExpr)318   ObjCAtThrowStmt(SourceLocation atThrowLoc, Stmt *throwExpr)
319   : Stmt(ObjCAtThrowStmtClass), Throw(throwExpr) {
320     AtThrowLoc = atThrowLoc;
321   }
ObjCAtThrowStmt(EmptyShell Empty)322   explicit ObjCAtThrowStmt(EmptyShell Empty) :
323     Stmt(ObjCAtThrowStmtClass, Empty) { }
324 
getThrowExpr()325   const Expr *getThrowExpr() const { return reinterpret_cast<Expr*>(Throw); }
getThrowExpr()326   Expr *getThrowExpr() { return reinterpret_cast<Expr*>(Throw); }
setThrowExpr(Stmt * S)327   void setThrowExpr(Stmt *S) { Throw = S; }
328 
getThrowLoc()329   SourceLocation getThrowLoc() const LLVM_READONLY { return AtThrowLoc; }
setThrowLoc(SourceLocation Loc)330   void setThrowLoc(SourceLocation Loc) { AtThrowLoc = Loc; }
331 
getLocStart()332   SourceLocation getLocStart() const LLVM_READONLY { return AtThrowLoc; }
getLocEnd()333   SourceLocation getLocEnd() const LLVM_READONLY {
334     return Throw ? Throw->getLocEnd() : AtThrowLoc;
335   }
336 
classof(const Stmt * T)337   static bool classof(const Stmt *T) {
338     return T->getStmtClass() == ObjCAtThrowStmtClass;
339   }
340 
children()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:
ObjCAutoreleasePoolStmt(SourceLocation atLoc,Stmt * subStmt)350   ObjCAutoreleasePoolStmt(SourceLocation atLoc, Stmt *subStmt)
351       : Stmt(ObjCAutoreleasePoolStmtClass), AtLoc(atLoc), SubStmt(subStmt) {}
352 
ObjCAutoreleasePoolStmt(EmptyShell Empty)353   explicit ObjCAutoreleasePoolStmt(EmptyShell Empty) :
354     Stmt(ObjCAutoreleasePoolStmtClass, Empty) { }
355 
getSubStmt()356   const Stmt *getSubStmt() const { return SubStmt; }
getSubStmt()357   Stmt *getSubStmt() { return SubStmt; }
setSubStmt(Stmt * S)358   void setSubStmt(Stmt *S) { SubStmt = S; }
359 
getLocStart()360   SourceLocation getLocStart() const LLVM_READONLY { return AtLoc; }
getLocEnd()361   SourceLocation getLocEnd() const LLVM_READONLY { return SubStmt->getLocEnd();}
362 
getAtLoc()363   SourceLocation getAtLoc() const { return AtLoc; }
setAtLoc(SourceLocation Loc)364   void setAtLoc(SourceLocation Loc) { AtLoc = Loc; }
365 
classof(const Stmt * T)366   static bool classof(const Stmt *T) {
367     return T->getStmtClass() == ObjCAutoreleasePoolStmtClass;
368   }
369 
children()370   child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
371 };
372 
373 }  // end namespace clang
374 
375 #endif
376