Classes
struct	AccAtomicCapture

struct	AccAtomicRead

struct	AccAtomicUpdate

struct	AccAtomicWrite

struct	AccBeginBlockDirective

struct	AccBeginCombinedDirective

struct	AccBeginLoopDirective

struct	AccBindClause

struct	AccBlockDirective

struct	AccClause

struct	AccClauseList

struct	AccCollapseArg

struct	AccCombinedDirective

struct	AccDataModifier

struct	AccDeclarativeDirective

struct	AccDefaultClause

struct	AccDeviceTypeExpr

struct	AccDeviceTypeExprList

struct	AccEndBlockDirective

struct	AccEndCombinedDirective

struct	AccessSpec

struct	AccessStmt

struct	AccGangArg

struct	AccGangArgList

struct	AccLoopDirective

struct	AccObject

struct	AccObjectListWithModifier

struct	AccObjectListWithReduction

struct	AccSelfClause

struct	AccSizeExpr

struct	AccSizeExprList

struct	AccStandaloneDirective

struct	AccTileExpr

struct	AccTileExprList

struct	AccWaitArgument

struct	AcImpliedDo

struct	AcImpliedDoControl

struct	AcSpec

struct	ActionStmt

struct	ActualArg

struct	ActualArgSpec

struct	AcValue

class	AllCookedSources

struct	AllocateCoarraySpec

struct	AllocateObject

struct	AllocateShapeSpec

struct	AllocateStmt

struct	Allocation

struct	AllocOpt

class	AllSources

class	AlternativesParser

struct	AnalyzedObjectsAsFortran

class	AnyOfChars

class	ApplyConstructor

class	ApplyFunction

class	ApplyMemberFunction

struct	ArithmeticIfStmt

struct	ArrayElement

struct	ArraySpec

struct	AssignedGotoStmt

struct	AssignmentStmt

struct	AssignStmt

struct	AssociateConstruct

struct	AssociateStmt

struct	Association

struct	AssumedSizeSpec

struct	AttrSpec

class	BacktrackingParser

struct	BasedPointer

struct	BindAttr

struct	BindEntity

struct	BindStmt

struct	BlockConstruct

struct	BlockData

struct	BoundsRemapping

struct	BOZLiteral

struct	Call

struct	CallStmt

class	CanonicalizationOfDoLoops

struct	CapturedLabelDoStmt

struct	CaseConstruct

struct	CaseSelector

struct	CaseStmt

struct	CaseValueRange

struct	ChangeTeamConstruct

struct	ChangeTeamStmt

class	CharBlock

struct	CharBlockPointerComparator

class	CharBuffer

struct	CharLength

struct	CharLiteral

struct	CharLiteralChar

struct	CharLiteralConstant

struct	CharLiteralConstantSubstring

struct	CharSelector

struct	CloseStmt

struct	CoarrayAssociation

struct	CoarraySpec

struct	CodimensionDecl

struct	CoindexedNamedObject

struct	CommonBlockObject

struct	CommonStmt

struct	CompilerDirective

struct	ComplexLiteralConstant

struct	ComplexPart

struct	ComponentArraySpec

struct	ComponentAttrSpec

struct	ComponentDecl

struct	ComponentDefStmt

struct	ComponentOrFill

struct	ComponentSpec

struct	ComputedGotoStmt

struct	ConcurrentControl

struct	ConcurrentHeader

struct	ConnectSpec

struct	ConsParser

struct	Constant

struct	ConsumedAllInputParser

class	ContextualMessages

class	CookedSource

struct	CriticalConstruct

struct	CriticalStmt

struct	CUDAAttributesStmt

struct	CUFKernelDoConstruct

struct	CUFReduction

struct	DataComponentDefStmt

struct	DataIDoObject

struct	DataImpliedDo

struct	DataRef

struct	DataStmtConstant

struct	DataStmtObject

struct	DataStmtRepeat

struct	DataStmtSet

struct	DataStmtValue

struct	DeallocateStmt

class	DebugParser

struct	DeclarationConstruct

struct	DeclarationTypeSpec

struct	DecodedCharacter

struct	DefaultChar

class	DefaultedParser

struct	DefinedOperator

class	Definition

class	DeprecatedParser

struct	DerivedTypeDef

struct	DerivedTypeSpec

struct	DerivedTypeStmt

struct	Designator

struct	DigitString

struct	DigitString64

struct	DigitStringIgnoreSpaces

struct	DimensionStmt

struct	DoConstruct

struct	DummyArg

struct	ElseIfStmt

struct	EncodedCharacter

struct	EndChangeTeamStmt

struct	EndDoStmtForCapturedLabelDoStmt

struct	EnterNonlabelDoConstruct

struct	EntityDecl

struct	EntryStmt

struct	EnumDef

struct	Enumerator

struct	EventPostStmt

struct	EventWaitSpec

struct	EventWaitStmt

struct	ExecutableConstruct

struct	ExecutionPartConstruct

struct	ExplicitCoshapeSpec

struct	ExplicitShapeSpec

struct	Expr

class	FailParser

struct	FillDecl

class	FollowParser

struct	ForallAssignmentStmt

struct	ForallBodyConstruct

struct	ForallConstruct

struct	ForallConstructStmt

struct	ForallStmt

struct	Format

struct	FormTeamStmt

struct	FunctionReference

struct	FunctionStmt

struct	FunctionSubprogram

struct	GenericSpec

struct	GenericStmt

struct	GetSourceHelper

struct	HasSource

struct	HasSource< A, decltype(static_cast< void >(A::source), 0)>

struct	HasTypedExpr

struct	HasTypedExpr< A, decltype(static_cast< void >(A::typedExpr), 0)>

struct	HollerithLiteral

struct	HollerithLiteralConstant

struct	IfConstruct

struct	IfStmt

struct	IfThenStmt

struct	ImageSelector

struct	ImageSelectorSpec

struct	ImplicitPartStmt

struct	ImplicitSpec

struct	ImplicitStmt

struct	ImportStmt

struct	Initialization

struct	InputImpliedDo

struct	InputItem

struct	InquireSpec

struct	InquireStmt

class	InstrumentedParser

struct	Integer

struct	IntentSpec

struct	IntentStmt

struct	InterfaceBlock

struct	InterfaceBody

struct	InterfaceSpecification

struct	InterfaceStmt

struct	InternalSubprogram

struct	InternalSubprogramPart

struct	IntLiteralConstant

struct	IntrinsicTypeSpec

struct	IoControlSpec

struct	IoUnit

struct	KindParam

struct	KindSelector

struct	LabelDoStmt

struct	LanguageBindingSpec

struct	LeaveDoConstruct

struct	LengthSelector

struct	LetterSpec

struct	LiteralConstant

struct	LocalitySpec

struct	LockStmt

struct	Logical

struct	LogicalLiteralConstant

class	LookAheadParser

struct	LoopBounds

struct	LoopControl

struct	LooselyStructuredBlockParser

struct	MainProgram

class	ManyParser

struct	Map

struct	MaskedElsewhereStmt

class	MaybeParser

class	Message

class	MessageContextParser

class	MessageExpectedText

class	MessageFixedText

class	MessageFormattedText

class	Messages

struct	ModifierList

struct	Module

struct	ModuleSubprogram

struct	ModuleSubprogramPart

struct	Mutator

struct	Name

struct	NamedConstantDef

struct	NamelistStmt

class	NegatedParser

struct	NestedStructureStmt

struct	NextCh

class	NonemptySeparated

struct	NonLabelDoStmt

class	NonstandardParser

struct	NotifyWaitStmt

struct	ObjectDecl

class	OffsetToProvenanceMappings

struct	OkParser

struct	OldStructureComponentName

struct	OmpAbsentClause

struct	OmpAccessGroup

struct	OmpAdjustArgsClause

struct	OmpAffinityClause

struct	OmpAlignClause

struct	OmpAlignedClause

struct	OmpAlignment

struct	OmpAlignModifier

struct	OmpAllocateClause

struct	OmpAllocatorComplexModifier

struct	OmpAllocatorSimpleModifier

struct	OmpAlwaysModifier

struct	OmpAppendArgsClause

struct	OmpArgument

struct	OmpArgumentList

struct	OmpAtClause

struct	OmpAtomicConstructParser

struct	OmpAtomicDefaultMemOrderClause

struct	OmpAutomapModifier

struct	OmpBeginDirective

struct	OmpBeginLoopDirective

struct	OmpBeginSectionsDirective

struct	OmpBindClause

struct	OmpBlockConstruct

struct	OmpBlockConstructParser

struct	OmpCancellationConstructTypeClause

struct	OmpChunkModifier

struct	OmpClause

struct	OmpClauseList

struct	OmpCloseModifier

struct	OmpContainsClause

struct	OmpContextSelectorSpecification

struct	OmpDeclareTargetSpecifier

struct	OmpDeclareTargetWithClause

struct	OmpDeclareTargetWithList

struct	OmpDeclareVariantDirective

struct	OmpDefaultClause

struct	OmpDefaultmapClause

struct	OmpDeleteModifier

struct	OmpDependClause

struct	OmpDependenceType

struct	OmpDetachClause

struct	OmpDeviceClause

struct	OmpDeviceModifier

struct	OmpDeviceTypeClause

struct	OmpDirectiveName

struct	OmpDirectiveNameModifier

struct	OmpDirectiveNameParser
	Parse OpenMP directive name (this includes compound directives). More...

struct	OmpDirectiveSpecification

struct	OmpDoacross

struct	OmpDynGroupprivateClause

struct	OmpEndDirective

struct	OmpEndDirectiveParser

struct	OmpEndLoopDirective

struct	OmpEndSectionsDirective

struct	OmpEnterClause

struct	OmpErrorDirective

struct	OmpExpectation

struct	OmpFailClause

struct	OmpFromClause

struct	OmpGrainsizeClause

struct	OmpHintClause

struct	OmpHoldsClause

struct	OmpIfClause

struct	OmpIndirectClause

struct	OmpInitClause

struct	OmpInitializerClause

struct	OmpInitializerProc

struct	OmpInReductionClause

struct	OmpInteropPreference

struct	OmpInteropRuntimeIdentifier

struct	OmpInteropType

struct	OmpIteration

struct	OmpIterationOffset

struct	OmpIterator

struct	OmpIteratorSpecifier

struct	OmpLastprivateClause

struct	OmpLastprivateModifier

struct	OmpLinearClause

struct	OmpLinearModifier

struct	OmpLocator

struct	OmpLoopDirective

struct	OmpMapClause

struct	OmpMapper

struct	OmpMapperSpecifier

struct	OmpMapType

struct	OmpMapTypeModifier

struct	OmpMatchClause

struct	OmpMessageClause

struct	OmpMetadirectiveDirective

struct	OmpNothingDirective

struct	OmpNumTasksClause

struct	OmpObject

struct	OmpOrderClause

struct	OmpOrderingModifier

struct	OmpOrderModifier

struct	OmpOtherwiseClause

struct	OmpPrescriptiveness

struct	OmpPresentModifier

struct	OmpProcBindClause

struct	OmpReductionClause

struct	OmpReductionCombiner

struct	OmpReductionIdentifier

struct	OmpReductionModifier

struct	OmpReductionSpecifier

struct	OmpRefModifier

struct	OmpScheduleClause

struct	OmpSectionsDirective

struct	OmpSelfModifier

struct	OmpSeverityClause

struct	OmpStatementConstructParser

struct	OmpStepComplexModifier

struct	OmpStepSimpleModifier

struct	OmpTaskDependenceType

struct	OmpTaskReductionClause

struct	OmpToClause

struct	OmpTraitProperty

struct	OmpTraitPropertyExtension

struct	OmpTraitPropertyName

struct	OmpTraitScore

struct	OmpTraitSelector

struct	OmpTraitSelectorName

struct	OmpTraitSetSelector

struct	OmpTraitSetSelectorName

struct	OmpTypeSpecifier

struct	OmpUpdateClause

struct	OmpVariableCategory

struct	OmpWhenClause

struct	OmpxHoldModifier

struct	Only

struct	OpenACCAtomicConstruct

struct	OpenACCBlockConstruct

struct	OpenACCCacheConstruct

struct	OpenACCCombinedConstruct

struct	OpenACCConstruct

struct	OpenACCDeclarativeConstruct

struct	OpenACCEndConstruct

struct	OpenACCLoopConstruct

struct	OpenACCRoutineConstruct

struct	OpenACCStandaloneConstruct

struct	OpenACCStandaloneDeclarativeConstruct

struct	OpenACCWaitConstruct

struct	OpenMPAllocatorsConstruct

struct	OpenMPAssumeConstruct

struct	OpenMPAtomicConstruct

struct	OpenMPCancelConstruct

struct	OpenMPCancellationPointConstruct

struct	OpenMPConstruct

struct	OpenMPCriticalConstruct

struct	OpenMPDeclarativeAllocate

struct	OpenMPDeclarativeAssumes

struct	OpenMPDeclarativeConstruct

struct	OpenMPDeclareMapperConstruct

struct	OpenMPDeclareReductionConstruct

struct	OpenMPDeclareSimdConstruct

struct	OpenMPDeclareTargetConstruct

struct	OpenMPDepobjConstruct

struct	OpenMPDispatchConstruct

struct	OpenMPExecDirective

struct	OpenMPExecutableAllocate

struct	OpenMPFlushConstruct

struct	OpenMPGroupprivate

struct	OpenMPInteropConstruct

struct	OpenMPLoopConstruct

struct	OpenMPRequiresConstruct

struct	OpenMPSectionConstruct

struct	OpenMPSectionsConstruct

struct	OpenMPSimpleStandaloneConstruct

struct	OpenMPStandaloneConstruct

struct	OpenMPThreadprivate

struct	OpenMPUtilityConstruct

struct	Options

struct	OtherSpecificationStmt

struct	OutputImpliedDo

struct	OutputItem

struct	ParentIdentifier

struct	Parser

class	ParseState

class	ParseTreeDumper

class	Parsing

class	ParsingLog

struct	PartRef

struct	PointerAssignmentStmt

struct	PointerDecl

struct	PointerObject

struct	PositionOrFlushSpec

struct	PositiveDigitStringIgnoreSpaces

struct	PredicatedParser

struct	PrefixSpec

class	Preprocessor

class	Prescanner

struct	PrintStmt

struct	PrivateOrSequence

struct	ProcAttrSpec

struct	ProcComponentAttrSpec

struct	ProcComponentDefStmt

struct	ProcComponentRef

struct	ProcDecl

struct	ProcedureDeclarationStmt

struct	ProcedureDesignator

struct	ProcedureStmt

struct	ProcInterface

struct	ProcPointerInit

struct	ProgramUnit

class	Provenance

class	ProvenanceRangeToOffsetMappings

class	PureDefaultParser

class	PureParser

struct	ReadStmt

struct	RealLiteralConstant

class	RecoveryParser

struct	ReductionOperator

struct	Rename

struct	SavedEntity

struct	Scalar

struct	SectionSubscript

struct	SelectCaseStmt

struct	Selector

struct	SelectRankCaseStmt

struct	SelectRankConstruct

struct	SelectRankStmt

struct	SelectTypeConstruct

struct	SelectTypeStmt

struct	SeparateModuleSubprogram

class	SequenceParser

struct	SetOfChars

struct	SignedComplexLiteralConstant

struct	SignedDigitString

struct	SignedDigitStringIgnoreSpaces

struct	SignedIntLiteralConstant

struct	SignedIntLiteralConstantWithoutKind

struct	SignedRealLiteralConstant

class	SkipManyFastParser

class	SkipManyParser

struct	SkipPast

struct	SkipPastNested

struct	SkipStuffBeforeStatement

struct	SkipTo

class	SomeParser

class	SourcedParser

class	SourceFile

struct	SourceLocationFindingVisitor

struct	SourcePosition

struct	Space

struct	SpaceCheck

struct	SpecificationConstruct

struct	SpecificationPart

struct	SpecificModifierParser

struct	StartNewSubprogram

struct	Statement

struct	StatOrErrmsg

struct	StmtFunctionStmt

struct	StopStmt

struct	StrictlyStructuredBlockParser

struct	StructureComponent

struct	StructureComponents

struct	StructureConstructor

struct	StructureDef

struct	StructureField

struct	StructureStmt

struct	Submodule

struct	SubmoduleStmt

struct	SubroutineStmt

struct	SubroutineSubprogram

struct	SubscriptTriplet

struct	Substring

struct	SubstringInquiry

struct	SubstringRange

class	Success

struct	Suffix

struct	SyncImagesStmt

struct	SyncTeamStmt

class	TokenSequence

class	TokenStringMatch

struct	TraitSelectorParser

struct	TypeAttrSpec

struct	TypeBoundGenericStmt

struct	TypeBoundProcBinding

struct	TypeBoundProcDecl

struct	TypeBoundProcedurePart

struct	TypeBoundProcedureStmt

struct	TypeDeclarationStmt

struct	TypeGuardStmt

struct	TypeParamDecl

struct	TypeParamDefStmt

struct	TypeParamSpec

struct	TypeParamValue

struct	TypeSpec

struct	Union

struct	UnlabeledStatement

struct	UnlockStmt

class	UnparseVisitor

struct	UnsignedLiteralConstant

struct	UnwrapParser

struct	UnwrapperHelper

class	UserState

struct	UseStmt

struct	Variable

struct	VectorElementType

struct	VectorTypeSpec

struct	Verbatim

struct	WaitSpec

struct	WhereBodyConstruct

struct	WhereConstruct

struct	WhereConstructStmt

struct	WhereStmt

class	WithMessageParser

struct	WriteStmt

Typedefs
using	Location = const char *

using	LogicalExpr = Logical< common::Indirection< Expr > >

using	DefaultCharExpr = DefaultChar< common::Indirection< Expr > >

using	IntExpr = Integer< common::Indirection< Expr > >

using	ConstantExpr = Constant< common::Indirection< Expr > >

using	IntConstantExpr = Integer< ConstantExpr >

using	ScalarLogicalExpr = Scalar< LogicalExpr >

using	ScalarIntExpr = Scalar< IntExpr >

using	ScalarIntConstantExpr = Scalar< IntConstantExpr >

using	ScalarDefaultCharExpr = Scalar< DefaultCharExpr >

using	ScalarDefaultCharConstantExpr = Scalar< DefaultChar< ConstantExpr > >

using	Label = common::Label

using	Block = std::list< ExecutionPartConstruct >

using	ObjectName = Name

using	InitialDataTarget = common::Indirection< Designator >

using	DoVariable = Scalar< Integer< Name > >

using	ScalarName = Scalar< Name >

using	ScalarExpr = Scalar< common::Indirection< Expr > >

using	ConstantSubobject = Constant< common::Indirection< Designator > >

using	TypedExpr = common::ForwardOwningPointer< evaluate::GenericExprWrapper >

using	Subscript = ScalarIntExpr

using	Cosubscript = ScalarIntExpr

using	ScalarLogicalVariable = Scalar< Logical< Variable > >

using	ScalarDefaultCharVariable = Scalar< DefaultChar< Variable > >

using	ScalarIntVariable = Scalar< Integer< Variable > >

using	BoundExpr = ScalarIntExpr

using	AllocateCoshapeSpec = AllocateShapeSpec

using	CaseValue = Scalar< ConstantExpr >

using	EventVariable = Scalar< Variable >

using	TeamVariable = Scalar< Variable >

using	LockVariable = Scalar< Variable >

using	FileNameExpr = ScalarDefaultCharExpr

using	IoImpliedDoControl = LoopBounds< DoVariable, ScalarIntExpr >

using	OmpContextSelector = traits::OmpContextSelectorSpecification

using	OmpDirectiveList = std::list< llvm::omp::Directive >

using	NestedConstruct = std::variant< DoConstruct, common::Indirection< OpenMPLoopConstruct > >

using	ProvenanceRange = common::Interval< Provenance >

using	preStatementType = std::function< void(const CharBlock &, llvm::raw_ostream &, int)>

template<typename... PARSER>
using	ApplyArgs = std::tuple< std::optional< typename PARSER::resultType >... >

template<typename RESULT , typename... PARSER>
using	ApplicableFunctionPointer = RESULT(*)(typename PARSER::resultType &&...)

template<typename RESULT , typename... PARSER>
using	ApplicableFunctionObject = const std::function< RESULT(typename PARSER::resultType &&...)> &

Enumerations
enum class	Encoding { LATIN_1 , UTF_8 }

enum class	Severity { Error , Warning , Portability , Because , Context , Todo , None }

enum class	Sign { Positive , Negative }

Functions
bool	operator< (const char *left, const CharBlock &right)

bool	operator<= (const char *left, const CharBlock &right)

bool	operator== (const char *left, const CharBlock &right)

bool	operator!= (const char *left, const CharBlock &right)

bool	operator>= (const char *left, const CharBlock &right)

bool	operator> (const char *left, const CharBlock &right)

llvm::raw_ostream &	operator<< (llvm::raw_ostream &os, const CharBlock &x)

constexpr bool	IsUpperCaseLetter (char ch)

constexpr bool	IsLowerCaseLetter (char ch)

constexpr bool	IsLetter (char ch)

constexpr bool	IsDecimalDigit (char ch)

constexpr bool	IsHexadecimalDigit (char ch)

constexpr bool	IsOctalDigit (char ch)

constexpr bool	IsLegalIdentifierStart (char ch)

constexpr bool	IsLegalInIdentifier (char ch)

constexpr bool	IsPrintable (char ch)

constexpr bool	IsWhiteSpace (char ch)

constexpr char	ToLowerCaseLetter (char ch)

constexpr char	ToLowerCaseLetter (char &&ch)

std::string	ToLowerCaseLetters (std::string_view str)

constexpr char	ToUpperCaseLetter (char ch)

constexpr char	ToUpperCaseLetter (char &&ch)

std::string	ToUpperCaseLetters (std::string_view str)

constexpr bool	IsSameApartFromCase (char x, char y)

constexpr char	DecimalDigitValue (char ch)

constexpr char	HexadecimalDigitValue (char ch)

constexpr std::optional< char >	BackslashEscapeValue (char ch)

constexpr std::optional< char >	BackslashEscapeChar (char ch)

constexpr bool	IsValidFortranTokenCharacter (char ch)

template<Encoding ENCODING>
EncodedCharacter	EncodeCharacter (char32_t ucs)

template<>
EncodedCharacter	EncodeCharacter< Encoding::LATIN_1 > (char32_t)

template<>
EncodedCharacter	EncodeCharacter< Encoding::UTF_8 > (char32_t)

EncodedCharacter	EncodeCharacter (Encoding, char32_t ucs)

template<Encoding ENCODING, typename STRING >
std::string	EncodeString (const STRING &)

template std::string	EncodeString< Encoding::LATIN_1, std::string > (const std::string &)

template std::string	EncodeString< Encoding::UTF_8, std::u32string > (const std::u32string &)

template<typename NORMAL , typename INSERTED >
void	EmitQuotedChar (char32_t ch, const NORMAL &emit, const INSERTED &insert, bool backslashEscapes=true, Encoding encoding=Encoding::UTF_8)

std::string	QuoteCharacterLiteral (const std::string &, bool backslashEscapes=true, Encoding=Encoding::LATIN_1)

std::string	QuoteCharacterLiteral (const std::u16string &, bool backslashEscapes=true, Encoding=Encoding::UTF_8)

std::string	QuoteCharacterLiteral (const std::u32string &, bool backslashEscapes=true, Encoding=Encoding::UTF_8)

int	UTF_8CharacterBytes (const char *)

template<Encoding ENCODING>
DecodedCharacter	DecodeRawCharacter (const char *, std::size_t)

template<>
DecodedCharacter	DecodeRawCharacter< Encoding::LATIN_1 > (const char *, std::size_t)

template<>
DecodedCharacter	DecodeRawCharacter< Encoding::UTF_8 > (const char *, std::size_t)

template<Encoding ENCODING>
DecodedCharacter	DecodeCharacter (const char *, std::size_t, bool backslashEscapes)

template DecodedCharacter	DecodeCharacter< Encoding::LATIN_1 > (const char *, std::size_t, bool)

template DecodedCharacter	DecodeCharacter< Encoding::UTF_8 > (const char *, std::size_t, bool)

DecodedCharacter	DecodeCharacter (Encoding, const char *, std::size_t, bool backslashEscapes)

template<typename RESULT , Encoding ENCODING>
RESULT	DecodeString (const std::string &, bool backslashEscapes)

template std::string	DecodeString< std::string, Encoding::LATIN_1 > (const std::string &, bool)

template std::u16string	DecodeString< std::u16string, Encoding::UTF_8 > (const std::string &, bool)

template std::u32string	DecodeString< std::u32string, Encoding::UTF_8 > (const std::string &, bool)

template<typename T >
llvm::raw_ostream &	DumpTree (llvm::raw_ostream &out, const T &x, const AnalyzedObjectsAsFortran *asFortran=nullptr)

template<typename PA >
constexpr auto	instrumented (const MessageFixedText &tag, const PA &parser)

constexpr MessageFixedText	operator""_err_en_US (const char str[], std::size_t n)

constexpr MessageFixedText	operator""_warn_en_US (const char str[], std::size_t n)

constexpr MessageFixedText	operator""_port_en_US (const char str[], std::size_t n)

constexpr MessageFixedText	operator""_because_en_US (const char str[], std::size_t n)

constexpr MessageFixedText	operator""_todo_en_US (const char str[], std::size_t n)

constexpr MessageFixedText	operator""_en_US (const char str[], std::size_t n)

template<typename A , typename V >
void	Walk (const A &x, V &visitor)

template<typename A , typename M >
void	Walk (A &x, M &mutator)

	EMPTY_CLASS (ErrorRecovery)

	WRAPPER_CLASS (ImplicitPart, std::list< ImplicitPartStmt >)

	EMPTY_CLASS (ContainsStmt)

	EMPTY_CLASS (ContinueStmt)

	EMPTY_CLASS (FailImageStmt)

	WRAPPER_CLASS (ExecutionPart, Block)

	WRAPPER_CLASS (Program, std::list< ProgramUnit >)

	WRAPPER_CLASS (Keyword, Name)

	WRAPPER_CLASS (NamedConstant, Name)

	WRAPPER_CLASS (DefinedOpName, Name)

	EMPTY_CLASS (Star)

	WRAPPER_CLASS (IntegerTypeSpec, std::optional< KindSelector >)

	WRAPPER_CLASS (UnsignedTypeSpec, std::optional< KindSelector >)

	WRAPPER_CLASS (IntrinsicVectorTypeSpec, VectorElementType)

	WRAPPER_CLASS (BOZLiteralConstant, std::string)

	EMPTY_CLASS (Abstract)

	EMPTY_CLASS (SequenceStmt)

	EMPTY_CLASS (PrivateStmt)

	WRAPPER_CLASS (SpecificationExpr, ScalarIntExpr)

	WRAPPER_CLASS (DeferredCoshapeSpecList, int)

	WRAPPER_CLASS (DeferredShapeSpecList, int)

	EMPTY_CLASS (Allocatable)

	EMPTY_CLASS (Pointer)

	EMPTY_CLASS (Contiguous)

	WRAPPER_CLASS (NullInit, common::Indirection< Expr >)

	EMPTY_CLASS (NoPass)

	WRAPPER_CLASS (Pass, std::optional< Name >)

	WRAPPER_CLASS (FinalProcedureStmt, std::list< Name >)

	WRAPPER_CLASS (EndTypeStmt, std::optional< Name >)

	WRAPPER_CLASS (ComponentDataSource, common::Indirection< Expr >)

	EMPTY_CLASS (EnumDefStmt)

	WRAPPER_CLASS (EnumeratorDefStmt, std::list< Enumerator >)

	EMPTY_CLASS (EndEnumStmt)

	WRAPPER_CLASS (ArrayConstructor, AcSpec)

	WRAPPER_CLASS (ParameterStmt, std::list< NamedConstantDef >)

	WRAPPER_CLASS (AssumedShapeSpec, std::optional< SpecificationExpr >)

	WRAPPER_CLASS (AssumedImpliedSpec, std::optional< SpecificationExpr >)

	WRAPPER_CLASS (ImpliedShapeSpec, std::list< AssumedImpliedSpec >)

	EMPTY_CLASS (AssumedRankSpec)

	EMPTY_CLASS (Asynchronous)

	EMPTY_CLASS (External)

	EMPTY_CLASS (Intrinsic)

	EMPTY_CLASS (Optional)

	EMPTY_CLASS (Parameter)

	EMPTY_CLASS (Protected)

	EMPTY_CLASS (Save)

	EMPTY_CLASS (Target)

	EMPTY_CLASS (Value)

	EMPTY_CLASS (Volatile)

	WRAPPER_CLASS (AccessId, common::Indirection< GenericSpec >)

	WRAPPER_CLASS (AllocatableStmt, std::list< ObjectDecl >)

	WRAPPER_CLASS (AsynchronousStmt, std::list< ObjectName >)

	WRAPPER_CLASS (CodimensionStmt, std::list< CodimensionDecl >)

	WRAPPER_CLASS (ContiguousStmt, std::list< ObjectName >)

	WRAPPER_CLASS (DataStmt, std::list< DataStmtSet >)

	WRAPPER_CLASS (OptionalStmt, std::list< Name >)

	WRAPPER_CLASS (PointerStmt, std::list< PointerDecl >)

	WRAPPER_CLASS (ProtectedStmt, std::list< Name >)

	WRAPPER_CLASS (SaveStmt, std::list< SavedEntity >)

	WRAPPER_CLASS (TargetStmt, std::list< ObjectDecl >)

	WRAPPER_CLASS (ValueStmt, std::list< Name >)

	WRAPPER_CLASS (VolatileStmt, std::list< ObjectName >)

	WRAPPER_CLASS (EquivalenceObject, common::Indirection< Designator >)

	WRAPPER_CLASS (EquivalenceStmt, std::list< std::list< EquivalenceObject > >)

	WRAPPER_CLASS (TeamValue, Scalar< common::Indirection< Expr > >)

	WRAPPER_CLASS (StatVariable, ScalarIntVariable)

	WRAPPER_CLASS (MsgVariable, ScalarDefaultCharVariable)

	WRAPPER_CLASS (NullifyStmt, std::list< PointerObject >)

	WRAPPER_CLASS (BoundsSpec, BoundExpr)

	WRAPPER_CLASS (ElsewhereStmt, std::optional< Name >)

	WRAPPER_CLASS (EndWhereStmt, std::optional< Name >)

	WRAPPER_CLASS (EndForallStmt, std::optional< Name >)

	WRAPPER_CLASS (EndAssociateStmt, std::optional< Name >)

	WRAPPER_CLASS (BlockStmt, std::optional< Name >)

	WRAPPER_CLASS (EndBlockStmt, std::optional< Name >)

	WRAPPER_CLASS (BlockSpecificationPart, SpecificationPart)

	WRAPPER_CLASS (EndCriticalStmt, std::optional< Name >)

	WRAPPER_CLASS (EndDoStmt, std::optional< Name >)

	WRAPPER_CLASS (CycleStmt, std::optional< Name >)

	WRAPPER_CLASS (ElseStmt, std::optional< Name >)

	WRAPPER_CLASS (EndIfStmt, std::optional< Name >)

	EMPTY_CLASS (Default)

	WRAPPER_CLASS (EndSelectStmt, std::optional< Name >)

	WRAPPER_CLASS (ExitStmt, std::optional< Name >)

	WRAPPER_CLASS (GotoStmt, Label)

	WRAPPER_CLASS (StopCode, Scalar< Expr >)

	WRAPPER_CLASS (SyncAllStmt, std::list< StatOrErrmsg >)

	WRAPPER_CLASS (SyncMemoryStmt, std::list< StatOrErrmsg >)

	WRAPPER_CLASS (FileUnitNumber, ScalarIntExpr)

	WRAPPER_CLASS (StatusExpr, ScalarDefaultCharExpr)

	WRAPPER_CLASS (ErrLabel, Label)

	WRAPPER_CLASS (OpenStmt, std::list< ConnectSpec >)

	WRAPPER_CLASS (IdVariable, ScalarIntVariable)

	WRAPPER_CLASS (EndLabel, Label)

	WRAPPER_CLASS (EorLabel, Label)

	WRAPPER_CLASS (IdExpr, ScalarIntExpr)

	WRAPPER_CLASS (WaitStmt, std::list< WaitSpec >)

	WRAPPER_CLASS (BackspaceStmt, std::list< PositionOrFlushSpec >)

	WRAPPER_CLASS (EndfileStmt, std::list< PositionOrFlushSpec >)

	WRAPPER_CLASS (RewindStmt, std::list< PositionOrFlushSpec >)

	WRAPPER_CLASS (FlushStmt, std::list< PositionOrFlushSpec >)

	WRAPPER_CLASS (FormatStmt, format::FormatSpecification)

	WRAPPER_CLASS (ProgramStmt, Name)

	WRAPPER_CLASS (EndProgramStmt, std::optional< Name >)

	WRAPPER_CLASS (ModuleStmt, Name)

	WRAPPER_CLASS (EndModuleStmt, std::optional< Name >)

	WRAPPER_CLASS (EndSubmoduleStmt, std::optional< Name >)

	WRAPPER_CLASS (BlockDataStmt, std::optional< Name >)

	WRAPPER_CLASS (EndBlockDataStmt, std::optional< Name >)

	WRAPPER_CLASS (EndFunctionStmt, std::optional< Name >)

	WRAPPER_CLASS (EndSubroutineStmt, std::optional< Name >)

	WRAPPER_CLASS (EndInterfaceStmt, std::optional< GenericSpec >)

	WRAPPER_CLASS (ExternalStmt, std::list< Name >)

	WRAPPER_CLASS (IntrinsicStmt, std::list< Name >)

	WRAPPER_CLASS (AltReturnSpec, Label)

	WRAPPER_CLASS (MpSubprogramStmt, Name)

	WRAPPER_CLASS (EndMpSubprogramStmt, std::optional< Name >)

	WRAPPER_CLASS (ReturnStmt, std::optional< ScalarIntExpr >)

	WRAPPER_CLASS (BasedPointerStmt, std::list< BasedPointer >)

	WRAPPER_CLASS (OldParameterStmt, std::list< NamedConstantDef >)

	WRAPPER_CLASS (PauseStmt, std::optional< StopCode >)

	WRAPPER_CLASS (OmpObjectList, std::list< OmpObject >)

	WRAPPER_CLASS (OmpTypeNameList, std::list< OmpTypeSpecifier >)

	WRAPPER_CLASS (OmpLocatorList, std::list< OmpLocator >)

	WRAPPER_CLASS (OmpIterationVector, std::list< OmpIteration >)

	WRAPPER_CLASS (OmpDoacrossClause, OmpDoacross)

	WRAPPER_CLASS (OmpDestroyClause, OmpObject)

	EMPTY_CLASS (OmpNoOpenMPClause)

	EMPTY_CLASS (OmpNoOpenMPRoutinesClause)

	EMPTY_CLASS (OmpNoParallelismClause)

	WRAPPER_CLASS (OmpUseClause, OmpObject)

	WRAPPER_CLASS (AccObjectList, std::list< AccObject >)

	EMPTY_CLASS (AccEndAtomic)

	EMPTY_CLASS (AccEndLoop)

std::string	DirectoryName (std::string path)

std::optional< std::string >	LocateSourceFile (std::string name, const std::list< std::string > &searchPath)

std::vector< std::string >	LocateSourceFileAll (std::string name, const std::vector< std::string > &searchPath)

const Name &	GetLastName (const Name &)

const Name &	GetLastName (const StructureComponent &)

const Name &	GetLastName (const DataRef &)

const Name &	GetLastName (const Substring &)

const Name &	GetLastName (const Designator &)

const Name &	GetLastName (const ProcComponentRef &)

const Name &	GetLastName (const ProcedureDesignator &)

const Name &	GetLastName (const Call &)

const Name &	GetLastName (const FunctionReference &)

const Name &	GetLastName (const Variable &)

const Name &	GetLastName (const AllocateObject &)

const Name &	GetFirstName (const Name &)

const Name &	GetFirstName (const StructureComponent &)

const Name &	GetFirstName (const DataRef &)

const Name &	GetFirstName (const Substring &)

const Name &	GetFirstName (const Designator &)

const Name &	GetFirstName (const ProcComponentRef &)

const Name &	GetFirstName (const ProcedureDesignator &)

const Name &	GetFirstName (const Call &)

const Name &	GetFirstName (const FunctionReference &)

const Name &	GetFirstName (const Variable &)

const Name &	GetFirstName (const EntityDecl &)

template<typename A , typename B >
const A *	Unwrap (const B &x)

template<typename A , typename B >
A *	Unwrap (B &x)

const CoindexedNamedObject *	GetCoindexedNamedObject (const AllocateObject &)

const CoindexedNamedObject *	GetCoindexedNamedObject (const DataRef &)

const CoindexedNamedObject *	GetCoindexedNamedObject (const Designator &)

const CoindexedNamedObject *	GetCoindexedNamedObject (const Variable &)

template<typename A >
std::optional< CharBlock >	GetSource (const A &x)

template<typename A >
std::optional< CharBlock >	GetSource (A &x)

template<typename A >
std::optional< CharBlock >	GetLastSource (const A &x)

template<typename A >
std::optional< CharBlock >	GetLastSource (A &x)

bool	CheckForSingleVariableOnRHS (const AssignmentStmt &)

template<typename A >
void	Unparse (llvm::raw_ostream &out, const A &root, const common::LangOptions &langOpts, Encoding encoding=Encoding::UTF_8, bool capitalizeKeywords=true, bool backslashEscapes=true, preStatementType preStatement=nullptr, AnalyzedObjectsAsFortran =nullptr)

template void	Unparse (llvm::raw_ostream &out, const Program &program, const common::LangOptions &langOpts, Encoding encoding, bool capitalizeKeywords, bool backslashEscapes, preStatementType preStatement, AnalyzedObjectsAsFortran )

template void	Unparse (llvm::raw_ostream &out, const Expr &expr, const common::LangOptions &langOpts, Encoding encoding, bool capitalizeKeywords, bool backslashEscapes, preStatementType preStatement, AnalyzedObjectsAsFortran )

template<typename A >
CharBlock	FindSourceLocation (const A &x)

template<typename A = Success>
constexpr auto	fail (MessageFixedText t)

template<typename A >
constexpr auto	pure (A x)

template<typename A >
constexpr auto	pure ()

template<typename A >
constexpr auto	attempt (const A &parser)

template<typename PA , typename = typename PA::resultType>
constexpr auto	operator! (PA p)

template<typename PA >
constexpr auto	lookAhead (PA p)

template<typename PA >
constexpr auto	inContext (MessageFixedText context, PA parser)

template<typename PA >
constexpr auto	withMessage (MessageFixedText msg, PA parser)

template<typename PA , typename PB >
constexpr auto	operator>> (PA pa, PB pb)

template<typename PA , typename PB >
constexpr auto	operator/ (PA pa, PB pb)

template<typename... Ps>
constexpr auto	first (Ps... ps)

template<typename PA , typename PB >
constexpr auto	operator\|\| (PA pa, PB pb)

template<typename PA , typename PB >
constexpr auto	recovery (PA pa, PB pb)

template<typename PA >
constexpr auto	many (PA parser)

template<typename PA >
constexpr auto	some (PA parser)

template<typename PA >
constexpr auto	skipMany (PA parser)

template<typename PA >
constexpr auto	skipManyFast (PA parser)

template<typename PA >
constexpr auto	maybe (PA parser)

template<typename PA >
constexpr auto	defaulted (PA p)

template<typename... PARSER, std::size_t... J>
bool	ApplyHelperArgs (const std::tuple< PARSER... > &parsers, ApplyArgs< PARSER... > &args, ParseState &state, std::index_sequence< J... >)

template<template< typename... > class FUNCTION, typename RESULT , typename... PARSER, std::size_t... J>
RESULT	ApplyHelperFunction (FUNCTION< RESULT, PARSER... > f, ApplyArgs< PARSER... > &&args, std::index_sequence< J... >)

template<typename RESULT , typename... PARSER>
constexpr auto	applyFunction (ApplicableFunctionPointer< RESULT, PARSER... > f, const PARSER &...parser)

template<typename RESULT , typename... PARSER>
auto	applyLambda (ApplicableFunctionObject< RESULT, PARSER... > f, const PARSER &...parser)

template<typename MEMFUNC , typename OBJPARSER , typename... PARSER, std::size_t... J>
auto	ApplyHelperMember (MEMFUNC mfp, ApplyArgs< OBJPARSER, PARSER... > &&args, std::index_sequence< J... >)

template<typename MEMFUNC , typename OBJPARSER , typename... PARSER>
constexpr auto	applyMem (MEMFUNC memfn, const OBJPARSER &objParser, PARSER... parser)

template<typename RESULT , typename... PARSER, std::size_t... J>
RESULT	ApplyHelperConstructor (ApplyArgs< PARSER... > &&args, std::index_sequence< J... >)

template<typename RESULT , typename... PARSER>
constexpr auto	construct (PARSER... p)

template<typename PA >
constexpr auto	indirect (PA p)

template<typename T >
common::IfNoLvalue< std::list< T >, T >	prepend (T &&head, std::list< T > &&rest)

template<typename PA , typename PB >
constexpr auto	nonemptySeparated (PA p, PB sep)

template<typename PA , typename PB >
constexpr auto	localRecovery (MessageFixedText msg, PA pa, PB pb)

template<LanguageFeature LF, typename PA >
constexpr auto	extension (MessageFixedText feature, PA parser)

template<LanguageFeature LF, typename PA >
constexpr auto	extension (PA parser)

template<LanguageFeature LF, typename PA >
constexpr auto	deprecated (PA parser)

template<typename PA >
constexpr auto	sourced (PA parser)

template<typename STRING >
std::string	QuoteCharacterLiteralHelper (const STRING &str, bool backslashEscapes, Encoding encoding)

template<>
EncodedCharacter	EncodeCharacter< Encoding::LATIN_1 > (char32_t ucs)

template<>
EncodedCharacter	EncodeCharacter< Encoding::UTF_8 > (char32_t ucs)

template std::string	EncodeString< Encoding::UTF_8, std::u16string > (const std::u16string &)

template<>
DecodedCharacter	DecodeRawCharacter< Encoding::LATIN_1 > (const char *cp, std::size_t bytes)

template<>
DecodedCharacter	DecodeRawCharacter< Encoding::UTF_8 > (const char *cp, std::size_t bytes)

constexpr DebugParser	operator""_debug (const char str[], std::size_t n)

	TYPE_PARSER (recovery(CONTEXT_PARSER("execution part construct"_en_US, first(construct< ExecutionPartConstruct >(executableConstruct), construct< ExecutionPartConstruct >(statement(indirect(formatStmt))), construct< ExecutionPartConstruct >(statement(indirect(entryStmt))), construct< ExecutionPartConstruct >(statement(indirect(dataStmt))), extension< LanguageFeature::ExecutionPartNamelist >("nonstandard usage: NAMELIST in execution part"_port_en_US, construct< ExecutionPartConstruct >(statement(indirect(Parser< NamelistStmt >{})))), obsoleteExecutionPartConstruct, lookAhead(declarationConstruct) > > SkipTo<'\n'>{} > > fail< ExecutionPartConstruct >("misplaced declaration in the execution part"_err_en_US))), construct< ExecutionPartConstruct >(executionPartErrorRecovery))) TYPE_CONTEXT_PARSER("execution part"_en_US

	construct< ExecutionPart > (many(executionPartConstruct))) TYPE_PARSER(first(construct< ActionStmt >(indirect(Parser< AllocateStmt >

	construct< ActionStmt > (indirect(assignmentStmt))

	construct< ActionStmt > (indirect(pointerAssignmentStmt))

	construct< ActionStmt > (indirect(Parser< BackspaceStmt >{}))

	construct< ActionStmt > (indirect(Parser< CallStmt >{}))

	construct< ActionStmt > (indirect(Parser< CloseStmt >{}))

	construct< ActionStmt > (construct< ContinueStmt >("CONTINUE"_tok))

	construct< ActionStmt > (indirect(Parser< CycleStmt >{}))

	construct< ActionStmt > (indirect(Parser< DeallocateStmt >{}))

	construct< ActionStmt > (indirect(Parser< EndfileStmt >{}))

	construct< ActionStmt > (indirect(Parser< EventPostStmt >{}))

	construct< ActionStmt > (indirect(Parser< EventWaitStmt >{}))

	construct< ActionStmt > (indirect(Parser< ExitStmt >{}))

	construct< ActionStmt > (construct< FailImageStmt >("FAIL IMAGE"_sptok))

	construct< ActionStmt > (indirect(Parser< FlushStmt >{}))

	construct< ActionStmt > (indirect(Parser< FormTeamStmt >{}))

	construct< ActionStmt > (indirect(Parser< GotoStmt >{}))

	construct< ActionStmt > (indirect(Parser< IfStmt >{}))

	construct< ActionStmt > (indirect(Parser< InquireStmt >{}))

	construct< ActionStmt > (indirect(Parser< LockStmt >{}))

	construct< ActionStmt > (indirect(Parser< NotifyWaitStmt >{}))

	construct< ActionStmt > (indirect(Parser< NullifyStmt >{}))

	construct< ActionStmt > (indirect(Parser< OpenStmt >{}))

	construct< ActionStmt > (indirect(Parser< PrintStmt >{}))

	construct< ActionStmt > (indirect(Parser< ReadStmt >{}))

	construct< ActionStmt > (indirect(Parser< ReturnStmt >{}))

	construct< ActionStmt > (indirect(Parser< RewindStmt >{}))

	construct< ActionStmt > (indirect(Parser< StopStmt >{}))

	construct< ActionStmt > (indirect(Parser< SyncAllStmt >{}))

	construct< ActionStmt > (indirect(Parser< SyncImagesStmt >{}))

	construct< ActionStmt > (indirect(Parser< SyncMemoryStmt >{}))

	construct< ActionStmt > (indirect(Parser< SyncTeamStmt >{}))

	construct< ActionStmt > (indirect(Parser< UnlockStmt >{}))

	construct< ActionStmt > (indirect(Parser< WaitStmt >{}))

	construct< ActionStmt > (indirect(whereStmt))

	construct< ActionStmt > (indirect(Parser< WriteStmt >{}))

	construct< ActionStmt > (indirect(Parser< ComputedGotoStmt >{}))

	construct< ActionStmt > (indirect(forallStmt))

	construct< ActionStmt > (indirect(Parser< ArithmeticIfStmt >{}))

	construct< ActionStmt > (indirect(Parser< AssignStmt >{}))

	construct< ActionStmt > (indirect(Parser< AssignedGotoStmt >{}))

	construct< ActionStmt > (indirect(Parser< PauseStmt >{})))) TYPE_CONTEXT_PARSER("ASSOCIATE const ruct"_en_US

	construct< AssociateConstruct > (statement(Parser< AssociateStmt >{}), block, statement(Parser< EndAssociateStmt >{}))) TYPE_CONTEXT_PARSER("ASSOCIATE statement"_en_US

	construct< AssociateStmt > (maybe(name/":"), "ASSOCIATE" > > parenthesized(nonemptyList(Parser< Association >{})))) TYPE_PARSER(construct< Selector >(variable)/lookAhead("

_tok _tok	construct< Selector > (expr)) TYPE_PARSER(construct< EndAssociateStmt >(recovery("END ASSOCIATE" > > maybe(name)

_tok _tok namedConstructEndStmtErrorRecovery TYPE_CONTEXT_PARSER("BLOCK construct"_en_US, construct< BlockConstruct >(statement(Parser< BlockStmt >{}), Parser< BlockSpecificationPart >{}, block, statement(Parser< EndBlockStmt >{}))) TYPE_PARSER(construct< BlockStmt >(maybe(name/" n _ch	construct< std::optional< LoopControl > > ()}

	TYPE_CONTEXT_PARSER ("label DO statement"_en_US, construct< LabelDoStmt >("DO" > > label, loopControlOrEndOfStmt)) TYPE_CONTEXT_PARSER("nonlabel DO statement"_en_US

construct< NonLabelDoStmt >(name/":", "DO" > > maybe(label), loopControlOrEndOfStmt)\|\|const ruct< NonLabelDoStmt >(construct< std	TYPE_PARSER (parenthesized(construct< CaseSelector >(nonemptyList(Parser< CaseValueRange >{})))\|\|construct< CaseSelector >(defaultKeyword)) const expr auto caseValue

	TYPE_PARSER (construct< CaseValueRange >(construct< CaseValueRange::Range >(construct< std::optional< CaseValue > >(caseValue), ":" > > maybe(caseValue)))\|\|construct< CaseValueRange >(construct< CaseValueRange::Range >(construct< std::optional< CaseValue > >(), ":" > > construct< std::optional< CaseValue > >(caseValue)))\|\|construct< CaseValueRange >(caseValue)) TYPE_CONTEXT_PARSER("SELECT RANK const ruct"_en_US

	construct< SelectRankConstruct > (statement(Parser< SelectRankStmt >{}), many(construct< SelectRankConstruct::RankCase >(unambiguousStatement(Parser< SelectRankCaseStmt >{}), block)), statement(endSelectStmt))) TYPE_CONTEXT_PARSER("SELECT RANK statement"_en_US

	construct< SelectRankStmt > (maybe(name/":"), "SELECT RANK"_sptok > > "("_tok > > maybe(name/"=>"), selector/")")) TYPE_CONTEXT_PARSER("RANK case statement"_en_US

	RANK (construct< SelectRankCaseStmt >(parenthesized(construct< SelectRankCaseStmt::Rank >(scalarIntConstantExpr)\|\|construct< SelectRankCaseStmt::Rank >(star))\|\|construct< SelectRankCaseStmt::Rank >(defaultKeyword), maybe(name)))) TYPE_CONTEXT_PARSER("SELECT TYPE const ruct"_en_US

	construct< SelectTypeConstruct > (statement(Parser< SelectTypeStmt >{}), many(construct< SelectTypeConstruct::TypeCase >(unambiguousStatement(Parser< TypeGuardStmt >{}), block)), statement(endSelectStmt))) TYPE_CONTEXT_PARSER("SELECT TYPE statement"_en_US

	construct< SelectTypeStmt > (maybe(name/":"), "SELECT TYPE (" > > maybe(name/"=>"), selector/")")) TYPE_CONTEXT_PARSER("type guard statement"_en_US

	construct< TypeGuardStmt > ("TYPE IS"_sptok > > parenthesized(construct< TypeGuardStmt::Guard >(typeSpec))\|\|"CLASS IS"_sptok > > parenthesized(construct< TypeGuardStmt::Guard >(derivedTypeSpec))\|\|construct< TypeGuardStmt::Guard >("CLASS" > > defaultKeyword), maybe(name))) TYPE_CONTEXT_PARSER("EXIT statement"_en_US

	construct< ExitStmt > ("EXIT" > > maybe(name))) TYPE_CONTEXT_PARSER("GOTO statement"_en_US

	construct< GotoStmt > ("GO TO" > > label)) TYPE_CONTEXT_PARSER("computed GOTO statement"_en_US

	construct< ComputedGotoStmt > ("GO TO" > > parenthesized(nonemptyList(label)), maybe(","_tok) > > scalarIntExpr)) TYPE_CONTEXT_PARSER("STOP statement"_en_US

	construct< StopStmt > ("STOP" > > pure(StopStmt::Kind::Stop)\|\|"ERROR STOP"_sptok > > pure(StopStmt::Kind::ErrorStop), maybe(Parser< StopCode >{}), maybe(", QUIET =" > > scalarLogicalExpr))) TYPE_PARSER(construct< StopCode >(scalar(expr))) TYPE_CONTEXT_PARSER("NOTIFY WAIT statement"_en_US

	construct< NotifyWaitStmt > ("NOTIFY WAIT"_sptok > > "("_tok > > scalar(variable), defaulted("," > > nonemptyList(Parser< EventWaitSpec >{}))/")")) TYPE_CONTEXT_PARSER("SYNC ALL statement"_en_US

	construct< SyncAllStmt > ("SYNC ALL"_sptok > > defaulted(parenthesized(optionalList(statOrErrmsg))))) TYPE_CONTEXT_PARSER("SYNC IMAGES statement"_en_US

SYNC IMAGES _sptok	parenthesized (construct< SyncImagesStmt >(construct< SyncImagesStmt::ImageSet >(intExpr)\|\|construct< SyncImagesStmt::ImageSet >(star), defaulted("," > > nonemptyList(statOrErrmsg))))) TYPE_CONTEXT_PARSER("SYNC MEMORY statement"_en_US

SYNC IMAGES _sptok	construct< SyncMemoryStmt > ("SYNC MEMORY"_sptok > > defaulted(parenthesized(optionalList(statOrErrmsg))))) TYPE_CONTEXT_PARSER("SYNC TEAM statement"_en_US

SYNC IMAGES _sptok	construct< SyncTeamStmt > ("SYNC TEAM"_sptok > > "("_tok > > teamValue, defaulted("," > > nonemptyList(statOrErrmsg))/")")) TYPE_CONTEXT_PARSER("EVENT POST statement"_en_US

SYNC IMAGES _sptok	construct< EventPostStmt > ("EVENT POST"_sptok > > "("_tok > > scalar(variable), defaulted("," > > nonemptyList(statOrErrmsg))/")")) TYPE_CONTEXT_PARSER("EVENT WAIT statement"_en_US

SYNC IMAGES _sptok	construct< EventWaitStmt > ("EVENT WAIT"_sptok > > "("_tok > > scalar(variable), defaulted("," > > nonemptyList(Parser< EventWaitSpec >{}))/")")) const expr auto untilSpec

	TYPE_PARSER (construct< EventWaitSpec >(untilSpec)\|\|construct< EventWaitSpec >(statOrErrmsg)) const expr auto teamVariable

template<typename PA >
constexpr auto	scalar (const PA &p)

template<typename PA >
constexpr auto	constant (const PA &p)

template<typename PA >
constexpr auto	integer (const PA &p)

template<typename PA >
constexpr auto	logical (const PA &p)

template<typename PA >
constexpr auto	defaultChar (const PA &p)

constexpr auto	loopBounds (decltype(scalarExpr) &p)

template<typename PA >
constexpr auto	loopBounds (const PA &p)

	TYPE_PARSER (space > > sourced(rawName > > construct< Name >())) const expr auto namedIntrinsicOperator

	TYPE_PARSER (construct< DefinedOperator >(intrinsicOperator)\|\|construct< DefinedOperator >(definedOpName)) TYPE_CONTEXT_PARSER("implicit part"_en_US

	construct< ImplicitPart > (many(Parser< ImplicitPartStmt >{}))) TYPE_PARSER(first(const ruct< ImplicitPartStmt >(statement(indirect(Parser< ImplicitStmt >

	construct< ImplicitPartStmt > (statement(indirect(parameterStmt)))

	construct< ImplicitPartStmt > (statement(indirect(oldParameterStmt)))

	construct< ImplicitPartStmt > (statement(indirect(formatStmt)))

	construct< ImplicitPartStmt > (statement(indirect(entryStmt)))

	construct< ImplicitPartStmt > (indirect(compilerDirective))

	construct< ImplicitPartStmt > (indirect(openaccDeclarativeConstruct)))) TYPE_CONTEXT_PARSER("internal subprogram"_en_US

	construct< InternalSubprogram > (indirect(functionSubprogram))\|\|const ruct< InternalSubprogram >(indirect(subroutineSubprogram)))/forceEndOfStmt\|\|const ruct< InternalSubprogram >(indirect(compilerDirective))) TYPE_CONTEXT_PARSER("internal subprogram part"_en_US

	construct< InternalSubprogramPart > (statement(containsStmt), many(StartNewSubprogram{} > > Parser< InternalSubprogram >{}))) TYPE_PARSER(first(construct< LiteralConstant >(Parser< HollerithLiteralConstant >

	construct< LiteralConstant > (realLiteralConstant)

	construct< LiteralConstant > (intLiteralConstant)

	construct< LiteralConstant > (Parser< ComplexLiteralConstant >{})

	construct< LiteralConstant > (Parser< BOZLiteralConstant >{})

	construct< LiteralConstant > (charLiteralConstant)

	construct< LiteralConstant > (Parser< LogicalLiteralConstant >{})

construct< LiteralConstant >(unsignedLiteralConstant))) TYPE_PARSER(construct< TypeParamValue >(scalarIntExpr)\|\|const ruct< TypeParamValue >(star)\|\|const ruct< TypeParamValue >(construct< TypeParamValue	TYPE_PARSER (sourced(construct< SignedIntLiteralConstant >(SignedIntLiteralConstantWithoutKind{}, maybe(noSpace > > underscore > > noSpace > > kindParam)))) TYPE_PARSER(construct< IntLiteralConstant >(space > > digitString/!"u"_ch

construct< LiteralConstant >(unsignedLiteralConstant))) TYPE_PARSER(construct< TypeParamValue >(scalarIntExpr)\|\|const ruct< TypeParamValue >(star)\|\|const ruct< TypeParamValue >(construct< TypeParamValue	maybe (underscore > > noSpace > > kindParam)/!underscore)) TYPE_PARSER(construct< UnsignedLiteralConstant >(space > > digitString/"u"_ch

	TYPE_CONTEXT_PARSER ("REAL literal constant"_en_US, space > > construct< RealLiteralConstant >(sourced((digitString > > "."_ch > > !(some(letter) > > "."_ch) > > maybe(digitString) > > maybe(exponentPart) > > ok\|\|"."_ch > > digitString > > maybe(exponentPart) > > ok\|\|digitString > > exponentPart > > ok) > > construct< RealLiteralConstant::Real >()), maybe(noSpace > > underscore > > noSpace > > kindParam))) TYPE_CONTEXT_PARSER("COMPLEX literal const ant"_en_US

	parenthesized (construct< ComplexLiteralConstant >(Parser< ComplexPart >{}/",", Parser< ComplexPart >{}))) TYPE_PARSER(construct< SignedComplexLiteralConstant >(sign

	TYPE_PARSER (construct< TypeParamDefStmt >(integerTypeSpec/",", kindOrLen, "::" > > nonemptyList("expected type parameter declarations"_err_en_US, Parser< TypeParamDecl >{}))) TYPE_PARSER(construct< TypeParamDecl >(name

	maybe ("=" > > scalarIntConstantExpr))) TYPE_PARSER(recovery(withMessage("expected component definition"_err_en_US

	first (construct< ComponentDefStmt >(Parser< DataComponentDefStmt >{}), construct< ComponentDefStmt >(Parser< ProcComponentDefStmt >{}), construct< ComponentDefStmt >(indirect(compilerDirective))))

	construct< ComponentDefStmt > (inStmtErrorRecovery))) TYPE_PARSER(construct< DataComponentDefStmt >(declarationTypeSpec

	optionalListBeforeColons (Parser< ComponentAttrSpec >{})

	TYPE_PARSER (construct< ProcComponentAttrSpec >(accessSpec)\|\|construct< ProcComponentAttrSpec >(noPass)\|\|construct< ProcComponentAttrSpec >(pass)\|\|construct< ProcComponentAttrSpec >(pointer)) const expr auto initialDataTarget

	TYPE_PARSER (construct< Initialization >("=>" > > nullInit)\|\|construct< Initialization >("=>" > > initialDataTarget)\|\|construct< Initialization >("=" > > constantExpr)\|\|extension< LanguageFeature::SlashInitialization >("nonstandard usage: /initialization/"_port_en_US, construct< Initialization >("/" > > nonemptyList("expected values"_err_en_US, indirect(Parser< DataStmtValue >{}))/"/"))) TYPE_CONTEXT_PARSER("type bound procedure part"_en_US

	construct< TypeBoundProcedurePart > (statement(containsStmt), maybe(statement(Parser< PrivateStmt >{})), many(statement(Parser< TypeBoundProcBinding >{})))) TYPE_CONTEXT_PARSER("type bound procedure binding"_en_US

	recovery (first(construct< TypeBoundProcBinding >(Parser< TypeBoundProcedureStmt >{}), construct< TypeBoundProcBinding >(Parser< TypeBoundGenericStmt >{}), construct< TypeBoundProcBinding >(Parser< FinalProcedureStmt >{})), construct< TypeBoundProcBinding >(!"END"_tok > > SkipTo<'\n'>{} > > construct< ErrorRecovery >()))) TYPE_CONTEXT_PARSER("type bound PROCEDURE statement"_en_US

	PROCEDURE (construct< TypeBoundProcedureStmt >(construct< TypeBoundProcedureStmt::WithInterface >(parenthesized(name), localRecovery("expected list of binding attributes"_err_en_US, "," > > nonemptyList(Parser< BindAttr >{}), ok), localRecovery("expected list of binding names"_err_en_US, "::" > > listOfNames, SkipTo<'\n'>{})))\|\|construct< TypeBoundProcedureStmt >(construct< TypeBoundProcedureStmt::WithoutInterface >(pure< std::list< BindAttr > >(), nonemptyList("expected type bound procedure declarations"_err_en_US, construct< TypeBoundProcDecl >(name, maybe(extension< LanguageFeature::MissingColons >("type-bound procedure statement should have '::' if it has '=>'"_port_en_US, "=>" > > name))))))\|\|construct< TypeBoundProcedureStmt >(construct< TypeBoundProcedureStmt::WithoutInterface >(optionalListBeforeColons(Parser< BindAttr >{}), nonemptyList("expected type bound procedure declarations"_err_en_US, Parser< TypeBoundProcDecl >{}))))) TYPE_PARSER(construct< TypeBoundProcDecl >(name

	maybe ("=>" > > name))) TYPE_CONTEXT_PARSER("type bound GENERIC statement"_en_US

construct< TypeBoundGenericStmt >("GENERIC" > > maybe("," > > accessSpec), "::" > > indirect(genericSpec), "=>" > > listOfNames)) TYPE_PARSER(construct< BindAttr >(accessSpec)\|\|const ruct< BindAttr >(construct< BindAttr TYPE_PARSER(construct< TypeDeclarationStmt >(declarationTypeSpec, defaulted("," > > nonemptyList(Parser< AttrSpec >{}))/"::", nonemptyList("expected entity declarations"_err_en_US, entityDecl))\|\|construct< TypeDeclarationStmt >(declarationTypeSpec, construct< std::list< AttrSpec > >(), nonemptyList("expected entity declarations"_err_en_US, entityDeclWithoutEqInit))\|\|extension< LanguageFeature::MissingColons >("nonstandard usage: ',' in place of '::'"_port_en_US, construct< TypeDeclarationStmt >(declarationTypeSpec, defaulted("," > > nonemptyList(Parser< AttrSpec >{})), withMessage("expected entity declarations"_err_en_US, "," > > nonemptyList(entityDecl))))) TYPE_PARSER(construct< AttrSpec >(accessSpec)\|\|const ruct< AttrSpec >(allocatable)\|\|const ruct< AttrSpec >(construct< Asynchronous >("ASYNCHRONOUS"_tok))\|\|const ruct< AttrSpec >("CODIMENSION" > > coarraySpec)\|\|const ruct< AttrSpec >(contiguous)\|\|const ruct< AttrSpec >("DIMENSION" > > arraySpec)\|\|const ruct< AttrSpec >(construct< External >("EXTERNAL"_tok))\|\|const ruct< AttrSpec >("INTENT" > > parenthesized(intentSpec))\|\|const ruct< AttrSpec >(construct< Intrinsic >("INTRINSIC"_tok))\|\|const ruct< AttrSpec >(languageBindingSpec)\|\|const ruct< AttrSpec >(optional)\|\|const ruct< AttrSpec >(construct< Parameter >("PARAMETER"_tok))\|\|const ruct< AttrSpec >(pointer)\|\|const ruct< AttrSpec >(protectedAttr)\|\|const ruct< AttrSpec >(save)\|\|const ruct< AttrSpec >(construct< Target >("TARGET"_tok))\|\|const ruct< AttrSpec >(construct< Value >("VALUE"_tok))\|\|const ruct< AttrSpec >(construct< Volatile >("VOLATILE"_tok))\|\|extension< LanguageFeature	TYPE_PARSER (construct< EntityDecl >(objectName, "" > > charLength, maybe(arraySpec), maybe(coarraySpec), maybe(initialization))\|\|construct< EntityDecl >(objectName, maybe(arraySpec), maybe(coarraySpec), maybe("" > > charLength), maybe(initialization))) TYPE_PARSER(lookAhead(name/"( )") > > const ruct< NullInit >(expr)) TYPE_PARSER(construct< AccessSpec >("PUBLIC" > > pure(AccessSpec

	TYPE_PARSER (construct< DeferredCoshapeSpecList >(applyFunction(listLength, nonemptyList(":"_tok)))) TYPE_PARSER(construct< ExplicitCoshapeSpec >(many(explicitShapeSpec/"

	maybe (specificationExpr/":")/"*")) TYPE_PARSER(const ruct< ArraySpec >(parenthesized(nonemptyList(explicitShapeSpec)))\|\|const ruct< ArraySpec >(parenthesized(deferredShapeSpecList))\|\|const ruct< ArraySpec >(parenthesized(nonemptyList(Parser< AssumedShapeSpec >

	construct< ArraySpec > (parenthesized(Parser< AssumedSizeSpec >{}))\|\|const ruct< ArraySpec >(parenthesized(Parser< ImpliedShapeSpec >

bool	operator< (const MessageFixedText &x, const MessageFixedText &y)

	TYPE_PARSER (construct< IoUnit >(variable/lookAhead(space/",);\n"_ch))\|\|construct< IoUnit >(indirect(expr)/(lookAhead(space > > ",)"_ch)\|\|atEndOfStmt))\|\|construct< IoUnit >(star)) TYPE_PARSER(construct< FileUnitNumber >(scalarIntExpr/(lookAhead(space > > "

_ch atEndOfStmt	TYPE_CONTEXT_PARSER ("OPEN statement"_en_US, construct< OpenStmt >("OPEN (" > > nonemptyList("expected connection specifications"_err_en_US, Parser< ConnectSpec >{})/")")) const expr auto fileNameExpr

	TYPE_PARSER (first(construct< ConnectSpec >(maybe("UNIT ="_tok) > > fileUnitNumber), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ACCESS =" > > pure(ConnectSpec::CharExpr::Kind::Access), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ACTION =" > > pure(ConnectSpec::CharExpr::Kind::Action), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ASYNCHRONOUS =" > > pure(ConnectSpec::CharExpr::Kind::Asynchronous), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("BLANK =" > > pure(ConnectSpec::CharExpr::Kind::Blank), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("DECIMAL =" > > pure(ConnectSpec::CharExpr::Kind::Decimal), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("DELIM =" > > pure(ConnectSpec::CharExpr::Kind::Delim), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ENCODING =" > > pure(ConnectSpec::CharExpr::Kind::Encoding), scalarDefaultCharExpr)), construct< ConnectSpec >("ERR =" > > errLabel), construct< ConnectSpec >("FILE =" > > fileNameExpr), extension< LanguageFeature::FileName >("nonstandard usage: NAME= in place of FILE="_port_en_US, construct< ConnectSpec >("NAME =" > > fileNameExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("FORM =" > > pure(ConnectSpec::CharExpr::Kind::Form), scalarDefaultCharExpr)), construct< ConnectSpec >("IOMSG =" > > msgVariable), construct< ConnectSpec >("IOSTAT =" > > statVariable), construct< ConnectSpec >(construct< ConnectSpec::Newunit >("NEWUNIT =" > > scalar(integer(variable)))), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("PAD =" > > pure(ConnectSpec::CharExpr::Kind::Pad), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("POSITION =" > > pure(ConnectSpec::CharExpr::Kind::Position), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::Recl >("RECL =" > > scalarIntExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ROUND =" > > pure(ConnectSpec::CharExpr::Kind::Round), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("SIGN =" > > pure(ConnectSpec::CharExpr::Kind::Sign), scalarDefaultCharExpr)), construct< ConnectSpec >("STATUS =" > > statusExpr), extension< LanguageFeature::Carriagecontrol >("nonstandard usage: CARRIAGECONTROL="_port_en_US, construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("CARRIAGECONTROL =" > > pure(ConnectSpec::CharExpr::Kind::Carriagecontrol), scalarDefaultCharExpr))), extension< LanguageFeature::Convert >("nonstandard usage: CONVERT="_port_en_US, construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("CONVERT =" > > pure(ConnectSpec::CharExpr::Kind::Convert), scalarDefaultCharExpr))), extension< LanguageFeature::Dispose >("nonstandard usage: DISPOSE="_port_en_US, construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("DISPOSE =" > > pure(ConnectSpec::CharExpr::Kind::Dispose), scalarDefaultCharExpr))))) const expr auto closeSpec

	TYPE_CONTEXT_PARSER ("CLOSE statement"_en_US, construct< CloseStmt >("CLOSE" > > parenthesized(nonemptyList(closeSpec)))) const expr auto inputItemList

	TYPE_CONTEXT_PARSER ("READ statement"_en_US, construct< ReadStmt >("READ (" > > construct< std::optional< IoUnit > >(maybe("UNIT ="_tok) > > ioUnit), "," > > construct< std::optional< Format > >(format), defaulted("," > > nonemptyList(ioControlSpec))/")", inputItemList)\|\|construct< ReadStmt >("READ (" > > construct< std::optional< IoUnit > >(ioUnit), construct< std::optional< Format > >(), defaulted("," > > nonemptyList(ioControlSpec))/")", inputItemList)\|\|construct< ReadStmt >("READ" > > construct< std::optional< IoUnit > >(), construct< std::optional< Format > >(), parenthesized(nonemptyList(ioControlSpec)), inputItemList)\|\|construct< ReadStmt >("READ" > > construct< std::optional< IoUnit > >(), construct< std::optional< Format > >(format), construct< std::list< IoControlSpec > >(), many("," > > inputItem))) const expr auto idVariable

	TYPE_PARSER (first(construct< IoControlSpec >("UNIT =" > > ioUnit), construct< IoControlSpec >("FMT =" > > format), construct< IoControlSpec >("NML =" > > name), construct< IoControlSpec >("ADVANCE =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Advance), scalarDefaultCharExpr)), construct< IoControlSpec >(construct< IoControlSpec::Asynchronous >("ASYNCHRONOUS =" > > scalarDefaultCharConstantExpr)), construct< IoControlSpec >("BLANK =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Blank), scalarDefaultCharExpr)), construct< IoControlSpec >("DECIMAL =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Decimal), scalarDefaultCharExpr)), construct< IoControlSpec >("DELIM =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Delim), scalarDefaultCharExpr)), construct< IoControlSpec >("END =" > > endLabel), construct< IoControlSpec >("EOR =" > > eorLabel), construct< IoControlSpec >("ERR =" > > errLabel), construct< IoControlSpec >("ID =" > > idVariable), construct< IoControlSpec >("IOMSG = " > > msgVariable), construct< IoControlSpec >("IOSTAT = " > > statVariable), construct< IoControlSpec >("PAD =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Pad), scalarDefaultCharExpr)), construct< IoControlSpec >("POS =" > > construct< IoControlSpec::Pos >(scalarIntExpr)), construct< IoControlSpec >("REC =" > > construct< IoControlSpec::Rec >(scalarIntExpr)), construct< IoControlSpec >("ROUND =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Round), scalarDefaultCharExpr)), construct< IoControlSpec >("SIGN =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Sign), scalarDefaultCharExpr)), construct< IoControlSpec >("SIZE =" > > construct< IoControlSpec::Size >(scalarIntVariable)))) const expr auto outputItemList

	TYPE_CONTEXT_PARSER ("WRITE statement"_en_US, construct< WriteStmt >("WRITE (" > > construct< std::optional< IoUnit > >(maybe("UNIT ="_tok) > > ioUnit), "," > > construct< std::optional< Format > >(format), defaulted("," > > nonemptyList(ioControlSpec))/")", outputItemList)\|\|construct< WriteStmt >("WRITE (" > > construct< std::optional< IoUnit > >(ioUnit), construct< std::optional< Format > >(), defaulted("," > > nonemptyList(ioControlSpec))/")", outputItemList)\|\|construct< WriteStmt >("WRITE" > > construct< std::optional< IoUnit > >(), construct< std::optional< Format > >(), parenthesized(nonemptyList(ioControlSpec)), outputItemList)) TYPE_CONTEXT_PARSER("PRINT statement"_en_US

	construct< PrintStmt > ("PRINT" > > format, defaulted("," > > nonemptyList(outputItem)))) TYPE_PARSER(construct< Format >(label/!"_."_ch)\|\|const ruct< Format >(expr/!"

ioImpliedDoControl	TYPE_CONTEXT_PARSER ("output implied DO"_en_US, parenthesized(construct< OutputImpliedDo >(nonemptyList(outputItem/lookAhead(","_tok)), "," > > ioImpliedDoControl))) TYPE_CONTEXT_PARSER("WAIT statement"_en_US

ioImpliedDoControl WAIT	parenthesized (construct< WaitStmt >(nonemptyList(Parser< WaitSpec >{})))) const expr auto idExpr

	TYPE_PARSER (first(construct< WaitSpec >(maybe("UNIT ="_tok) > > fileUnitNumber), construct< WaitSpec >("END =" > > endLabel), construct< WaitSpec >("EOR =" > > eorLabel), construct< WaitSpec >("ERR =" > > errLabel), construct< WaitSpec >("ID =" > > idExpr), construct< WaitSpec >("IOMSG =" > > msgVariable), construct< WaitSpec >("IOSTAT =" > > statVariable))) const expr auto bareUnitNumberAsList

	TYPE_CONTEXT_PARSER ("BACKSPACE statement"_en_US, construct< BackspaceStmt >("BACKSPACE" > > positionOrFlushSpecList)) TYPE_CONTEXT_PARSER("ENDFILE statement"_en_US

	construct< EndfileStmt > ("END FILE" > > positionOrFlushSpecList)) TYPE_CONTEXT_PARSER("REWIND statement"_en_US

	construct< RewindStmt > ("REWIND" > > positionOrFlushSpecList)) TYPE_PARSER(const ruct< PositionOrFlushSpec >(maybe("UNIT

	TYPE_PARSER (construct< format::IntrinsicTypeDataEditDesc >("I " > > pure(format::IntrinsicTypeDataEditDesc::Kind::I)\|\|"B " > > pure(format::IntrinsicTypeDataEditDesc::Kind::B)\|\|"O " > > pure(format::IntrinsicTypeDataEditDesc::Kind::O)\|\|"Z " > > pure(format::IntrinsicTypeDataEditDesc::Kind::Z), mandatoryWidth, maybe("." > > digits), noInt)\|\|construct< format::IntrinsicTypeDataEditDesc >("F " > > pure(format::IntrinsicTypeDataEditDesc::Kind::F)\|\|"D " > > pure(format::IntrinsicTypeDataEditDesc::Kind::D), mandatoryWidth, mandatoryDigits, noInt)\|\|construct< format::IntrinsicTypeDataEditDesc >("E " > >("N " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EN)\|\|"S " > > pure(format::IntrinsicTypeDataEditDesc::Kind::ES)\|\|"X " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EX)\|\|pure(format::IntrinsicTypeDataEditDesc::Kind::E)), mandatoryWidth, mandatoryDigits, maybe("E " > > digits))\|\|construct< format::IntrinsicTypeDataEditDesc >("G " > > pure(format::IntrinsicTypeDataEditDesc::Kind::G), mandatoryWidth, mandatoryDigits, maybe("E " > > digits))\|\|construct< format::IntrinsicTypeDataEditDesc >("G " > > pure(format::IntrinsicTypeDataEditDesc::Kind::G)\|\|"L " > > pure(format::IntrinsicTypeDataEditDesc::Kind::L), mandatoryWidth, noInt, noInt)\|\|construct< format::IntrinsicTypeDataEditDesc >("A " > > pure(format::IntrinsicTypeDataEditDesc::Kind::A), maybe(width), noInt, noInt)\|\|extension< LanguageFeature::AbbreviatedEditDescriptor >(construct< format::IntrinsicTypeDataEditDesc >("I " > > pure(format::IntrinsicTypeDataEditDesc::Kind::I)\|\|("B "_tok/!letter) > > pure(format::IntrinsicTypeDataEditDesc::Kind::B)\|\|"O " > > pure(format::IntrinsicTypeDataEditDesc::Kind::O)\|\|"Z " > > pure(format::IntrinsicTypeDataEditDesc::Kind::Z)\|\|"F " > > pure(format::IntrinsicTypeDataEditDesc::Kind::F)\|\|("D "_tok/!letter) > > pure(format::IntrinsicTypeDataEditDesc::Kind::D)\|\|"E " > >("N " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EN)\|\|"S " > > pure(format::IntrinsicTypeDataEditDesc::Kind::ES)\|\|"X " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EX)\|\|pure(format::IntrinsicTypeDataEditDesc::Kind::E))\|\|"G " > > pure(format::IntrinsicTypeDataEditDesc::Kind::G)\|\|"L " > > pure(format::IntrinsicTypeDataEditDesc::Kind::L), noInt, noInt, noInt))) const expr SignedDigitStringIgnoreSpaces scaleFactor

	TYPE_PARSER (construct< format::DerivedTypeDataEditDesc >("D T" > > defaulted(charLiteralConstantWithoutKind), defaulted(parenthesized(nonemptyList(scaleFactor))))) const expr PositiveDigitStringIgnoreSpaces count

llvm::raw_ostream &	operator<< (llvm::raw_ostream &o, const MessageFixedText &t)

template<typename PA >
constexpr auto	nonemptyList (const PA &p)

template<typename PA >
constexpr auto	nonemptyList (MessageFixedText error, const PA &p)

template<typename PA >
constexpr auto	optionalList (const PA &p)

template<typename A >
common::IfNoLvalue< std::list< A >, A >	singletonList (A &&x)

template<typename A >
common::IfNoLvalue< std::optional< A >, A >	presentOptional (A &&x)

	TYPE_PARSER (construct< AccObject >(designator)\|\|construct< AccObject >("/" > > name/"/")) TYPE_PARSER(construct< AccObjectList >(nonemptyList(Parser< AccObject >

	TYPE_PARSER (construct< AccObjectListWithModifier >(maybe(Parser< AccDataModifier >{}), Parser< AccObjectList >{})) TYPE_PARSER(construct< AccObjectListWithReduction >(Parser< ReductionOperator >

template<typename ParserH , typename ParserT , typename ValueH = typename ParserH::resultType, typename ValueT = typename ParserT::resultType, typename = std::enable_if_t<std::is_same_v<std::list<ValueH>, ValueT>>>
constexpr auto	cons (ParserH head, ParserT tail)

template<typename Parser >
constexpr auto	unwrap (const Parser &p)

template<typename PA , typename PB >
constexpr auto	operator>= (PA checker, PB parser)

template<typename PA , typename CF >
constexpr auto	predicated (PA parser, CF condition)

template<typename Clause , typename Separator >
constexpr ModifierList< Clause, Separator >	modifierList (Separator sep)

	TYPE_PARSER (construct< OmpLocator >(Parser< OmpObject >{})\|\|construct< OmpLocator >(Parser< FunctionReference >{})) TYPE_PARSER(sourced(const ruct< OmpArgument >(Parser< OmpMapperSpecifier >

	construct< OmpArgument > (Parser< OmpReductionSpecifier >{})\|\|const ruct< OmpArgument >(Parser< OmpLocator >

	TYPE_PARSER (construct< OmpLocatorList >(nonemptyList(Parser< OmpLocator >{}))) TYPE_PARSER(sourced(const ruct< OmpArgumentList >(nonemptyList(Parser< OmpArgument >

	TYPE_PARSER (construct< OmpTypeSpecifier >(Parser< DeclarationTypeSpec >{})\|\|construct< OmpTypeSpecifier >(Parser< TypeSpec >{})) TYPE_PARSER(construct< OmpReductionIdentifier >(Parser< DefinedOperator >

	construct< OmpReductionIdentifier > (Parser< ProcedureDesignator >{})) TYPE_PARSER(construct< OmpReductionSpecifier >(Parser< OmpReductionIdentifier >

	maybe (":"_tok > > Parser< OmpReductionCombiner >{}))) static std

	TYPE_PARSER (sourced(construct< OmpTraitPropertyName >(construct< OmpTraitPropertyName >(space > > charLiteralConstantWithoutKind)\|\|construct< OmpTraitPropertyName >(applyFunction(nameToString, Parser< Name >{}))))) TYPE_PARSER(sourced(construct< OmpTraitScore >("SCORE"_id > > parenthesized(scalarIntExpr)))) TYPE_PARSER(sourced(construct< OmpTraitPropertyExtension

	TYPE_PARSER (sourced(construct< OmpTraitSelector >(sourced(TraitSelectorParser(Parser< OmpTraitSelectorName >{}))))) TYPE_PARSER(construct< OmpTraitSetSelectorName

	TYPE_PARSER (construct< OmpAdjustArgsClause >((Parser< OmpAdjustArgsClause::OmpAdjustOp >{}/":"), Parser< OmpObjectList >{})) TYPE_PARSER(construct< OmpAffinityClause >(maybe(nonemptyList(Parser< OmpAffinityClause

	TYPE_PARSER (construct< OmpLinearClause >(applyFunction< OmpLinearClause >(makeLinearFromOldSyntax, SpecificModifierParser< OmpLinearModifier, OmpLinearClause >{}, parenthesized(Parser< OmpObjectList >{}), maybe(":"_tok > > SpecificModifierParser< OmpStepSimpleModifier, OmpLinearClause >{})))\|\|construct< OmpLinearClause >(Parser< OmpObjectList >{}, maybe(":"_tok > > nonemptyList(Parser< OmpLinearClause::Modifier >{})), pure(true))) TYPE_PARSER(construct< OmpInitClause >(maybe(nonemptyList(Parser< OmpInitClause

	TYPE_PARSER (sourced(construct< OmpDirectiveSpecification >(applyFunction< OmpDirectiveSpecification >(makeFlushFromOldSyntax, verbatim("FLUSH"_tok)/!lookAhead("("_tok), maybe(Parser< OmpClauseList >{}), maybe(parenthesized(Parser< OmpArgumentList >{})), pure(OmpDirectiveSpecification::Flags::DeprecatedSyntax)))\|\|construct< OmpDirectiveSpecification >(sourced(OmpDirectiveNameParser{}), maybe(parenthesized(Parser< OmpArgumentList >{})), maybe(Parser< OmpClauseList >{}), pure(OmpDirectiveSpecification::Flags::None)))) static bool IsFortranBlockConstruct(const ExecutionPartConstruct &epc)

	TYPE_PARSER (sourced(construct< OmpNothingDirective >("NOTHING" > > ok))) TYPE_PARSER(sourced(construct< OpenMPUtilityConstruct >(sourced(construct< OpenMPUtilityConstruct >(sourced(Parser< OmpErrorDirective >

	sourced (construct< OpenMPUtilityConstruct >(sourced(Parser< OmpNothingDirective >{})))))) TYPE_PARSER(sourced(construct< OmpMetadirectiveDirective >(verbatim("METADIRECTIVE"_tok)

	TYPE_PARSER (sourced(construct< OpenMPAllocatorsConstruct >(OmpStatementConstructParser{llvm::omp::Directive::OMPD_allocators}))) TYPE_PARSER(sourced(construct< OpenMPDispatchConstruct >(OmpStatementConstructParser

	TYPE_PARSER (sourced(construct< OpenMPAtomicConstruct >(OmpAtomicConstructParser{}))) static bool IsSimpleStandalone(const OmpDirectiveName &name)

	TYPE_PARSER (sourced(construct< OpenMPSimpleStandaloneConstruct >(predicated(OmpDirectiveNameParser{}, IsSimpleStandalone) >=Parser< OmpDirectiveSpecification >{}))) TYPE_PARSER(sourced(const ruct< OpenMPFlushConstruct >(predicated(OmpDirectiveNameParser

	IsDirective (llvm::omp::Directive::OMPD_flush)) >

	TYPE_PARSER (sourced(construct< OpenMPSectionsConstruct >(Parser< OmpBeginSectionsDirective >{}/endOmpLine, cons(construct< OpenMPConstruct >(sourced(construct< OpenMPSectionConstruct >(maybe(sectionDir), block))), many(construct< OpenMPConstruct >(sourced(construct< OpenMPSectionConstruct >(sectionDir, block))))), maybe(Parser< OmpEndSectionsDirective >{}/endOmpLine)))) static bool IsExecutionPart(const OmpDirectiveName &name)

	TYPE_PARSER (construct< OpenMPExecDirective >(startOmpLine > > predicated(Parser< OmpDirectiveName >{}, IsExecutionPart))) TYPE_CONTEXT_PARSER("OpenMP const ruct"_en_US

startOmpLine	withMessage ("expected OpenMP construct"_err_en_US, first(construct< OpenMPConstruct >(Parser< OpenMPSectionsConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPLoopConstruct >{}), construct< OpenMPConstruct >(Parser< OmpBlockConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPStandaloneConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPAtomicConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPUtilityConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPDispatchConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPExecutableAllocate >{}), construct< OpenMPConstruct >(Parser< OpenMPAllocatorsConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPDeclarativeAllocate >{}), construct< OpenMPConstruct >(Parser< OpenMPAssumeConstruct >{}), construct< OpenMPConstruct >(Parser< OpenMPCriticalConstruct >{})))) TYPE_PARSER(startOmpLine > > sourced(construct< OmpEndLoopDirective >(sourced("END"_tok > > Parser< OmpLoopDirective >

template<typename T >
T	WithSource (CharBlock source, T &&x)

llvm::raw_ostream &	operator<< (llvm::raw_ostream &os, const Name &x)

constexpr bool	IsTokenPasting (CharBlock opr)

constexpr bool	IsDefinedKeyword (CharBlock token)

constexpr bool	IsDirective (const char match, const char dir)

	TYPE_PARSER (validFunctionStmt\|\|construct< FunctionStmt >(many(prefixSpec), "FUNCTION" > > name, defaulted(parenthesized(optionalList(name))), maybe(suffix))/checkEndOfKnownStmt) static const expr auto programUnit

	TYPE_PARSER (construct< Program >(extension< LanguageFeature::EmptySourceFile >("nonstandard usage: empty source file"_port_en_US, skipStuffBeforeStatement > > !nextCh > > pure< std::list< ProgramUnit > >())\|\|some(globalCompilerDirective\|\|globalOpenACCCompilerDirective\|\|normalProgramUnit)/skipStuffBeforeStatement)) const expr auto actionStmtLookAhead

	TYPE_CONTEXT_PARSER ("declaration construct"_en_US, first(construct< DeclarationConstruct >(specificationConstruct), construct< DeclarationConstruct >(statement(indirect(dataStmt))), construct< DeclarationConstruct >(statement(indirect(formatStmt))), construct< DeclarationConstruct >(statement(indirect(entryStmt))), construct< DeclarationConstruct >(statement(indirect(Parser< StmtFunctionStmt >{}))), misplacedSpecificationStmt)) const expr auto recoveredDeclarationConstruct

	TYPE_CONTEXT_PARSER ("specification part"_en_US, construct< SpecificationPart >(many(openaccDeclarativeConstruct), many(openmpDeclarativeConstruct), many(indirect(compilerDirective)), many(statement(indirect(Parser< UseStmt >{}))), many(unambiguousStatement(indirect(Parser< ImportStmt >{}))), implicitPart, many(recoveredDeclarationConstruct))) const expr auto invalidDeclarationStmt

	TYPE_CONTEXT_PARSER ("specification construct"_en_US, first(construct< SpecificationConstruct >(indirect(Parser< DerivedTypeDef >{})), construct< SpecificationConstruct >(indirect(Parser< EnumDef >{})), construct< SpecificationConstruct >(statement(indirect(Parser< GenericStmt >{}))), construct< SpecificationConstruct >(indirect(interfaceBlock)), construct< SpecificationConstruct >(statement(indirect(parameterStmt))), construct< SpecificationConstruct >(statement(indirect(oldParameterStmt))), construct< SpecificationConstruct >(statement(indirect(Parser< ProcedureDeclarationStmt >{}))), construct< SpecificationConstruct >(statement(Parser< OtherSpecificationStmt >{})), construct< SpecificationConstruct >(statement(indirect(typeDeclarationStmt))), construct< SpecificationConstruct >(indirect(Parser< StructureDef >{})), construct< SpecificationConstruct >(indirect(openaccDeclarativeConstruct)), construct< SpecificationConstruct >(indirect(openmpDeclarativeConstruct)), construct< SpecificationConstruct >(indirect(compilerDirective)))) TYPE_PARSER(first(const ruct< OtherSpecificationStmt >(indirect(Parser< AccessStmt >

	construct< OtherSpecificationStmt > (indirect(Parser< AllocatableStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< AsynchronousStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< BindStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< CodimensionStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< ContiguousStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< DimensionStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< ExternalStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< IntentStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< IntrinsicStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< NamelistStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< OptionalStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< PointerStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< ProtectedStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< SaveStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< TargetStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< ValueStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< VolatileStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< CommonStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< EquivalenceStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< BasedPointerStmt >{}))

	construct< OtherSpecificationStmt > (indirect(Parser< CUDAAttributesStmt >{})))) TYPE_CONTEXT_PARSER("main program"_en_US

	construct< MainProgram > (maybe(statement(Parser< ProgramStmt >{})), specificationPart, executionPart, maybe(internalSubprogramPart), unterminatedStatement(Parser< EndProgramStmt >{}))) TYPE_CONTEXT_PARSER("PROGRAM statement"_en_US

	construct< ProgramStmt > ("PROGRAM" > > name/maybe(extension< LanguageFeature::ProgramParentheses >("nonstandard usage: parentheses in PROGRAM statement"_port_en_US, parenthesized(ok))))) TYPE_CONTEXT_PARSER("END PROGRAM statement"_en_US

	construct< EndProgramStmt > (recovery("END" > > defaulted("PROGRAM" > > maybe(name))/atEndOfStmt, progUnitEndStmtErrorRecovery))) TYPE_CONTEXT_PARSER("module"_en_US

	construct< Module > (statement(Parser< ModuleStmt >{}), limitedSpecificationPart, maybe(Parser< ModuleSubprogramPart >{}), unterminatedStatement(Parser< EndModuleStmt >{}))) TYPE_CONTEXT_PARSER("MODULE statement"_en_US

	construct< ModuleStmt > ("MODULE" > > name)) TYPE_CONTEXT_PARSER("END MODULE statement"_en_US

	construct< EndModuleStmt > (recovery("END" > > defaulted("MODULE" > > maybe(name))/atEndOfStmt, progUnitEndStmtErrorRecovery))) TYPE_CONTEXT_PARSER("module subprogram part"_en_US

	construct< ModuleSubprogramPart > (statement(containsStmt), many(StartNewSubprogram{} > > Parser< ModuleSubprogram >{}))) TYPE_PARSER(construct< ModuleSubprogram >(indirect(functionSubprogram))\|\|const ruct< ModuleSubprogram >(indirect(subroutineSubprogram))\|\|const ruct< ModuleSubprogram >(indirect(Parser< SeparateModuleSubprogram >

	construct< ModuleSubprogram > (indirect(compilerDirective))) const expr auto moduleNature

TYPE_PARSER(construct< UseStmt >("USE" > > optionalBeforeColons(moduleNature), name, ", ONLY :" > > optionalList(Parser< Only >{}))\|\|construct< UseStmt >("USE" > > optionalBeforeColons(moduleNature), name, defaulted("," > > nonemptyList("expected renamings"_err_en_US, Parser< Rename >{}))/lookAhead(endOfStmt))) TYPE_PARSER(construct< Rename >("OPERATOR (" > > const ruct< Rename	TYPE_PARSER (construct< ProcedureStmt >("MODULE PROCEDURE"_sptok > > pure(ProcedureStmt::Kind::ModuleProcedure), maybe("::"_tok) > > specificProcedures)\|\|construct< ProcedureStmt >("PROCEDURE" > > pure(ProcedureStmt::Kind::Procedure), maybe("::"_tok) > > specificProcedures)) TYPE_PARSER(sourced(first(construct< GenericSpec >("OPERATOR" > > parenthesized(Parser< DefinedOperator >

	construct< GenericSpec > (construct< GenericSpec::Assignment >("ASSIGNMENT ( = )"_tok))

	construct< GenericSpec > (construct< GenericSpec::ReadFormatted >("READ ( FORMATTED )"_tok))

	construct< GenericSpec > (construct< GenericSpec::ReadUnformatted >("READ ( UNFORMATTED )"_tok))

	construct< GenericSpec > (construct< GenericSpec::WriteFormatted >("WRITE ( FORMATTED )"_tok))

	construct< GenericSpec > (construct< GenericSpec::WriteUnformatted >("WRITE ( UNFORMATTED )"_tok))

	construct< GenericSpec > (name)))) TYPE_PARSER(construct< GenericStmt >("GENERIC" > > maybe("

std::size_t	RemoveCarriageReturns (llvm::MutableArrayRef< char > buf)

template<typename PA >
constexpr auto	unterminatedStatement (const PA &p)

template<typename PA >
constexpr auto	statement (const PA &p)

template<typename PA >
constexpr auto	unlabeledStatement (const PA &p)

template<typename PA >
constexpr auto	unambiguousStatement (const PA &p)

constexpr AnyOfChars	operator""_ch (const char str[], std::size_t n)

void	MissingSpace (ParseState &state)

constexpr TokenStringMatch	operator""_tok (const char str[], std::size_t n)

constexpr TokenStringMatch< true >	operator""_sptok (const char str[], std::size_t n)

constexpr TokenStringMatch< false, true >	operator""_id (const char str[], std::size_t n)

template<class PA >
constexpr std::enable_if_t< std::is_class_v< PA >, SequenceParser< TokenStringMatch<>, PA > >	operator>> (const char *str, const PA &p)

template<class PA >
constexpr std::enable_if_t< std::is_class_v< PA >, FollowParser< PA, TokenStringMatch<> > >	operator/ (const PA &p, const char *str)

template<class PA >
constexpr auto	parenthesized (const PA &p)

template<class PA >
constexpr auto	bracketed (const PA &p)

template<class PA >
constexpr auto	braced (const PA &p)

template<typename PA >
constexpr auto	optionalBeforeColons (const PA &p)

template<typename PA >
constexpr auto	optionalListBeforeColons (const PA &p)

template<typename A >
constexpr decltype(auto)	verbatim (A x)

template void	Unparse< Program > (llvm::raw_ostream &, const Program &, const common::LangOptions &, Encoding, bool, bool, preStatementType , AnalyzedObjectsAsFortran )

template void	Unparse< Expr > (llvm::raw_ostream &, const Expr &, const common::LangOptions &, Encoding, bool, bool, preStatementType , AnalyzedObjectsAsFortran )

template void	Unparse< parser::OpenMPDeclareReductionConstruct > (llvm::raw_ostream &, const parser::OpenMPDeclareReductionConstruct &, const common::LangOptions &, Encoding, bool, bool, preStatementType , AnalyzedObjectsAsFortran )

template void	Unparse< parser::OmpMetadirectiveDirective > (llvm::raw_ostream &, const parser::OmpMetadirectiveDirective &, const common::LangOptions &, Encoding, bool, bool, preStatementType , AnalyzedObjectsAsFortran )

bool	CanonicalizeDo (Program &program)

Variables
bool	useHexadecimalEscapeSequences {false}

constexpr OkParser	ok

constexpr NextCh	nextCh

constexpr auto	executableConstruct

constexpr auto	obsoleteExecutionPartConstruct

TYPE_CONTEXT_PARSER("FORM TEAM statement"_en_US, construct< FormTeamStmt >("FORM TEAM"_sptok > > "("_tok > > scalarIntExpr, "," > > teamVariable, defaulted("," > > nonemptyList(Parser< FormTeamStmt::FormTeamSpec >{}))/")")) TYPE_PARSER(const ruct< FormTeamStmt TYPE_CONTEXT_PARSER("LOCK statement"_en_US, construct< LockStmt >("LOCK (" > > lockVariable, defaulted("," > > nonemptyList(Parser< LockStmt::LockStat >{}))/")")) TYPE_PARSER(const ruct< LockStmt constexpr auto	gridOrBlock

constexpr auto	charLiteralConstantWithoutKind

constexpr auto	scalarLogicalVariable {scalar(logical(variable))}

constexpr auto	scalarDefaultCharVariable {scalar(defaultChar(variable))}

constexpr auto	scalarIntVariable {scalar(integer(variable))}

constexpr auto	msgVariable {construct<MsgVariable>(scalarDefaultCharVariable)}

constexpr auto	logicalExpr {logical(indirect(expr))}

constexpr auto	scalarLogicalExpr {scalar(logicalExpr)}

constexpr auto	defaultCharExpr {defaultChar(indirect(expr))}

constexpr auto	scalarDefaultCharExpr {scalar(defaultCharExpr)}

constexpr auto	intExpr {integer(indirect(expr))}

constexpr auto	scalarIntExpr {scalar(intExpr)}

constexpr auto	constantExpr {constant(indirect(expr))}

constexpr auto	scalarExpr {scalar(indirect(expr))}

constexpr auto	scalarDefaultCharConstantExpr {scalar(defaultChar(constantExpr))}

constexpr auto	intConstantExpr {integer(constantExpr)}

constexpr auto	scalarIntConstantExpr {scalar(intConstantExpr)}

constexpr auto	boundExpr {scalarIntExpr}

constexpr auto	teamValue {scalar(indirect(expr))}

constexpr auto	doVariable {scalar(integer(name))}

constexpr auto	nonDigitIdChar {letter \|\| otherIdChar}

constexpr auto	rawName {nonDigitIdChar >> many(nonDigitIdChar \|\| digit)}

constexpr auto	intrinsicOperator

constexpr auto	signedRealLiteralConstant

constexpr auto	exponentPart

	Parser< ComplexLiteralConstant >

nonemptyList("expected component declarations"_err_en_US, Parser< ComponentOrFill >{}))) TYPE_PARSER(construct< ComponentAttrSpec >(accessSpec)\|\|const ruct< ComponentAttrSpec >(allocatable)\|\|const ruct< ComponentAttrSpec >("CODIMENSION" > > coarraySpec)\|\|const ruct< ComponentAttrSpec >(contiguous)\|\|const ruct< ComponentAttrSpec >("DIMENSION" > > componentArraySpec)\|\|const ruct< ComponentAttrSpec >(pointer)\|\|extension< LanguageFeature constexpr auto	pass {construct<Pass>("PASS" >> maybe(parenthesized(name)))}

constexpr auto	statusExpr {construct<StatusExpr>(scalarDefaultCharExpr)}

constexpr auto	errLabel {construct<ErrLabel>(label)}

constexpr auto	endLabel {construct<EndLabel>(label)}

constexpr auto	eorLabel {construct<EorLabel>(label)}

	_tok

constexpr auto	positionOrFlushSpecList

constexpr DigitStringIgnoreSpaces	repeat

TYPE_PARSER(construct< format::FormatItem >(maybe(repeat), Parser< format::IntrinsicTypeDataEditDesc >{})\|\|construct< format::FormatItem >(maybe(repeat), Parser< format::DerivedTypeDataEditDesc >{})\|\|construct< format::FormatItem >(Parser< format::ControlEditDesc >{})\|\|construct< format::FormatItem >(charStringEditDesc)\|\|construct< format::FormatItem >(maybe(repeat), parenthesized(formatItems))) TYPE_PARSER(parenthesized(construct< format constexpr auto	mandatoryWidth {construct<std::optional<int>>(width)}

constexpr auto	digits {repeat}

constexpr auto	noInt {construct<std::optional<int>>()}

constexpr auto	mandatoryDigits {construct<std::optional<int>>("." >> width)}

constexpr auto	keyword {construct<Keyword>(name)}

constexpr auto	block {many(executionPartConstruct)}

constexpr auto	listOfNames {nonemptyList("expected names"_err_en_US, name)}

constexpr auto	star {construct<Star>("*"_tok)}

constexpr auto	allocatable {construct<Allocatable>("ALLOCATABLE"_tok)}

constexpr auto	contiguous {construct<Contiguous>("CONTIGUOUS"_tok)}

constexpr auto	optional {construct<Optional>("OPTIONAL"_tok)}

constexpr auto	pointer {construct<Pointer>("POINTER"_tok)}

constexpr auto	protectedAttr {construct<Protected>("PROTECTED"_tok)}

constexpr auto	save {construct<Save>("SAVE"_tok)}

constexpr auto	startAccLine

constexpr auto	endAccLine

	__pad0__

constexpr auto	startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok

constexpr auto	endOmpLine = space >> endOfLine

	Parser< OmpClauseList >

constexpr auto	execPartLookAhead

constexpr auto	declErrorRecovery

constexpr auto	misplacedSpecificationStmt

constexpr auto	limitedDeclarationConstruct

constexpr auto	limitedSpecificationPart

	accessSpec

::	genericSpec

constexpr auto	label {space >> digitString64 / spaceCheck}

constexpr auto	atEndOfStmt

constexpr auto	checkEndOfKnownStmt {recovery(atEndOfStmt, SkipTo<'\n'>{})}

constexpr auto	endOfLine

constexpr auto	semicolons {";"_ch >> skipMany(";"_tok) / space / maybe("\n"_ch)}

constexpr auto	endOfStmt

constexpr auto	forceEndOfStmt {recovery(endOfStmt, SkipPast<'\n'>{})}

constexpr auto	ignoredStatementPrefix

constexpr auto	inStmtErrorRecovery

constexpr auto	skipStmtErrorRecovery

constexpr auto	stmtErrorRecoveryStart {ignoredStatementPrefix}

constexpr auto	skipBadLine {SkipPast<'\n'>{} >> construct<ErrorRecovery>()}

constexpr auto	executionPartErrorRecovery

constexpr auto	missingOptionalName {pure<std::optional<Name>>()}

constexpr auto	noNameEnd {"END" >> missingOptionalName}

constexpr auto	progUnitEndStmt

constexpr auto	constructEndStmtErrorRecovery

constexpr auto	namedConstructEndStmtErrorRecovery

constexpr auto	progUnitEndStmtErrorRecovery

constexpr auto	beginDirective {skipStuffBeforeStatement >> "!"_ch}

constexpr auto	endDirective {space >> endOfLine}

constexpr auto	letter {"abcdefghijklmnopqrstuvwxyz"_ch}

constexpr auto	digit {"0123456789"_ch}

constexpr Space	space

constexpr SpaceCheck	spaceCheck

constexpr DigitString	digitString

constexpr DigitString64	digitString64

constexpr ConsumedAllInputParser	consumedAllInput

constexpr SkipStuffBeforeStatement	skipStuffBeforeStatement

constexpr auto	underscore {"_"_ch}

constexpr auto	otherIdChar

constexpr auto	logicalTRUE

constexpr auto	logicalFALSE

constexpr auto	rawHollerithLiteral

constexpr Parser< Program >	program

constexpr Parser< SpecificationPart >	specificationPart

constexpr Parser< ImplicitPart >	implicitPart

constexpr Parser< DeclarationConstruct >	declarationConstruct

constexpr Parser< SpecificationConstruct >	specificationConstruct

constexpr Parser< ExecutionPart >	executionPart

constexpr Parser< ExecutionPartConstruct >	executionPartConstruct

constexpr Parser< InternalSubprogramPart >	internalSubprogramPart

constexpr Parser< ActionStmt >	actionStmt

constexpr Parser< Name >	name

constexpr Parser< LiteralConstant >	literalConstant

constexpr Parser< NamedConstant >	namedConstant

constexpr Parser< TypeParamValue >	typeParamValue

constexpr Parser< TypeSpec >	typeSpec

constexpr Parser< DeclarationTypeSpec >	declarationTypeSpec

constexpr Parser< IntrinsicTypeSpec >	intrinsicTypeSpec

constexpr Parser< IntegerTypeSpec >	integerTypeSpec

constexpr Parser< KindSelector >	kindSelector

constexpr Parser< SignedIntLiteralConstant >	signedIntLiteralConstant

constexpr Parser< IntLiteralConstant >	intLiteralConstant

constexpr Parser< UnsignedLiteralConstant >	unsignedLiteralConstant

constexpr Parser< KindParam >	kindParam

constexpr Parser< RealLiteralConstant >	realLiteralConstant

constexpr Parser< CharLength >	charLength

constexpr Parser< CharLiteralConstant >	charLiteralConstant

constexpr Parser< CharLiteralConstantSubstring >	charLiteralConstantSubstring

constexpr Parser< Initialization >	initialization

constexpr Parser< DerivedTypeSpec >	derivedTypeSpec

constexpr Parser< TypeDeclarationStmt >	typeDeclarationStmt

constexpr Parser< NullInit >	nullInit

constexpr Parser< LanguageBindingSpec >	languageBindingSpec

constexpr Parser< EntityDecl >	entityDecl

constexpr Parser< CoarraySpec >	coarraySpec

constexpr Parser< ArraySpec >	arraySpec

constexpr Parser< ComponentArraySpec >	componentArraySpec

constexpr Parser< ExplicitShapeSpec >	explicitShapeSpec

constexpr Parser< DeferredShapeSpecList >	deferredShapeSpecList

constexpr Parser< AssumedImpliedSpec >	assumedImpliedSpec

constexpr Parser< IntentSpec >	intentSpec

constexpr Parser< DataStmt >	dataStmt

constexpr Parser< DataImpliedDo >	dataImpliedDo

constexpr Parser< ParameterStmt >	parameterStmt

constexpr Parser< OldParameterStmt >	oldParameterStmt

constexpr Parser< Designator >	designator

constexpr Parser< Variable >	variable

constexpr Parser< Substring >	substring

constexpr Parser< DataRef >	dataRef

constexpr Parser< StructureComponent >	structureComponent

constexpr Parser< SubscriptTriplet >	subscriptTriplet

constexpr Parser< AllocateStmt >	allocateStmt

constexpr Parser< StatVariable >	statVariable

constexpr Parser< StatOrErrmsg >	statOrErrmsg

constexpr Parser< DefinedOpName >	definedOpName

constexpr Parser< Expr >	expr

constexpr Parser< SpecificationExpr >	specificationExpr

constexpr Parser< AssignmentStmt >	assignmentStmt

constexpr Parser< PointerAssignmentStmt >	pointerAssignmentStmt

constexpr Parser< WhereStmt >	whereStmt

constexpr Parser< WhereConstruct >	whereConstruct

constexpr Parser< WhereBodyConstruct >	whereBodyConstruct

constexpr Parser< ForallConstruct >	forallConstruct

constexpr Parser< ForallAssignmentStmt >	forallAssignmentStmt

constexpr Parser< ForallStmt >	forallStmt

constexpr Parser< Selector >	selector

constexpr Parser< EndSelectStmt >	endSelectStmt

constexpr Parser< ConcurrentHeader >	concurrentHeader

constexpr Parser< IoUnit >	ioUnit

constexpr Parser< FileUnitNumber >	fileUnitNumber

constexpr Parser< IoControlSpec >	ioControlSpec

constexpr Parser< Format >	format

constexpr Parser< InputItem >	inputItem

constexpr Parser< OutputItem >	outputItem

constexpr Parser< InputImpliedDo >	inputImpliedDo

constexpr Parser< OutputImpliedDo >	outputImpliedDo

constexpr Parser< PositionOrFlushSpec >	positionOrFlushSpec

constexpr Parser< FormatStmt >	formatStmt

constexpr Parser< InterfaceBlock >	interfaceBlock

constexpr Parser< ProcInterface >	procInterface

constexpr Parser< ProcDecl >	procDecl

constexpr Parser< FunctionReference >	functionReference

constexpr Parser< ActualArgSpec >	actualArgSpec

constexpr Parser< PrefixSpec >	prefixSpec

constexpr Parser< FunctionSubprogram >	functionSubprogram

constexpr Parser< FunctionStmt >	functionStmt

constexpr Parser< Suffix >	suffix

constexpr Parser< EndFunctionStmt >	endFunctionStmt

constexpr Parser< SubroutineSubprogram >	subroutineSubprogram

constexpr Parser< SubroutineStmt >	subroutineStmt

constexpr Parser< DummyArg >	dummyArg

constexpr Parser< EndSubroutineStmt >	endSubroutineStmt

constexpr Parser< EntryStmt >	entryStmt

constexpr Parser< ContainsStmt >	containsStmt

constexpr Parser< CompilerDirective >	compilerDirective

constexpr Parser< OpenACCConstruct >	openaccConstruct

constexpr Parser< OpenACCDeclarativeConstruct >	openaccDeclarativeConstruct

constexpr Parser< OpenMPConstruct >	openmpConstruct

constexpr Parser< OpenMPExecDirective >	openmpExecDirective

constexpr Parser< OpenMPDeclarativeConstruct >	openmpDeclarativeConstruct

constexpr Parser< OmpEndLoopDirective >	ompEndLoopDirective

constexpr Parser< IntrinsicVectorTypeSpec >	intrinsicVectorTypeSpec

constexpr Parser< VectorTypeSpec >	vectorTypeSpec

constexpr Parser< UnsignedTypeSpec >	unsignedTypeSpec

Detailed Description

Parse tree visitor Call Walk(x, visitor) to visit x and, by default, each node under x. If x is non-const, the visitor member functions can modify the tree.

visitor.Pre(x) is called before visiting x and its children are not visited if it returns false.

visitor.Post(x) is called after visiting x.

Function Documentation

◆ TYPE_PARSER()

Fortran::parser::TYPE_PARSER ( sourced(construct< OmpTraitSelector >( sourced(TraitSelectorParser(Parser< OmpTraitSelectorName >{})))) )

MOBClause is a clause that has a std::tuple<Modifiers, OmpObjectList, bool>. Helper function to create a typical modifiers-objects clause, where the commas separating individual modifiers are optional, and the clause contains a bool member to indicate whether it was fully comma-separated or not.

Variable Documentation

◆ atEndOfStmt

constexpr auto Fortran::parser::atEndOfStmt

constexpr

Initial value:

{space >>

withMessage("expected end of statement"_err_en_US, lookAhead(";\n"_ch))}

◆ charLiteralConstantWithoutKind

constexpr auto Fortran::parser::charLiteralConstantWithoutKind

constexpr

Initial value:

{

"'"_ch >> CharLiteral<'\''>{} || "\""_ch >> CharLiteral<'"'>{}}

Fortran::parser::CharLiteral

Definition: token-parsers.h:251

◆ constructEndStmtErrorRecovery

constexpr auto Fortran::parser::constructEndStmtErrorRecovery

constexpr

Initial value:

{

!progUnitEndStmt >> ("END"_tok >> SkipTo<'\n'>{} || ok)}

◆ declErrorRecovery

constexpr auto Fortran::parser::declErrorRecovery

constexpr

Initial value:

{

stmtErrorRecoveryStart >> !execPartLookAhead >> skipStmtErrorRecovery}

◆ endAccLine

constexpr auto Fortran::parser::endAccLine

constexpr

Initial value:

{space >>
    recovery(
        withMessage("expected end of OpenACC directive"_err_en_US, endOfLine),
        SkipTo<'\n'>{} || ok)}

◆ endOfLine

constexpr auto Fortran::parser::endOfLine

constexpr

Initial value:

{

"\n"_ch >> ok || fail("expected end of line"_err_en_US)}

◆ endOfStmt

constexpr auto Fortran::parser::endOfStmt

constexpr

Initial value:

{
    space >> withMessage("expected end of statement"_err_en_US,
                 semicolons || endOfLine)}

◆ execPartLookAhead

constexpr auto Fortran::parser::execPartLookAhead

constexpr

Initial value:

{first(actionStmtLookAhead >> ok,
    openaccConstruct >> ok, openmpExecDirective >> ok, "ASSOCIATE ("_tok,
    "BLOCK"_tok, "SELECT"_tok, "CHANGE TEAM"_sptok, "CRITICAL"_tok, "DO"_tok,
    "IF ("_tok, "WHERE ("_tok, "FORALL ("_tok, "!$CUF"_tok)}

◆ executableConstruct

constexpr auto Fortran::parser::executableConstruct

constexpr

Initial value:

{first(
    construct<ExecutableConstruct>(CapturedLabelDoStmt{}),
    construct<ExecutableConstruct>(EndDoStmtForCapturedLabelDoStmt{}),
    construct<ExecutableConstruct>(indirect(Parser<DoConstruct>{})),
    
    
    construct<ExecutableConstruct>(statement(actionStmt)),
    construct<ExecutableConstruct>(indirect(Parser<AssociateConstruct>{})),
    construct<ExecutableConstruct>(indirect(Parser<BlockConstruct>{})),
    construct<ExecutableConstruct>(indirect(Parser<CaseConstruct>{})),
    construct<ExecutableConstruct>(indirect(Parser<ChangeTeamConstruct>{})),
    construct<ExecutableConstruct>(indirect(Parser<CriticalConstruct>{})),
    construct<ExecutableConstruct>(indirect(Parser<IfConstruct>{})),
    construct<ExecutableConstruct>(indirect(Parser<SelectRankConstruct>{})),
    construct<ExecutableConstruct>(indirect(Parser<SelectTypeConstruct>{})),
    construct<ExecutableConstruct>(indirect(whereConstruct)),
    construct<ExecutableConstruct>(indirect(forallConstruct)),
    construct<ExecutableConstruct>(indirect(ompEndLoopDirective)),
    construct<ExecutableConstruct>(indirect(openmpConstruct)),
    construct<ExecutableConstruct>(indirect(Parser<OpenACCConstruct>{})),
    construct<ExecutableConstruct>(indirect(compilerDirective)),
    construct<ExecutableConstruct>(indirect(Parser<CUFKernelDoConstruct>{})))}

◆ executionPartErrorRecovery

constexpr auto Fortran::parser::executionPartErrorRecovery

constexpr

Initial value:

{stmtErrorRecoveryStart >>
    !"END"_tok >> !"CONTAINS"_tok >> !"ELSE"_tok >> !"CASE"_tok >>
    !"TYPE IS"_tok >> !"CLASS"_tok >> !"RANK"_tok >>
    !("!$ACC "_sptok >> "END"_tok) >>
    !("!$OMP "_sptok >> ("END"_tok || "SECTION"_id)) >> skipBadLine}

◆ exponentPart

constexpr auto Fortran::parser::exponentPart

constexpr

Initial value:

{
    ("ed"_ch ||
        extension<LanguageFeature::QuadPrecision>(
            "nonstandard usage: Q exponent"_port_en_US, "q"_ch)) >>
    SignedDigitString{}}

◆ gridOrBlock

TYPE_CONTEXT_PARSER ("FORM TEAM statement"_en_US, construct<FormTeamStmt>("FORM TEAM"_sptok >> "("_tok >> scalarIntExpr, "," >> teamVariable, defaulted("," >> nonemptyList(Parser<FormTeamStmt::FormTeamSpec>{})) / ")")) TYPE_PARSER( const ruct<FormTeamStmt TYPE_CONTEXT_PARSER ("LOCK statement"_en_US, construct<LockStmt>("LOCK (" >> lockVariable, defaulted("," >> nonemptyList(Parser<LockStmt::LockStat>{})) / ")")) TYPE_PARSER( const ruct<LockStmt constexpr auto Fortran::parser::gridOrBlock

constexpr

Initial value:

{parenthesized(nonemptyList(starOrExpr)) ||

applyFunction(singletonList<CUFKernelDoConstruct::StarOrExpr>, starOrExpr)}

◆ ignoredStatementPrefix

constexpr auto Fortran::parser::ignoredStatementPrefix

constexpr

Initial value:

{

skipStuffBeforeStatement >> maybe(label) >> maybe(name / ":") >> space}

◆ inStmtErrorRecovery

constexpr auto Fortran::parser::inStmtErrorRecovery

constexpr

Initial value:

{!"END"_tok >> !"CONTAINS"_tok >>

SkipTo<'\n'>{} >> construct<ErrorRecovery>()}

◆ intrinsicOperator

constexpr auto Fortran::parser::intrinsicOperator

constexpr

Initial value:

{
    "**" >> pure(DefinedOperator::IntrinsicOperator::Power) ||
    "*" >> pure(DefinedOperator::IntrinsicOperator::Multiply) ||
    "//" >> pure(DefinedOperator::IntrinsicOperator::Concat) ||
    "/=" >> pure(DefinedOperator::IntrinsicOperator::NE) ||
    "/" >> pure(DefinedOperator::IntrinsicOperator::Divide) ||
    "+" >> pure(DefinedOperator::IntrinsicOperator::Add) ||
    "-" >> pure(DefinedOperator::IntrinsicOperator::Subtract) ||
    "<=" >> pure(DefinedOperator::IntrinsicOperator::LE) ||
    extension<LanguageFeature::AlternativeNE>(
        "nonstandard usage: <> spelling of /= or .NE."_port_en_US,
        "<>" >> pure(DefinedOperator::IntrinsicOperator::NE)) ||
    "<" >> pure(DefinedOperator::IntrinsicOperator::LT) ||
    "==" >> pure(DefinedOperator::IntrinsicOperator::EQ) ||
    ">=" >> pure(DefinedOperator::IntrinsicOperator::GE) ||
    ">" >> pure(DefinedOperator::IntrinsicOperator::GT) ||
    namedIntrinsicOperator}

◆ limitedDeclarationConstruct

constexpr auto Fortran::parser::limitedDeclarationConstruct

constexpr

Initial value:

{recovery(
    withMessage("expected declaration construct"_err_en_US,
        inContext("declaration construct"_en_US,
            first(construct<DeclarationConstruct>(specificationConstruct),
                construct<DeclarationConstruct>(statement(indirect(dataStmt))),
                misplacedSpecificationStmt, invalidDeclarationStmt))),
    construct<DeclarationConstruct>(
        stmtErrorRecoveryStart >> skipStmtErrorRecovery))}

◆ limitedSpecificationPart

constexpr auto Fortran::parser::limitedSpecificationPart

constexpr

Initial value:

{inContext("specification part"_en_US,
    construct<SpecificationPart>(many(openaccDeclarativeConstruct),
        many(openmpDeclarativeConstruct), many(indirect(compilerDirective)),
        many(statement(indirect(Parser<UseStmt>{}))),
        many(unambiguousStatement(indirect(Parser<ImportStmt>{}))),
        implicitPart, many(limitedDeclarationConstruct)))}

◆ logicalFALSE

constexpr auto Fortran::parser::logicalFALSE

constexpr

Initial value:

{
    (".FALSE."_tok ||
        extension<LanguageFeature::LogicalAbbreviations>(
            "nonstandard usage: .F. spelling of .FALSE."_port_en_US,
            ".F."_tok)) >>
    pure(false)}

◆ logicalTRUE

constexpr auto Fortran::parser::logicalTRUE

constexpr

Initial value:

{
    (".TRUE."_tok ||
        extension<LanguageFeature::LogicalAbbreviations>(
            "nonstandard usage: .T. spelling of .TRUE."_port_en_US,
            ".T."_tok)) >>
    pure(true)}

◆ misplacedSpecificationStmt

constexpr auto Fortran::parser::misplacedSpecificationStmt

constexpr

Initial value:

{Parser<UseStmt>{} >>
        fail<DeclarationConstruct>("misplaced USE statement"_err_en_US) ||
    Parser<ImportStmt>{} >>
        fail<DeclarationConstruct>(
            "IMPORT statements must follow any USE statements and precede all other declarations"_err_en_US) ||
    Parser<ImplicitStmt>{} >>
        fail<DeclarationConstruct>(
            "IMPLICIT statements must follow USE and IMPORT and precede all other declarations"_err_en_US)}

◆ namedConstructEndStmtErrorRecovery

constexpr auto Fortran::parser::namedConstructEndStmtErrorRecovery

constexpr

Initial value:

{

constructEndStmtErrorRecovery >> missingOptionalName}

◆ obsoleteExecutionPartConstruct

constexpr auto Fortran::parser::obsoleteExecutionPartConstruct

constexpr

Initial value:

{recovery(ignoredStatementPrefix >>
        fail<ExecutionPartConstruct>(
            "obsolete legacy extension is not supported"_err_en_US),
    construct<ExecutionPartConstruct>(construct<ErrorRecovery>(ok /
        statement("REDIMENSION" >> name /
                parenthesized(nonemptyList(Parser<AllocateShapeSpec>{}))))))}

◆ otherIdChar

constexpr auto Fortran::parser::otherIdChar

constexpr

Initial value:

{underscore / !"'\""_ch ||
    extension<LanguageFeature::PunctuationInNames>(
        "nonstandard usage: punctuation in name"_port_en_US, "$@"_ch)}

◆ positionOrFlushSpecList

constexpr auto Fortran::parser::positionOrFlushSpecList

constexpr

Initial value:

{

parenthesized(nonemptyList(positionOrFlushSpec)) || bareUnitNumberAsList}

◆ progUnitEndStmt

constexpr auto Fortran::parser::progUnitEndStmt

constexpr

Initial value:

{
    "END" >> (lookAhead("\n"_ch) || "SUBROUTINE"_tok || "FUNCTION"_tok ||
                 "PROCEDURE"_tok || "MODULE"_tok || "SUBMODULE"_tok ||
                 "PROGRAM"_tok || "BLOCK DATA"_tok)}

◆ progUnitEndStmtErrorRecovery

constexpr auto Fortran::parser::progUnitEndStmtErrorRecovery

constexpr

Initial value:

{
    (many(!"END"_tok >> SkipPast<'\n'>{}) >>
        ("END"_tok >> SkipTo<'\n'>{} || consumedAllInput)) >>
    missingOptionalName}

◆ rawHollerithLiteral

constexpr auto Fortran::parser::rawHollerithLiteral

constexpr

Initial value:

{

deprecated<LanguageFeature::Hollerith>(HollerithLiteral{})}

◆ signedRealLiteralConstant

constexpr auto Fortran::parser::signedRealLiteralConstant

constexpr

Initial value:

{

construct<SignedRealLiteralConstant>(maybe(sign), realLiteralConstant)}

◆ skipStmtErrorRecovery

constexpr auto Fortran::parser::skipStmtErrorRecovery

constexpr

Initial value:

{!"END"_tok >> !"CONTAINS"_tok >>

SkipPast<'\n'>{} >> construct<ErrorRecovery>()}

◆ startAccLine

constexpr auto Fortran::parser::startAccLine

constexpr

Initial value:

{skipStuffBeforeStatement >>
    withMessage(
        "expected OpenACC directive sentinel: !$ACC, C$ACC, or *$ACC"_err_en_US,
        "!$ACC "_sptok)}

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Function Documentation

◆ TYPE_PARSER()

Variable Documentation

◆ atEndOfStmt

◆ charLiteralConstantWithoutKind

◆ constructEndStmtErrorRecovery

◆ declErrorRecovery

◆ endAccLine

◆ endOfLine

◆ endOfStmt

◆ execPartLookAhead

◆ executableConstruct

◆ executionPartErrorRecovery

◆ exponentPart

◆ gridOrBlock

◆ ignoredStatementPrefix

◆ inStmtErrorRecovery

◆ intrinsicOperator

◆ limitedDeclarationConstruct

◆ limitedSpecificationPart

◆ logicalFALSE

◆ logicalTRUE

◆ misplacedSpecificationStmt

◆ namedConstructEndStmtErrorRecovery

◆ obsoleteExecutionPartConstruct

◆ otherIdChar

◆ positionOrFlushSpecList

◆ progUnitEndStmt

◆ progUnitEndStmtErrorRecovery

◆ rawHollerithLiteral

◆ signedRealLiteralConstant

◆ skipStmtErrorRecovery

◆ startAccLine