WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/clang/AST/LambdaCapture.h

Rev	Author	Line No.	Line
14	pmbaty	1	//===--- LambdaCapture.h - Types for C++ Lambda Captures --------- 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 LambdaCapture class.
		11	///
		12	//===----------------------------------------------------------------------===//
		13
		14	#ifndef LLVM_CLANG_AST_LAMBDACAPTURE_H
		15	#define LLVM_CLANG_AST_LAMBDACAPTURE_H
		16
		17	#include "clang/AST/Decl.h"
		18	#include "clang/Basic/Lambda.h"
		19	#include "llvm/ADT/PointerIntPair.h"
		20
		21	namespace clang {
		22
		23	/// Describes the capture of a variable or of \c this, or of a
		24	/// C++1y init-capture.
		25	class LambdaCapture {
		26	enum {
		27	/// Flag used by the Capture class to indicate that the given
		28	/// capture was implicit.
		29	Capture_Implicit = 0x01,
		30
		31	/// Flag used by the Capture class to indicate that the
		32	/// given capture was by-copy.
		33	///
		34	/// This includes the case of a non-reference init-capture.
		35	Capture_ByCopy = 0x02,
		36
		37	/// Flag used by the Capture class to distinguish between a capture
		38	/// of '*this' and a capture of a VLA type.
		39	Capture_This = 0x04
		40	};
		41
		42	// Decl could represent:
		43	// - a VarDecl* that represents the variable that was captured or the
		44	// init-capture.
		45	// - or, is a nullptr and Capture_This is set in Bits if this represents a
		46	// capture of '*this' by value or reference.
		47	// - or, is a nullptr and Capture_This is not set in Bits if this represents
		48	// a capture of a VLA type.
		49	llvm::PointerIntPair<Decl*, 3> DeclAndBits;
		50
		51	SourceLocation Loc;
		52	SourceLocation EllipsisLoc;
		53
		54	friend class ASTStmtReader;
		55	friend class ASTStmtWriter;
		56
		57	public:
		58	/// Create a new capture of a variable or of \c this.
		59	///
		60	/// \param Loc The source location associated with this capture.
		61	///
		62	/// \param Kind The kind of capture (this, byref, bycopy), which must
		63	/// not be init-capture.
		64	///
		65	/// \param Implicit Whether the capture was implicit or explicit.
		66	///
		67	/// \param Var The local variable being captured, or null if capturing
		68	/// \c this.
		69	///
		70	/// \param EllipsisLoc The location of the ellipsis (...) for a
		71	/// capture that is a pack expansion, or an invalid source
		72	/// location to indicate that this is not a pack expansion.
		73	LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind,
		74	ValueDecl *Var = nullptr,
		75	SourceLocation EllipsisLoc = SourceLocation());
		76
		77	/// Determine the kind of capture.
		78	LambdaCaptureKind getCaptureKind() const;
		79
		80	/// Determine whether this capture handles the C++ \c this
		81	/// pointer.
		82	bool capturesThis() const {
		83	return DeclAndBits.getPointer() == nullptr &&
		84	(DeclAndBits.getInt() & Capture_This);
		85	}
		86
		87	/// Determine whether this capture handles a variable.
		88	bool capturesVariable() const {
		89	return isa_and_nonnull<ValueDecl>(DeclAndBits.getPointer());
		90	}
		91
		92	/// Determine whether this captures a variable length array bound
		93	/// expression.
		94	bool capturesVLAType() const {
		95	return DeclAndBits.getPointer() == nullptr &&
		96	!(DeclAndBits.getInt() & Capture_This);
		97	}
		98
		99	/// Retrieve the declaration of the local variable being
		100	/// captured.
		101	///
		102	/// This operation is only valid if this capture is a variable capture
		103	/// (other than a capture of \c this).
		104	ValueDecl *getCapturedVar() const {
		105	assert(capturesVariable() && "No variable available for capture");
		106	return static_cast<ValueDecl *>(DeclAndBits.getPointer());
		107	}
		108
		109	/// Determine whether this was an implicit capture (not
		110	/// written between the square brackets introducing the lambda).
		111	bool isImplicit() const {
		112	return DeclAndBits.getInt() & Capture_Implicit;
		113	}
		114
		115	/// Determine whether this was an explicit capture (written
		116	/// between the square brackets introducing the lambda).
		117	bool isExplicit() const { return !isImplicit(); }
		118
		119	/// Retrieve the source location of the capture.
		120	///
		121	/// For an explicit capture, this returns the location of the
		122	/// explicit capture in the source. For an implicit capture, this
		123	/// returns the location at which the variable or \c this was first
		124	/// used.
		125	SourceLocation getLocation() const { return Loc; }
		126
		127	/// Determine whether this capture is a pack expansion,
		128	/// which captures a function parameter pack.
		129	bool isPackExpansion() const { return EllipsisLoc.isValid(); }
		130
		131	/// Retrieve the location of the ellipsis for a capture
		132	/// that is a pack expansion.
		133	SourceLocation getEllipsisLoc() const {
		134	assert(isPackExpansion() && "No ellipsis location for a non-expansion");
		135	return EllipsisLoc;
		136	}
		137	};
		138
		139	} // end namespace clang
		140
		141	#endif // LLVM_CLANG_AST_LAMBDACAPTURE_H

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/clang/AST/LambdaCapture.h – Rev 14