| //===--- StmtCXX.cpp - Classes for representing C++ statements ------------===// |
| // |
| // 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 |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the subclesses of Stmt class declared in StmtCXX.h |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/AST/StmtCXX.h" |
| |
| #include "clang/AST/ASTContext.h" |
| |
| using namespace clang; |
| |
| QualType CXXCatchStmt::getCaughtType() const { |
| if (ExceptionDecl) |
| return ExceptionDecl->getType(); |
| return QualType(); |
| } |
| |
| CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, SourceLocation tryLoc, |
| Stmt *tryBlock, ArrayRef<Stmt *> handlers) { |
| const size_t Size = totalSizeToAlloc<Stmt *>(handlers.size() + 1); |
| void *Mem = C.Allocate(Size, alignof(CXXTryStmt)); |
| return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers); |
| } |
| |
| CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, EmptyShell Empty, |
| unsigned numHandlers) { |
| const size_t Size = totalSizeToAlloc<Stmt *>(numHandlers + 1); |
| void *Mem = C.Allocate(Size, alignof(CXXTryStmt)); |
| return new (Mem) CXXTryStmt(Empty, numHandlers); |
| } |
| |
| CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock, |
| ArrayRef<Stmt *> handlers) |
| : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) { |
| Stmt **Stmts = getStmts(); |
| Stmts[0] = tryBlock; |
| std::copy(handlers.begin(), handlers.end(), Stmts + 1); |
| } |
| |
| CXXForRangeStmt::CXXForRangeStmt(Stmt *Init, DeclStmt *Range, |
| DeclStmt *BeginStmt, DeclStmt *EndStmt, |
| Expr *Cond, Expr *Inc, DeclStmt *LoopVar, |
| Stmt *Body, SourceLocation FL, |
| SourceLocation CAL, SourceLocation CL, |
| SourceLocation RPL) |
| : Stmt(CXXForRangeStmtClass), ForLoc(FL), CoawaitLoc(CAL), ColonLoc(CL), |
| RParenLoc(RPL) { |
| SubExprs[INIT] = Init; |
| SubExprs[RANGE] = Range; |
| SubExprs[BEGINSTMT] = BeginStmt; |
| SubExprs[ENDSTMT] = EndStmt; |
| SubExprs[COND] = Cond; |
| SubExprs[INC] = Inc; |
| SubExprs[LOOPVAR] = LoopVar; |
| SubExprs[BODY] = Body; |
| } |
| |
| Expr *CXXForRangeStmt::getRangeInit() { |
| DeclStmt *RangeStmt = getRangeStmt(); |
| VarDecl *RangeDecl = dyn_cast_or_null<VarDecl>(RangeStmt->getSingleDecl()); |
| assert(RangeDecl && "for-range should have a single var decl"); |
| return RangeDecl->getInit(); |
| } |
| |
| const Expr *CXXForRangeStmt::getRangeInit() const { |
| return const_cast<CXXForRangeStmt *>(this)->getRangeInit(); |
| } |
| |
| VarDecl *CXXForRangeStmt::getLoopVariable() { |
| Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl(); |
| assert(LV && "No loop variable in CXXForRangeStmt"); |
| return cast<VarDecl>(LV); |
| } |
| |
| const VarDecl *CXXForRangeStmt::getLoopVariable() const { |
| return const_cast<CXXForRangeStmt *>(this)->getLoopVariable(); |
| } |
| |
| CoroutineBodyStmt *CoroutineBodyStmt::Create( |
| const ASTContext &C, CoroutineBodyStmt::CtorArgs const &Args) { |
| std::size_t Size = totalSizeToAlloc<Stmt *>( |
| CoroutineBodyStmt::FirstParamMove + Args.ParamMoves.size()); |
| |
| void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt)); |
| return new (Mem) CoroutineBodyStmt(Args); |
| } |
| |
| CoroutineBodyStmt *CoroutineBodyStmt::Create(const ASTContext &C, EmptyShell, |
| unsigned NumParams) { |
| std::size_t Size = totalSizeToAlloc<Stmt *>( |
| CoroutineBodyStmt::FirstParamMove + NumParams); |
| |
| void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt)); |
| auto *Result = new (Mem) CoroutineBodyStmt(CtorArgs()); |
| Result->NumParams = NumParams; |
| auto *ParamBegin = Result->getStoredStmts() + SubStmt::FirstParamMove; |
| std::uninitialized_fill(ParamBegin, ParamBegin + NumParams, |
| static_cast<Stmt *>(nullptr)); |
| return Result; |
| } |
| |
| CoroutineBodyStmt::CoroutineBodyStmt(CoroutineBodyStmt::CtorArgs const &Args) |
| : Stmt(CoroutineBodyStmtClass), NumParams(Args.ParamMoves.size()) { |
| Stmt **SubStmts = getStoredStmts(); |
| SubStmts[CoroutineBodyStmt::Body] = Args.Body; |
| SubStmts[CoroutineBodyStmt::Promise] = Args.Promise; |
| SubStmts[CoroutineBodyStmt::InitSuspend] = Args.InitialSuspend; |
| SubStmts[CoroutineBodyStmt::FinalSuspend] = Args.FinalSuspend; |
| SubStmts[CoroutineBodyStmt::OnException] = Args.OnException; |
| SubStmts[CoroutineBodyStmt::OnFallthrough] = Args.OnFallthrough; |
| SubStmts[CoroutineBodyStmt::Allocate] = Args.Allocate; |
| SubStmts[CoroutineBodyStmt::Deallocate] = Args.Deallocate; |
| SubStmts[CoroutineBodyStmt::ReturnValue] = Args.ReturnValue; |
| SubStmts[CoroutineBodyStmt::ResultDecl] = Args.ResultDecl; |
| SubStmts[CoroutineBodyStmt::ReturnStmt] = Args.ReturnStmt; |
| SubStmts[CoroutineBodyStmt::ReturnStmtOnAllocFailure] = |
| Args.ReturnStmtOnAllocFailure; |
| std::copy(Args.ParamMoves.begin(), Args.ParamMoves.end(), |
| const_cast<Stmt **>(getParamMoves().data())); |
| } |