Fortran::parser Namespace Reference

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	OmpArgumentParser< llvm::omp::Directive::OMPD_declare_variant >
struct	OmpAtClause
struct	OmpAtomicConstructParser
struct	OmpAtomicDefaultMemOrderClause
struct	OmpAutomapModifier
struct	OmpBaseVariantNames
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	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	OmpGraphIdClause
struct	OmpGraphResetClause
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	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	OmpReplayableClause
struct	OmpScheduleClause
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	OmpTransparentClause
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
using	ProvenanceRange = common::Interval<Provenance>
using	preStatementType
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
using	DirectiveSet

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 (!consumedAllInput > > 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(construct< OmpBaseVariantNames >(Parser< OmpObject >
TYPE_PARSER(construct< OmpLocatorList >(nonemptyList(Parser< OmpLocator >{}))) template< llvm	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< OmpDirectiveName >(OmpDirectiveNameParser{}))) OmpDirectiveSpecification static makeFlushFromOldSyntax(Verbatim &&text
	TYPE_PARSER (sourced(construct< OmpDirectiveSpecification >(applyFunction< OmpDirectiveSpecification >(makeFlushFromOldSyntax, verbatim("FLUSH"_tok)/!lookAhead("("_tok), maybe(Parser< OmpClauseList >{}), maybe(parenthesized(OmpArgumentListParser< llvm::omp::Directive::OMPD_flush >{})), pure(OmpDirectiveSpecification::Flags::DeprecatedSyntax))))||predicated(Parser< OmpDirectiveName >{}, IsDirective(llvm::omp::Directive::OMPD_declare_variant)) >=sourced(construct< OmpDirectiveSpecification >(sourced(OmpDirectiveNameParser{}), maybe(parenthesized(OmpArgumentListParser< llvm::omp::Directive::OMPD_declare_variant >{})), maybe(Parser< OmpClauseList >{}), pure(OmpDirectiveSpecification::Flags::None)))||sourced(construct< OmpDirectiveSpecification >(sourced(OmpDirectiveNameParser{}), maybe(parenthesized(OmpArgumentListParser<>{})), maybe(Parser< OmpClauseList >{}), pure(OmpDirectiveSpecification::Flags::None)))) static bool IsStandaloneOrdered(const OmpDirectiveSpecification &dirSpec)
	TYPE_PARSER (construct< OmpErrorDirective >(predicated(Parser< OmpDirectiveName >{}, IsDirective(llvm::omp::Directive::OMPD_error)) >=Parser< OmpDirectiveSpecification >{})) TYPE_PARSER(construct< OmpNothingDirective >(predicated(Parser< OmpDirectiveName >
	IsDirective (llvm::omp::Directive::OMPD_nothing)) >
	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 >{})||construct< OpenMPSimpleStandaloneConstruct >(predicated(Parser< OmpDirectiveSpecification >{}, IsStandaloneOrdered)))) 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 >{})))) static const expr DirectiveSet GetLoopDirectives()
	TYPE_PARSER (sourced(construct< OmpBeginLoopDirective >(sourced(OmpBeginDirectiveParser(GetLoopDirectives()))))) TYPE_PARSER(sourced(construct< OmpEndLoopDirective >(sourced(OmpEndDirectiveParser(GetLoopDirectives()))))) TYPE_PARSER(construct< OpenMPLoopConstruct >(Parser< OmpBeginLoopDirective >
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 > > consumedAllInput > > 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::OpenMPDeclarativeConstruct > (llvm::raw_ostream &, const parser::OpenMPDeclarativeConstruct &, 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
constexpr auto	logicalConstantExpr {logical(constantExpr)}
constexpr auto	scalarLogicalConstantExpr {scalar(logicalConstantExpr)}
	Parser< OmpObject >
	__pad1__
std::optional< OmpClauseList > &&	clauses
std::optional< OmpClauseList > std::optional< OmpArgumentList > &&	args
std::optional< OmpClauseList > std::optional< OmpArgumentList > OmpDirectiveSpecification::Flags &&	flags
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	skipToNextLineIfAny {consumedAllInput || SkipPast<'\n'>{}}
constexpr auto	forceEndOfStmt {recovery(endOfStmt, skipToNextLineIfAny)}
constexpr auto	ignoredStatementPrefix
constexpr auto	inStmtErrorRecovery
constexpr auto	skipStmtErrorRecovery
constexpr auto	stmtErrorRecoveryStart {ignoredStatementPrefix}
constexpr auto	skipBadLine {skipToNextLineIfAny >> 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.

Typedef Documentation

ApplicableFunctionObject

template<typename RESULT, typename... PARSER>

using Fortran::parser::ApplicableFunctionObject

Initial value:

 
    const std::function<RESULT(typename PARSER::resultType &&...)> &

DirectiveSet

using Fortran::parser::DirectiveSet

Initial value:

 
    llvm::Bitset<llvm::NextPowerOf2(llvm::omp::Directive_enumSize)>

NestedConstruct

using Fortran::parser::NestedConstruct

Initial value:

 
    std::variant<DoConstruct, common::Indirection<OpenMPLoopConstruct>>

preStatementType

using Fortran::parser::preStatementType

Initial value:

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

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

auto Fortran::parser::atEndOfStmt

constexpr

Initial value:

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

charLiteralConstantWithoutKind

auto Fortran::parser::charLiteralConstantWithoutKind

constexpr

Initial value:

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

constructEndStmtErrorRecovery

auto Fortran::parser::constructEndStmtErrorRecovery

constexpr

Initial value:

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

declErrorRecovery

auto Fortran::parser::declErrorRecovery

constexpr

Initial value:

{
    stmtErrorRecoveryStart >> !execPartLookAhead >> skipStmtErrorRecovery}

endAccLine

auto Fortran::parser::endAccLine

constexpr

Initial value:

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

endOfLine

auto Fortran::parser::endOfLine

constexpr

Initial value:

{consumedAllInput ||
    withMessage("expected end of line"_err_en_US, "\n"_ch >> ok)}

endOfStmt

auto Fortran::parser::endOfStmt

constexpr

Initial value:

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

execPartLookAhead

auto Fortran::parser::execPartLookAhead

constexpr

Initial value:

{first(actionStmtLookAhead,
    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

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

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

auto Fortran::parser::exponentPart

constexpr

Initial value:

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

flags

std::optional<OmpClauseList> std::optional<OmpArgumentList> OmpDirectiveSpecification::Flags&& Fortran::parser::flags

Initial value:

{
  return OmpDirectiveSpecification{OmpDirectiveName(text), std::move(args),
      std::move(clauses), std::move(flags)}

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

auto Fortran::parser::ignoredStatementPrefix

constexpr

Initial value:

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

inStmtErrorRecovery

auto Fortran::parser::inStmtErrorRecovery

constexpr

Initial value:

{!"END"_tok >> !"CONTAINS"_tok >>
    (consumedAllInput || SkipTo<'\n'>{}) >> construct<ErrorRecovery>()}

intrinsicOperator

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

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

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

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

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

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

auto Fortran::parser::namedConstructEndStmtErrorRecovery

constexpr

Initial value:

{
    constructEndStmtErrorRecovery >> missingOptionalName}

obsoleteExecutionPartConstruct

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

auto Fortran::parser::otherIdChar

constexpr

Initial value:

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

Parser< OmpObject >

Fortran::parser::Parser< OmpObject >

Initial value:

{}))
 
 
 
 
 
 
 
template <llvm::omp::Directive Id = llvm::omp::Directive::OMPD_unknown>
struct OmpArgumentParser {
  using resultType = OmpArgument;
 
  std::optional<resultType> Parse(ParseState &state) const {
    constexpr auto parser{sourced(first( 
        construct<OmpArgument>(Parser<OmpMapperSpecifier>{}),
        
        construct<OmpArgument>(Parser<OmpReductionSpecifier>{}),
        construct<OmpArgument>(Parser<OmpLocator>{})))};
    return parser.Parse(state);
  }
}

positionOrFlushSpecList

auto Fortran::parser::positionOrFlushSpecList

constexpr

Initial value:

{
    parenthesized(nonemptyList(positionOrFlushSpec)) || bareUnitNumberAsList}

progUnitEndStmt

auto Fortran::parser::progUnitEndStmt

constexpr

Initial value:

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

progUnitEndStmtErrorRecovery

auto Fortran::parser::progUnitEndStmtErrorRecovery

constexpr

Initial value:

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

rawHollerithLiteral

auto Fortran::parser::rawHollerithLiteral

constexpr

Initial value:

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

signedRealLiteralConstant

auto Fortran::parser::signedRealLiteralConstant

constexpr

Initial value:

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

skipStmtErrorRecovery

auto Fortran::parser::skipStmtErrorRecovery

constexpr

Initial value:

{!"END"_tok >> !"CONTAINS"_tok >>
    (consumedAllInput || SkipPast<'\n'>{}) >> construct<ErrorRecovery>()}

startAccLine

auto Fortran::parser::startAccLine

constexpr

Initial value:

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