Line data Source code
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 0 : 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 0 : 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 0 : 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 0 : 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 0 : return child_range(getStmts(),
250 0 : 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 0 : 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 0 : 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 0 : child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
371 : };
372 :
373 : } // end namespace clang
374 :
375 : #endif
|
