FLANG

Classes | Typedefs | Enumerations | Functions | Variables
Fortran::parser Namespace Reference

## Classes
struct | AccAtomicCapture
struct | AccAtomicRead
struct | AccAtomicUpdate
struct | AccAtomicWrite
struct | AccBeginBlockDirective
struct | AccBeginCombinedDirective
struct | AccBeginLoopDirective
struct | AccBlockDirective
struct | AccClause
struct | AccClauseList
struct | AccCombinedDirective
struct | AccDataModifier
struct | AccDeclarativeDirective
struct | AccDefaultClause
struct | AccEndBlockDirective
struct | AccEndCombinedDirective
struct | AccessId
struct | AccessSpec
struct | AccessStmt
struct | AccGangArgument
struct | AccLoopDirective
struct | AccObject
struct | AccObjectListWithModifier
struct | AccObjectListWithReduction
struct | AccReductionOperator
struct | AccSizeExpr
struct | AccSizeExprList
struct | AccStandaloneDirective
struct | AccWaitArgument
struct | AcImpliedDo
struct | AcImpliedDoControl
struct | AcSpec
struct | ActionStmt
struct | ActualArg
struct | ActualArgSpec
struct | AcValue
struct | AllocateCoarraySpec
struct | AllocateObject
struct | AllocateShapeSpec
struct | AllocateStmt
struct | Allocation
struct | AllocOpt
class | AllSources
class | AlternativesParser
class | AMFPHelper
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
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 | ComponentSpec
struct | ComputedGotoStmt
struct | ConcurrentControl
struct | ConcurrentHeader
struct | ConnectSpec
struct | Constant
struct | ConstantValue
struct | ConsumedAllInputParser
class | ContextualMessages
class | CookedSource
struct | CriticalConstruct
struct | CriticalStmt
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 | EventWaitStmt
struct | ExecutableConstruct
struct | ExecutionPartConstruct
struct | ExplicitCoshapeSpec
struct | ExplicitShapeSpec
struct | Expr
class | FailParser
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 | HasSource
struct | HasSource< A, decltype(static_cast< void >(A::source), 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 | LeaveDoConstruct
struct | LengthSelector
struct | LetterSpec
struct | LiteralConstant
struct | LocalitySpec
struct | LockStmt
struct | Logical
struct | LogicalLiteralConstant
class | LookAheadParser
struct | LoopBounds
struct | LoopControl
struct | MainProgram
class | ManyParser
struct | Map
struct | MaskedElsewhereStmt
class | MaybeParser
class | Message
class | MessageContextParser
class | MessageExpectedText
class | MessageFixedText
class | MessageFormattedText
class | Messages
struct | Module
struct | ModuleSubprogram
struct | ModuleSubprogramPart
struct | Name
struct | NamedConstantDef
struct | NamelistStmt
class | NegatedParser
struct | NextCh
class | NonemptySeparated
struct | NonLabelDoStmt
class | NonstandardParser
struct | ObjectDecl
class | OffsetToProvenanceMappings
struct | OkParser
struct | OldStructureComponentName
struct | OmpAlignedClause
struct | OmpAtomic
struct | OmpAtomicCapture
struct | OmpAtomicRead
struct | OmpAtomicUpdate
struct | OmpAtomicWrite
struct | OmpBeginBlockDirective
struct | OmpBeginLoopDirective
struct | OmpBeginSectionsDirective
struct | OmpBlockDirective
struct | OmpCancelType
struct | OmpClause
struct | OmpClauseList
struct | OmpCriticalDirective
struct | OmpDeclareTargetSpecifier
struct | OmpDeclareTargetWithClause
struct | OmpDeclareTargetWithList
struct | OmpDefaultClause
struct | OmpDefaultmapClause
struct | OmpDependClause
struct | OmpDependenceType
struct | OmpDependSinkVec
struct | OmpDependSinkVecLength
struct | OmpEndBlockDirective
struct | OmpEndCriticalDirective
struct | OmpEndLoopDirective
struct | OmpEndSectionsDirective
struct | OmpFlushMemoryClause
struct | OmpIfClause
struct | OmpLinearClause
struct | OmpLinearModifier
struct | OmpLoopDirective
struct | OmpMapClause
struct | OmpMapType
struct | OmpMemoryClause
struct | OmpObject
struct | OmpProcBindClause
struct | OmpReductionClause
struct | OmpReductionCombiner
struct | OmpReductionOperator
struct | OmpScheduleClause
struct | OmpScheduleModifier
struct | OmpScheduleModifierType
struct | OmpSectionsDirective
struct | OmpSimpleStandaloneDirective
struct | Only
struct | OpenACCAtomicConstruct
struct | OpenACCBlockConstruct
struct | OpenACCCacheConstruct
struct | OpenACCCombinedConstruct
struct | OpenACCConstruct
struct | OpenACCDeclarativeConstruct
struct | OpenACCLoopConstruct
struct | OpenACCRoutineConstruct
struct | OpenACCStandaloneConstruct
struct | OpenACCStandaloneDeclarativeConstruct
struct | OpenACCWaitConstruct
struct | OpenMPAtomicConstruct
struct | OpenMPBlockConstruct
struct | OpenMPCancelConstruct
struct | OpenMPCancellationPointConstruct
struct | OpenMPConstruct
struct | OpenMPCriticalConstruct
struct | OpenMPDeclarativeConstruct
struct | OpenMPDeclareReductionConstruct
struct | OpenMPDeclareSimdConstruct
struct | OpenMPDeclareTargetConstruct
struct | OpenMPFlushConstruct
struct | OpenMPLoopConstruct
struct | OpenMPSectionsConstruct
struct | OpenMPSimpleStandaloneConstruct
struct | OpenMPStandaloneConstruct
struct | OpenMPThreadprivate
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 | 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 | 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 | SkipStuffBeforeStatement
struct | SkipTo
class | SomeParser
class | SourcedParser
class | SourceFile
struct | SourceLocationFindingVisitor
struct | SourcePosition
struct | Space
struct | SpaceCheck
struct | SpecificationConstruct
struct | SpecificationPart
struct | StartNewSubprogram
struct | Statement
struct | StatOrErrmsg
struct | StmtFunctionStmt
struct | StopStmt
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 | SubstringRange
class | Success
struct | Suffix
struct | SyncImagesStmt
struct | SyncTeamStmt
class | TokenSequence
class | TokenStringMatch
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 | UnwrapperHelper
class | UserState
struct | UseStmt
struct | Variable
struct | Verbatim
struct | WaitSpec
struct | WhereBodyConstruct
struct | WhereConstruct
struct | WhereConstructStmt
struct | WhereStmt
class | WithMessageParser
struct | WriteStmt

## Typedefs
using | Label = std::uint64_t
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 | 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 | Block = std::list< ExecutionPartConstruct >
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 | ProvenanceRange = common::Interval< Provenance >
using | preStatementType = std::function< void(const CharBlock &, llvm::raw_ostream &, int)>
template<typename... PARSER>
using | ApplyArgs = std::tuple< std::optional< typename PARSER::resultType >... >
template<typename RESULT , typename... PARSER>
using | ApplicableFunctionPointer = RESULT(*)(typename PARSER::resultType &&...)
template<typename RESULT , typename... PARSER>
using | ApplicableFunctionObject = const std::function< RESULT(typename PARSER::resultType &&...)> &
template<typename OBJPARSER , typename... PARSER>
using | ApplicableMemberFunctionPointer = typename AMFPHelper< OBJPARSER, PARSER... >::type

## Enumerations
enum | Encoding { LATIN_1, UTF_8 }
enum | 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 char | ToLowerCaseLetter (char ch)
constexpr char | ToLowerCaseLetter (char &&ch)
std::string | ToLowerCaseLetters (const std::string &str)
constexpr char | ToUpperCaseLetter (char ch)
constexpr char | ToUpperCaseLetter (char &&ch)
std::string | ToUpperCaseLetters (const std::string &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)
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""_en_US (const char str[], std::size_t n)
constexpr MessageFixedText | operator""_err_en_US (const char str[], std::size_t n)
template<typename A , typename V >
std::enable_if_t<!std::is_class_v< A >||std::is_same_v< std::string, A >||std::is_same_v< CharBlock, A > > | Walk (const A &x, V &visitor)
template<typename A , typename M >
std::enable_if_t<!std::is_class_v< A >||std::is_same_v< std::string, A >||std::is_same_v< CharBlock, A > > | Walk (A &x, M &mutator)
template<typename V >
void | Walk (const format::ControlEditDesc &, V &)
template<typename M >
void | Walk (format::ControlEditDesc &, M &)
template<typename V >
void | Walk (const format::DerivedTypeDataEditDesc &, V &)
template<typename M >
void | Walk (format::DerivedTypeDataEditDesc &, M &)
template<typename V >
void | Walk (const format::FormatItem &, V &)
template<typename M >
void | Walk (format::FormatItem &, M &)
template<typename V >
void | Walk (const format::FormatSpecification &, V &)
template<typename M >
void | Walk (format::FormatSpecification &, M &)
template<typename V >
void | Walk (const format::IntrinsicTypeDataEditDesc &, V &)
template<typename M >
void | Walk (format::IntrinsicTypeDataEditDesc &, M &)
template<typename T , typename V >
void | Walk (const std::optional< T > &x, V &visitor)
template<typename T , typename M >
void | Walk (std::optional< T > &x, M &mutator)
template<typename T , typename V >
void | Walk (const std::list< T > &x, V &visitor)
template<typename T , typename M >
void | Walk (std::list< T > &x, M &mutator)
template<typename V >
void | Walk (const Block &x, V &visitor)
template<typename M >
void | Walk (Block &x, M &mutator)
template<std::size_t I = 0, typename Func , typename T >
void | ForEachInTuple (const T &tuple, Func func)
template<typename V , typename... A>
void | Walk (const std::tuple< A... > &x, V &visitor)
template<std::size_t I = 0, typename Func , typename T >
void | ForEachInTuple (T &tuple, Func func)
template<typename M , typename... A>
void | Walk (std::tuple< A... > &x, M &mutator)
template<typename V , typename... A>
void | Walk (const std::variant< A... > &x, V &visitor)
template<typename M , typename... A>
void | Walk (std::variant< A... > &x, M &mutator)
template<typename A , typename B , typename V >
void | Walk (const std::pair< A, B > &x, V &visitor)
template<typename A , typename B , typename M >
void | Walk (std::pair< A, B > &x, M &mutator)
template<typename A , typename V >
std::enable_if_t< EmptyTrait< A > > | Walk (const A &x, V &visitor)
template<typename A , typename M >
std::enable_if_t< EmptyTrait< A > > | Walk (A &x, M &mutator)
template<typename A , typename V >
std::enable_if_t< TupleTrait< A > > | Walk (const A &x, V &visitor)
template<typename A , typename M >
std::enable_if_t< TupleTrait< A > > | Walk (A &x, M &mutator)
template<typename A , typename V >
std::enable_if_t< UnionTrait< A > > | Walk (const A &x, V &visitor)
template<typename A , typename M >
std::enable_if_t< UnionTrait< A > > | Walk (A &x, M &mutator)
template<typename A , typename V >
std::enable_if_t< WrapperTrait< A > > | Walk (const A &x, V &visitor)
template<typename A , typename M >
std::enable_if_t< WrapperTrait< A > > | Walk (A &x, M &mutator)
template<typename A , typename V >
std::enable_if_t< ConstraintTrait< A > > | Walk (const A &x, V &visitor)
template<typename A , typename M >
std::enable_if_t< ConstraintTrait< A > > | Walk (A &x, M &mutator)
template<typename T , typename V >
void | Walk (const common::Indirection< T > &x, V &visitor)
template<typename T , typename M >
void | Walk (common::Indirection< T > &x, M &mutator)
template<typename T , typename V >
void | Walk (const Statement< T > &x, V &visitor)
template<typename T , typename M >
void | Walk (Statement< T > &x, M &mutator)
template<typename T , typename V >
void | Walk (const UnlabeledStatement< T > &x, V &visitor)
template<typename T , typename M >
void | Walk (UnlabeledStatement< T > &x, M &mutator)
template<typename V >
void | Walk (const Name &x, V &visitor)
template<typename M >
void | Walk (Name &x, M &mutator)
template<typename V >
void | Walk (const AcSpec &x, V &visitor)
template<typename M >
void | Walk (AcSpec &x, M &mutator)
template<typename V >
void | Walk (const ArrayElement &x, V &visitor)
template<typename M >
void | Walk (ArrayElement &x, M &mutator)
template<typename V >
void | Walk (const CharSelector::LengthAndKind &x, V &visitor)
template<typename M >
void | Walk (CharSelector::LengthAndKind &x, M &mutator)
template<typename V >
void | Walk (const CaseValueRange::Range &x, V &visitor)
template<typename M >
void | Walk (CaseValueRange::Range &x, M &mutator)
template<typename V >
void | Walk (const CoindexedNamedObject &x, V &visitor)
template<typename M >
void | Walk (CoindexedNamedObject &x, M &mutator)
template<typename V >
void | Walk (const DeclarationTypeSpec::Class &x, V &visitor)
template<typename M >
void | Walk (DeclarationTypeSpec::Class &x, M &mutator)
template<typename V >
void | Walk (const DeclarationTypeSpec::Type &x, V &visitor)
template<typename M >
void | Walk (DeclarationTypeSpec::Type &x, M &mutator)
template<typename V >
void | Walk (const ImportStmt &x, V &visitor)
template<typename M >
void | Walk (ImportStmt &x, M &mutator)
template<typename V >
void | Walk (const IntrinsicTypeSpec::Character &x, V &visitor)
template<typename M >
void | Walk (IntrinsicTypeSpec::Character &x, M &mutator)
template<typename V >
void | Walk (const IntrinsicTypeSpec::Complex &x, V &visitor)
template<typename M >
void | Walk (IntrinsicTypeSpec::Complex &x, M &mutator)
template<typename V >
void | Walk (const IntrinsicTypeSpec::Logical &x, V &visitor)
template<typename M >
void | Walk (IntrinsicTypeSpec::Logical &x, M &mutator)
template<typename V >
void | Walk (const IntrinsicTypeSpec::Real &x, V &visitor)
template<typename M >
void | Walk (IntrinsicTypeSpec::Real &x, M &mutator)
template<typename A , typename B , typename V >
void | Walk (const LoopBounds< A, B > &x, V &visitor)
template<typename A , typename B , typename M >
void | Walk (LoopBounds< A, B > &x, M &mutator)
template<typename V >
void | Walk (const CommonStmt &x, V &visitor)
template<typename M >
void | Walk (CommonStmt &x, M &mutator)
template<typename V >
void | Walk (const Expr &x, V &visitor)
template<typename M >
void | Walk (Expr &x, M &mutator)
template<typename V >
void | Walk (const Designator &x, V &visitor)
template<typename M >
void | Walk (Designator &x, M &mutator)
template<typename V >
void | Walk (const Call &x, V &visitor)
template<typename M >
void | Walk (Call &x, M &mutator)
template<typename V >
void | Walk (const PartRef &x, V &visitor)
template<typename M >
void | Walk (PartRef &x, M &mutator)
template<typename V >
void | Walk (const ReadStmt &x, V &visitor)
template<typename M >
void | Walk (ReadStmt &x, M &mutator)
template<typename V >
void | Walk (const SignedIntLiteralConstant &x, V &visitor)
template<typename M >
void | Walk (SignedIntLiteralConstant &x, M &mutator)
template<typename V >
void | Walk (const RealLiteralConstant &x, V &visitor)
template<typename M >
void | Walk (RealLiteralConstant &x, M &mutator)
template<typename V >
void | Walk (const RealLiteralConstant::Real &x, V &visitor)
template<typename M >
void | Walk (RealLiteralConstant::Real &x, M &mutator)
template<typename V >
void | Walk (const StructureComponent &x, V &visitor)
template<typename M >
void | Walk (StructureComponent &x, M &mutator)
template<typename V >
void | Walk (const Suffix &x, V &visitor)
template<typename M >
void | Walk (Suffix &x, M &mutator)
template<typename V >
void | Walk (const TypeBoundProcedureStmt::WithInterface &x, V &visitor)
template<typename M >
void | Walk (TypeBoundProcedureStmt::WithInterface &x, M &mutator)
template<typename V >
void | Walk (const TypeBoundProcedureStmt::WithoutInterface &x, V &visitor)
template<typename M >
void | Walk (TypeBoundProcedureStmt::WithoutInterface &x, M &mutator)
template<typename V >
void | Walk (const UseStmt &x, V &visitor)
template<typename M >
void | Walk (UseStmt &x, M &mutator)
template<typename V >
void | Walk (const WriteStmt &x, V &visitor)
template<typename M >
void | Walk (WriteStmt &x, M &mutator)
template<typename V >
void | Walk (const CompilerDirective &x, V &visitor)
template<typename M >
void | Walk (CompilerDirective &x, M &mutator)
template<typename V >
void | Walk (const OmpLinearClause::WithModifier &x, V &visitor)
template<typename M >
void | Walk (OmpLinearClause::WithModifier &x, M &mutator)
template<typename V >
void | Walk (const OmpLinearClause::WithoutModifier &x, V &visitor)
template<typename M >
void | Walk (OmpLinearClause::WithoutModifier &x, M &mutator)
| EMPTY_CLASS (ErrorRecovery)
| WRAPPER_CLASS (ImplicitPart, std::list< ImplicitPartStmt >)
| EMPTY_CLASS (ContainsStmt)
| EMPTY_CLASS (ContinueStmt)
| EMPTY_CLASS (FailImageStmt)
| WRAPPER_CLASS (ExecutionPart, std::list< ExecutionPartConstruct >)
| 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 (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)
| EMPTY_CLASS (NullInit)
| 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 (LanguageBindingSpec, std::optional< ScalarDefaultCharConstantExpr >)
| 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 (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 >)
| EMPTY_CLASS (OmpNowait)
| WRAPPER_CLASS (OmpSectionBlocks, std::list< Block >)
| WRAPPER_CLASS (OmpReductionInitializerClause, Expr)
| EMPTY_CLASS (OmpEndAtomic)
| WRAPPER_CLASS (OmpMemoryClauseList, std::list< OmpMemoryClause >)
| WRAPPER_CLASS (OmpMemoryClausePostList, std::list< OmpMemoryClause >)
| WRAPPER_CLASS (AccObjectList, std::list< AccObject >)
| EMPTY_CLASS (AccEndAtomic)
std::string | DirectoryName (std::string path)
std::string | LocateSourceFile (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 &)
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 &)
void | Unparse (llvm::raw_ostream &out, const Program &program, Encoding encoding=Encoding::UTF_8, bool capitalizeKeywords=true, bool backslashEscapes=true, preStatementType *preStatement=nullptr, AnalyzedObjectsAsFortran *=nullptr)
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 OBJPARSER , typename... PARSER, std::size_t... J>
auto | ApplyHelperMember (ApplicableMemberFunctionPointer< OBJPARSER, PARSER... > mfp, ApplyArgs< OBJPARSER, PARSER... > &&args, std::index_sequence< J... >) -> typename OBJPARSER::resultType
template<typename OBJPARSER , typename... PARSER>
constexpr auto | applyMem (ApplicableMemberFunctionPointer< OBJPARSER, PARSER... > mfp, 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 (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 std::string | EncodeString< Encoding::UTF_8, std::u16string > (const std::u16string &)
constexpr DebugParser | operator""_debug (const char str[], std::size_t n)
| TYPE_PARSER (recovery(withMessage("expected execution part construct"_err_en_US, 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 >(construct< ExecutionPartConstruct >(statement(indirect(Parser< NamelistStmt >{})))), obsoleteExecutionPartConstruct))), 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< 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)
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 >())) TYPE_PARSER(construct< ConstantValue >(literalConstant)||const ruct< ConstantValue >(namedConstant/!"%"_tok/!"("_tok)) 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))))) TYPE_CONTEXT_PARSER("internal subprogram"_en_US
| construct< InternalSubprogram > (indirect(functionSubprogram))||const ruct< InternalSubprogram >(indirect(subroutineSubprogram)))/forceEndOfStmt) 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)
| 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(underscore >> 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 > (inStmtErrorRecovery))) TYPE_PARSER(construct< DataComponentDefStmt >(declarationTypeSpec
| optionalListBeforeColons (Parser< ComponentAttrSpec >{})
| nonemptyList ("expected component declarations"_err_en_US, Parser< ComponentDecl >{}))) TYPE_PARSER(construct< ComponentAttrSpec >(accessSpec)||const ruct< ComponentAttrSpec >(allocatable)||const ruct< ComponentAttrSpec >("CODIMENSION" >> coarraySpec)||const ruct< ComponentAttrSpec >(contiguous)||const ruct< ComponentAttrSpec >("DIMENSION" >> Parser< ComponentArraySpec >
| construct< ComponentAttrSpec > (pointer)||const ruct< ComponentAttrSpec >(recovery(fail< ErrorRecovery >("type parameter definitions must appear before component declarations"_err_en_US)
kindOrLen | construct< ErrorRecovery > ()))) TYPE_CONTEXT_PARSER("component declaration"_en_US
kindOrLen | construct< ComponentDecl > (name, maybe(Parser< ComponentArraySpec >{}), maybe(coarraySpec), maybe("*" >> charLength), maybe(initialization))) TYPE_PARSER(construct< ComponentArraySpec >(parenthesized(nonemptyList("expected explicit shape specifications"_err_en_US
kindOrLen explicitShapeSpec | construct< ComponentArraySpec > (parenthesized(deferredShapeSpecList))) TYPE_CONTEXT_PARSER("PROCEDURE component definition statement"_en_US
kindOrLen explicitShapeSpec | construct< ProcComponentDefStmt > ("PROCEDURE" >> parenthesized(maybe(procInterface)), localRecovery("expected PROCEDURE component attributes"_err_en_US, "," >> nonemptyList(Parser< ProcComponentAttrSpec >{}), ok), localRecovery("expected PROCEDURE declarations"_err_en_US, "::" >> nonemptyList(procDecl), SkipTo<'\n'>{}))) const expr auto noPass
| 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 >(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 >(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 >(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))) const expr auto objectName
| TYPE_PARSER (construct< EntityDecl >(objectName, maybe(arraySpec), maybe(coarraySpec), maybe("*" >> charLength), maybe(initialization))) TYPE_PARSER(construct< NullInit >("NULL ( )"_tok)/!"("_tok) 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/!"="_tok)||construct< IoUnit >(fileUnitNumber)||construct< IoUnit >(star)) 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 >(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::Convert >(construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("CONVERT =" >> pure(ConnectSpec::CharExpr::Kind::Convert), scalarDefaultCharExpr))), extension< LanguageFeature::Dispose >(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))) template< typename A > common
| TYPE_CONTEXT_PARSER ("BACKSPACE statement"_en_US, construct< BackspaceStmt >("BACKSPACE" >> positionOrFlushSpecList)) TYPE_CONTEXT_PARSER("ENDFILE statement"_en_US
| construct< EndfileStmt > ("ENDFILE" >> 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"_tok >> 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)
| TYPE_PARSER ("AUTO" >> construct< AccClause >(construct< AccClause::Auto >())||"ASYNC" >> construct< AccClause >(construct< AccClause::Async >(maybe(parenthesized(scalarIntExpr))))||"ATTACH" >> construct< AccClause >(construct< AccClause::Attach >(parenthesized(Parser< AccObjectList >{})))||"BIND" >> construct< AccClause >(construct< AccClause::Bind >(parenthesized(name)))||"CAPTURE" >> construct< AccClause >(construct< AccClause::Capture >())||"COLLAPSE" >> construct< AccClause >(construct< AccClause::Collapse >(parenthesized(scalarIntConstantExpr)))||("COPY"_tok||"PRESENT_OR_COPY"_tok||"PCOPY"_tok) >> construct< AccClause >(construct< AccClause::Copy >(parenthesized(Parser< AccObjectList >{})))||("COPYIN"_tok||"PRESENT_OR_COPYIN"_tok||"PCOPYIN"_tok) >> construct< AccClause >(construct< AccClause::Copyin >(parenthesized(Parser< AccObjectListWithModifier >{})))||("COPYOUT"_tok||"PRESENT_OR_COPYOUT"_tok||"PCOPYOUT"_tok) >> construct< AccClause >(construct< AccClause::Copyout >(parenthesized(Parser< AccObjectListWithModifier >{})))||("CREATE"_tok||"PRESENT_OR_CREATE"_tok||"PCREATE"_tok) >> construct< AccClause >(construct< AccClause::Create >(parenthesized(Parser< AccObjectListWithModifier >{})))||"DEFAULT" >> construct< AccClause >(construct< AccClause::Default >(Parser< AccDefaultClause >{}))||"DEFAULT_ASYNC" >> construct< AccClause >(construct< AccClause::DefaultAsync >(parenthesized(scalarIntExpr)))||"DELETE" >> construct< AccClause >(construct< AccClause::Delete >(parenthesized(Parser< AccObjectList >{})))||"DETACH" >> construct< AccClause >(construct< AccClause::Detach >(parenthesized(Parser< AccObjectList >{})))||"DEVICE" >> construct< AccClause >(construct< AccClause::Device >(parenthesized(Parser< AccObjectList >{})))||"DEVICEPTR" >> construct< AccClause >(construct< AccClause::DevicePtr >(parenthesized(Parser< AccObjectList >{})))||"DEVICENUM" >> construct< AccClause >(construct< AccClause::DeviceNum >(parenthesized(scalarIntConstantExpr)))||"DEVICE_RESIDENT" >> construct< AccClause >(construct< AccClause::DeviceResident >(parenthesized(Parser< AccObjectList >{})))||("DEVICE_TYPE"_tok||"DTYPE"_tok) >> construct< AccClause >(construct< AccClause::DeviceType >(parenthesized("*" >> construct< std::optional< std::list< Name >>>())))||("DEVICE_TYPE"_tok||"DTYPE"_tok) >> construct< AccClause >(construct< AccClause::DeviceType >(parenthesized(maybe(nonemptyList(name)))))||"FINALIZE" >> construct< AccClause >(construct< AccClause::Finalize >())||"FIRSTPRIVATE" >> construct< AccClause >(construct< AccClause::FirstPrivate >(parenthesized(Parser< AccObjectList >{})))||"GANG" >> construct< AccClause >(construct< AccClause::Gang >(maybe(parenthesized(Parser< AccGangArgument >{}))))||"HOST" >> construct< AccClause >(construct< AccClause::Host >(parenthesized(Parser< AccObjectList >{})))||"IF" >> construct< AccClause >(construct< AccClause::If >(parenthesized(scalarLogicalExpr)))||"IF_PRESENT" >> construct< AccClause >(construct< AccClause::IfPresent >())||"INDEPENDENT" >> construct< AccClause >(construct< AccClause::Independent >())||"LINK" >> construct< AccClause >(construct< AccClause::Link >(parenthesized(Parser< AccObjectList >{})))||"NO_CREATE" >> construct< AccClause >(construct< AccClause::NoCreate >(parenthesized(Parser< AccObjectList >{})))||"NOHOST" >> construct< AccClause >(construct< AccClause::NoHost >())||"NUM_GANGS" >> construct< AccClause >(construct< AccClause::NumGangs >(parenthesized(scalarIntExpr)))||"NUM_WORKERS" >> construct< AccClause >(construct< AccClause::NumWorkers >(parenthesized(scalarIntExpr)))||"PRESENT" >> construct< AccClause >(construct< AccClause::Present >(parenthesized(Parser< AccObjectList >{})))||"PRIVATE" >> construct< AccClause >(construct< AccClause::Private >(parenthesized(Parser< AccObjectList >{})))||"READ" >> construct< AccClause >(construct< AccClause::Read >())||"REDUCTION" >> construct< AccClause >(construct< AccClause::Reduction >(parenthesized(construct< AccObjectListWithReduction >(Parser< AccReductionOperator >{}/":", Parser< AccObjectList >{}))))||"SELF" >> construct< AccClause >(construct< AccClause::Self >(maybe(parenthesized(scalarLogicalExpr))))||"SEQ" >> construct< AccClause >(construct< AccClause::Seq >())||"TILE" >> construct< AccClause >(construct< AccClause::Tile >(parenthesized(Parser< AccSizeExprList >{})))||"USE_DEVICE" >> construct< AccClause >(construct< AccClause::UseDevice >(parenthesized(Parser< AccObjectList >{})))||"VECTOR_LENGTH" >> construct< AccClause >(construct< AccClause::VectorLength >(parenthesized(scalarIntExpr)))||"VECTOR" >> construct< AccClause >(construct< AccClause::Vector >(maybe(parenthesized(("LENGTH:" >> scalarIntExpr||scalarIntExpr)))))||"WAIT" >> construct< AccClause >(construct< AccClause::Wait >(maybe(Parser< AccWaitArgument >{})))||"WORKER" >> construct< AccClause >(construct< AccClause::Worker >(maybe(parenthesized(("NUM:" >> scalarIntExpr||scalarIntExpr)))))||"WRITE" >> construct< AccClause >(construct< AccClause::Auto >())) TYPE_PARSER(const ruct< AccObject >(designator)||const ruct< AccObject >("/" >> name/"/")) TYPE_PARSER(construct< AccObjectList >(nonemptyList(Parser< AccObject >
template<typename T >
T | WithSource (CharBlock source, T &&x)
llvm::raw_ostream & | operator<< (llvm::raw_ostream &os, const Name &x)
| TYPE_PARSER (construct< Program >(extension< LanguageFeature::EmptySourceFile >(skipStuffBeforeStatement >> !nextCh >> pure< std::list< ProgramUnit >>())||some(StartNewSubprogram{} >> Parser< ProgramUnit >{}/skipMany(";"_tok)/space/recovery(endOfLine, SkipPast<'\n'>{}))/skipStuffBeforeStatement)) TYPE_PARSER(construct< ProgramUnit >(indirect(Parser< Module >
| construct< ProgramUnit > (indirect(functionSubprogram))||const ruct< ProgramUnit >(indirect(subroutineSubprogram))||const ruct< ProgramUnit >(indirect(Parser< Submodule >
| construct< ProgramUnit > (indirect(Parser< BlockData >{}))||const ruct< ProgramUnit >(indirect(Parser< MainProgram >
| TYPE_CONTEXT_PARSER ("specification part"_en_US, construct< SpecificationPart >(many(openaccDeclarativeConstruct), many(openmpDeclarativeConstruct), many(statement(indirect(Parser< UseStmt >{}))), many(unambiguousStatement(indirect(Parser< ImportStmt >{}))), implicitPart, many(declarationConstruct))) const expr auto execPartLookAhead
| TYPE_PARSER (recovery(withMessage("expected declaration construct"_err_en_US, 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))), construct< DeclarationConstruct >(declErrorRecovery))) 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 >{})))) 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 >(parenthesized(ok))))) TYPE_CONTEXT_PARSER("END PROGRAM statement"_en_US
| construct< EndProgramStmt > (recovery("END PROGRAM" >> maybe(name)||bareEnd, 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 MODULE" >> maybe(name)||bareEnd, 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 >
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<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)
bool | CanonicalizeDo (Program &program)

## Variables
bool | useHexadecimalEscapeSequences {false}
constexpr struct Fortran::parser::OkParser | ok
constexpr NextCh | nextCh
constexpr auto | executableConstruct
constexpr auto | obsoleteExecutionPartConstruct
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 construct< LiteralConstant >(Parser< LogicalLiteralConstant >{}))) TYPE_PARSER(construct< TypeParamValue >(scalarIntExpr)||const ruct< TypeParamValue >(star)||const ruct< TypeParamValue >(construct< TypeParamValue auto | signedRealLiteralConstant
constexpr auto | exponentPart
| Parser< ComplexLiteralConstant >
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 | bareUnitNumberAsList
constexpr auto | positionOrFlushSpecList
constexpr DigitStringIgnoreSpaces | repeat
constexpr 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 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 = skipStuffBeforeStatement >> "!$ACC "_sptok
constexpr auto | endAccLine = space >> endOfLine
constexpr auto | startOmpLine = skipStuffBeforeStatement >> "!$OMP "_sptok
constexpr auto | endOmpLine = space >> endOfLine
constexpr auto | declErrorRecovery
constexpr auto | misplacedSpecificationStmt
constexpr auto | limitedDeclarationConstruct
constexpr auto | limitedSpecificationPart
constexpr auto | moduleNature
| accessSpec
:: | genericSpec
constexpr auto | label {space >> digitString64 / spaceCheck}
constexpr auto | endOfLine
constexpr auto | semicolons {";"_ch >> skipMany(";"_tok) / space / maybe("\n"_ch)}
constexpr auto | endOfStmt
constexpr auto | forceEndOfStmt {recovery(endOfStmt, SkipPast<'\n'>{})}
constexpr auto | ignoredStatementPrefix
constexpr auto | inStmtErrorRecovery
constexpr auto | skipStmtErrorRecovery
constexpr auto | stmtErrorRecoveryStart {ignoredStatementPrefix}
constexpr auto | skipBadLine {SkipPast<'\n'>{} >> construct<ErrorRecovery>()}
constexpr auto | executionPartErrorRecovery
constexpr auto | missingOptionalName {pure<std::optional<Name>>()}
constexpr auto | noNameEnd {"END" >> missingOptionalName}
constexpr auto | atEndOfStmt
constexpr auto | bareEnd {noNameEnd / recovery(atEndOfStmt, SkipTo<'\n'>{})}
constexpr auto | endStmtErrorRecovery
constexpr auto | progUnitEndStmtErrorRecovery
constexpr auto | letter {"abcdefghijklmnopqrstuvwxyz"_ch}
constexpr auto | digit {"0123456789"_ch}
constexpr struct Fortran::parser::Space | space
constexpr struct Fortran::parser::SpaceCheck | spaceCheck
constexpr struct Fortran::parser::DigitString | digitString
constexpr struct Fortran::parser::DigitString64 | digitString64
constexpr struct Fortran::parser::ConsumedAllInputParser | consumedAllInput
constexpr struct Fortran::parser::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< KindParam > | kindParam
constexpr Parser< RealLiteralConstant > | realLiteralConstant
constexpr Parser< CharLength > | charLength
constexpr Parser< CharLiteralConstant > | charLiteralConstant
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< 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< 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< LoopControl > | loopControl
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< OpenMPDeclarativeConstruct > | openmpDeclarativeConstruct
constexpr Parser< OmpEndLoopDirective > | ompEndLoopDirective

## 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.

## Variable Documentation

## ◆ atEndOfStmt

constexpr auto Fortran::parser::atEndOfStmt
| constexpr

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

## ◆ bareUnitNumberAsList

constexpr auto Fortran::parser::bareUnitNumberAsList
| constexpr

Initial value:
{
applyFunction(singletonList<PositionOrFlushSpec>,
construct<PositionOrFlushSpec>(fileUnitNumber))}

## ◆ charLiteralConstantWithoutKind

constexpr auto Fortran::parser::charLiteralConstantWithoutKind
| constexpr

Initial value:
{
"'"_ch >> CharLiteral<'\''>{} || "\""_ch >> CharLiteral<'"'>{}}

## ◆ declErrorRecovery

constexpr auto Fortran::parser::declErrorRecovery
| constexpr

Initial value:
{
stmtErrorRecoveryStart >> !execPartLookAhead >> skipStmtErrorRecovery}

## ◆ endOfLine

constexpr auto Fortran::parser::endOfLine
| constexpr

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

## ◆ endOfStmt

constexpr auto Fortran::parser::endOfStmt
| constexpr

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

## ◆ endStmtErrorRecovery

constexpr auto Fortran::parser::endStmtErrorRecovery
| constexpr

Initial value:
{
("END"_tok >> SkipTo<'\n'>{} || ok) >> missingOptionalName}

## ◆ executableConstruct

constexpr auto Fortran::parser::executableConstruct
| constexpr

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

## ◆ executionPartErrorRecovery

constexpr auto Fortran::parser::executionPartErrorRecovery
| constexpr

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

## ◆ exponentPart

constexpr auto Fortran::parser::exponentPart
| constexpr

Initial value:
{
("ed"_ch || extension<LanguageFeature::QuadPrecision>("q"_ch)) >>
SignedDigitString{}}

## ◆ ignoredStatementPrefix

constexpr auto Fortran::parser::ignoredStatementPrefix
| constexpr

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

## ◆ inStmtErrorRecovery

constexpr auto Fortran::parser::inStmtErrorRecovery
| constexpr

Initial value:
{!"END"_tok >> !"CONTAINS"_tok >>
SkipTo<'\n'>{} >> construct<ErrorRecovery>()}

## ◆ intrinsicOperator

constexpr auto Fortran::parser::intrinsicOperator
| constexpr

Initial value:
{
"**" >> pure(DefinedOperator::IntrinsicOperator::Power) ||
"*" >> pure(DefinedOperator::IntrinsicOperator::Multiply) ||
"//" >> pure(DefinedOperator::IntrinsicOperator::Concat) ||
"/=" >> pure(DefinedOperator::IntrinsicOperator::NE) ||
"/" >> pure(DefinedOperator::IntrinsicOperator::Divide) ||
"+" >> pure(DefinedOperator::IntrinsicOperator::Add) ||
"-" >> pure(DefinedOperator::IntrinsicOperator::Subtract) ||
"<=" >> pure(DefinedOperator::IntrinsicOperator::LE) ||
extension<LanguageFeature::AlternativeNE>(
"<>" >> pure(DefinedOperator::IntrinsicOperator::NE)) ||
"<" >> pure(DefinedOperator::IntrinsicOperator::LT) ||
"==" >> pure(DefinedOperator::IntrinsicOperator::EQ) ||
">=" >> pure(DefinedOperator::IntrinsicOperator::GE) ||
">" >> pure(DefinedOperator::IntrinsicOperator::GT) ||
namedIntrinsicOperator}

## ◆ limitedDeclarationConstruct

constexpr auto Fortran::parser::limitedDeclarationConstruct
| constexpr

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

## ◆ limitedSpecificationPart

constexpr auto Fortran::parser::limitedSpecificationPart
| constexpr

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

## ◆ logicalFALSE

constexpr auto Fortran::parser::logicalFALSE
| constexpr

Initial value:
{
(".FALSE."_tok ||
extension<LanguageFeature::LogicalAbbreviations>(".F."_tok)) >>
pure(false)}

## ◆ logicalTRUE

constexpr auto Fortran::parser::logicalTRUE
| constexpr

Initial value:
{
(".TRUE."_tok ||
extension<LanguageFeature::LogicalAbbreviations>(".T."_tok)) >>
pure(true)}

## ◆ misplacedSpecificationStmt

constexpr auto Fortran::parser::misplacedSpecificationStmt
| constexpr

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

## ◆ moduleNature

constexpr auto Fortran::parser::moduleNature
| constexpr

Initial value:
{
"INTRINSIC" >> pure(UseStmt::ModuleNature::Intrinsic) ||
"NON_INTRINSIC" >> pure(UseStmt::ModuleNature::Non_Intrinsic)}

## ◆ obsoleteExecutionPartConstruct

constexpr auto Fortran::parser::obsoleteExecutionPartConstruct
| constexpr

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

## ◆ otherIdChar

constexpr auto Fortran::parser::otherIdChar
| constexpr

Initial value:
{underscore / !"'\""_ch ||
extension<LanguageFeature::PunctuationInNames>("$@"_ch)}

## ◆ positionOrFlushSpecList

constexpr auto Fortran::parser::positionOrFlushSpecList
| constexpr

Initial value:
{
parenthesized(nonemptyList(positionOrFlushSpec)) || bareUnitNumberAsList}

## ◆ progUnitEndStmtErrorRecovery

constexpr auto Fortran::parser::progUnitEndStmtErrorRecovery
| constexpr

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

## ◆ rawHollerithLiteral

constexpr auto Fortran::parser::rawHollerithLiteral
| constexpr

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

## ◆ signedRealLiteralConstant

constexpr construct<LiteralConstant> (Parser<LogicalLiteralConstant>{}))) TYPE_PARSER(construct<TypeParamValue>(scalarIntExpr) || const ruct<TypeParamValue>(star) || const ruct<TypeParamValue>(construct<TypeParamValue auto Fortran::parser::signedRealLiteralConstant
| constexpr

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

## ◆ skipStmtErrorRecovery

constexpr auto Fortran::parser::skipStmtErrorRecovery
| constexpr

Initial value:
{!"END"_tok >> !"CONTAINS"_tok >>
SkipPast<'\n'>{} >> construct<ErrorRecovery>()}