Fortran::evaluate Namespace Reference

Classes
class	ActualArgument
struct	Add
struct	AllTraverse
class	AnyTraverse
class	ArgumentAnalyzer
struct	ArgumentVerifier
struct	ArrayAndMask
class	ArrayConstantBoundChanger
class	ArrayConstructor
class	ArrayConstructor< SomeDerived >
class	ArrayConstructor< Type< TypeCategory::Character, KIND > >
class	ArrayConstructorContext
class	ArrayConstructorFolder
struct	ArrayConstructorValue
class	ArrayConstructorValues
class	ArrayRef
class	AsConstantHelper
class	Assignment
struct	BaseObject
struct	CallCharacteristics
class	CharacterUtils
struct	CheckConformanceFlags
class	CheckSpecificationExprHelper
class	CoarrayRef
struct	CollectCudaSymbolsHelper
struct	CollectSymbolsHelper
struct	ComplexComponent
struct	ComplexConstructor
class	ComplexPart
struct	ComplexPartExtractor
class	Component
struct	ComponentCompare
struct	Concat
class	Constant
class	Constant< SomeDerived >
class	Constant< Type< TypeCategory::Character, KIND > >
class	ConstantBase
class	ConstantBounds
struct	ConstantObjectPointer
struct	Convert
struct	ConvertToKindHelper
class	CountAccumulator
struct	DataRef
class	DescriptorInquiry
class	Designator
class	DesignatorFolder
struct	Divide
class	DynamicType
struct	DynamicTypeWithLength
class	Expr
class	Expr< SomeCharacter >
class	Expr< SomeDerived >
class	Expr< SomeKind< CAT > >
class	Expr< SomeType >
class	Expr< Type< TypeCategory::Character, KIND > >
class	Expr< Type< TypeCategory::Complex, KIND > >
class	Expr< Type< TypeCategory::Integer, KIND > >
class	Expr< Type< TypeCategory::Logical, KIND > >
class	Expr< Type< TypeCategory::Real, KIND > >
class	Expr< Type< TypeCategory::Unsigned, KIND > >
class	ExpressionAnalyzer
class	ExpressionBase
struct	ExtractCoindexedObjectHelper
struct	ExtractSubstringHelper
struct	Extremum
class	FindImpureCallHelper
class	Folder
class	FolderFactory
class	FoldingContext
class	FunctionRef
struct	FuncTypeAnalyzer
struct	FuncTypeAnalyzer< FuncPointer< HostTR, HostTA... > >
struct	GenericAssignmentWrapper
struct	GenericExprWrapper
class	GetConstantArrayBoundHelper
struct	GetLastSymbolHelper
class	GetLowerBoundHelper
class	GetShapeHelper
struct	GetSymbolVectorHelper
struct	HasConstantHelper
struct	HasVectorSubscriptHelper
struct	HostRuntimeFunction
struct	HostRuntimeLibrary
struct	HostRuntimeLibrary< HostT, LibraryVersion::Libm >
struct	HostRuntimeLibrary< std::complex< HostT >, LibraryVersion::Libm >
class	ImpliedDo
struct	ImpliedDoIndex
class	InitialImage
class	IntrinsicCallHelper
struct	IntrinsicInterface
struct	IntTypeVisitor
struct	IsActuallyConstantHelper
struct	IsAvailable
	Define pgmath description. More...
struct	IsAvailable< T, decltype((void) T::table, void())>
class	IsConstantExprHelper
class	IsContiguousHelper
struct	IsErrorExprHelper
class	IsInitialDataTargetHelper
struct	IsNullPointerHelper
struct	IsVariableHelper
class	LocationHelper
struct	LogicalOperation
class	MaxvalMinvalAccumulator
struct	Multiply
class	NamedEntity
struct	Negate
class	Norm2Accumulator
struct	Not
struct	NullPointer
class	OffsetSymbol
class	Operation
class	OperationAccumulator
struct	OperatorSpelling
struct	Parentheses
struct	Parentheses< SomeDerived >
struct	Power
struct	ProcedureDesignator
class	ProcedureRef
class	ProductAccumulator
class	RealToIntLimitHelper
struct	RealToIntPower
struct	RealTypeVisitor
class	Relational
class	Relational< SomeType >
struct	SameKindExprsHelper
class	ScalarConstantExpander
class	SelectedIntKindVisitor
class	SelectedLogicalKindVisitor
class	SelectedRealKindVisitor
struct	SetExprHelper
struct	SetLength
struct	SetTraverse
struct	SmallestUInt
struct	SmallestUInt< false, false, false, true >
struct	SmallestUInt< false, false, true, true >
struct	SmallestUInt< false, true, true, true >
struct	SmallestUInt< true, true, true, true >
struct	SomeKind
class	SomeKind< TypeCategory::Derived >
struct	SomeType
struct	SpecificCall
struct	SpecificIntrinsic
struct	SpecificIntrinsicFunctionInterface
struct	SpecificIntrinsicInterface
class	StaticDataObject
class	StmtFunctionChecker
class	StructureConstructor
struct	Subscript
class	Substring
struct	Subtract
class	SumAccumulator
class	TargetCharacteristics
class	Traverse
class	Triplet
class	Type
class	Type< TypeCategory::Character, 1 >
class	Type< TypeCategory::Character, 2 >
class	Type< TypeCategory::Character, 4 >
class	Type< TypeCategory::Complex, KIND >
class	Type< TypeCategory::Integer, KIND >
class	Type< TypeCategory::Logical, KIND >
class	Type< TypeCategory::Real, KIND >
class	Type< TypeCategory::Unsigned, KIND >
struct	TypeBase
struct	TypeKindVisitor
struct	TypeOfHelper
class	TypeParamInquiry
struct	TypeVector
struct	TypeVectorStorage
struct	TypeVectorStorage<>
class	UnexpandabilityFindingVisitor
struct	ValueWithRealFlags
struct	Variable

Typedefs
using	SymbolRef = common::Reference< const Symbol >
using	ActualArguments = std::vector< std::optional< ActualArgument > >
using	IntrinsicProcedure = std::string
using	Chevrons = std::vector< Expr< SomeType > >
template<int BITS>
using	HostUnsignedInt = typename SmallestUInt< BITS<=8, BITS<=16, BITS<=32, BITS<=64 >::type
using	ConstantSubscripts = std::vector< ConstantSubscript >
using	StructureConstructorValues = std::map< SymbolRef, common::CopyableIndirection< Expr< SomeType > >, ComponentCompare >
template<typename A >
using	ResultType = typename std::decay_t< A >::Result
using	CategoryExpression = common::MapTemplate< Expr, SomeCategory >
using	BOZLiteralConstant = typename LargestReal::Scalar::Word
using	TypelessExpression = std::variant< BOZLiteralConstant, NullPointer, ProcedureDesignator, ProcedureRef >
using	HostRuntimeWrapper = std::function< Expr< SomeType >(FoldingContext &, std::vector< Expr< SomeType > > &&)>
using	ExtentType = SubscriptInteger
using	ExtentExpr = Expr< ExtentType >
using	MaybeExtentExpr = std::optional< ExtentExpr >
using	Shape = std::vector< MaybeExtentExpr >
template<typename A , int N = 2>
using	SameExprs = std::array< Expr< A >, N >
template<TypeCategory CAT, int N = 2>
using	SameKindExprs = common::MapTemplate< SameKindExprsHelper< N >::template SameExprs, CategoryTypes< CAT > >
using	ConvertRealOperandsResult = std::optional< SameKindExprs< TypeCategory::Real, 2 > >
using	SubscriptInteger = Type< TypeCategory::Integer, 8 >
using	CInteger = Type< TypeCategory::Integer, 4 >
using	LargestInt = Type< TypeCategory::Integer, 16 >
using	LogicalResult = Type< TypeCategory::Logical, 4 >
using	LargestReal = Type< TypeCategory::Real, 16 >
using	Ascii = Type< TypeCategory::Character, 1 >
template<TypeCategory CATEGORY, typename T >
using	SameKind = Type< CATEGORY, std::decay_t< T >::kind >
using	IndirectSubscriptIntegerExpr = common::CopyableIndirection< Expr< SubscriptInteger > >
template<TypeCategory CATEGORY, int KIND>
using	CategoryKindTuple = std::conditional_t< IsValidKindOfIntrinsicType(CATEGORY, KIND), std::tuple< Type< CATEGORY, KIND > >, std::tuple<> >
template<TypeCategory CATEGORY, int... KINDS>
using	CategoryTypesHelper = common::CombineTuples< CategoryKindTuple< CATEGORY, KINDS >... >
template<TypeCategory CATEGORY>
using	CategoryTypes = CategoryTypesHelper< CATEGORY, 1, 2, 3, 4, 8, 10, 16, 32 >
using	IntegerTypes = CategoryTypes< TypeCategory::Integer >
using	RealTypes = CategoryTypes< TypeCategory::Real >
using	ComplexTypes = CategoryTypes< TypeCategory::Complex >
using	CharacterTypes = CategoryTypes< TypeCategory::Character >
using	LogicalTypes = CategoryTypes< TypeCategory::Logical >
using	UnsignedTypes = CategoryTypes< TypeCategory::Unsigned >
using	FloatingTypes = common::CombineTuples< RealTypes, ComplexTypes >
using	NumericTypes = common::CombineTuples< IntegerTypes, FloatingTypes, UnsignedTypes >
using	RelationalTypes = common::CombineTuples< IntegerTypes, RealTypes, CharacterTypes, UnsignedTypes >
using	AllIntrinsicTypes = common::CombineTuples< NumericTypes, CharacterTypes, LogicalTypes >
using	LengthlessIntrinsicTypes = common::CombineTuples< NumericTypes, LogicalTypes >
using	NumericCategoryTypes = std::tuple< SomeKind< TypeCategory::Integer >, SomeKind< TypeCategory::Real >, SomeKind< TypeCategory::Complex >, SomeKind< TypeCategory::Unsigned > >
using	AllIntrinsicCategoryTypes = std::tuple< SomeKind< TypeCategory::Integer >, SomeKind< TypeCategory::Real >, SomeKind< TypeCategory::Complex >, SomeKind< TypeCategory::Character >, SomeKind< TypeCategory::Logical >, SomeKind< TypeCategory::Unsigned > >
using	SomeInteger = SomeKind< TypeCategory::Integer >
using	SomeReal = SomeKind< TypeCategory::Real >
using	SomeComplex = SomeKind< TypeCategory::Complex >
using	SomeCharacter = SomeKind< TypeCategory::Character >
using	SomeLogical = SomeKind< TypeCategory::Logical >
using	SomeUnsigned = SomeKind< TypeCategory::Unsigned >
using	SomeDerived = SomeKind< TypeCategory::Derived >
using	SomeCategory = std::tuple< SomeInteger, SomeReal, SomeComplex, SomeCharacter, SomeLogical, SomeUnsigned, SomeDerived >
using	AllTypes = common::CombineTuples< AllIntrinsicTypes, std::tuple< SomeDerived > >
template<typename T >
using	Scalar = typename std::decay_t< T >::Scalar
template<typename CONST >
using	TypeOf = typename TypeOfHelper< CONST >::type
using	SymbolVector = std::vector< SymbolRef >
template<typename TR , typename... TArgs>
using	ScalarFunc = std::function< Scalar< TR >(const Scalar< TArgs > &...)>
template<typename TR , typename... TArgs>
using	ScalarFuncWithContext = std::function< Scalar< TR >(FoldingContext &, const Scalar< TArgs > &...)>
template<typename TR , typename... TA>
using	FuncPointer = TR(*)(TA...)
using	HostRuntimeMap = common::StaticMultimapView< HostRuntimeFunction >
using	ArgumentVerifierFunc = bool(*)(const std::vector< Expr< SomeType > > &, FoldingContext &)
	Structure to register intrinsic argument checks that must be performed.
using	CategorySet = common::EnumSet< TypeCategory, 8 >
using	SetOfDerivedTypePairs = std::set< std::pair< const semantics::DerivedTypeSpec *, const semantics::DerivedTypeSpec * > >
using	ActualArgumentRef = common::Reference< const ActualArgument >

Enumerations
enum class	WhichLocation { Findloc , Maxloc , Minloc }
enum class	Precedence {   DefinedBinary , Or , And , Equivalence ,   Not , Relational , Additive , Negate ,   Multiplicative , Power , DefinedUnary , Top }
enum class	LibraryVersion {   Libm , LibmExtensions , PgmathFast , PgmathRelaxed ,   PgmathPrecise }

Functions
template<typename A >
bool	IsConstantExpr (const A &)
template bool	IsConstantExpr (const Expr< SomeType > &)
template bool	IsConstantExpr (const Expr< SomeInteger > &)
template bool	IsConstantExpr (const Expr< SubscriptInteger > &)
template bool	IsConstantExpr (const StructureConstructor &)
template<typename A >
bool	IsScopeInvariantExpr (const A &)
template bool	IsScopeInvariantExpr (const Expr< SomeType > &)
template bool	IsScopeInvariantExpr (const Expr< SomeInteger > &)
template bool	IsScopeInvariantExpr (const Expr< SubscriptInteger > &)
template<typename A >
bool	IsActuallyConstant (const A &)
template bool	IsActuallyConstant (const Expr< SomeType > &)
template bool	IsActuallyConstant (const Expr< SomeInteger > &)
template bool	IsActuallyConstant (const Expr< SubscriptInteger > &)
template bool	IsActuallyConstant (const std::optional< Expr< SubscriptInteger > > &)
bool	IsInitialDataTarget (const Expr< SomeType > &, parser::ContextualMessages *=nullptr)
bool	IsInitialProcedureTarget (const Symbol &)
bool	IsInitialProcedureTarget (const ProcedureDesignator &)
bool	IsInitialProcedureTarget (const Expr< SomeType > &)
std::optional< Expr< SomeType > >	NonPointerInitializationExpr (const Symbol &, Expr< SomeType > &&, FoldingContext &, const semantics::Scope *instantiation=nullptr)
template<typename A >
void	CheckSpecificationExpr (const A &, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const Expr< SomeType > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const Expr< SomeInteger > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const Expr< SubscriptInteger > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const std::optional< Expr< SomeType > > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const std::optional< Expr< SomeInteger > > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template void	CheckSpecificationExpr (const std::optional< Expr< SubscriptInteger > > &x, const semantics::Scope &, FoldingContext &, bool forElementalFunctionResult)
template<typename A >
std::optional< bool >	IsContiguous (const A &, FoldingContext &)
template std::optional< bool >	IsContiguous (const Expr< SomeType > &, FoldingContext &)
template std::optional< bool >	IsContiguous (const ArrayRef &, FoldingContext &)
template std::optional< bool >	IsContiguous (const Substring &, FoldingContext &)
template std::optional< bool >	IsContiguous (const Component &, FoldingContext &)
template std::optional< bool >	IsContiguous (const ComplexPart &, FoldingContext &)
template std::optional< bool >	IsContiguous (const CoarrayRef &, FoldingContext &)
template std::optional< bool >	IsContiguous (const Symbol &, FoldingContext &)
template<typename A >
bool	IsSimplyContiguous (const A &x, FoldingContext &context)
template<typename A >
bool	IsErrorExpr (const A &)
template bool	IsErrorExpr (const Expr< SomeType > &)
std::optional< parser::Message >	CheckStatementFunction (const Symbol &, const Expr< SomeType > &, FoldingContext &)
void	RealFlagWarnings (FoldingContext &, const RealFlags &, const char *op)
int	GetRank (const ConstantSubscripts &s)
std::optional< uint64_t >	TotalElementCount (const ConstantSubscripts &shape)
std::optional< std::vector< int > >	ValidateDimensionOrder (int rank, const std::vector< int > &order)
bool	HasNegativeExtent (const ConstantSubscripts &)
std::optional< Expr< SomeType > >	OffsetToDesignator (FoldingContext &, const Symbol &, ConstantSubscript offset, std::size_t)
std::optional< Expr< SomeType > >	OffsetToDesignator (FoldingContext &, const OffsetSymbol &)
template<typename T >
Expr< T >	Fold (FoldingContext &context, Expr< T > &&expr)
characteristics::TypeAndShape	Fold (FoldingContext &, characteristics::TypeAndShape &&)
template<typename A >
std::optional< A >	Fold (FoldingContext &context, std::optional< A > &&x)
template<typename T , typename EXPR >
auto	UnwrapConstantValue (EXPR &expr) -> common::Constify< Constant< T >, EXPR > *
template<typename T , typename EXPR >
constexpr auto	GetScalarConstantValue (const EXPR &expr) -> std::optional< Scalar< T > >
template<int KIND>
constexpr std::optional< std::int64_t >	ToInt64 (const Expr< Type< TypeCategory::Integer, KIND > > &expr)
template<int KIND>
constexpr std::optional< std::int64_t >	ToInt64 (const Expr< Type< TypeCategory::Unsigned, KIND > > &expr)
std::optional< std::int64_t >	ToInt64 (const Expr< SomeInteger > &)
std::optional< std::int64_t >	ToInt64 (const Expr< SomeType > &)
std::optional< std::int64_t >	ToInt64 (const ActualArgument &)
template<typename A >
std::optional< std::int64_t >	ToInt64 (const std::optional< A > &x)
template<typename A >
std::optional< std::int64_t >	ToInt64 (A *p)
template<typename A >
auto	operator<< (llvm::raw_ostream &o, const A &x) -> decltype(x.AsFortran(o))
template<typename A , bool COPYABLE>
auto	operator<< (llvm::raw_ostream &o, const Fortran::common::Indirection< A, COPYABLE > &x) -> decltype(o<< x.value())
template<typename A >
auto	operator<< (llvm::raw_ostream &o, const std::optional< A > &x) -> decltype(o<< *x)
std::optional< HostRuntimeWrapper >	GetHostRuntimeWrapper (const std::string &name, DynamicType resultType, const std::vector< DynamicType > &argTypes)
bool	CheckAndRearrangeArguments (ActualArguments &, parser::ContextualMessages &, const char *const dummyKeywords[], std::size_t trailingOptionals=0)
	ENUM_CLASS (IntrinsicClass, atomicSubroutine, collectiveSubroutine, elementalFunction, elementalSubroutine, inquiryFunction, pureSubroutine, impureSubroutine, transformationalFunction, noClass) class IntrinsicProcTable
bool	AcceptsIntentOutAllocatableCoarray (const std::string &)
bool	IsImpliedShape (const Symbol &)
bool	IsExplicitShape (const Symbol &)
std::optional< ExtentExpr >	AsExtentArrayExpr (const Shape &)
std::optional< Constant< ExtentType > >	AsConstantShape (FoldingContext &, const Shape &)
Constant< ExtentType >	AsConstantShape (const ConstantSubscripts &)
ConstantSubscripts	AsConstantExtents (const Constant< ExtentType > &)
std::optional< ConstantSubscripts >	AsConstantExtents (FoldingContext &, const Shape &)
std::optional< ConstantSubscripts >	AsConstantExtents (FoldingContext &foldingContext, const std::optional< Shape > &maybeShape)
Shape	AsShape (const ConstantSubscripts &)
std::optional< Shape >	AsShape (const std::optional< ConstantSubscripts > &)
int	GetRank (const Shape &s)
Shape	Fold (FoldingContext &, Shape &&)
std::optional< Shape >	Fold (FoldingContext &, std::optional< Shape > &&)
template<typename A >
std::optional< Shape >	GetShape (FoldingContext &, const A &, bool invariantOnly=true)
template<typename A >
std::optional< Shape >	GetShape (const A &, bool invariantOnly=true)
ExtentExpr	GetRawLowerBound (const NamedEntity &, int dimension, bool invariantOnly=true)
ExtentExpr	GetRawLowerBound (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetLBOUND (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetLBOUND (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetRawUpperBound (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetRawUpperBound (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetUBOUND (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetUBOUND (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	ComputeUpperBound (ExtentExpr &&lower, MaybeExtentExpr &&extent)
MaybeExtentExpr	ComputeUpperBound (FoldingContext &, ExtentExpr &&lower, MaybeExtentExpr &&extent)
Shape	GetRawLowerBounds (const NamedEntity &, bool invariantOnly=true)
Shape	GetRawLowerBounds (FoldingContext &, const NamedEntity &, bool invariantOnly=true)
Shape	GetLBOUNDs (const NamedEntity &, bool invariantOnly=true)
Shape	GetLBOUNDs (FoldingContext &, const NamedEntity &, bool invariantOnly=true)
Shape	GetUBOUNDs (const NamedEntity &, bool invariantOnly=true)
Shape	GetUBOUNDs (FoldingContext &, const NamedEntity &, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (FoldingContext &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (const Subscript &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetExtent (FoldingContext &, const Subscript &, const NamedEntity &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetLCOBOUND (const Symbol &, int dimension, bool invariantOnly=true)
MaybeExtentExpr	GetUCOBOUND (const Symbol &, int dimension, bool invariantOnly=true)
Shape	GetLCOBOUNDs (const Symbol &, bool invariantOnly=true)
Shape	GetUCOBOUNDs (const Symbol &, bool invariantOnly=true)
ExtentExpr	CountTrips (ExtentExpr &&lower, ExtentExpr &&upper, ExtentExpr &&stride)
ExtentExpr	CountTrips (const ExtentExpr &lower, const ExtentExpr &upper, const ExtentExpr &stride)
MaybeExtentExpr	CountTrips (MaybeExtentExpr &&lower, MaybeExtentExpr &&upper, MaybeExtentExpr &&stride)
MaybeExtentExpr	GetSize (Shape &&)
ConstantSubscript	GetSize (const ConstantSubscripts &)
MaybeExtentExpr	GetSize (const std::optional< Shape > &maybeShape)
bool	ContainsAnyImpliedDoIndex (const ExtentExpr &)
template<typename A >
std::optional< Shape >	GetShape (FoldingContext *context, const A &x, bool invariantOnly=true)
template<typename A >
std::optional< Constant< ExtentType > >	GetConstantShape (FoldingContext &context, const A &x)
template<typename A >
std::optional< ConstantSubscripts >	GetConstantExtents (FoldingContext &context, const A &x)
template<typename A >
std::optional< Shape >	GetContextFreeShape (FoldingContext &context, const A &x)
std::optional< bool >	CheckConformance (parser::ContextualMessages &, const Shape &left, const Shape &right, CheckConformanceFlags::Flags flags=CheckConformanceFlags::None, const char *leftIs="left operand", const char *rightIs="right operand")
bool	IncrementSubscripts (ConstantSubscripts &, const ConstantSubscripts &extents)
	ENUM_CLASS (IeeeFeature, Denormal, Divide, Flags, Halting, Inf, Io, NaN, Rounding, Sqrt, Standard, Subnormal, UnderflowControl) using IeeeFeatures
template<typename A >
bool	IsVariable (const A &x)
bool	IsAssumedRank (const Symbol &)
bool	IsAssumedRank (const ActualArgument &)
template<typename A >
bool	IsAssumedRank (const A &)
template<typename A >
bool	IsAssumedRank (const Designator< A > &designator)
template<typename T >
bool	IsAssumedRank (const Expr< T > &expr)
template<typename A >
bool	IsAssumedRank (const std::optional< A > &x)
template<typename A >
bool	IsAssumedRank (const A *x)
int	GetCorank (const ActualArgument &)
template<typename A >
int	GetCorank (const A &)
template<typename T >
int	GetCorank (const Designator< T > &designator)
template<typename T >
int	GetCorank (const Expr< T > &expr)
template<typename A >
int	GetCorank (const std::optional< A > &x)
template<typename A >
int	GetCorank (const A *x)
template<typename A >
bool	IsCoarray (const A &x)
template<typename A >
common::IfNoLvalue< Expr< ResultType< A > >, A >	AsExpr (A &&x)
template<typename T >
Expr< T >	AsExpr (Expr< T > &&x)
template<TypeCategory CATEGORY>
Expr< SomeKind< CATEGORY > >	AsCategoryExpr (Expr< SomeKind< CATEGORY > > &&x)
template<typename A >
common::IfNoLvalue< Expr< SomeType >, A >	AsGenericExpr (A &&x)
Expr< SomeType >	AsGenericExpr (Expr< SomeType > &&x)
std::optional< Expr< SomeType > >	AsGenericExpr (DataRef &&)
std::optional< Expr< SomeType > >	AsGenericExpr (const Symbol &)
template<typename A >
std::optional< Expr< SomeType > >	AsGenericExpr (std::optional< A > &&x)
template<typename A >
common::IfNoLvalue< Expr< SomeKind< ResultType< A >::category > >, A >	AsCategoryExpr (A &&x)
Expr< SomeType >	Parenthesize (Expr< SomeType > &&)
template<typename A >
constexpr bool	IsNumericCategoryExpr ()
template<typename A , typename B >
auto	UnwrapExpr (B &x) -> common::Constify< A, B > *
template<typename A , typename B >
const A *	UnwrapExpr (const std::optional< B > &x)
template<typename A , typename B >
A *	UnwrapExpr (std::optional< B > &x)
template<typename A , typename B >
const A *	UnwrapExpr (const B *x)
template<typename A , typename B >
A *	UnwrapExpr (B *x)
template<typename A , typename B >
auto	UnwrapConvertedExpr (B &x) -> common::Constify< A, B > *
template<typename A >
const ProcedureRef *	UnwrapProcedureRef (const A &)
const ProcedureRef *	UnwrapProcedureRef (const ProcedureRef &proc)
template<typename T >
const ProcedureRef *	UnwrapProcedureRef (const FunctionRef< T > &func)
template<typename T >
const ProcedureRef *	UnwrapProcedureRef (const Expr< T > &expr)
template<typename A >
const Symbol *	ExtractBareLenParameter (const A &expr)
template<typename A >
common::IfNoLvalue< std::optional< DataRef >, A >	ExtractDataRef (const A &, bool intoSubstring, bool intoComplexPart)
template<typename T >
std::optional< DataRef >	ExtractDataRef (const Designator< T > &d, bool intoSubstring=false, bool intoComplexPart=false)
template<typename T >
std::optional< DataRef >	ExtractDataRef (const Expr< T > &expr, bool intoSubstring=false, bool intoComplexPart=false)
template<typename A >
std::optional< DataRef >	ExtractDataRef (const std::optional< A > &x, bool intoSubstring=false, bool intoComplexPart=false)
template<typename A >
std::optional< DataRef >	ExtractDataRef (A *p, bool intoSubstring=false, bool intoComplexPart=false)
std::optional< DataRef >	ExtractDataRef (const ActualArgument &, bool intoSubstring=false, bool intoComplexPart=false)
std::optional< DataRef >	ExtractSubstringBase (const Substring &)
template<typename T >
bool	IsArrayElement (const Expr< T > &expr, bool intoSubstring=true, bool skipComponents=false)
template<typename A >
std::optional< NamedEntity >	ExtractNamedEntity (const A &x)
template<typename A >
std::optional< CoarrayRef >	ExtractCoarrayRef (const A &x)
template<typename A >
std::optional< Substring >	ExtractSubstring (const A &x)
template<typename A >
const Symbol *	UnwrapWholeSymbolDataRef (const A &x)
template<typename A >
const Symbol *	UnwrapWholeSymbolOrComponentDataRef (const A &x)
template<typename A >
const Symbol *	UnwrapWholeSymbolOrComponentOrCoarrayRef (const A &x)
template<typename A >
const Symbol *	GetFirstSymbol (const A &x)
const Symbol *	GetLastPointerSymbol (const evaluate::DataRef &)
template<typename TO , TypeCategory FROMCAT>
Expr< TO >	ConvertToType (Expr< SomeKind< FROMCAT > > &&x)
template<typename TO , TypeCategory FROMCAT, int FROMKIND>
Expr< TO >	ConvertToType (Expr< Type< FROMCAT, FROMKIND > > &&x)
template<typename TO >
Expr< TO >	ConvertToType (BOZLiteralConstant &&x)
template<typename T >
bool	IsBOZLiteral (const Expr< T > &expr)
std::optional< Expr< SomeType > >	ConvertToType (const DynamicType &, Expr< SomeType > &&)
std::optional< Expr< SomeType > >	ConvertToType (const DynamicType &, std::optional< Expr< SomeType > > &&)
std::optional< Expr< SomeType > >	ConvertToType (const Symbol &, Expr< SomeType > &&)
std::optional< Expr< SomeType > >	ConvertToType (const Symbol &, std::optional< Expr< SomeType > > &&)
template<TypeCategory TC, int TK, typename FROM >
common::IfNoLvalue< Expr< Type< TC, TK > >, FROM >	ConvertTo (const Expr< Type< TC, TK > > &, FROM &&x)
template<TypeCategory TC, typename FROM >
common::IfNoLvalue< Expr< SomeKind< TC > >, FROM >	ConvertTo (const Expr< SomeKind< TC > > &to, FROM &&from)
template<typename FROM >
common::IfNoLvalue< Expr< SomeType >, FROM >	ConvertTo (const Expr< SomeType > &to, FROM &&from)
template<TypeCategory TOCAT, typename VALUE >
common::IfNoLvalue< Expr< SomeKind< TOCAT > >, VALUE >	ConvertToKind (int kind, VALUE &&x)
template<TypeCategory CAT>
SameKindExprs< CAT, 2 >	AsSameKindExprs (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
ConvertRealOperandsResult	ConvertRealOperands (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
std::optional< Expr< SomeComplex > >	ConstructComplex (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
std::optional< Expr< SomeComplex > >	ConstructComplex (parser::ContextualMessages &, std::optional< Expr< SomeType > > &&, std::optional< Expr< SomeType > > &&, int defaultRealKind)
template<typename A >
Expr< TypeOf< A > >	ScalarConstantToExpr (const A &x)
template<template< typename > class OPR, typename SPECIFIC >
Expr< SPECIFIC >	Combine (Expr< SPECIFIC > &&x, Expr< SPECIFIC > &&y)
template<template< typename > class OPR, TypeCategory CAT>
Expr< SomeKind< CAT > >	PromoteAndCombine (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<template< typename > class OPR, bool CAN_BE_UNSIGNED = true>
std::optional< Expr< SomeType > >	NumericOperation (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Power, false > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Multiply > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Divide > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Add > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
template std::optional< Expr< SomeType > >	NumericOperation< Subtract > (parser::ContextualMessages &, Expr< SomeType > &&, Expr< SomeType > &&, int defaultRealKind)
std::optional< Expr< SomeType > >	Negation (parser::ContextualMessages &, Expr< SomeType > &&)
std::optional< Expr< LogicalResult > >	Relate (parser::ContextualMessages &, RelationalOperator, Expr< SomeType > &&, Expr< SomeType > &&)
template<typename T >
Expr< LogicalResult >	PackageRelation (RelationalOperator opr, Expr< T > &&x, Expr< T > &&y)
template<int K>
Expr< Type< TypeCategory::Logical, K > >	LogicalNegation (Expr< Type< TypeCategory::Logical, K > > &&x)
Expr< SomeLogical >	LogicalNegation (Expr< SomeLogical > &&)
template<int K>
Expr< Type< TypeCategory::Logical, K > >	BinaryLogicalOperation (LogicalOperator opr, Expr< Type< TypeCategory::Logical, K > > &&x, Expr< Type< TypeCategory::Logical, K > > &&y)
Expr< SomeLogical >	BinaryLogicalOperation (LogicalOperator, Expr< SomeLogical > &&, Expr< SomeLogical > &&)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator- (Expr< Type< C, K > > &&x)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator+ (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&y)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator- (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&y)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator* (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&y)
template<TypeCategory C, int K>
Expr< Type< C, K > >	operator/ (Expr< Type< C, K > > &&x, Expr< Type< C, K > > &&y)
template<TypeCategory C>
Expr< SomeKind< C > >	operator- (Expr< SomeKind< C > > &&x)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator+ (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator- (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator* (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CAT>
Expr< SomeKind< CAT > >	operator/ (Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory CATEGORY, template< typename > typename WRAPPER, typename WRAPPED >
common::IfNoLvalue< std::optional< Expr< SomeType > >, WRAPPED >	WrapperHelper (int kind, WRAPPED &&x)
template<template< typename > typename WRAPPER, typename WRAPPED >
common::IfNoLvalue< std::optional< Expr< SomeType > >, WRAPPED >	TypedWrapper (const DynamicType &dyType, WRAPPED &&x)
template<typename A >
const Symbol *	GetLastSymbol (const A &x)
template<typename A >
semantics::Attrs	GetAttrs (const A &x)
template<>
semantics::Attrs	GetAttrs< Expr< SomeType > > (const Expr< SomeType > &x)
template<typename A >
semantics::Attrs	GetAttrs (const std::optional< A > &x)
template<typename A >
std::optional< BaseObject >	GetBaseObject (const A &)
template<typename T >
std::optional< BaseObject >	GetBaseObject (const Designator< T > &x)
template<typename T >
std::optional< BaseObject >	GetBaseObject (const Expr< T > &x)
template<typename A >
std::optional< BaseObject >	GetBaseObject (const std::optional< A > &x)
bool	IsAllocatableOrPointerObject (const Expr< SomeType > &)
bool	IsAllocatableDesignator (const Expr< SomeType > &)
bool	IsProcedureDesignator (const Expr< SomeType > &)
bool	IsFunctionDesignator (const Expr< SomeType > &)
bool	IsPointer (const Expr< SomeType > &)
bool	IsProcedurePointer (const Expr< SomeType > &)
bool	IsProcedure (const Expr< SomeType > &)
bool	IsProcedurePointerTarget (const Expr< SomeType > &)
bool	IsBareNullPointer (const Expr< SomeType > *)
bool	IsNullObjectPointer (const Expr< SomeType > &)
bool	IsNullProcedurePointer (const Expr< SomeType > &)
bool	IsNullPointer (const Expr< SomeType > &)
bool	IsObjectPointer (const Expr< SomeType > &)
bool	MayBePassedAsAbsentOptional (const Expr< SomeType > &)
template<typename A >
SymbolVector	GetSymbolVector (const A &x)
const Symbol *	GetLastTarget (const SymbolVector &)
template<typename A >
semantics::UnorderedSymbolSet	CollectSymbols (const A &)
template semantics::UnorderedSymbolSet	CollectSymbols (const Expr< SomeType > &)
template semantics::UnorderedSymbolSet	CollectSymbols (const Expr< SomeInteger > &)
template semantics::UnorderedSymbolSet	CollectSymbols (const Expr< SubscriptInteger > &)
template<typename A >
semantics::UnorderedSymbolSet	CollectCudaSymbols (const A &)
template semantics::UnorderedSymbolSet	CollectCudaSymbols (const Expr< SomeType > &)
template semantics::UnorderedSymbolSet	CollectCudaSymbols (const Expr< SomeInteger > &)
template semantics::UnorderedSymbolSet	CollectCudaSymbols (const Expr< SubscriptInteger > &)
bool	HasVectorSubscript (const Expr< SomeType > &)
bool	HasConstant (const Expr< SomeType > &)
parser::Message *	AttachDeclaration (parser::Message &, const Symbol &)
parser::Message *	AttachDeclaration (parser::Message *, const Symbol &)
template<typename MESSAGES , typename... A>
parser::Message *	SayWithDeclaration (MESSAGES &messages, const Symbol &symbol, A &&...x)
std::optional< std::string >	FindImpureCall (FoldingContext &, const Expr< SomeType > &)
std::optional< std::string >	FindImpureCall (FoldingContext &, const ProcedureRef &)
template<typename T >
bool	IsExpandableScalar (const Expr< T > &expr, FoldingContext &context, const Shape &shape, bool admitPureCall=false)
std::optional< parser::MessageFixedText >	CheckProcCompatibility (bool isCall, const std::optional< characteristics::Procedure > &lhsProcedure, const characteristics::Procedure *rhsProcedure, const SpecificIntrinsic *specificIntrinsic, std::string &whyNotCompatible, std::optional< std::string > &warning, bool ignoreImplicitVsExplicit)
template<typename T >
Constant< T >	PackageConstant (std::vector< Scalar< T > > &&elements, const Constant< T > &reference, const ConstantSubscripts &shape)
std::optional< Expr< SomeType > >	DataConstantConversionExtension (FoldingContext &, const DynamicType &, const Expr< SomeType > &)
std::optional< Expr< SomeType > >	HollerithToBOZ (FoldingContext &, const Expr< SomeType > &, const DynamicType &)
template<typename T >
std::optional< bool >	AreEquivalentInInterface (const Expr< T > &, const Expr< T > &)
template std::optional< bool >	AreEquivalentInInterface< SubscriptInteger > (const Expr< SubscriptInteger > &, const Expr< SubscriptInteger > &)
template std::optional< bool >	AreEquivalentInInterface< SomeInteger > (const Expr< SomeInteger > &, const Expr< SomeInteger > &)
bool	CheckForCoindexedObject (parser::ContextualMessages &, const std::optional< ActualArgument > &, const std::string &procName, const std::string &argName)
bool	CanCUDASymbolHaveSaveAttr (const Symbol &sym)
bool	IsCUDADeviceSymbol (const Symbol &sym)
template<typename A >
int	GetNbOfCUDADeviceSymbols (const A &expr)
template<typename A >
bool	HasCUDADeviceAttrs (const A &expr)
bool	HasCUDAImplicitTransfer (const Expr< SomeType > &expr)
const semantics::DerivedTypeSpec *	GetDerivedTypeSpec (const DynamicType &)
const semantics::DerivedTypeSpec *	GetDerivedTypeSpec (const std::optional< DynamicType > &)
const semantics::DerivedTypeSpec *	GetParentTypeSpec (const semantics::DerivedTypeSpec &)
int	SelectedCharKind (const std::string &, int defaultKind)
std::optional< DynamicType >	ComparisonType (const DynamicType &, const DynamicType &)
std::optional< bool >	IsInteroperableIntrinsicType (const DynamicType &, const common::LanguageFeatureControl *=nullptr, bool checkCharLength=true)
bool	IsCUDAIntrinsicType (const DynamicType &)
bool	AreSameDerivedType (const semantics::DerivedTypeSpec &, const semantics::DerivedTypeSpec &)
bool	AreSameDerivedTypeIgnoringTypeParameters (const semantics::DerivedTypeSpec &, const semantics::DerivedTypeSpec &)
template<typename T >
void	ResetExpr (const T &x)
template<typename T >
void	SetExpr (const T &x, Expr< SomeType > &&expr)
bool	AreConformable (int leftRank, int rightRank)
template<typename L , typename R >
bool	AreConformable (const L &left, const R &right)
template<typename L , typename R >
void	ConformabilityCheck (parser::ContextualMessages &context, const L &left, const R &right)
template<int KIND>
Expr< Type< TypeCategory::Character, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Character, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Character, KIND > >	FoldOperation (FoldingContext &context, Concat< KIND > &&x)
template<int KIND>
Expr< Type< TypeCategory::Character, KIND > >	FoldOperation (FoldingContext &context, SetLength< KIND > &&x)
template<int KIND>
Expr< Type< TypeCategory::Complex, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Complex, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Complex, KIND > >	FoldOperation (FoldingContext &context, ComplexConstructor< KIND > &&x)
std::optional< Constant< SubscriptInteger > >	GetConstantSubscript (FoldingContext &, Subscript &, const NamedEntity &, int dim)
template<typename TR , typename... TA>
std::optional< std::function< Scalar< TR >(FoldingContext &, Scalar< TA >...)> >	GetHostRuntimeWrapper (const std::string &name)
template<typename A >
common::IfNoLvalue< Expr< ResultType< A > >, A >	FoldOperation (FoldingContext &, A &&x)
Component	FoldOperation (FoldingContext &, Component &&)
NamedEntity	FoldOperation (FoldingContext &, NamedEntity &&)
Triplet	FoldOperation (FoldingContext &, Triplet &&)
Subscript	FoldOperation (FoldingContext &, Subscript &&)
ArrayRef	FoldOperation (FoldingContext &, ArrayRef &&)
CoarrayRef	FoldOperation (FoldingContext &, CoarrayRef &&)
DataRef	FoldOperation (FoldingContext &, DataRef &&)
Substring	FoldOperation (FoldingContext &, Substring &&)
ComplexPart	FoldOperation (FoldingContext &, ComplexPart &&)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &, FunctionRef< T > &&)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Designator< T > &&designator)
Expr< TypeParamInquiry::Result >	FoldOperation (FoldingContext &, TypeParamInquiry &&)
Expr< ImpliedDoIndex::Result >	FoldOperation (FoldingContext &context, ImpliedDoIndex &&)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &, ArrayConstructor< T > &&)
Expr< SomeDerived >	FoldOperation (FoldingContext &, StructureConstructor &&)
template<typename... A, std::size_t... I>
std::optional< std::tuple< const Constant< A > *... > >	GetConstantArgumentsHelper (FoldingContext &context, ActualArguments &arguments, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename... A>
std::optional< std::tuple< const Constant< A > *... > >	GetConstantArguments (FoldingContext &context, ActualArguments &args, bool hasOptionalArgument)
template<typename... A, std::size_t... I>
std::optional< std::tuple< Scalar< A >... > >	GetScalarConstantArgumentsHelper (FoldingContext &context, ActualArguments &args, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename... A>
std::optional< std::tuple< Scalar< A >... > >	GetScalarConstantArguments (FoldingContext &context, ActualArguments &args, bool hasOptionalArgument)
template<template< typename, typename... > typename WrapperType, typename TR , typename... TA, std::size_t... I>
Expr< TR >	FoldElementalIntrinsicHelper (FoldingContext &context, FunctionRef< TR > &&funcRef, WrapperType< TR, TA... > func, bool hasOptionalArgument, std::index_sequence< I... >)
template<typename TR , typename... TA>
Expr< TR >	FoldElementalIntrinsic (FoldingContext &context, FunctionRef< TR > &&funcRef, ScalarFunc< TR, TA... > func, bool hasOptionalArgument=false)
template<typename TR , typename... TA>
Expr< TR >	FoldElementalIntrinsic (FoldingContext &context, FunctionRef< TR > &&funcRef, ScalarFuncWithContext< TR, TA... > func, bool hasOptionalArgument=false)
std::optional< std::int64_t >	GetInt64ArgOr (const std::optional< ActualArgument > &, std::int64_t defaultValue)
template<typename A , typename B >
std::optional< std::vector< A > >	GetIntegerVector (const B &x)
template<typename T >
Expr< T >	MakeInvalidIntrinsic (FunctionRef< T > &&funcRef)
std::optional< Expr< SomeType > >	FoldTransfer (FoldingContext &, const ActualArguments &)
template<typename T >
Expr< T >	FoldMINorMAX (FoldingContext &context, FunctionRef< T > &&funcRef, Ordering order)
template<typename T >
Expr< T >	RewriteSpecificMINorMAX (FoldingContext &context, FunctionRef< T > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&)
template<int KIND>
Expr< Type< TypeCategory::Unsigned, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Unsigned, KIND > > &&)
template<int KIND>
Expr< Type< TypeCategory::Real, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Real, KIND > > &&)
template<int KIND>
Expr< Type< TypeCategory::Logical, KIND > >	FoldIntrinsicFunction (FoldingContext &context, FunctionRef< Type< TypeCategory::Logical, KIND > > &&)
template<typename T >
bool	ArrayConstructorIsFlat (const ArrayConstructorValues< T > &values)
template<typename T >
std::optional< Expr< T > >	AsFlatArrayConstructor (const Expr< T > &expr)
template<TypeCategory CAT>
std::enable_if_t< CAT !=TypeCategory::Derived, std::optional< Expr< SomeKind< CAT > > > >	AsFlatArrayConstructor (const Expr< SomeKind< CAT > > &expr)
template<typename T >
std::optional< Expr< T > >	FromArrayConstructor (FoldingContext &context, ArrayConstructor< T > &&values, const Shape &shape)
template<typename RESULT , typename OPERAND >
std::optional< Expr< RESULT > >	MapOperation (FoldingContext &context, std::function< Expr< RESULT >(Expr< OPERAND > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, Expr< OPERAND > &&values)
template<typename RESULT , typename A >
ArrayConstructor< RESULT >	ArrayConstructorFromMold (const A &prototype, std::optional< Expr< SubscriptInteger > > &&length)
template<typename LEFT , typename RIGHT >
bool	ShapesMatch (FoldingContext &context, const ArrayConstructor< LEFT > &leftArrConst, const ArrayConstructor< RIGHT > &rightArrConst)
template<typename RESULT , typename LEFT , typename RIGHT >
auto	MapOperation (FoldingContext &context, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, Expr< LEFT > &&leftValues, Expr< RIGHT > &&rightValues) -> std::optional< Expr< RESULT > >
template<typename RESULT , typename LEFT , typename RIGHT >
auto	MapOperation (FoldingContext &context, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, Expr< LEFT > &&leftValues, const Expr< RIGHT > &rightScalar) -> std::optional< Expr< RESULT > >
template<typename RESULT , typename LEFT , typename RIGHT >
auto	MapOperation (FoldingContext &context, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f, const Shape &shape, std::optional< Expr< SubscriptInteger > > &&length, const Expr< LEFT > &leftScalar, Expr< RIGHT > &&rightValues) -> std::optional< Expr< RESULT > >
template<typename DERIVED , typename RESULT , typename... OPD>
std::optional< Expr< SubscriptInteger > >	ComputeResultLength (Operation< DERIVED, RESULT, OPD... > &operation)
template<typename DERIVED , typename RESULT , typename OPERAND >
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, OPERAND > &operation, std::function< Expr< RESULT >(Expr< OPERAND > &&)> &&f) -> std::optional< Expr< RESULT > >
template<typename DERIVED , typename RESULT , typename OPERAND >
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, OPERAND > &operation) -> std::optional< Expr< RESULT > >
template<typename DERIVED , typename RESULT , typename LEFT , typename RIGHT >
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, LEFT, RIGHT > &operation, std::function< Expr< RESULT >(Expr< LEFT > &&, Expr< RIGHT > &&)> &&f) -> std::optional< Expr< RESULT > >
template<typename DERIVED , typename RESULT , typename LEFT , typename RIGHT >
auto	ApplyElementwise (FoldingContext &context, Operation< DERIVED, RESULT, LEFT, RIGHT > &operation) -> std::optional< Expr< RESULT > >
template<typename TO , typename FROM >
common::IfNoLvalue< std::optional< TO >, FROM >	ConvertString (FROM &&s)
template<typename TO , TypeCategory FROMCAT>
Expr< TO >	FoldOperation (FoldingContext &context, Convert< TO, FROMCAT > &&convert)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Parentheses< T > &&x)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Negate< T > &&x)
template<typename LEFT , typename RIGHT >
std::optional< std::pair< Scalar< LEFT >, Scalar< RIGHT > > >	OperandsAreConstants (const Expr< LEFT > &x, const Expr< RIGHT > &y)
template<typename DERIVED , typename RESULT , typename LEFT , typename RIGHT >
std::optional< std::pair< Scalar< LEFT >, Scalar< RIGHT > > >	OperandsAreConstants (const Operation< DERIVED, RESULT, LEFT, RIGHT > &operation)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Add< T > &&x)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Subtract< T > &&x)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Multiply< T > &&x)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Divide< T > &&x)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Power< T > &&x)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, RealToIntPower< T > &&x)
template<typename T >
Expr< T >	FoldOperation (FoldingContext &context, Extremum< T > &&x)
template<int KIND>
Expr< Type< TypeCategory::Real, KIND > >	ToReal (FoldingContext &context, Expr< SomeType > &&expr)
template<int KIND>
Expr< Type< TypeCategory::Real, KIND > >	FoldOperation (FoldingContext &context, ComplexComponent< KIND > &&x)
template<typename T >
Expr< T >	PackageConstantBounds (const ConstantSubscripts &&bounds, bool asScalar=false)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	LBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	UBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&funcRef)
template<int KIND>
Expr< Type< TypeCategory::Integer, KIND > >	COBOUND (FoldingContext &context, FunctionRef< Type< TypeCategory::Integer, KIND > > &&funcRef, bool isUCOBOUND)
template<typename T >
std::optional< Expr< T > >	FoldIntrinsicFunctionCommon (FoldingContext &context, FunctionRef< T > &funcRef)
template<int X_RKIND, int MOLD_IKIND>
Expr< SomeReal >	RealToIntBoundHelper (bool round, bool negate)
template<int X_RKIND, int MOLD_RKIND>
std::optional< std::pair< Expr< SomeReal >, Expr< SomeReal > > >	RealToRealBoundsHelper ()
template<int X_IKIND, int MOLD_RKIND>
std::optional< Expr< SomeInteger > >	IntToRealBoundHelper (bool negate)
template<int X_IKIND, int MOLD_IKIND>
std::optional< Expr< SomeInteger > >	IntToIntBoundHelper ()
template<typename T >
Expr< LogicalResult >	FoldOperation (FoldingContext &context, Relational< T > &&relation)
Expr< LogicalResult >	FoldOperation (FoldingContext &context, Relational< SomeType > &&relation)
template<int KIND>
Expr< Type< TypeCategory::Logical, KIND > >	FoldOperation (FoldingContext &context, Not< KIND > &&x)
template<int KIND>
Expr< Type< TypeCategory::Logical, KIND > >	FoldOperation (FoldingContext &context, LogicalOperation< KIND > &&operation)
bool	CheckReductionDIM (std::optional< int > &dim, FoldingContext &context, ActualArguments &arg, std::optional< int > dimIndex, int rank)
Constant< LogicalResult > *	GetReductionMASK (std::optional< ActualArgument > &maskArg, const ConstantSubscripts &shape, FoldingContext &context)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const Symbol &symbol, std::optional< parser::CharBlock > name=std::nullopt)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::string &lit)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::u16string &lit)
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::u32string &lit)
template<typename A >
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const A &x)
template<typename A >
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, common::Reference< A > x)
template<typename A >
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const A *p, const char *kw=nullptr)
template<typename A >
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::optional< A > &x, const char *kw=nullptr)
template<typename A , bool COPY>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const common::Indirection< A, COPY > &p, const char *kw=nullptr)
template<typename A >
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::shared_ptr< A > &p)
template<typename... A>
llvm::raw_ostream &	EmitVar (llvm::raw_ostream &o, const std::variant< A... > &u)
template<typename A >
constexpr Precedence	ToPrecedence (const A &)
template<int KIND>
constexpr Precedence	ToPrecedence (const Not< KIND > &)
template<typename T >
constexpr Precedence	ToPrecedence (const Relational< T > &)
template<typename T >
constexpr Precedence	ToPrecedence (const Add< T > &)
template<typename T >
constexpr Precedence	ToPrecedence (const Subtract< T > &)
template<int KIND>
constexpr Precedence	ToPrecedence (const Concat< KIND > &)
template<typename T >
constexpr Precedence	ToPrecedence (const Negate< T > &)
template<typename T >
constexpr Precedence	ToPrecedence (const Multiply< T > &)
template<typename T >
constexpr Precedence	ToPrecedence (const Divide< T > &)
template<typename T >
constexpr Precedence	ToPrecedence (const Power< T > &)
template<typename T >
constexpr Precedence	ToPrecedence (const RealToIntPower< T > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const A &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const Negate< A > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const Parentheses< A > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const Not< KIND > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const SetLength< KIND > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const ComplexConstructor< KIND > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const Add< A > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const Subtract< A > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const Multiply< A > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const Divide< A > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const Power< A > &)
template<typename A >
constexpr OperatorSpelling	SpellOperator (const RealToIntPower< A > &)
template<int KIND>
constexpr OperatorSpelling	SpellOperator (const Concat< KIND > &)
template<typename T >
llvm::raw_ostream &	EmitArray (llvm::raw_ostream &o, const Expr< T > &expr)
template<typename T >
llvm::raw_ostream &	EmitArray (llvm::raw_ostream &, const ArrayConstructorValues< T > &)
template<typename T >
llvm::raw_ostream &	EmitArray (llvm::raw_ostream &o, const ImpliedDo< T > &implDo)
template<typename REAL , typename INT >
ValueWithRealFlags< REAL >	TimesIntPowerOf (const REAL &factor, const REAL &base, const INT &power, Rounding rounding=TargetCharacteristics::defaultRounding)
template<typename REAL , typename INT >
ValueWithRealFlags< REAL >	IntPower (const REAL &base, const INT &power, Rounding rounding=TargetCharacteristics::defaultRounding)
bool	operator== (const TypeVector &lhs, const std::vector< DynamicType > &rhs)
template<typename HostTR , typename... HostTA>
Expr< SomeType >	ApplyHostFunction (FuncPointer< HostTR, HostTA... > func, FoldingContext &context, std::vector< Expr< SomeType > > &&args)
const ArgumentVerifierFunc *	findVerifier (const std::string &intrinsicName)
	ENUM_CLASS (KindCode, none, defaultIntegerKind, defaultRealKind, doublePrecision, defaultCharKind, defaultLogicalKind, greaterOrEqualToKind, any, same, sameKind, operand, typeless, ieeeFlagType, ieeeRoundType, teamType, kindArg, effectiveKind, dimArg, likeMultiply, subscript, size, addressable, nullPointerType, exactKind, atomicIntKind, atomicIntOrLogicalKind, sameAtom,) struct TypePattern
	ENUM_CLASS (Rank, elemental, elementalOrBOZ, scalar, vector, shape, matrix, array, coarray, atom, known, anyOrAssumedRank, arrayOrAssumedRank, conformable, reduceOperation, dimReduced, dimRemovedOrScalar, scalarIfDim, locReduced, rankPlus1, shaped,) ENUM_CLASS(Optionality
	ENUM_CLASS (ArgFlag, none, canBeNull, canBeMoldNull, defaultsToSameKind, defaultsToSizeKind, defaultsToDefaultForResult, notAssumedSize) struct IntrinsicDummyArgument
template<TypeCategory CAT>
std::optional< Expr< SomeType > >	Package (Expr< SomeKind< CAT > > &&catExpr)
template<TypeCategory CAT>
std::optional< Expr< SomeType > >	Package (std::optional< Expr< SomeKind< CAT > > > &&catExpr)
template<template< typename > class OPR>
std::optional< Expr< SomeType > >	MixedRealLeft (Expr< SomeReal > &&rx, Expr< SomeInteger > &&iy)
template<int KIND>
Expr< SomeComplex >	MakeComplex (Expr< Type< TypeCategory::Real, KIND > > &&re, Expr< Type< TypeCategory::Real, KIND > > &&im)
Expr< SomeComplex >	PromoteRealToComplex (Expr< SomeReal > &&someX)
template<template< typename > class OPR, TypeCategory RCAT>
std::optional< Expr< SomeType > >	MixedComplexLeft (parser::ContextualMessages &messages, const Expr< SomeComplex > &zx, const Expr< SomeKind< RCAT > > &iry, int defaultRealKind)
template<template< typename > class OPR, TypeCategory LCAT>
std::optional< Expr< SomeType > >	MixedComplexRight (parser::ContextualMessages &messages, const Expr< SomeKind< LCAT > > &irx, const Expr< SomeComplex > &zy, int defaultRealKind)
template<template< typename > class OPR, TypeCategory XCAT, TypeCategory YCAT>
Expr< SomeComplex >	PromoteMixedComplexReal (Expr< SomeKind< XCAT > > &&x, Expr< SomeKind< YCAT > > &&y)
template<TypeCategory CAT>
Expr< LogicalResult >	PromoteAndRelate (RelationalOperator opr, Expr< SomeKind< CAT > > &&x, Expr< SomeKind< CAT > > &&y)
template<TypeCategory TO>
std::optional< Expr< SomeType > >	ConvertToNumeric (int kind, Expr< SomeType > &&x)
template<typename T >
const Symbol *	GetBoundSymbol (const Expr< T > &)
template<int KIND>
const Symbol *	GetBoundSymbol (const Expr< Type< TypeCategory::Integer, KIND > > &expr)
template<>
const Symbol *	GetBoundSymbol< SomeInteger > (const Expr< SomeInteger > &expr)
template<typename A >
bool	PointeeComparison (const A *x, const A *y)
bool	operator< (ActualArgumentRef x, ActualArgumentRef y)
template<typename A >
common::IfNoLvalue< MaybeExpr, A >	AsMaybeExpr (A &&x)
template<typename A >
MaybeExpr	AsMaybeExpr (std::optional< A > &&x)
template<typename TYPE >
Constant< TYPE >	ReadRealLiteral (parser::CharBlock source, FoldingContext &context)
template<typename T >
ArrayConstructorValues< T >	MakeSpecific (ArrayConstructorValues< SomeType > &&from)
template<>
const Symbol *	AssumedTypeDummy< parser::Name > (const parser::Name &name)
template<>
const Symbol *	AssumedTypeDummy< parser::AllocateObject > (const parser::AllocateObject &x)
template<>
const Symbol *	AssumedTypeDummy< parser::PointerObject > (const parser::PointerObject &x)
template<template< typename > class OPR, NumericOperator opr>
MaybeExpr	NumericBinaryHelper (ExpressionAnalyzer &context, const parser::Expr::IntrinsicBinary &x)
MaybeExpr	RelationHelper (ExpressionAnalyzer &context, RelationalOperator opr, const parser::Expr::IntrinsicBinary &x)
MaybeExpr	LogicalBinaryHelper (ExpressionAnalyzer &context, LogicalOperator opr, const parser::Expr::IntrinsicBinary &x)

Variables
template<typename T >
constexpr bool	IsSpecificIntrinsicType {common::HasMember<T, AllIntrinsicTypes>}
template<typename T >
constexpr bool	IsLengthlessIntrinsicType
	required
	optional
	missing
	repeats

Detailed Description

Implements the conversion from evaluate::ArrayConstructor to HLFIR.

Function Documentation

HasCUDAImplicitTransfer()

bool Fortran::evaluate::HasCUDAImplicitTransfer ( const Expr< SomeType > &  expr )

inline

Check if the expression is a mix of host and device variables that require implicit data transfer.

Variable Documentation

IsLengthlessIntrinsicType

template<typename T >

constexpr bool Fortran::evaluate::IsLengthlessIntrinsicType

constexpr

Initial value:

{
    common::HasMember<T, LengthlessIntrinsicTypes>}