/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/AST/StmtObjC.h

Source (jump to first uncovered line)
//===--- StmtObjC.h - Classes for representing ObjC statements --*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

/// \file
/// Defines the Objective-C statement AST node classes.

#ifndef LLVM_CLANG_AST_STMTOBJC_H
#define LLVM_CLANG_AST_STMTOBJC_H

#include "clang/AST/Stmt.h"
#include "llvm/Support/Compiler.h"

namespace clang {

/// Represents Objective-C's collection statement.
///
/// This is represented as 'for (element 'in' collection-expression)' stmt.
class ObjCForCollectionStmt : public Stmt {
  enum { ELEM, COLLECTION, BODY, END_EXPR };
  Stmt* SubExprs[END_EXPR]; // SubExprs[ELEM] is an expression or declstmt.
  SourceLocation ForLoc;
  SourceLocation RParenLoc;
public:
  ObjCForCollectionStmt(Stmt *Elem, Expr *Collect, Stmt *Body,
                        SourceLocation FCL, SourceLocation RPL);
  explicit ObjCForCollectionStmt(EmptyShell Empty) :
    Stmt(ObjCForCollectionStmtClass, Empty) { }

  Stmt *getElement() { return SubExprs[ELEM]; }
  Expr *getCollection() {
    return reinterpret_cast<Expr*>(SubExprs[COLLECTION]);
  }
  Stmt *getBody() { return SubExprs[BODY]; }

  const Stmt *getElement() const { return SubExprs[ELEM]; }
  const Expr *getCollection() const {
    return reinterpret_cast<Expr*>(SubExprs[COLLECTION]);
  }
  const Stmt *getBody() const { return SubExprs[BODY]; }

  void setElement(Stmt *S) { SubExprs[ELEM] = S; }
  void setCollection(Expr *E) {
    SubExprs[COLLECTION] = reinterpret_cast<Stmt*>(E);
  }
  void setBody(Stmt *S) { SubExprs[BODY] = S; }

  SourceLocation getForLoc() const { return ForLoc; }
  void setForLoc(SourceLocation Loc) { ForLoc = Loc; }
  SourceLocation getRParenLoc() const { return RParenLoc; }
  void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return ForLoc; }
  SourceLocation getEndLoc() const LLVM_READONLY {
    return SubExprs[BODY]->getEndLoc();
  }

  static bool classof(const Stmt *T) {
    return T->getStmtClass() == ObjCForCollectionStmtClass;
  }

  // Iterators
  child_range children() {
    return child_range(&SubExprs[0], &SubExprs[END_EXPR]);
  }

  const_child_range children() const {
    return const_child_range(&SubExprs[0], &SubExprs[END_EXPR]);
  }
};

/// Represents Objective-C's \@catch statement.
class ObjCAtCatchStmt : public Stmt {
private:
  VarDecl *ExceptionDecl;
  Stmt *Body;
  SourceLocation AtCatchLoc, RParenLoc;

public:
  ObjCAtCatchStmt(SourceLocation atCatchLoc, SourceLocation rparenloc,
                  VarDecl *catchVarDecl,
                  Stmt *atCatchStmt)
    : Stmt(ObjCAtCatchStmtClass), ExceptionDecl(catchVarDecl),
    Body(atCatchStmt), AtCatchLoc(atCatchLoc), RParenLoc(rparenloc) { }

  explicit ObjCAtCatchStmt(EmptyShell Empty) :
    Stmt(ObjCAtCatchStmtClass, Empty) { }

  const Stmt *getCatchBody() const { return Body; }
  Stmt *getCatchBody() { return Body; }
  void setCatchBody(Stmt *S) { Body = S; }

  const VarDecl *getCatchParamDecl() const {
    return ExceptionDecl;
  }
  VarDecl *getCatchParamDecl() {
    return ExceptionDecl;
  }
  void setCatchParamDecl(VarDecl *D) { ExceptionDecl = D; }

  SourceLocation getAtCatchLoc() const { return AtCatchLoc; }
  void setAtCatchLoc(SourceLocation Loc) { AtCatchLoc = Loc; }
  SourceLocation getRParenLoc() const { return RParenLoc; }
  void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return AtCatchLoc; }
  SourceLocation getEndLoc() const LLVM_READONLY { return Body->getEndLoc(); }

  bool hasEllipsis() const { return getCatchParamDecl() == nullptr; }

  static bool classof(const Stmt *T) {
    return T->getStmtClass() == ObjCAtCatchStmtClass;
  }

  child_range children() { return child_range(&Body, &Body + 1); }

  const_child_range children() const {
    return const_child_range(&Body, &Body + 1);
  }
};

/// Represents Objective-C's \@finally statement
class ObjCAtFinallyStmt : public Stmt {
  SourceLocation AtFinallyLoc;
  Stmt *AtFinallyStmt;

public:
  ObjCAtFinallyStmt(SourceLocation atFinallyLoc, Stmt *atFinallyStmt)
      : Stmt(ObjCAtFinallyStmtClass), AtFinallyLoc(atFinallyLoc),
        AtFinallyStmt(atFinallyStmt) {}

  explicit ObjCAtFinallyStmt(EmptyShell Empty) :
    Stmt(ObjCAtFinallyStmtClass, Empty) { }

  const Stmt *getFinallyBody() const { return AtFinallyStmt; }
  Stmt *getFinallyBody() { return AtFinallyStmt; }
  void setFinallyBody(Stmt *S) { AtFinallyStmt = S; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return AtFinallyLoc; }
  SourceLocation getEndLoc() const LLVM_READONLY {
    return AtFinallyStmt->getEndLoc();
  }

  SourceLocation getAtFinallyLoc() const { return AtFinallyLoc; }
  void setAtFinallyLoc(SourceLocation Loc) { AtFinallyLoc = Loc; }

  static bool classof(const Stmt *T) {
    return T->getStmtClass() == ObjCAtFinallyStmtClass;
  }

  child_range children() {
    return child_range(&AtFinallyStmt, &AtFinallyStmt+1);
  }

  const_child_range children() const {
    return const_child_range(&AtFinallyStmt, &AtFinallyStmt + 1);
  }
};

/// Represents Objective-C's \@try ... \@catch ... \@finally statement.
class ObjCAtTryStmt : public Stmt {
private:
  // The location of the @ in the \@try.
  SourceLocation AtTryLoc;

  // The number of catch blocks in this statement.
  unsigned NumCatchStmts : 16;

  // Whether this statement has a \@finally statement.
  bool HasFinally : 1;

  /// Retrieve the statements that are stored after this \@try statement.
  ///
  /// The order of the statements in memory follows the order in the source,
  /// with the \@try body first, followed by the \@catch statements (if any)
  /// and, finally, the \@finally (if it exists).
  Stmt **getStmts() { return reinterpret_cast<Stmt **> (this + 1); }
  const Stmt* const *getStmts() const {
    return reinterpret_cast<const Stmt * const*> (this + 1);
  }

  ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
                Stmt **CatchStmts, unsigned NumCatchStmts,
                Stmt *atFinallyStmt);

  explicit ObjCAtTryStmt(EmptyShell Empty, unsigned NumCatchStmts,
                         bool HasFinally)
    : Stmt(ObjCAtTryStmtClass, Empty), NumCatchStmts(NumCatchStmts),
      HasFinally(HasFinally) { }

public:
  static ObjCAtTryStmt *Create(const ASTContext &Context,
                               SourceLocation atTryLoc, Stmt *atTryStmt,
                               Stmt **CatchStmts, unsigned NumCatchStmts,
                               Stmt *atFinallyStmt);
  static ObjCAtTryStmt *CreateEmpty(const ASTContext &Context,
                                    unsigned NumCatchStmts, bool HasFinally);

  /// Retrieve the location of the @ in the \@try.
  SourceLocation getAtTryLoc() const { return AtTryLoc; }
  void setAtTryLoc(SourceLocation Loc) { AtTryLoc = Loc; }

  /// Retrieve the \@try body.
  const Stmt *getTryBody() const { return getStmts()[0]; }
  Stmt *getTryBody() { return getStmts()[0]; }
  void setTryBody(Stmt *S) { getStmts()[0] = S; }

  /// Retrieve the number of \@catch statements in this try-catch-finally
  /// block.
  unsigned getNumCatchStmts() const { return NumCatchStmts; }

  /// Retrieve a \@catch statement.
  const ObjCAtCatchStmt *getCatchStmt(unsigned I) const {
    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
    return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]);
  }

  /// Retrieve a \@catch statement.
  ObjCAtCatchStmt *getCatchStmt(unsigned I) {
    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
    return cast_or_null<ObjCAtCatchStmt>(getStmts()[I + 1]);
  }

  /// Set a particular catch statement.
  void setCatchStmt(unsigned I, ObjCAtCatchStmt *S) {
    assert(I < NumCatchStmts && "Out-of-bounds @catch index");
    getStmts()[I + 1] = S;
  }

  /// Retrieve the \@finally statement, if any.
  const ObjCAtFinallyStmt *getFinallyStmt() const {
    if (!HasFinally)
      return nullptr;

    return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
  }
  ObjCAtFinallyStmt *getFinallyStmt() {
    if (!HasFinally)
      return nullptr;

    return cast_or_null<ObjCAtFinallyStmt>(getStmts()[1 + NumCatchStmts]);
  }
  void setFinallyStmt(Stmt *S) {
    assert(HasFinally && "@try does not have a @finally slot!");
    getStmts()[1 + NumCatchStmts] = S;
  }

  SourceLocation getBeginLoc() const LLVM_READONLY { return AtTryLoc; }
  SourceLocation getEndLoc() const LLVM_READONLY;

  static bool classof(const Stmt *T) {
    return T->getStmtClass() == ObjCAtTryStmtClass;
  }

  child_range children() {
    return child_range(getStmts(),
                       getStmts() + 1 + NumCatchStmts + HasFinally);
  }

  const_child_range children() const {
    return const_child_range(const_cast<ObjCAtTryStmt *>(this)->children());
  }
};

/// Represents Objective-C's \@synchronized statement.
///
/// Example:
/// \code
///   @synchronized (sem) {
///     do-something;
///   }
/// \endcode
class ObjCAtSynchronizedStmt : public Stmt {
private:
  SourceLocation AtSynchronizedLoc;
  enum { SYNC_EXPR, SYNC_BODY, END_EXPR };
  Stmt* SubStmts[END_EXPR];

public:
  ObjCAtSynchronizedStmt(SourceLocation atSynchronizedLoc, Stmt *synchExpr,
                         Stmt *synchBody)
  : Stmt(ObjCAtSynchronizedStmtClass) {
    SubStmts[SYNC_EXPR] = synchExpr;
    SubStmts[SYNC_BODY] = synchBody;
    AtSynchronizedLoc = atSynchronizedLoc;
  }
  explicit ObjCAtSynchronizedStmt(EmptyShell Empty) :
    Stmt(ObjCAtSynchronizedStmtClass, Empty) { }

  SourceLocation getAtSynchronizedLoc() const { return AtSynchronizedLoc; }
  void setAtSynchronizedLoc(SourceLocation Loc) { AtSynchronizedLoc = Loc; }

  const CompoundStmt *getSynchBody() const {
    return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
  }
  CompoundStmt *getSynchBody() {
    return reinterpret_cast<CompoundStmt*>(SubStmts[SYNC_BODY]);
  }
  void setSynchBody(Stmt *S) { SubStmts[SYNC_BODY] = S; }

  const Expr *getSynchExpr() const {
    return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
  }
  Expr *getSynchExpr() {
    return reinterpret_cast<Expr*>(SubStmts[SYNC_EXPR]);
  }
  void setSynchExpr(Stmt *S) { SubStmts[SYNC_EXPR] = S; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return AtSynchronizedLoc; }
  SourceLocation getEndLoc() const LLVM_READONLY {
    return getSynchBody()->getEndLoc();
  }

  static bool classof(const Stmt *T) {
    return T->getStmtClass() == ObjCAtSynchronizedStmtClass;
  }

  child_range children() {
    return child_range(&SubStmts[0], &SubStmts[0]+END_EXPR);
  }

  const_child_range children() const {
    return const_child_range(&SubStmts[0], &SubStmts[0] + END_EXPR);
  }
};

/// Represents Objective-C's \@throw statement.
class ObjCAtThrowStmt : public Stmt {
  SourceLocation AtThrowLoc;
  Stmt *Throw;

public:
  ObjCAtThrowStmt(SourceLocation atThrowLoc, Stmt *throwExpr)
  : Stmt(ObjCAtThrowStmtClass), Throw(throwExpr) {
    AtThrowLoc = atThrowLoc;
  }
  explicit ObjCAtThrowStmt(EmptyShell Empty) :
    Stmt(ObjCAtThrowStmtClass, Empty) { }

  const Expr *getThrowExpr() const { return reinterpret_cast<Expr*>(Throw); }
  Expr *getThrowExpr() { return reinterpret_cast<Expr*>(Throw); }
  void setThrowExpr(Stmt *S) { Throw = S; }

  SourceLocation getThrowLoc() const LLVM_READONLY { return AtThrowLoc; }
  void setThrowLoc(SourceLocation Loc) { AtThrowLoc = Loc; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return AtThrowLoc; }
  SourceLocation getEndLoc() const LLVM_READONLY {
    return Throw ? Throw->getEndLoc()10 : AtThrowLoc6;
  }

  static bool classof(const Stmt *T) {
    return T->getStmtClass() == ObjCAtThrowStmtClass;
  }

  child_range children() { return child_range(&Throw, &Throw+1); }

  const_child_range children() const {
    return const_child_range(&Throw, &Throw + 1);
  }
};

/// Represents Objective-C's \@autoreleasepool Statement
class ObjCAutoreleasePoolStmt : public Stmt {
  SourceLocation AtLoc;
  Stmt *SubStmt;

public:
  ObjCAutoreleasePoolStmt(SourceLocation atLoc, Stmt *subStmt)
      : Stmt(ObjCAutoreleasePoolStmtClass), AtLoc(atLoc), SubStmt(subStmt) {}

  explicit ObjCAutoreleasePoolStmt(EmptyShell Empty) :
    Stmt(ObjCAutoreleasePoolStmtClass, Empty) { }

  const Stmt *getSubStmt() const { return SubStmt; }
  Stmt *getSubStmt() { return SubStmt; }
  void setSubStmt(Stmt *S) { SubStmt = S; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
  SourceLocation getEndLoc() const LLVM_READONLY {
    return SubStmt->getEndLoc();
  }

  SourceLocation getAtLoc() const { return AtLoc; }
  void setAtLoc(SourceLocation Loc) { AtLoc = Loc; }

  static bool classof(const Stmt *T) {
    return T->getStmtClass() == ObjCAutoreleasePoolStmtClass;
  }

  child_range children() { return child_range(&SubStmt, &SubStmt + 1); }

  const_child_range children() const {
    return const_child_range(&SubStmt, &SubStmt + 1);
  }
};

}  // end namespace clang

#endif

Coverage Report

Created: 2021-08-24 07:12

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