clang  8.0.0svn
StmtCXX.cpp
Go to the documentation of this file.
1 //===--- StmtCXX.cpp - Classes for representing C++ statements ------------===//
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 // This file implements the subclesses of Stmt class declared in StmtCXX.h
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/StmtCXX.h"
15 
16 #include "clang/AST/ASTContext.h"
17 
18 using namespace clang;
19 
21  if (ExceptionDecl)
22  return ExceptionDecl->getType();
23  return QualType();
24 }
25 
27  Stmt *tryBlock, ArrayRef<Stmt *> handlers) {
28  const size_t Size = totalSizeToAlloc<Stmt *>(handlers.size() + 1);
29  void *Mem = C.Allocate(Size, alignof(CXXTryStmt));
30  return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
31 }
32 
34  unsigned numHandlers) {
35  const size_t Size = totalSizeToAlloc<Stmt *>(numHandlers + 1);
36  void *Mem = C.Allocate(Size, alignof(CXXTryStmt));
37  return new (Mem) CXXTryStmt(Empty, numHandlers);
38 }
39 
40 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
41  ArrayRef<Stmt *> handlers)
42  : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
43  Stmt **Stmts = getStmts();
44  Stmts[0] = tryBlock;
45  std::copy(handlers.begin(), handlers.end(), Stmts + 1);
46 }
47 
49  DeclStmt *BeginStmt, DeclStmt *EndStmt,
50  Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
51  Stmt *Body, SourceLocation FL,
53  SourceLocation RPL)
54  : Stmt(CXXForRangeStmtClass), ForLoc(FL), CoawaitLoc(CAL), ColonLoc(CL),
55  RParenLoc(RPL) {
56  SubExprs[RANGE] = Range;
57  SubExprs[BEGINSTMT] = BeginStmt;
58  SubExprs[ENDSTMT] = EndStmt;
59  SubExprs[COND] = Cond;
60  SubExprs[INC] = Inc;
61  SubExprs[LOOPVAR] = LoopVar;
62  SubExprs[BODY] = Body;
63 }
64 
66  DeclStmt *RangeStmt = getRangeStmt();
67  VarDecl *RangeDecl = dyn_cast_or_null<VarDecl>(RangeStmt->getSingleDecl());
68  assert(RangeDecl && "for-range should have a single var decl");
69  return RangeDecl->getInit();
70 }
71 
73  return const_cast<CXXForRangeStmt *>(this)->getRangeInit();
74 }
75 
77  Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
78  assert(LV && "No loop variable in CXXForRangeStmt");
79  return cast<VarDecl>(LV);
80 }
81 
83  return const_cast<CXXForRangeStmt *>(this)->getLoopVariable();
84 }
85 
87  const ASTContext &C, CoroutineBodyStmt::CtorArgs const &Args) {
88  std::size_t Size = totalSizeToAlloc<Stmt *>(
89  CoroutineBodyStmt::FirstParamMove + Args.ParamMoves.size());
90 
91  void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt));
92  return new (Mem) CoroutineBodyStmt(Args);
93 }
94 
96  unsigned NumParams) {
97  std::size_t Size = totalSizeToAlloc<Stmt *>(
98  CoroutineBodyStmt::FirstParamMove + NumParams);
99 
100  void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt));
101  auto *Result = new (Mem) CoroutineBodyStmt(CtorArgs());
102  Result->NumParams = NumParams;
103  auto *ParamBegin = Result->getStoredStmts() + SubStmt::FirstParamMove;
104  std::uninitialized_fill(ParamBegin, ParamBegin + NumParams,
105  static_cast<Stmt *>(nullptr));
106  return Result;
107 }
108 
109 CoroutineBodyStmt::CoroutineBodyStmt(CoroutineBodyStmt::CtorArgs const &Args)
110  : Stmt(CoroutineBodyStmtClass), NumParams(Args.ParamMoves.size()) {
111  Stmt **SubStmts = getStoredStmts();
112  SubStmts[CoroutineBodyStmt::Body] = Args.Body;
113  SubStmts[CoroutineBodyStmt::Promise] = Args.Promise;
114  SubStmts[CoroutineBodyStmt::InitSuspend] = Args.InitialSuspend;
115  SubStmts[CoroutineBodyStmt::FinalSuspend] = Args.FinalSuspend;
116  SubStmts[CoroutineBodyStmt::OnException] = Args.OnException;
117  SubStmts[CoroutineBodyStmt::OnFallthrough] = Args.OnFallthrough;
118  SubStmts[CoroutineBodyStmt::Allocate] = Args.Allocate;
119  SubStmts[CoroutineBodyStmt::Deallocate] = Args.Deallocate;
120  SubStmts[CoroutineBodyStmt::ReturnValue] = Args.ReturnValue;
121  SubStmts[CoroutineBodyStmt::ResultDecl] = Args.ResultDecl;
122  SubStmts[CoroutineBodyStmt::ReturnStmt] = Args.ReturnStmt;
123  SubStmts[CoroutineBodyStmt::ReturnStmtOnAllocFailure] =
125  std::copy(Args.ParamMoves.begin(), Args.ParamMoves.end(),
126  const_cast<Stmt **>(getParamMoves().data()));
127 }
Defines the clang::ASTContext interface.
A (possibly-)qualified type.
Definition: Type.h:642
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:60
Stmt - This represents one statement.
Definition: Stmt.h:66
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
Represents a variable declaration or definition.
Definition: Decl.h:812
Stmt(StmtClass SC, EmptyShell)
Construct an empty statement.
Definition: Stmt.h:379
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
QualType getCaughtType() const
Definition: StmtCXX.cpp:20
CXXForRangeStmt - This represents C++0x [stmt.ranged]&#39;s ranged for statement, represented as &#39;for (ra...
Definition: StmtCXX.h:126
This represents one expression.
Definition: Expr.h:105
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:65
The result type of a method or function.
static CoroutineBodyStmt * Create(const ASTContext &C, CtorArgs const &Args)
Definition: StmtCXX.cpp:86
Encodes a location in the source.
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:505
ArrayRef< Stmt * > ParamMoves
Definition: StmtCXX.h:342
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:338
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:678
CXXForRangeStmt(DeclStmt *Range, DeclStmt *Begin, DeclStmt *End, Expr *Cond, Expr *Inc, DeclStmt *LoopVar, Stmt *Body, SourceLocation FL, SourceLocation CAL, SourceLocation CL, SourceLocation RPL)
Definition: StmtCXX.cpp:48
Dataflow Directional Tag Classes.
const Expr * getInit() const
Definition: Decl.h:1217
const Decl * getSingleDecl() const
Definition: Stmt.h:522
Represents the body of a coroutine.
Definition: StmtCXX.h:299
DeclStmt * getRangeStmt()
Definition: StmtCXX.h:152
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, Stmt *tryBlock, ArrayRef< Stmt *> handlers)
Definition: StmtCXX.cpp:26
VarDecl * getLoopVariable()
Definition: StmtCXX.cpp:76
DeclStmt * getLoopVarStmt()
Definition: StmtCXX.h:159
QualType getType() const
Definition: Decl.h:647
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:108