StmtObjC.h revision dab7845798d673cabeef792451354aeb394cdd54 
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
19namespace clang {
20
21/// \brief Represents Objective-C's collection statement.
22///
23/// This is represented as 'for (element 'in' collection-expression)' stmt.
24class 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;
29public:
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.
74class ObjCAtCatchStmt : public Stmt {
75private:
76  VarDecl *ExceptionDecl;
77  Stmt *Body;
78  SourceLocation AtCatchLoc, RParenLoc;
79
80public:
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() == 0; }
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
120class ObjCAtFinallyStmt : public Stmt {
121  Stmt *AtFinallyStmt;
122  SourceLocation AtFinallyLoc;
123public:
124  ObjCAtFinallyStmt(SourceLocation atFinallyLoc, Stmt *atFinallyStmt)
125  : Stmt(ObjCAtFinallyStmtClass),
126    AtFinallyStmt(atFinallyStmt), AtFinallyLoc(atFinallyLoc) {}
127
128  explicit ObjCAtFinallyStmt(EmptyShell Empty) :
129    Stmt(ObjCAtFinallyStmtClass, Empty) { }
130
131  const Stmt *getFinallyBody() const { return AtFinallyStmt; }
132  Stmt *getFinallyBody() { return AtFinallyStmt; }
133  void setFinallyBody(Stmt *S) { AtFinallyStmt = S; }
134
135  SourceLocation getLocStart() const LLVM_READONLY { return AtFinallyLoc; }
136  SourceLocation getLocEnd() const LLVM_READONLY {
137    return AtFinallyStmt->getLocEnd();
138  }
139
140  SourceLocation getAtFinallyLoc() const { return AtFinallyLoc; }
141  void setAtFinallyLoc(SourceLocation Loc) { AtFinallyLoc = Loc; }
142
143  static bool classof(const Stmt *T) {
144    return T->getStmtClass() == ObjCAtFinallyStmtClass;
145  }
146
147  child_range children() {
148    return child_range(&AtFinallyStmt, &AtFinallyStmt+1);
149  }
150};
151
152/// \brief Represents Objective-C's \@try ... \@catch ... \@finally statement.
153class ObjCAtTryStmt : public Stmt {
154private:
155  // The location of the @ in the \@try.
156  SourceLocation AtTryLoc;
157
158  // The number of catch blocks in this statement.
159  unsigned NumCatchStmts : 16;
160
161  // Whether this statement has a \@finally statement.
162  bool HasFinally : 1;
163
164  /// \brief Retrieve the statements that are stored after this \@try statement.
165  ///
166  /// The order of the statements in memory follows the order in the source,
167  /// with the \@try body first, followed by the \@catch statements (if any)
168  /// and, finally, the \@finally (if it exists).
169  Stmt **getStmts() { return reinterpret_cast<Stmt **> (this + 1); }
170  const Stmt* const *getStmts() const {
171    return reinterpret_cast<const Stmt * const*> (this + 1);
172  }
173
174  ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
175                Stmt **CatchStmts, unsigned NumCatchStmts,
176                Stmt *atFinallyStmt);
177
178  explicit ObjCAtTryStmt(EmptyShell Empty, unsigned NumCatchStmts,
179                         bool HasFinally)
180    : Stmt(ObjCAtTryStmtClass, Empty), NumCatchStmts(NumCatchStmts),
181      HasFinally(HasFinally) { }
182
183public:
184  static ObjCAtTryStmt *Create(const ASTContext &Context,
185                               SourceLocation atTryLoc, Stmt *atTryStmt,
186                               Stmt **CatchStmts, unsigned NumCatchStmts,
187                               Stmt *atFinallyStmt);
188  static ObjCAtTryStmt *CreateEmpty(const ASTContext &Context,
189                                    unsigned NumCatchStmts, bool HasFinally);
190
191  /// \brief Retrieve the location of the @ in the \@try.
192  SourceLocation getAtTryLoc() const { return AtTryLoc; }
193  void setAtTryLoc(SourceLocation Loc) { AtTryLoc = Loc; }
194
195  /// \brief Retrieve the \@try body.
196  const Stmt *getTryBody() const { return getStmts()[0]; }
197  Stmt *getTryBody() { return getStmts()[0]; }
198  void setTryBody(Stmt *S) { getStmts()[0] = S; }
199
200  /// \brief Retrieve the number of \@catch statements in this try-catch-finally
201  /// block.
202  unsigned getNumCatchStmts() const { return NumCatchStmts; }
203
204  /// \brief Retrieve a \@catch statement.
205  const ObjCAtCatchStmt *getCatchStmt(unsigned I) const {
206    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
207    return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]);
208  }
209
210  /// \brief Retrieve a \@catch statement.
211  ObjCAtCatchStmt *getCatchStmt(unsigned I) {
212    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
213    return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]);
214  }
215
216  /// \brief Set a particular catch statement.
217  void setCatchStmt(unsigned I, ObjCAtCatchStmt *S) {
218    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
219    getStmts()[I + 1] = S;
220  }
221
222  /// \brief Retrieve the \@finally statement, if any.
223  const ObjCAtFinallyStmt *getFinallyStmt() const {
224    if (!HasFinally)
225      return 0;
226
227    return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
228  }
229  ObjCAtFinallyStmt *getFinallyStmt() {
230    if (!HasFinally)
231      return 0;
232
233    return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
234  }
235  void setFinallyStmt(Stmt *S) {
236    assert(HasFinally && "@try does not have a @finally slot!");
237    getStmts()[1 + NumCatchStmts] = S;
238  }
239
240  SourceLocation getLocStart() const LLVM_READONLY { return AtTryLoc; }
241  SourceLocation getLocEnd() const LLVM_READONLY;
242
243  static bool classof(const Stmt *T) {
244    return T->getStmtClass() == ObjCAtTryStmtClass;
245  }
246
247  child_range children() {
248    return child_range(getStmts(),
249                       getStmts() + 1 + NumCatchStmts + HasFinally);
250  }
251};
252
253/// \brief Represents Objective-C's \@synchronized statement.
254///
255/// Example:
256/// \code
257///   @synchronized (sem) {
258///     do-something;
259///   }
260/// \endcode
261class ObjCAtSynchronizedStmt : public Stmt {
262private:
263  enum { SYNC_EXPR, SYNC_BODY, END_EXPR };
264  Stmt* SubStmts[END_EXPR];
265  SourceLocation AtSynchronizedLoc;
266
267public:
268  ObjCAtSynchronizedStmt(SourceLocation atSynchronizedLoc, Stmt *synchExpr,
269                         Stmt *synchBody)
270  : Stmt(ObjCAtSynchronizedStmtClass) {
271    SubStmts[SYNC_EXPR] = synchExpr;
272    SubStmts[SYNC_BODY] = synchBody;
273    AtSynchronizedLoc = atSynchronizedLoc;
274  }
275  explicit ObjCAtSynchronizedStmt(EmptyShell Empty) :
276    Stmt(ObjCAtSynchronizedStmtClass, Empty) { }
277
278  SourceLocation getAtSynchronizedLoc() const { return AtSynchronizedLoc; }
279  void setAtSynchronizedLoc(SourceLocation Loc) { AtSynchronizedLoc = Loc; }
280
281  const CompoundStmt *getSynchBody() const {
282    return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
283  }
284  CompoundStmt *getSynchBody() {
285    return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
286  }
287  void setSynchBody(Stmt *S) { SubStmts[SYNC_BODY] = S; }
288
289  const Expr *getSynchExpr() const {
290    return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
291  }
292  Expr *getSynchExpr() {
293    return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
294  }
295  void setSynchExpr(Stmt *S) { SubStmts[SYNC_EXPR] = S; }
296
297  SourceLocation getLocStart() const LLVM_READONLY { return AtSynchronizedLoc; }
298  SourceLocation getLocEnd() const LLVM_READONLY {
299    return getSynchBody()->getLocEnd();
300  }
301
302  static bool classof(const Stmt *T) {
303    return T->getStmtClass() == ObjCAtSynchronizedStmtClass;
304  }
305
306  child_range children() {
307    return child_range(&SubStmts[0], &SubStmts[0]+END_EXPR);
308  }
309};
310
311/// \brief Represents Objective-C's \@throw statement.
312class ObjCAtThrowStmt : public Stmt {
313  Stmt *Throw;
314  SourceLocation AtThrowLoc;
315public:
316  ObjCAtThrowStmt(SourceLocation atThrowLoc, Stmt *throwExpr)
317  : Stmt(ObjCAtThrowStmtClass), Throw(throwExpr) {
318    AtThrowLoc = atThrowLoc;
319  }
320  explicit ObjCAtThrowStmt(EmptyShell Empty) :
321    Stmt(ObjCAtThrowStmtClass, Empty) { }
322
323  const Expr *getThrowExpr() const { return reinterpret_cast<Expr*>(Throw); }
324  Expr *getThrowExpr() { return reinterpret_cast<Expr*>(Throw); }
325  void setThrowExpr(Stmt *S) { Throw = S; }
326
327  SourceLocation getThrowLoc() { return AtThrowLoc; }
328  void setThrowLoc(SourceLocation Loc) { AtThrowLoc = Loc; }
329
330  SourceLocation getLocStart() const LLVM_READONLY { return AtThrowLoc; }
331  SourceLocation getLocEnd() const LLVM_READONLY {
332    return Throw ? Throw->getLocEnd() : AtThrowLoc;
333  }
334
335  static bool classof(const Stmt *T) {
336    return T->getStmtClass() == ObjCAtThrowStmtClass;
337  }
338
339  child_range children() { return child_range(&Throw, &Throw+1); }
340};
341
342/// \brief Represents Objective-C's \@autoreleasepool Statement
343class ObjCAutoreleasePoolStmt : public Stmt {
344  Stmt *SubStmt;
345  SourceLocation AtLoc;
346public:
347  ObjCAutoreleasePoolStmt(SourceLocation atLoc,
348                            Stmt *subStmt)
349  : Stmt(ObjCAutoreleasePoolStmtClass),
350    SubStmt(subStmt), AtLoc(atLoc) {}
351
352  explicit ObjCAutoreleasePoolStmt(EmptyShell Empty) :
353    Stmt(ObjCAutoreleasePoolStmtClass, Empty) { }
354
355  const Stmt *getSubStmt() const { return SubStmt; }
356  Stmt *getSubStmt() { return SubStmt; }
357  void setSubStmt(Stmt *S) { SubStmt = S; }
358
359  SourceLocation getLocStart() const LLVM_READONLY { return AtLoc; }
360  SourceLocation getLocEnd() const LLVM_READONLY { return SubStmt->getLocEnd();}
361
362  SourceLocation getAtLoc() const { return AtLoc; }
363  void setAtLoc(SourceLocation Loc) { AtLoc = Loc; }
364
365  static bool classof(const Stmt *T) {
366    return T->getStmtClass() == ObjCAutoreleasePoolStmtClass;
367  }
368
369  child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
370};
371
372}  // end namespace clang
373
374#endif
375