|
|
bool | operator< (const char *left, const CharBlock &right) |
| |
|
bool | operator<= (const char *left, const CharBlock &right) |
| |
|
bool | operator== (const char *left, const CharBlock &right) |
| |
|
bool | operator!= (const char *left, const CharBlock &right) |
| |
|
bool | operator>= (const char *left, const CharBlock &right) |
| |
|
bool | operator> (const char *left, const CharBlock &right) |
| |
|
llvm::raw_ostream & | operator<< (llvm::raw_ostream &os, const CharBlock &x) |
| |
|
constexpr bool | IsUpperCaseLetter (char ch) |
| |
|
constexpr bool | IsLowerCaseLetter (char ch) |
| |
|
constexpr bool | IsLetter (char ch) |
| |
|
constexpr bool | IsDecimalDigit (char ch) |
| |
|
constexpr bool | IsHexadecimalDigit (char ch) |
| |
|
constexpr bool | IsOctalDigit (char ch) |
| |
|
constexpr bool | IsLegalIdentifierStart (char ch) |
| |
|
constexpr bool | IsLegalInIdentifier (char ch) |
| |
|
constexpr bool | IsPrintable (char ch) |
| |
|
constexpr bool | IsWhiteSpace (char ch) |
| |
|
constexpr char | ToLowerCaseLetter (char ch) |
| |
|
constexpr char | ToLowerCaseLetter (char &&ch) |
| |
|
std::string | ToLowerCaseLetters (std::string_view str) |
| |
|
constexpr char | ToUpperCaseLetter (char ch) |
| |
|
constexpr char | ToUpperCaseLetter (char &&ch) |
| |
|
std::string | ToUpperCaseLetters (std::string_view str) |
| |
|
constexpr bool | IsSameApartFromCase (char x, char y) |
| |
|
constexpr char | DecimalDigitValue (char ch) |
| |
|
constexpr char | HexadecimalDigitValue (char ch) |
| |
|
constexpr std::optional< char > | BackslashEscapeValue (char ch) |
| |
|
constexpr std::optional< char > | BackslashEscapeChar (char ch) |
| |
|
constexpr bool | IsValidFortranTokenCharacter (char ch) |
| |
|
template<Encoding ENCODING> |
| EncodedCharacter | EncodeCharacter (char32_t ucs) |
| |
|
template<> |
| EncodedCharacter | EncodeCharacter< Encoding::LATIN_1 > (char32_t) |
| |
|
template<> |
| EncodedCharacter | EncodeCharacter< Encoding::UTF_8 > (char32_t) |
| |
|
EncodedCharacter | EncodeCharacter (Encoding, char32_t ucs) |
| |
|
template<Encoding ENCODING, typename STRING > |
| std::string | EncodeString (const STRING &) |
| |
|
template std::string | EncodeString< Encoding::LATIN_1, std::string > (const std::string &) |
| |
|
template std::string | EncodeString< Encoding::UTF_8, std::u32string > (const std::u32string &) |
| |
|
template<typename NORMAL , typename INSERTED > |
| void | EmitQuotedChar (char32_t ch, const NORMAL &emit, const INSERTED &insert, bool backslashEscapes=true, Encoding encoding=Encoding::UTF_8) |
| |
|
std::string | QuoteCharacterLiteral (const std::string &, bool backslashEscapes=true, Encoding=Encoding::LATIN_1) |
| |
|
std::string | QuoteCharacterLiteral (const std::u16string &, bool backslashEscapes=true, Encoding=Encoding::UTF_8) |
| |
|
std::string | QuoteCharacterLiteral (const std::u32string &, bool backslashEscapes=true, Encoding=Encoding::UTF_8) |
| |
|
int | UTF_8CharacterBytes (const char *) |
| |
|
template<Encoding ENCODING> |
| DecodedCharacter | DecodeRawCharacter (const char *, std::size_t) |
| |
|
template<> |
| DecodedCharacter | DecodeRawCharacter< Encoding::LATIN_1 > (const char *, std::size_t) |
| |
|
template<> |
| DecodedCharacter | DecodeRawCharacter< Encoding::UTF_8 > (const char *, std::size_t) |
| |
|
template<Encoding ENCODING> |
| DecodedCharacter | DecodeCharacter (const char *, std::size_t, bool backslashEscapes) |
| |
|
template DecodedCharacter | DecodeCharacter< Encoding::LATIN_1 > (const char *, std::size_t, bool) |
| |
|
template DecodedCharacter | DecodeCharacter< Encoding::UTF_8 > (const char *, std::size_t, bool) |
| |
|
DecodedCharacter | DecodeCharacter (Encoding, const char *, std::size_t, bool backslashEscapes) |
| |
|
template<typename RESULT , Encoding ENCODING> |
| RESULT | DecodeString (const std::string &, bool backslashEscapes) |
| |
|
template std::string | DecodeString< std::string, Encoding::LATIN_1 > (const std::string &, bool) |
| |
|
template std::u16string | DecodeString< std::u16string, Encoding::UTF_8 > (const std::string &, bool) |
| |
|
template std::u32string | DecodeString< std::u32string, Encoding::UTF_8 > (const std::string &, bool) |
| |
|
template<typename T > |
| llvm::raw_ostream & | DumpTree (llvm::raw_ostream &out, const T &x, const AnalyzedObjectsAsFortran *asFortran=nullptr) |
| |
|
template<typename PA > |
| constexpr auto | instrumented (const MessageFixedText &tag, const PA &parser) |
| |
|
constexpr MessageFixedText | operator""_err_en_US (const char str[], std::size_t n) |
| |
|
constexpr MessageFixedText | operator""_warn_en_US (const char str[], std::size_t n) |
| |
|
constexpr MessageFixedText | operator""_port_en_US (const char str[], std::size_t n) |
| |
|
constexpr MessageFixedText | operator""_because_en_US (const char str[], std::size_t n) |
| |
|
constexpr MessageFixedText | operator""_todo_en_US (const char str[], std::size_t n) |
| |
|
constexpr MessageFixedText | operator""_en_US (const char str[], std::size_t n) |
| |
|
template<typename A , typename V > |
| void | Walk (const A &x, V &visitor) |
| |
|
template<typename A , typename M > |
| void | Walk (A &x, M &mutator) |
| |
|
| EMPTY_CLASS (ErrorRecovery) |
| |
|
| WRAPPER_CLASS (ImplicitPart, std::list< ImplicitPartStmt >) |
| |
|
| EMPTY_CLASS (ContainsStmt) |
| |
|
| EMPTY_CLASS (ContinueStmt) |
| |
|
| EMPTY_CLASS (FailImageStmt) |
| |
|
| WRAPPER_CLASS (ExecutionPart, Block) |
| |
|
| WRAPPER_CLASS (Program, std::list< ProgramUnit >) |
| |
|
| WRAPPER_CLASS (Keyword, Name) |
| |
|
| WRAPPER_CLASS (NamedConstant, Name) |
| |
|
| WRAPPER_CLASS (DefinedOpName, Name) |
| |
|
| EMPTY_CLASS (Star) |
| |
|
| WRAPPER_CLASS (IntegerTypeSpec, std::optional< KindSelector >) |
| |
|
| WRAPPER_CLASS (UnsignedTypeSpec, std::optional< KindSelector >) |
| |
|
| WRAPPER_CLASS (IntrinsicVectorTypeSpec, VectorElementType) |
| |
|
| WRAPPER_CLASS (BOZLiteralConstant, std::string) |
| |
|
| EMPTY_CLASS (Abstract) |
| |
|
| EMPTY_CLASS (SequenceStmt) |
| |
|
| EMPTY_CLASS (PrivateStmt) |
| |
|
| WRAPPER_CLASS (SpecificationExpr, ScalarIntExpr) |
| |
|
| WRAPPER_CLASS (DeferredCoshapeSpecList, int) |
| |
|
| WRAPPER_CLASS (DeferredShapeSpecList, int) |
| |
|
| EMPTY_CLASS (Allocatable) |
| |
|
| EMPTY_CLASS (Pointer) |
| |
|
| EMPTY_CLASS (Contiguous) |
| |
|
| WRAPPER_CLASS (NullInit, common::Indirection< Expr >) |
| |
|
| EMPTY_CLASS (NoPass) |
| |
|
| WRAPPER_CLASS (Pass, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (FinalProcedureStmt, std::list< Name >) |
| |
|
| WRAPPER_CLASS (EndTypeStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (ComponentDataSource, common::Indirection< Expr >) |
| |
|
| EMPTY_CLASS (EnumDefStmt) |
| |
|
| WRAPPER_CLASS (EnumeratorDefStmt, std::list< Enumerator >) |
| |
|
| EMPTY_CLASS (EndEnumStmt) |
| |
|
| WRAPPER_CLASS (ArrayConstructor, AcSpec) |
| |
|
| WRAPPER_CLASS (ParameterStmt, std::list< NamedConstantDef >) |
| |
|
| WRAPPER_CLASS (AssumedShapeSpec, std::optional< SpecificationExpr >) |
| |
|
| WRAPPER_CLASS (AssumedImpliedSpec, std::optional< SpecificationExpr >) |
| |
|
| WRAPPER_CLASS (ImpliedShapeSpec, std::list< AssumedImpliedSpec >) |
| |
|
| EMPTY_CLASS (AssumedRankSpec) |
| |
|
| EMPTY_CLASS (Asynchronous) |
| |
|
| EMPTY_CLASS (External) |
| |
|
| EMPTY_CLASS (Intrinsic) |
| |
|
| EMPTY_CLASS (Optional) |
| |
|
| EMPTY_CLASS (Parameter) |
| |
|
| EMPTY_CLASS (Protected) |
| |
|
| EMPTY_CLASS (Save) |
| |
|
| EMPTY_CLASS (Target) |
| |
|
| EMPTY_CLASS (Value) |
| |
|
| EMPTY_CLASS (Volatile) |
| |
|
| WRAPPER_CLASS (AccessId, common::Indirection< GenericSpec >) |
| |
|
| WRAPPER_CLASS (AllocatableStmt, std::list< ObjectDecl >) |
| |
|
| WRAPPER_CLASS (AsynchronousStmt, std::list< ObjectName >) |
| |
|
| WRAPPER_CLASS (CodimensionStmt, std::list< CodimensionDecl >) |
| |
|
| WRAPPER_CLASS (ContiguousStmt, std::list< ObjectName >) |
| |
|
| WRAPPER_CLASS (DataStmt, std::list< DataStmtSet >) |
| |
|
| WRAPPER_CLASS (OptionalStmt, std::list< Name >) |
| |
|
| WRAPPER_CLASS (PointerStmt, std::list< PointerDecl >) |
| |
|
| WRAPPER_CLASS (ProtectedStmt, std::list< Name >) |
| |
|
| WRAPPER_CLASS (SaveStmt, std::list< SavedEntity >) |
| |
|
| WRAPPER_CLASS (TargetStmt, std::list< ObjectDecl >) |
| |
|
| WRAPPER_CLASS (ValueStmt, std::list< Name >) |
| |
|
| WRAPPER_CLASS (VolatileStmt, std::list< ObjectName >) |
| |
|
| WRAPPER_CLASS (EquivalenceObject, common::Indirection< Designator >) |
| |
|
| WRAPPER_CLASS (EquivalenceStmt, std::list< std::list< EquivalenceObject > >) |
| |
|
| WRAPPER_CLASS (TeamValue, Scalar< common::Indirection< Expr > >) |
| |
|
| WRAPPER_CLASS (StatVariable, ScalarIntVariable) |
| |
|
| WRAPPER_CLASS (MsgVariable, ScalarDefaultCharVariable) |
| |
|
| WRAPPER_CLASS (NullifyStmt, std::list< PointerObject >) |
| |
|
| WRAPPER_CLASS (BoundsSpec, BoundExpr) |
| |
|
| WRAPPER_CLASS (ElsewhereStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndWhereStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndForallStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndAssociateStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (BlockStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndBlockStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (BlockSpecificationPart, SpecificationPart) |
| |
|
| WRAPPER_CLASS (EndCriticalStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndDoStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (CycleStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (ElseStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndIfStmt, std::optional< Name >) |
| |
|
| EMPTY_CLASS (Default) |
| |
|
| WRAPPER_CLASS (EndSelectStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (ExitStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (GotoStmt, Label) |
| |
|
| WRAPPER_CLASS (StopCode, Scalar< Expr >) |
| |
|
| WRAPPER_CLASS (SyncAllStmt, std::list< StatOrErrmsg >) |
| |
|
| WRAPPER_CLASS (SyncMemoryStmt, std::list< StatOrErrmsg >) |
| |
|
| WRAPPER_CLASS (FileUnitNumber, ScalarIntExpr) |
| |
|
| WRAPPER_CLASS (StatusExpr, ScalarDefaultCharExpr) |
| |
|
| WRAPPER_CLASS (ErrLabel, Label) |
| |
|
| WRAPPER_CLASS (OpenStmt, std::list< ConnectSpec >) |
| |
|
| WRAPPER_CLASS (IdVariable, ScalarIntVariable) |
| |
|
| WRAPPER_CLASS (EndLabel, Label) |
| |
|
| WRAPPER_CLASS (EorLabel, Label) |
| |
|
| WRAPPER_CLASS (IdExpr, ScalarIntExpr) |
| |
|
| WRAPPER_CLASS (WaitStmt, std::list< WaitSpec >) |
| |
|
| WRAPPER_CLASS (BackspaceStmt, std::list< PositionOrFlushSpec >) |
| |
|
| WRAPPER_CLASS (EndfileStmt, std::list< PositionOrFlushSpec >) |
| |
|
| WRAPPER_CLASS (RewindStmt, std::list< PositionOrFlushSpec >) |
| |
|
| WRAPPER_CLASS (FlushStmt, std::list< PositionOrFlushSpec >) |
| |
|
| WRAPPER_CLASS (FormatStmt, format::FormatSpecification) |
| |
|
| WRAPPER_CLASS (ProgramStmt, Name) |
| |
|
| WRAPPER_CLASS (EndProgramStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (ModuleStmt, Name) |
| |
|
| WRAPPER_CLASS (EndModuleStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndSubmoduleStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (BlockDataStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndBlockDataStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndFunctionStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndSubroutineStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (EndInterfaceStmt, std::optional< GenericSpec >) |
| |
|
| WRAPPER_CLASS (ExternalStmt, std::list< Name >) |
| |
|
| WRAPPER_CLASS (IntrinsicStmt, std::list< Name >) |
| |
|
| WRAPPER_CLASS (AltReturnSpec, Label) |
| |
|
| WRAPPER_CLASS (MpSubprogramStmt, Name) |
| |
|
| WRAPPER_CLASS (EndMpSubprogramStmt, std::optional< Name >) |
| |
|
| WRAPPER_CLASS (ReturnStmt, std::optional< ScalarIntExpr >) |
| |
|
| WRAPPER_CLASS (BasedPointerStmt, std::list< BasedPointer >) |
| |
|
| WRAPPER_CLASS (OldParameterStmt, std::list< NamedConstantDef >) |
| |
|
| WRAPPER_CLASS (PauseStmt, std::optional< StopCode >) |
| |
|
| WRAPPER_CLASS (OmpObjectList, std::list< OmpObject >) |
| |
|
| WRAPPER_CLASS (OmpIterationVector, std::list< OmpIteration >) |
| |
|
| WRAPPER_CLASS (OmpDoacrossClause, OmpDoacross) |
| |
|
| WRAPPER_CLASS (OmpDestroyClause, OmpObject) |
| |
|
| WRAPPER_CLASS (OmpSectionBlocks, std::list< OpenMPConstruct >) |
| |
|
| WRAPPER_CLASS (OmpReductionInitializerClause, Expr) |
| |
|
| EMPTY_CLASS (OmpEndAllocators) |
| |
|
| EMPTY_CLASS (OmpEndAtomic) |
| |
|
| WRAPPER_CLASS (AccObjectList, std::list< AccObject >) |
| |
|
| EMPTY_CLASS (AccEndAtomic) |
| |
|
| EMPTY_CLASS (AccEndLoop) |
| |
|
std::string | DirectoryName (std::string path) |
| |
|
std::optional< std::string > | LocateSourceFile (std::string name, const std::list< std::string > &searchPath) |
| |
|
std::vector< std::string > | LocateSourceFileAll (std::string name, const std::vector< std::string > &searchPath) |
| |
|
const Name & | GetLastName (const Name &) |
| |
|
const Name & | GetLastName (const StructureComponent &) |
| |
|
const Name & | GetLastName (const DataRef &) |
| |
|
const Name & | GetLastName (const Substring &) |
| |
|
const Name & | GetLastName (const Designator &) |
| |
|
const Name & | GetLastName (const ProcComponentRef &) |
| |
|
const Name & | GetLastName (const ProcedureDesignator &) |
| |
|
const Name & | GetLastName (const Call &) |
| |
|
const Name & | GetLastName (const FunctionReference &) |
| |
|
const Name & | GetLastName (const Variable &) |
| |
|
const Name & | GetLastName (const AllocateObject &) |
| |
|
const Name & | GetFirstName (const Name &) |
| |
|
const Name & | GetFirstName (const StructureComponent &) |
| |
|
const Name & | GetFirstName (const DataRef &) |
| |
|
const Name & | GetFirstName (const Substring &) |
| |
|
const Name & | GetFirstName (const Designator &) |
| |
|
const Name & | GetFirstName (const ProcComponentRef &) |
| |
|
const Name & | GetFirstName (const ProcedureDesignator &) |
| |
|
const Name & | GetFirstName (const Call &) |
| |
|
const Name & | GetFirstName (const FunctionReference &) |
| |
|
const Name & | GetFirstName (const Variable &) |
| |
|
const Name & | GetFirstName (const EntityDecl &) |
| |
|
template<typename A , typename B > |
| const A * | Unwrap (const B &x) |
| |
|
template<typename A , typename B > |
| A * | Unwrap (B &x) |
| |
|
const CoindexedNamedObject * | GetCoindexedNamedObject (const AllocateObject &) |
| |
|
const CoindexedNamedObject * | GetCoindexedNamedObject (const DataRef &) |
| |
|
const CoindexedNamedObject * | GetCoindexedNamedObject (const Designator &) |
| |
|
const CoindexedNamedObject * | GetCoindexedNamedObject (const Variable &) |
| |
|
template<typename A > |
| std::optional< CharBlock > | GetSource (const A &x) |
| |
|
template<typename A > |
| std::optional< CharBlock > | GetSource (A &x) |
| |
|
template<typename A > |
| std::optional< CharBlock > | GetLastSource (const A &x) |
| |
|
template<typename A > |
| std::optional< CharBlock > | GetLastSource (A &x) |
| |
|
template<typename A > |
| void | Unparse (llvm::raw_ostream &out, const A &root, Encoding encoding=Encoding::UTF_8, bool capitalizeKeywords=true, bool backslashEscapes=true, preStatementType *preStatement=nullptr, AnalyzedObjectsAsFortran *=nullptr) |
| |
|
template void | Unparse (llvm::raw_ostream &out, const Program &program, Encoding encoding, bool capitalizeKeywords, bool backslashEscapes, preStatementType *preStatement, AnalyzedObjectsAsFortran *) |
| |
|
template void | Unparse (llvm::raw_ostream &out, const Expr &expr, Encoding encoding, bool capitalizeKeywords, bool backslashEscapes, preStatementType *preStatement, AnalyzedObjectsAsFortran *) |
| |
|
template<typename A > |
| CharBlock | FindSourceLocation (const A &x) |
| |
|
template<typename A = Success> |
| constexpr auto | fail (MessageFixedText t) |
| |
|
template<typename A > |
| constexpr auto | pure (A x) |
| |
|
template<typename A > |
| constexpr auto | pure () |
| |
|
template<typename A > |
| constexpr auto | attempt (const A &parser) |
| |
|
template<typename PA , typename = typename PA::resultType> |
| constexpr auto | operator! (PA p) |
| |
|
template<typename PA > |
| constexpr auto | lookAhead (PA p) |
| |
|
template<typename PA > |
| constexpr auto | inContext (MessageFixedText context, PA parser) |
| |
|
template<typename PA > |
| constexpr auto | withMessage (MessageFixedText msg, PA parser) |
| |
|
template<typename PA , typename PB > |
| constexpr auto | operator>> (PA pa, PB pb) |
| |
|
template<typename PA , typename PB > |
| constexpr auto | operator/ (PA pa, PB pb) |
| |
|
template<typename... Ps> |
| constexpr auto | first (Ps... ps) |
| |
|
template<typename PA , typename PB > |
| constexpr auto | operator|| (PA pa, PB pb) |
| |
|
template<typename PA , typename PB > |
| constexpr auto | recovery (PA pa, PB pb) |
| |
|
template<typename PA > |
| constexpr auto | many (PA parser) |
| |
|
template<typename PA > |
| constexpr auto | some (PA parser) |
| |
|
template<typename PA > |
| constexpr auto | skipMany (PA parser) |
| |
|
template<typename PA > |
| constexpr auto | skipManyFast (PA parser) |
| |
|
template<typename PA > |
| constexpr auto | maybe (PA parser) |
| |
|
template<typename PA > |
| constexpr auto | defaulted (PA p) |
| |
|
template<typename... PARSER, std::size_t... J> |
| bool | ApplyHelperArgs (const std::tuple< PARSER... > &parsers, ApplyArgs< PARSER... > &args, ParseState &state, std::index_sequence< J... >) |
| |
|
template<template< typename... > class FUNCTION, typename RESULT , typename... PARSER, std::size_t... J> |
| RESULT | ApplyHelperFunction (FUNCTION< RESULT, PARSER... > f, ApplyArgs< PARSER... > &&args, std::index_sequence< J... >) |
| |
|
template<typename RESULT , typename... PARSER> |
| constexpr auto | applyFunction (ApplicableFunctionPointer< RESULT, PARSER... > f, const PARSER &...parser) |
| |
|
template<typename RESULT , typename... PARSER> |
| auto | applyLambda (ApplicableFunctionObject< RESULT, PARSER... > f, const PARSER &...parser) |
| |
|
template<typename MEMFUNC , typename OBJPARSER , typename... PARSER, std::size_t... J> |
| auto | ApplyHelperMember (MEMFUNC mfp, ApplyArgs< OBJPARSER, PARSER... > &&args, std::index_sequence< J... >) |
| |
|
template<typename MEMFUNC , typename OBJPARSER , typename... PARSER> |
| constexpr auto | applyMem (MEMFUNC memfn, const OBJPARSER &objParser, PARSER... parser) |
| |
|
template<typename RESULT , typename... PARSER, std::size_t... J> |
| RESULT | ApplyHelperConstructor (ApplyArgs< PARSER... > &&args, std::index_sequence< J... >) |
| |
|
template<typename RESULT , typename... PARSER> |
| constexpr auto | construct (PARSER... p) |
| |
|
template<typename PA > |
| constexpr auto | indirect (PA p) |
| |
|
template<typename T > |
| common::IfNoLvalue< std::list< T >, T > | prepend (T &&head, std::list< T > &&rest) |
| |
|
template<typename PA , typename PB > |
| constexpr auto | nonemptySeparated (PA p, PB sep) |
| |
|
template<typename PA , typename PB > |
| constexpr auto | localRecovery (MessageFixedText msg, PA pa, PB pb) |
| |
|
template<LanguageFeature LF, typename PA > |
| constexpr auto | extension (MessageFixedText feature, PA parser) |
| |
|
template<LanguageFeature LF, typename PA > |
| constexpr auto | extension (PA parser) |
| |
|
template<LanguageFeature LF, typename PA > |
| constexpr auto | deprecated (PA parser) |
| |
|
template<typename PA > |
| constexpr auto | sourced (PA parser) |
| |
|
template<typename STRING > |
| std::string | QuoteCharacterLiteralHelper (const STRING &str, bool backslashEscapes, Encoding encoding) |
| |
|
template<> |
| EncodedCharacter | EncodeCharacter< Encoding::LATIN_1 > (char32_t ucs) |
| |
|
template<> |
| EncodedCharacter | EncodeCharacter< Encoding::UTF_8 > (char32_t ucs) |
| |
|
template std::string | EncodeString< Encoding::UTF_8, std::u16string > (const std::u16string &) |
| |
|
template<> |
| DecodedCharacter | DecodeRawCharacter< Encoding::LATIN_1 > (const char *cp, std::size_t bytes) |
| |
|
template<> |
| DecodedCharacter | DecodeRawCharacter< Encoding::UTF_8 > (const char *cp, std::size_t bytes) |
| |
|
constexpr DebugParser | operator""_debug (const char str[], std::size_t n) |
| |
|
| TYPE_PARSER (recovery(CONTEXT_PARSER("execution part construct"_en_US, first(construct< ExecutionPartConstruct >(executableConstruct), construct< ExecutionPartConstruct >(statement(indirect(formatStmt))), construct< ExecutionPartConstruct >(statement(indirect(entryStmt))), construct< ExecutionPartConstruct >(statement(indirect(dataStmt))), extension< LanguageFeature::ExecutionPartNamelist >("nonstandard usage: NAMELIST in execution part"_port_en_US, construct< ExecutionPartConstruct >(statement(indirect(Parser< NamelistStmt >{})))), obsoleteExecutionPartConstruct, lookAhead(declarationConstruct) > > SkipTo<'\n'>{} > > fail< ExecutionPartConstruct >("misplaced declaration in the execution part"_err_en_US))), construct< ExecutionPartConstruct >(executionPartErrorRecovery))) TYPE_CONTEXT_PARSER("execution part"_en_US |
| |
|
| construct< ExecutionPart > (many(executionPartConstruct))) TYPE_PARSER(first(construct< ActionStmt >(indirect(Parser< AllocateStmt > |
| |
|
| construct< ActionStmt > (indirect(assignmentStmt)) |
| |
|
| construct< ActionStmt > (indirect(pointerAssignmentStmt)) |
| |
|
| construct< ActionStmt > (indirect(Parser< BackspaceStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< CallStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< CloseStmt >{})) |
| |
|
| construct< ActionStmt > (construct< ContinueStmt >("CONTINUE"_tok)) |
| |
|
| construct< ActionStmt > (indirect(Parser< CycleStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< DeallocateStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< EndfileStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< EventPostStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< EventWaitStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< ExitStmt >{})) |
| |
|
| construct< ActionStmt > (construct< FailImageStmt >("FAIL IMAGE"_sptok)) |
| |
|
| construct< ActionStmt > (indirect(Parser< FlushStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< FormTeamStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< GotoStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< IfStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< InquireStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< LockStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< NotifyWaitStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< NullifyStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< OpenStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< PrintStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< ReadStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< ReturnStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< RewindStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< StopStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< SyncAllStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< SyncImagesStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< SyncMemoryStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< SyncTeamStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< UnlockStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< WaitStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(whereStmt)) |
| |
|
| construct< ActionStmt > (indirect(Parser< WriteStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< ComputedGotoStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(forallStmt)) |
| |
|
| construct< ActionStmt > (indirect(Parser< ArithmeticIfStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< AssignStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< AssignedGotoStmt >{})) |
| |
|
| construct< ActionStmt > (indirect(Parser< PauseStmt >{})))) TYPE_CONTEXT_PARSER("ASSOCIATE const ruct"_en_US |
| |
|
| construct< AssociateConstruct > (statement(Parser< AssociateStmt >{}), block, statement(Parser< EndAssociateStmt >{}))) TYPE_CONTEXT_PARSER("ASSOCIATE statement"_en_US |
| |
|
| construct< AssociateStmt > (maybe(name/":"), "ASSOCIATE" > > parenthesized(nonemptyList(Parser< Association >{})))) TYPE_PARSER(construct< Selector >(variable)/lookAhead(" |
| |
|
_tok _tok | construct< Selector > (expr)) TYPE_PARSER(construct< EndAssociateStmt >(recovery("END ASSOCIATE" > > maybe(name) |
| |
|
_tok _tok namedConstructEndStmtErrorRecovery TYPE_CONTEXT_PARSER("BLOCK construct"_en_US, construct< BlockConstruct >(statement(Parser< BlockStmt >{}), Parser< BlockSpecificationPart >{}, block, statement(Parser< EndBlockStmt >{}))) TYPE_PARSER(construct< BlockStmt >(maybe(name/" n _ch | construct< std::optional< LoopControl > > ()} |
| |
|
| TYPE_CONTEXT_PARSER ("label DO statement"_en_US, construct< LabelDoStmt >("DO" > > label, loopControlOrEndOfStmt)) TYPE_CONTEXT_PARSER("nonlabel DO statement"_en_US |
| |
|
construct< NonLabelDoStmt >(name/":", "DO" > > maybe(label), loopControlOrEndOfStmt)||const ruct< NonLabelDoStmt >(construct< std | TYPE_PARSER (parenthesized(construct< CaseSelector >(nonemptyList(Parser< CaseValueRange >{})))||construct< CaseSelector >(defaultKeyword)) const expr auto caseValue |
| |
|
| TYPE_PARSER (construct< CaseValueRange >(construct< CaseValueRange::Range >(construct< std::optional< CaseValue > >(caseValue), ":" > > maybe(caseValue)))||construct< CaseValueRange >(construct< CaseValueRange::Range >(construct< std::optional< CaseValue > >(), ":" > > construct< std::optional< CaseValue > >(caseValue)))||construct< CaseValueRange >(caseValue)) TYPE_CONTEXT_PARSER("SELECT RANK const ruct"_en_US |
| |
|
| construct< SelectRankConstruct > (statement(Parser< SelectRankStmt >{}), many(construct< SelectRankConstruct::RankCase >(unambiguousStatement(Parser< SelectRankCaseStmt >{}), block)), statement(endSelectStmt))) TYPE_CONTEXT_PARSER("SELECT RANK statement"_en_US |
| |
|
| construct< SelectRankStmt > (maybe(name/":"), "SELECT RANK"_sptok > > "("_tok > > maybe(name/"=>"), selector/")")) TYPE_CONTEXT_PARSER("RANK case statement"_en_US |
| |
|
| RANK (construct< SelectRankCaseStmt >(parenthesized(construct< SelectRankCaseStmt::Rank >(scalarIntConstantExpr)||construct< SelectRankCaseStmt::Rank >(star))||construct< SelectRankCaseStmt::Rank >(defaultKeyword), maybe(name)))) TYPE_CONTEXT_PARSER("SELECT TYPE const ruct"_en_US |
| |
|
| construct< SelectTypeConstruct > (statement(Parser< SelectTypeStmt >{}), many(construct< SelectTypeConstruct::TypeCase >(unambiguousStatement(Parser< TypeGuardStmt >{}), block)), statement(endSelectStmt))) TYPE_CONTEXT_PARSER("SELECT TYPE statement"_en_US |
| |
|
| construct< SelectTypeStmt > (maybe(name/":"), "SELECT TYPE (" > > maybe(name/"=>"), selector/")")) TYPE_CONTEXT_PARSER("type guard statement"_en_US |
| |
|
| construct< TypeGuardStmt > ("TYPE IS"_sptok > > parenthesized(construct< TypeGuardStmt::Guard >(typeSpec))||"CLASS IS"_sptok > > parenthesized(construct< TypeGuardStmt::Guard >(derivedTypeSpec))||construct< TypeGuardStmt::Guard >("CLASS" > > defaultKeyword), maybe(name))) TYPE_CONTEXT_PARSER("EXIT statement"_en_US |
| |
|
| construct< ExitStmt > ("EXIT" > > maybe(name))) TYPE_CONTEXT_PARSER("GOTO statement"_en_US |
| |
|
| construct< GotoStmt > ("GO TO" > > label)) TYPE_CONTEXT_PARSER("computed GOTO statement"_en_US |
| |
|
| construct< ComputedGotoStmt > ("GO TO" > > parenthesized(nonemptyList(label)), maybe(","_tok) > > scalarIntExpr)) TYPE_CONTEXT_PARSER("STOP statement"_en_US |
| |
|
| construct< StopStmt > ("STOP" > > pure(StopStmt::Kind::Stop)||"ERROR STOP"_sptok > > pure(StopStmt::Kind::ErrorStop), maybe(Parser< StopCode >{}), maybe(", QUIET =" > > scalarLogicalExpr))) TYPE_PARSER(construct< StopCode >(scalar(expr))) TYPE_CONTEXT_PARSER("NOTIFY WAIT statement"_en_US |
| |
|
| construct< NotifyWaitStmt > ("NOTIFY WAIT"_sptok > > "("_tok > > scalar(variable), defaulted("," > > nonemptyList(Parser< EventWaitSpec >{}))/")")) TYPE_CONTEXT_PARSER("SYNC ALL statement"_en_US |
| |
|
| construct< SyncAllStmt > ("SYNC ALL"_sptok > > defaulted(parenthesized(optionalList(statOrErrmsg))))) TYPE_CONTEXT_PARSER("SYNC IMAGES statement"_en_US |
| |
|
SYNC IMAGES _sptok | parenthesized (construct< SyncImagesStmt >(construct< SyncImagesStmt::ImageSet >(intExpr)||construct< SyncImagesStmt::ImageSet >(star), defaulted("," > > nonemptyList(statOrErrmsg))))) TYPE_CONTEXT_PARSER("SYNC MEMORY statement"_en_US |
| |
|
SYNC IMAGES _sptok | construct< SyncMemoryStmt > ("SYNC MEMORY"_sptok > > defaulted(parenthesized(optionalList(statOrErrmsg))))) TYPE_CONTEXT_PARSER("SYNC TEAM statement"_en_US |
| |
|
SYNC IMAGES _sptok | construct< SyncTeamStmt > ("SYNC TEAM"_sptok > > "("_tok > > teamValue, defaulted("," > > nonemptyList(statOrErrmsg))/")")) TYPE_CONTEXT_PARSER("EVENT POST statement"_en_US |
| |
|
SYNC IMAGES _sptok | construct< EventPostStmt > ("EVENT POST"_sptok > > "("_tok > > scalar(variable), defaulted("," > > nonemptyList(statOrErrmsg))/")")) TYPE_CONTEXT_PARSER("EVENT WAIT statement"_en_US |
| |
|
SYNC IMAGES _sptok | construct< EventWaitStmt > ("EVENT WAIT"_sptok > > "("_tok > > scalar(variable), defaulted("," > > nonemptyList(Parser< EventWaitSpec >{}))/")")) const expr auto untilSpec |
| |
|
| TYPE_PARSER (construct< EventWaitSpec >(untilSpec)||construct< EventWaitSpec >(statOrErrmsg)) const expr auto teamVariable |
| |
|
template<typename PA > |
| constexpr auto | scalar (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | constant (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | integer (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | logical (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | defaultChar (const PA &p) |
| |
|
constexpr auto | loopBounds (decltype(scalarExpr) &p) |
| |
|
template<typename PA > |
| constexpr auto | loopBounds (const PA &p) |
| |
|
| TYPE_PARSER (space > > sourced(rawName > > construct< Name >())) const expr auto namedIntrinsicOperator |
| |
|
| TYPE_PARSER (construct< DefinedOperator >(intrinsicOperator)||construct< DefinedOperator >(definedOpName)) TYPE_CONTEXT_PARSER("implicit part"_en_US |
| |
|
| construct< ImplicitPart > (many(Parser< ImplicitPartStmt >{}))) TYPE_PARSER(first(const ruct< ImplicitPartStmt >(statement(indirect(Parser< ImplicitStmt > |
| |
|
| construct< ImplicitPartStmt > (statement(indirect(parameterStmt))) |
| |
|
| construct< ImplicitPartStmt > (statement(indirect(oldParameterStmt))) |
| |
|
| construct< ImplicitPartStmt > (statement(indirect(formatStmt))) |
| |
|
| construct< ImplicitPartStmt > (statement(indirect(entryStmt))) |
| |
|
| construct< ImplicitPartStmt > (indirect(compilerDirective)) |
| |
|
| construct< ImplicitPartStmt > (indirect(openaccDeclarativeConstruct)))) TYPE_CONTEXT_PARSER("internal subprogram"_en_US |
| |
|
| construct< InternalSubprogram > (indirect(functionSubprogram))||const ruct< InternalSubprogram >(indirect(subroutineSubprogram)))/forceEndOfStmt||const ruct< InternalSubprogram >(indirect(compilerDirective))) TYPE_CONTEXT_PARSER("internal subprogram part"_en_US |
| |
|
| construct< InternalSubprogramPart > (statement(containsStmt), many(StartNewSubprogram{} > > Parser< InternalSubprogram >{}))) TYPE_PARSER(first(construct< LiteralConstant >(Parser< HollerithLiteralConstant > |
| |
|
| construct< LiteralConstant > (realLiteralConstant) |
| |
|
| construct< LiteralConstant > (intLiteralConstant) |
| |
|
| construct< LiteralConstant > (Parser< ComplexLiteralConstant >{}) |
| |
|
| construct< LiteralConstant > (Parser< BOZLiteralConstant >{}) |
| |
|
| construct< LiteralConstant > (charLiteralConstant) |
| |
|
| construct< LiteralConstant > (Parser< LogicalLiteralConstant >{}) |
| |
|
construct< LiteralConstant >(unsignedLiteralConstant))) TYPE_PARSER(construct< TypeParamValue >(scalarIntExpr)||const ruct< TypeParamValue >(star)||const ruct< TypeParamValue >(construct< TypeParamValue | TYPE_PARSER (sourced(construct< SignedIntLiteralConstant >(SignedIntLiteralConstantWithoutKind{}, maybe(noSpace > > underscore > > noSpace > > kindParam)))) TYPE_PARSER(construct< IntLiteralConstant >(space > > digitString/!"u"_ch |
| |
|
construct< LiteralConstant >(unsignedLiteralConstant))) TYPE_PARSER(construct< TypeParamValue >(scalarIntExpr)||const ruct< TypeParamValue >(star)||const ruct< TypeParamValue >(construct< TypeParamValue | maybe (underscore > > noSpace > > kindParam)/!underscore)) TYPE_PARSER(construct< UnsignedLiteralConstant >(space > > digitString/"u"_ch |
| |
|
| TYPE_CONTEXT_PARSER ("REAL literal constant"_en_US, space > > construct< RealLiteralConstant >(sourced((digitString > > "."_ch > > !(some(letter) > > "."_ch) > > maybe(digitString) > > maybe(exponentPart) > > ok||"."_ch > > digitString > > maybe(exponentPart) > > ok||digitString > > exponentPart > > ok) > > construct< RealLiteralConstant::Real >()), maybe(noSpace > > underscore > > noSpace > > kindParam))) TYPE_CONTEXT_PARSER("COMPLEX literal const ant"_en_US |
| |
|
| parenthesized (construct< ComplexLiteralConstant >(Parser< ComplexPart >{}/",", Parser< ComplexPart >{}))) TYPE_PARSER(construct< SignedComplexLiteralConstant >(sign |
| |
|
| TYPE_PARSER (construct< TypeParamDefStmt >(integerTypeSpec/",", kindOrLen, "::" > > nonemptyList("expected type parameter declarations"_err_en_US, Parser< TypeParamDecl >{}))) TYPE_PARSER(construct< TypeParamDecl >(name |
| |
|
| maybe ("=" > > scalarIntConstantExpr))) TYPE_PARSER(recovery(withMessage("expected component definition"_err_en_US |
| |
|
| first (construct< ComponentDefStmt >(Parser< DataComponentDefStmt >{}), construct< ComponentDefStmt >(Parser< ProcComponentDefStmt >{}), construct< ComponentDefStmt >(indirect(compilerDirective)))) |
| |
|
| construct< ComponentDefStmt > (inStmtErrorRecovery))) TYPE_PARSER(construct< DataComponentDefStmt >(declarationTypeSpec |
| |
|
| optionalListBeforeColons (Parser< ComponentAttrSpec >{}) |
| |
|
| TYPE_PARSER (construct< ProcComponentAttrSpec >(accessSpec)||construct< ProcComponentAttrSpec >(noPass)||construct< ProcComponentAttrSpec >(pass)||construct< ProcComponentAttrSpec >(pointer)) const expr auto initialDataTarget |
| |
|
| TYPE_PARSER (construct< Initialization >("=>" > > nullInit)||construct< Initialization >("=>" > > initialDataTarget)||construct< Initialization >("=" > > constantExpr)||extension< LanguageFeature::SlashInitialization >("nonstandard usage: /initialization/"_port_en_US, construct< Initialization >("/" > > nonemptyList("expected values"_err_en_US, indirect(Parser< DataStmtValue >{}))/"/"))) TYPE_CONTEXT_PARSER("type bound procedure part"_en_US |
| |
|
| construct< TypeBoundProcedurePart > (statement(containsStmt), maybe(statement(Parser< PrivateStmt >{})), many(statement(Parser< TypeBoundProcBinding >{})))) TYPE_CONTEXT_PARSER("type bound procedure binding"_en_US |
| |
|
| recovery (first(construct< TypeBoundProcBinding >(Parser< TypeBoundProcedureStmt >{}), construct< TypeBoundProcBinding >(Parser< TypeBoundGenericStmt >{}), construct< TypeBoundProcBinding >(Parser< FinalProcedureStmt >{})), construct< TypeBoundProcBinding >(!"END"_tok > > SkipTo<'\n'>{} > > construct< ErrorRecovery >()))) TYPE_CONTEXT_PARSER("type bound PROCEDURE statement"_en_US |
| |
|
| PROCEDURE (construct< TypeBoundProcedureStmt >(construct< TypeBoundProcedureStmt::WithInterface >(parenthesized(name), localRecovery("expected list of binding attributes"_err_en_US, "," > > nonemptyList(Parser< BindAttr >{}), ok), localRecovery("expected list of binding names"_err_en_US, "::" > > listOfNames, SkipTo<'\n'>{})))||construct< TypeBoundProcedureStmt >(construct< TypeBoundProcedureStmt::WithoutInterface >(pure< std::list< BindAttr > >(), nonemptyList("expected type bound procedure declarations"_err_en_US, construct< TypeBoundProcDecl >(name, maybe(extension< LanguageFeature::MissingColons >("type-bound procedure statement should have '::' if it has '=>'"_port_en_US, "=>" > > name))))))||construct< TypeBoundProcedureStmt >(construct< TypeBoundProcedureStmt::WithoutInterface >(optionalListBeforeColons(Parser< BindAttr >{}), nonemptyList("expected type bound procedure declarations"_err_en_US, Parser< TypeBoundProcDecl >{}))))) TYPE_PARSER(construct< TypeBoundProcDecl >(name |
| |
|
| maybe ("=>" > > name))) TYPE_CONTEXT_PARSER("type bound GENERIC statement"_en_US |
| |
|
construct< TypeBoundGenericStmt >("GENERIC" > > maybe("," > > accessSpec), "::" > > indirect(genericSpec), "=>" > > listOfNames)) TYPE_PARSER(construct< BindAttr >(accessSpec)||const ruct< BindAttr >(construct< BindAttr TYPE_PARSER(construct< TypeDeclarationStmt >(declarationTypeSpec, defaulted("," > > nonemptyList(Parser< AttrSpec >{}))/"::", nonemptyList("expected entity declarations"_err_en_US, entityDecl))||construct< TypeDeclarationStmt >(declarationTypeSpec, construct< std::list< AttrSpec > >(), nonemptyList("expected entity declarations"_err_en_US, entityDeclWithoutEqInit))||extension< LanguageFeature::MissingColons >("nonstandard usage: ',' in place of '::'"_port_en_US, construct< TypeDeclarationStmt >(declarationTypeSpec, defaulted("," > > nonemptyList(Parser< AttrSpec >{})), withMessage("expected entity declarations"_err_en_US, "," > > nonemptyList(entityDecl))))) TYPE_PARSER(construct< AttrSpec >(accessSpec)||const ruct< AttrSpec >(allocatable)||const ruct< AttrSpec >(construct< Asynchronous >("ASYNCHRONOUS"_tok))||const ruct< AttrSpec >("CODIMENSION" > > coarraySpec)||const ruct< AttrSpec >(contiguous)||const ruct< AttrSpec >("DIMENSION" > > arraySpec)||const ruct< AttrSpec >(construct< External >("EXTERNAL"_tok))||const ruct< AttrSpec >("INTENT" > > parenthesized(intentSpec))||const ruct< AttrSpec >(construct< Intrinsic >("INTRINSIC"_tok))||const ruct< AttrSpec >(languageBindingSpec)||const ruct< AttrSpec >(optional)||const ruct< AttrSpec >(construct< Parameter >("PARAMETER"_tok))||const ruct< AttrSpec >(pointer)||const ruct< AttrSpec >(protectedAttr)||const ruct< AttrSpec >(save)||const ruct< AttrSpec >(construct< Target >("TARGET"_tok))||const ruct< AttrSpec >(construct< Value >("VALUE"_tok))||const ruct< AttrSpec >(construct< Volatile >("VOLATILE"_tok))||extension< LanguageFeature | TYPE_PARSER (construct< EntityDecl >(objectName, "*" > > charLength, maybe(arraySpec), maybe(coarraySpec), maybe(initialization))||construct< EntityDecl >(objectName, maybe(arraySpec), maybe(coarraySpec), maybe("*" > > charLength), maybe(initialization))) TYPE_PARSER(lookAhead(name/"( )") > > const ruct< NullInit >(expr)) TYPE_PARSER(construct< AccessSpec >("PUBLIC" > > pure(AccessSpec |
| |
|
| TYPE_PARSER (construct< DeferredCoshapeSpecList >(applyFunction(listLength, nonemptyList(":"_tok)))) TYPE_PARSER(construct< ExplicitCoshapeSpec >(many(explicitShapeSpec/" |
| |
|
| maybe (specificationExpr/":")/"*")) TYPE_PARSER(const ruct< ArraySpec >(parenthesized(nonemptyList(explicitShapeSpec)))||const ruct< ArraySpec >(parenthesized(deferredShapeSpecList))||const ruct< ArraySpec >(parenthesized(nonemptyList(Parser< AssumedShapeSpec > |
| |
|
| construct< ArraySpec > (parenthesized(Parser< AssumedSizeSpec >{}))||const ruct< ArraySpec >(parenthesized(Parser< ImpliedShapeSpec > |
| |
|
bool | operator< (const MessageFixedText &x, const MessageFixedText &y) |
| |
|
| TYPE_PARSER (construct< IoUnit >(variable/lookAhead(space/",);\n"_ch))||construct< IoUnit >(fileUnitNumber)||construct< IoUnit >(star)) TYPE_PARSER(construct< FileUnitNumber >(scalarIntExpr/(lookAhead(space > > " |
| |
|
_ch atEndOfStmt | TYPE_CONTEXT_PARSER ("OPEN statement"_en_US, construct< OpenStmt >("OPEN (" > > nonemptyList("expected connection specifications"_err_en_US, Parser< ConnectSpec >{})/")")) const expr auto fileNameExpr |
| |
|
| TYPE_PARSER (first(construct< ConnectSpec >(maybe("UNIT ="_tok) > > fileUnitNumber), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ACCESS =" > > pure(ConnectSpec::CharExpr::Kind::Access), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ACTION =" > > pure(ConnectSpec::CharExpr::Kind::Action), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ASYNCHRONOUS =" > > pure(ConnectSpec::CharExpr::Kind::Asynchronous), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("BLANK =" > > pure(ConnectSpec::CharExpr::Kind::Blank), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("DECIMAL =" > > pure(ConnectSpec::CharExpr::Kind::Decimal), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("DELIM =" > > pure(ConnectSpec::CharExpr::Kind::Delim), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ENCODING =" > > pure(ConnectSpec::CharExpr::Kind::Encoding), scalarDefaultCharExpr)), construct< ConnectSpec >("ERR =" > > errLabel), construct< ConnectSpec >("FILE =" > > fileNameExpr), extension< LanguageFeature::FileName >("nonstandard usage: NAME= in place of FILE="_port_en_US, construct< ConnectSpec >("NAME =" > > fileNameExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("FORM =" > > pure(ConnectSpec::CharExpr::Kind::Form), scalarDefaultCharExpr)), construct< ConnectSpec >("IOMSG =" > > msgVariable), construct< ConnectSpec >("IOSTAT =" > > statVariable), construct< ConnectSpec >(construct< ConnectSpec::Newunit >("NEWUNIT =" > > scalar(integer(variable)))), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("PAD =" > > pure(ConnectSpec::CharExpr::Kind::Pad), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("POSITION =" > > pure(ConnectSpec::CharExpr::Kind::Position), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::Recl >("RECL =" > > scalarIntExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("ROUND =" > > pure(ConnectSpec::CharExpr::Kind::Round), scalarDefaultCharExpr)), construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("SIGN =" > > pure(ConnectSpec::CharExpr::Kind::Sign), scalarDefaultCharExpr)), construct< ConnectSpec >("STATUS =" > > statusExpr), extension< LanguageFeature::Carriagecontrol >("nonstandard usage: CARRIAGECONTROL="_port_en_US, construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("CARRIAGECONTROL =" > > pure(ConnectSpec::CharExpr::Kind::Carriagecontrol), scalarDefaultCharExpr))), extension< LanguageFeature::Convert >("nonstandard usage: CONVERT="_port_en_US, construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("CONVERT =" > > pure(ConnectSpec::CharExpr::Kind::Convert), scalarDefaultCharExpr))), extension< LanguageFeature::Dispose >("nonstandard usage: DISPOSE="_port_en_US, construct< ConnectSpec >(construct< ConnectSpec::CharExpr >("DISPOSE =" > > pure(ConnectSpec::CharExpr::Kind::Dispose), scalarDefaultCharExpr))))) const expr auto closeSpec |
| |
|
| TYPE_CONTEXT_PARSER ("CLOSE statement"_en_US, construct< CloseStmt >("CLOSE" > > parenthesized(nonemptyList(closeSpec)))) const expr auto inputItemList |
| |
|
| TYPE_CONTEXT_PARSER ("READ statement"_en_US, construct< ReadStmt >("READ (" > > construct< std::optional< IoUnit > >(maybe("UNIT ="_tok) > > ioUnit), "," > > construct< std::optional< Format > >(format), defaulted("," > > nonemptyList(ioControlSpec))/")", inputItemList)||construct< ReadStmt >("READ (" > > construct< std::optional< IoUnit > >(ioUnit), construct< std::optional< Format > >(), defaulted("," > > nonemptyList(ioControlSpec))/")", inputItemList)||construct< ReadStmt >("READ" > > construct< std::optional< IoUnit > >(), construct< std::optional< Format > >(), parenthesized(nonemptyList(ioControlSpec)), inputItemList)||construct< ReadStmt >("READ" > > construct< std::optional< IoUnit > >(), construct< std::optional< Format > >(format), construct< std::list< IoControlSpec > >(), many("," > > inputItem))) const expr auto idVariable |
| |
|
| TYPE_PARSER (first(construct< IoControlSpec >("UNIT =" > > ioUnit), construct< IoControlSpec >("FMT =" > > format), construct< IoControlSpec >("NML =" > > name), construct< IoControlSpec >("ADVANCE =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Advance), scalarDefaultCharExpr)), construct< IoControlSpec >(construct< IoControlSpec::Asynchronous >("ASYNCHRONOUS =" > > scalarDefaultCharConstantExpr)), construct< IoControlSpec >("BLANK =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Blank), scalarDefaultCharExpr)), construct< IoControlSpec >("DECIMAL =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Decimal), scalarDefaultCharExpr)), construct< IoControlSpec >("DELIM =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Delim), scalarDefaultCharExpr)), construct< IoControlSpec >("END =" > > endLabel), construct< IoControlSpec >("EOR =" > > eorLabel), construct< IoControlSpec >("ERR =" > > errLabel), construct< IoControlSpec >("ID =" > > idVariable), construct< IoControlSpec >("IOMSG = " > > msgVariable), construct< IoControlSpec >("IOSTAT = " > > statVariable), construct< IoControlSpec >("PAD =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Pad), scalarDefaultCharExpr)), construct< IoControlSpec >("POS =" > > construct< IoControlSpec::Pos >(scalarIntExpr)), construct< IoControlSpec >("REC =" > > construct< IoControlSpec::Rec >(scalarIntExpr)), construct< IoControlSpec >("ROUND =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Round), scalarDefaultCharExpr)), construct< IoControlSpec >("SIGN =" > > construct< IoControlSpec::CharExpr >(pure(IoControlSpec::CharExpr::Kind::Sign), scalarDefaultCharExpr)), construct< IoControlSpec >("SIZE =" > > construct< IoControlSpec::Size >(scalarIntVariable)))) const expr auto outputItemList |
| |
|
| TYPE_CONTEXT_PARSER ("WRITE statement"_en_US, construct< WriteStmt >("WRITE (" > > construct< std::optional< IoUnit > >(maybe("UNIT ="_tok) > > ioUnit), "," > > construct< std::optional< Format > >(format), defaulted("," > > nonemptyList(ioControlSpec))/")", outputItemList)||construct< WriteStmt >("WRITE (" > > construct< std::optional< IoUnit > >(ioUnit), construct< std::optional< Format > >(), defaulted("," > > nonemptyList(ioControlSpec))/")", outputItemList)||construct< WriteStmt >("WRITE" > > construct< std::optional< IoUnit > >(), construct< std::optional< Format > >(), parenthesized(nonemptyList(ioControlSpec)), outputItemList)) TYPE_CONTEXT_PARSER("PRINT statement"_en_US |
| |
|
| construct< PrintStmt > ("PRINT" > > format, defaulted("," > > nonemptyList(outputItem)))) TYPE_PARSER(construct< Format >(label/!"_."_ch)||const ruct< Format >(expr/!" |
| |
|
ioImpliedDoControl | TYPE_CONTEXT_PARSER ("output implied DO"_en_US, parenthesized(construct< OutputImpliedDo >(nonemptyList(outputItem/lookAhead(","_tok)), "," > > ioImpliedDoControl))) TYPE_CONTEXT_PARSER("WAIT statement"_en_US |
| |
|
ioImpliedDoControl WAIT | parenthesized (construct< WaitStmt >(nonemptyList(Parser< WaitSpec >{})))) const expr auto idExpr |
| |
|
| TYPE_PARSER (first(construct< WaitSpec >(maybe("UNIT ="_tok) > > fileUnitNumber), construct< WaitSpec >("END =" > > endLabel), construct< WaitSpec >("EOR =" > > eorLabel), construct< WaitSpec >("ERR =" > > errLabel), construct< WaitSpec >("ID =" > > idExpr), construct< WaitSpec >("IOMSG =" > > msgVariable), construct< WaitSpec >("IOSTAT =" > > statVariable))) const expr auto bareUnitNumberAsList |
| |
|
| TYPE_CONTEXT_PARSER ("BACKSPACE statement"_en_US, construct< BackspaceStmt >("BACKSPACE" > > positionOrFlushSpecList)) TYPE_CONTEXT_PARSER("ENDFILE statement"_en_US |
| |
|
| construct< EndfileStmt > ("END FILE" > > positionOrFlushSpecList)) TYPE_CONTEXT_PARSER("REWIND statement"_en_US |
| |
|
| construct< RewindStmt > ("REWIND" > > positionOrFlushSpecList)) TYPE_PARSER(const ruct< PositionOrFlushSpec >(maybe("UNIT |
| |
|
| TYPE_PARSER (construct< format::IntrinsicTypeDataEditDesc >("I " > > pure(format::IntrinsicTypeDataEditDesc::Kind::I)||"B " > > pure(format::IntrinsicTypeDataEditDesc::Kind::B)||"O " > > pure(format::IntrinsicTypeDataEditDesc::Kind::O)||"Z " > > pure(format::IntrinsicTypeDataEditDesc::Kind::Z), mandatoryWidth, maybe("." > > digits), noInt)||construct< format::IntrinsicTypeDataEditDesc >("F " > > pure(format::IntrinsicTypeDataEditDesc::Kind::F)||"D " > > pure(format::IntrinsicTypeDataEditDesc::Kind::D), mandatoryWidth, mandatoryDigits, noInt)||construct< format::IntrinsicTypeDataEditDesc >("E " > >("N " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EN)||"S " > > pure(format::IntrinsicTypeDataEditDesc::Kind::ES)||"X " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EX)||pure(format::IntrinsicTypeDataEditDesc::Kind::E)), mandatoryWidth, mandatoryDigits, maybe("E " > > digits))||construct< format::IntrinsicTypeDataEditDesc >("G " > > pure(format::IntrinsicTypeDataEditDesc::Kind::G), mandatoryWidth, mandatoryDigits, maybe("E " > > digits))||construct< format::IntrinsicTypeDataEditDesc >("G " > > pure(format::IntrinsicTypeDataEditDesc::Kind::G)||"L " > > pure(format::IntrinsicTypeDataEditDesc::Kind::L), mandatoryWidth, noInt, noInt)||construct< format::IntrinsicTypeDataEditDesc >("A " > > pure(format::IntrinsicTypeDataEditDesc::Kind::A), maybe(width), noInt, noInt)||extension< LanguageFeature::AbbreviatedEditDescriptor >(construct< format::IntrinsicTypeDataEditDesc >("I " > > pure(format::IntrinsicTypeDataEditDesc::Kind::I)||("B "_tok/!letter) > > pure(format::IntrinsicTypeDataEditDesc::Kind::B)||"O " > > pure(format::IntrinsicTypeDataEditDesc::Kind::O)||"Z " > > pure(format::IntrinsicTypeDataEditDesc::Kind::Z)||"F " > > pure(format::IntrinsicTypeDataEditDesc::Kind::F)||("D "_tok/!letter) > > pure(format::IntrinsicTypeDataEditDesc::Kind::D)||"E " > >("N " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EN)||"S " > > pure(format::IntrinsicTypeDataEditDesc::Kind::ES)||"X " > > pure(format::IntrinsicTypeDataEditDesc::Kind::EX)||pure(format::IntrinsicTypeDataEditDesc::Kind::E))||"G " > > pure(format::IntrinsicTypeDataEditDesc::Kind::G)||"L " > > pure(format::IntrinsicTypeDataEditDesc::Kind::L), noInt, noInt, noInt))) const expr SignedDigitStringIgnoreSpaces scaleFactor |
| |
|
| TYPE_PARSER (construct< format::DerivedTypeDataEditDesc >("D T" > > defaulted(charLiteralConstantWithoutKind), defaulted(parenthesized(nonemptyList(scaleFactor))))) const expr PositiveDigitStringIgnoreSpaces count |
| |
|
llvm::raw_ostream & | operator<< (llvm::raw_ostream &o, const MessageFixedText &t) |
| |
|
template<typename PA > |
| constexpr auto | nonemptyList (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | nonemptyList (MessageFixedText error, const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | optionalList (const PA &p) |
| |
|
template<typename A > |
| common::IfNoLvalue< std::list< A >, A > | singletonList (A &&x) |
| |
|
template<typename A > |
| common::IfNoLvalue< std::optional< A >, A > | presentOptional (A &&x) |
| |
|
| TYPE_PARSER (construct< AccObject >(designator)||construct< AccObject >("/" > > name/"/")) TYPE_PARSER(construct< AccObjectList >(nonemptyList(Parser< AccObject > |
| |
|
| TYPE_PARSER (construct< AccObjectListWithModifier >(maybe(Parser< AccDataModifier >{}), Parser< AccObjectList >{})) TYPE_PARSER(construct< AccObjectListWithReduction >(Parser< ReductionOperator > |
| |
|
template<typename Clause , typename Separator > |
| constexpr ModifierList< Clause, Separator > | modifierList (Separator sep) |
| |
| | TYPE_PARSER (sourced(construct< OmpTraitPropertyName >((space > > charLiteralConstantWithoutKind)||applyFunction(nameToString, Parser< Name >{})))) TYPE_PARSER(sourced(construct< OmpTraitScore >("SCORE" > > parenthesized(scalarIntExpr)))) TYPE_PARSER(sourced(construct< OmpTraitPropertyExtension |
| |
|
| TYPE_PARSER (construct< OmpAffinityClause >(maybe(nonemptyList(Parser< OmpAffinityClause::Modifier >{})/":"), Parser< OmpObjectList >{})) TYPE_PARSER(construct< OmpDefaultClause >("PRIVATE" > > pure(OmpDefaultClause |
| |
|
| TYPE_PARSER (construct< OmpLinearClause >(applyFunction< OmpLinearClause >(makeLinearFromOldSyntax, SpecificModifierParser< OmpLinearModifier, OmpLinearClause >{}, parenthesized(Parser< OmpObjectList >{}), maybe(":"_tok > > SpecificModifierParser< OmpStepSimpleModifier, OmpLinearClause >{})))||construct< OmpLinearClause >(Parser< OmpObjectList >{}, maybe(":"_tok > > nonemptyList(Parser< OmpLinearClause::Modifier >{})), pure(true))) TYPE_PARSER(construct< OmpAlignedClause >(Parser< OmpObjectList > |
| |
|
| maybe (":" > > nonemptyList(Parser< OmpAlignedClause::Modifier >{})))) TYPE_PARSER(construct< OmpUpdateClause >(const ruct< OmpUpdateClause >(Parser< OmpDependenceType > |
| |
|
template<typename T > |
| T | WithSource (CharBlock source, T &&x) |
| |
|
llvm::raw_ostream & | operator<< (llvm::raw_ostream &os, const Name &x) |
| |
|
constexpr bool | IsTokenPasting (CharBlock opr) |
| |
|
constexpr bool | IsDefinedKeyword (CharBlock token) |
| |
|
constexpr bool | IsDirective (const char *match, const char *dir) |
| |
|
| TYPE_PARSER (validFunctionStmt||construct< FunctionStmt >(many(prefixSpec), "FUNCTION" > > name, defaulted(parenthesized(optionalList(name))), maybe(suffix))/checkEndOfKnownStmt) static const expr auto programUnit |
| |
|
| TYPE_PARSER (construct< Program >(extension< LanguageFeature::EmptySourceFile >("nonstandard usage: empty source file"_port_en_US, skipStuffBeforeStatement > > !nextCh > > pure< std::list< ProgramUnit > >())||some(globalCompilerDirective||globalOpenACCCompilerDirective||normalProgramUnit)/skipStuffBeforeStatement)) const expr auto actionStmtLookAhead |
| |
|
| TYPE_CONTEXT_PARSER ("declaration construct"_en_US, first(construct< DeclarationConstruct >(specificationConstruct), construct< DeclarationConstruct >(statement(indirect(dataStmt))), construct< DeclarationConstruct >(statement(indirect(formatStmt))), construct< DeclarationConstruct >(statement(indirect(entryStmt))), construct< DeclarationConstruct >(statement(indirect(Parser< StmtFunctionStmt >{}))), misplacedSpecificationStmt)) const expr auto recoveredDeclarationConstruct |
| |
|
| TYPE_CONTEXT_PARSER ("specification part"_en_US, construct< SpecificationPart >(many(openaccDeclarativeConstruct), many(openmpDeclarativeConstruct), many(indirect(compilerDirective)), many(statement(indirect(Parser< UseStmt >{}))), many(unambiguousStatement(indirect(Parser< ImportStmt >{}))), implicitPart, many(recoveredDeclarationConstruct))) const expr auto invalidDeclarationStmt |
| |
|
| TYPE_CONTEXT_PARSER ("specification construct"_en_US, first(construct< SpecificationConstruct >(indirect(Parser< DerivedTypeDef >{})), construct< SpecificationConstruct >(indirect(Parser< EnumDef >{})), construct< SpecificationConstruct >(statement(indirect(Parser< GenericStmt >{}))), construct< SpecificationConstruct >(indirect(interfaceBlock)), construct< SpecificationConstruct >(statement(indirect(parameterStmt))), construct< SpecificationConstruct >(statement(indirect(oldParameterStmt))), construct< SpecificationConstruct >(statement(indirect(Parser< ProcedureDeclarationStmt >{}))), construct< SpecificationConstruct >(statement(Parser< OtherSpecificationStmt >{})), construct< SpecificationConstruct >(statement(indirect(typeDeclarationStmt))), construct< SpecificationConstruct >(indirect(Parser< StructureDef >{})), construct< SpecificationConstruct >(indirect(openaccDeclarativeConstruct)), construct< SpecificationConstruct >(indirect(openmpDeclarativeConstruct)), construct< SpecificationConstruct >(indirect(compilerDirective)))) TYPE_PARSER(first(const ruct< OtherSpecificationStmt >(indirect(Parser< AccessStmt > |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< AllocatableStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< AsynchronousStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< BindStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< CodimensionStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< ContiguousStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< DimensionStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< ExternalStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< IntentStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< IntrinsicStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< NamelistStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< OptionalStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< PointerStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< ProtectedStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< SaveStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< TargetStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< ValueStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< VolatileStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< CommonStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< EquivalenceStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< BasedPointerStmt >{})) |
| |
|
| construct< OtherSpecificationStmt > (indirect(Parser< CUDAAttributesStmt >{})))) TYPE_CONTEXT_PARSER("main program"_en_US |
| |
|
| construct< MainProgram > (maybe(statement(Parser< ProgramStmt >{})), specificationPart, executionPart, maybe(internalSubprogramPart), unterminatedStatement(Parser< EndProgramStmt >{}))) TYPE_CONTEXT_PARSER("PROGRAM statement"_en_US |
| |
|
| construct< ProgramStmt > ("PROGRAM" > > name/maybe(extension< LanguageFeature::ProgramParentheses >("nonstandard usage: parentheses in PROGRAM statement"_port_en_US, parenthesized(ok))))) TYPE_CONTEXT_PARSER("END PROGRAM statement"_en_US |
| |
|
| construct< EndProgramStmt > (recovery("END" > > defaulted("PROGRAM" > > maybe(name))/atEndOfStmt, progUnitEndStmtErrorRecovery))) TYPE_CONTEXT_PARSER("module"_en_US |
| |
|
| construct< Module > (statement(Parser< ModuleStmt >{}), limitedSpecificationPart, maybe(Parser< ModuleSubprogramPart >{}), unterminatedStatement(Parser< EndModuleStmt >{}))) TYPE_CONTEXT_PARSER("MODULE statement"_en_US |
| |
|
| construct< ModuleStmt > ("MODULE" > > name)) TYPE_CONTEXT_PARSER("END MODULE statement"_en_US |
| |
|
| construct< EndModuleStmt > (recovery("END" > > defaulted("MODULE" > > maybe(name))/atEndOfStmt, progUnitEndStmtErrorRecovery))) TYPE_CONTEXT_PARSER("module subprogram part"_en_US |
| |
|
| construct< ModuleSubprogramPart > (statement(containsStmt), many(StartNewSubprogram{} > > Parser< ModuleSubprogram >{}))) TYPE_PARSER(construct< ModuleSubprogram >(indirect(functionSubprogram))||const ruct< ModuleSubprogram >(indirect(subroutineSubprogram))||const ruct< ModuleSubprogram >(indirect(Parser< SeparateModuleSubprogram > |
| |
|
| construct< ModuleSubprogram > (indirect(compilerDirective))) const expr auto moduleNature |
| |
|
TYPE_PARSER(construct< UseStmt >("USE" > > optionalBeforeColons(moduleNature), name, ", ONLY :" > > optionalList(Parser< Only >{}))||construct< UseStmt >("USE" > > optionalBeforeColons(moduleNature), name, defaulted("," > > nonemptyList("expected renamings"_err_en_US, Parser< Rename >{}))/lookAhead(endOfStmt))) TYPE_PARSER(construct< Rename >("OPERATOR (" > > const ruct< Rename | TYPE_PARSER (construct< ProcedureStmt >("MODULE PROCEDURE"_sptok > > pure(ProcedureStmt::Kind::ModuleProcedure), maybe("::"_tok) > > specificProcedures)||construct< ProcedureStmt >("PROCEDURE" > > pure(ProcedureStmt::Kind::Procedure), maybe("::"_tok) > > specificProcedures)) TYPE_PARSER(sourced(first(construct< GenericSpec >("OPERATOR" > > parenthesized(Parser< DefinedOperator > |
| |
|
| construct< GenericSpec > (construct< GenericSpec::Assignment >("ASSIGNMENT ( = )"_tok)) |
| |
|
| construct< GenericSpec > (construct< GenericSpec::ReadFormatted >("READ ( FORMATTED )"_tok)) |
| |
|
| construct< GenericSpec > (construct< GenericSpec::ReadUnformatted >("READ ( UNFORMATTED )"_tok)) |
| |
|
| construct< GenericSpec > (construct< GenericSpec::WriteFormatted >("WRITE ( FORMATTED )"_tok)) |
| |
|
| construct< GenericSpec > (construct< GenericSpec::WriteUnformatted >("WRITE ( UNFORMATTED )"_tok)) |
| |
|
| construct< GenericSpec > (name)))) TYPE_PARSER(construct< GenericStmt >("GENERIC" > > maybe(" |
| |
|
std::size_t | RemoveCarriageReturns (llvm::MutableArrayRef< char > buf) |
| |
|
template<typename PA > |
| constexpr auto | unterminatedStatement (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | statement (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | unlabeledStatement (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | unambiguousStatement (const PA &p) |
| |
|
constexpr AnyOfChars | operator""_ch (const char str[], std::size_t n) |
| |
|
void | MissingSpace (ParseState &state) |
| |
|
constexpr TokenStringMatch | operator""_tok (const char str[], std::size_t n) |
| |
|
constexpr TokenStringMatch< true > | operator""_sptok (const char str[], std::size_t n) |
| |
|
constexpr TokenStringMatch< false, true > | operator""_id (const char str[], std::size_t n) |
| |
|
template<class PA > |
| constexpr std::enable_if_t< std::is_class_v< PA >, SequenceParser< TokenStringMatch<>, PA > > | operator>> (const char *str, const PA &p) |
| |
|
template<class PA > |
| constexpr std::enable_if_t< std::is_class_v< PA >, FollowParser< PA, TokenStringMatch<> > > | operator/ (const PA &p, const char *str) |
| |
|
template<class PA > |
| constexpr auto | parenthesized (const PA &p) |
| |
|
template<class PA > |
| constexpr auto | bracketed (const PA &p) |
| |
|
template<class PA > |
| constexpr auto | braced (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | optionalBeforeColons (const PA &p) |
| |
|
template<typename PA > |
| constexpr auto | optionalListBeforeColons (const PA &p) |
| |
|
template<typename A > |
| constexpr decltype(auto) | verbatim (A x) |
| |
|
template void | Unparse< Program > (llvm::raw_ostream &, const Program &, Encoding, bool, bool, preStatementType *, AnalyzedObjectsAsFortran *) |
| |
|
template void | Unparse< Expr > (llvm::raw_ostream &, const Expr &, Encoding, bool, bool, preStatementType *, AnalyzedObjectsAsFortran *) |
| |
|
bool | CanonicalizeDo (Program &program) |
| |
