doxygen/dump-parse-tree_8h_source.html

//===-- include/flang/Parser/dump-parse-tree.h ------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//


#ifndef FORTRAN_PARSER_DUMP_PARSE_TREE_H_

#define FORTRAN_PARSER_DUMP_PARSE_TREE_H_


#include "format-specification.h"

#include "parse-tree-visitor.h"

#include "parse-tree.h"

#include "tools.h"

#include "unparse.h"

#include "flang/Common/enum-set.h"

#include "flang/Common/idioms.h"

#include "flang/Common/indirection.h"

#include "flang/Support/Fortran.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Frontend/OpenMP/OMP.h"

#include "llvm/Support/raw_ostream.h"

#include <string>

#include <type_traits>


namespace Fortran::parser {


//

// Dump the Parse Tree hierarchy of any node 'x' of the parse tree.

//


class ParseTreeDumper {

public:

  explicit ParseTreeDumper(llvm::raw_ostream &out,

      const AnalyzedObjectsAsFortran *asFortran = nullptr)

      : out_(out), asFortran_{asFortran} {}


  static constexpr const char *GetNodeName(const char *) { return "char *"; }


  template <typename T, typename E, size_t B>

  static std::string GetMemberNames(const common::EnumSet<E, B> &x) {

    llvm::ListSeparator sep;

    std::string s;

    llvm::raw_string_ostream stream(s);

    x.IterateOverMembers([&](E e) { stream << sep << T::EnumToString(e); });

    return stream.str();

  }

#define NODE_ENUMSET(T, S) \

  static std::string GetNodeName(const T::S &x) { \

    return #S " = {"s + GetMemberNames<T>(x) + "}"s; \

  }

#define NODE_NAME(T, N) \

  static constexpr const char *GetNodeName(const T &) { return N; }

#define NODE_ENUM(T, E) \

  static std::string GetNodeName(const T::E &x) { \

    return #E " = "s + std::string{T::EnumToString(x)}; \

  }

#define NODE(T1, T2) NODE_NAME(T1::T2, #T2)

  NODE_NAME(bool, "bool")

  NODE_NAME(int, "int")

  NODE(std, string)

  NODE(std, int64_t)

  NODE(std, uint64_t)

  NODE_ENUM(common, CUDADataAttr)

  NODE_ENUM(common, CUDASubprogramAttrs)

  NODE_ENUM(common, ImportKind)

  NODE_ENUM(common, OmpDependenceKind)

  NODE_ENUM(common, OmpDeviceType)

  NODE_ENUM(common, OmpMemoryOrderType)

  NODE_ENUM(common, OpenACCDeviceType)

  NODE(format, ControlEditDesc)

  NODE(format::ControlEditDesc, Kind)

  NODE(format, DerivedTypeDataEditDesc)

  NODE(format, FormatItem)

  NODE(format, FormatSpecification)

  NODE(format, IntrinsicTypeDataEditDesc)

  NODE(format::IntrinsicTypeDataEditDesc, Kind)

  NODE(parser, Abstract)

  NODE(parser, AccAtomicCapture)

  NODE(AccAtomicCapture, Stmt1)

  NODE(AccAtomicCapture, Stmt2)

  NODE(parser, AccAtomicRead)

  NODE(parser, AccAtomicUpdate)

  NODE(parser, AccAtomicWrite)

  NODE(parser, AccBeginBlockDirective)

  NODE(parser, AccBeginCombinedDirective)

  NODE(parser, AccBeginLoopDirective)

  NODE(parser, AccBlockDirective)

  NODE(parser, AccClause)

#define GEN_FLANG_DUMP_PARSE_TREE_CLAUSES

#include "llvm/Frontend/OpenACC/ACC.inc"

  NODE(parser, AccBindClause)

  NODE(parser, AccDefaultClause)

  static std::string GetNodeName(const llvm::acc::DefaultValue &x) {

    return llvm::Twine(

        "llvm::acc::DefaultValue = ", llvm::acc::getOpenACCDefaultValueName(x))

        .str();

  }

  NODE(parser, AccClauseList)

  NODE(parser, AccCombinedDirective)

  NODE(parser, AccDataModifier)

  NODE_ENUM(parser::AccDataModifier, Modifier)

  NODE(parser, AccDeclarativeDirective)

  NODE(parser, AccEndAtomic)

  NODE(parser, AccEndBlockDirective)

  NODE(parser, AccEndCombinedDirective)

  NODE(parser, AccCollapseArg)

  NODE(parser, AccGangArg)

  NODE(AccGangArg, Num)

  NODE(AccGangArg, Dim)

  NODE(AccGangArg, Static)

  NODE(parser, AccGangArgList)

  NODE(parser, AccObject)

  NODE(parser, AccObjectList)

  NODE(parser, AccObjectListWithModifier)

  NODE(parser, AccObjectListWithReduction)

  NODE(parser, AccSizeExpr)

  NODE(parser, AccSizeExprList)

  NODE(parser, AccSelfClause)

  NODE(parser, AccStandaloneDirective)

  NODE(parser, AccDeviceTypeExpr)


  NODE(parser, AccDeviceTypeExprList)

  NODE(parser, AccTileExpr)

  NODE(parser, AccTileExprList)

  NODE(parser, AccLoopDirective)

  NODE(parser, AccEndLoop)

  NODE(parser, AccWaitArgument)

  static std::string GetNodeName(const llvm::acc::Directive &x) {

    return llvm::Twine(

        "llvm::acc::Directive = ", llvm::acc::getOpenACCDirectiveName(x))

        .str();

  }

  NODE(parser, AcImpliedDo)

  NODE(parser, AcImpliedDoControl)

  NODE(parser, AcValue)

  NODE(parser, AccessStmt)

  NODE(parser, AccessId)

  NODE(parser, AccessSpec)

  NODE_ENUM(AccessSpec, Kind)

  NODE(parser, AcSpec)

  NODE(parser, ActionStmt)

  NODE(parser, ActualArg)

  NODE(ActualArg, PercentRef)

  NODE(ActualArg, PercentVal)

  NODE(parser, ActualArgSpec)

  NODE(AcValue, Triplet)

  NODE(parser, AllocOpt)

  NODE(AllocOpt, Mold)

  NODE(AllocOpt, Source)

  NODE(AllocOpt, Stream)

  NODE(AllocOpt, Pinned)

  NODE(parser, Allocatable)

  NODE(parser, AllocatableStmt)

  NODE(parser, AllocateCoarraySpec)

  NODE(parser, AllocateObject)

  NODE(parser, AllocateShapeSpec)

  NODE(parser, AllocateStmt)

  NODE(parser, Allocation)

  NODE(parser, AltReturnSpec)

  NODE(parser, ArithmeticIfStmt)

  NODE(parser, ArrayConstructor)

  NODE(parser, ArrayElement)

  NODE(parser, ArraySpec)

  NODE(parser, AssignStmt)

  NODE(parser, AssignedGotoStmt)

  NODE(parser, AssignmentStmt)

  NODE(parser, AssociateConstruct)

  NODE(parser, AssociateStmt)

  NODE(parser, Association)

  NODE(parser, AssumedImpliedSpec)

  NODE(parser, AssumedRankSpec)

  NODE(parser, AssumedShapeSpec)

  NODE(parser, AssumedSizeSpec)

  NODE(parser, Asynchronous)

  NODE(parser, AsynchronousStmt)

  NODE(parser, AttrSpec)

  NODE(parser, BOZLiteralConstant)

  NODE(parser, BackspaceStmt)

  NODE(parser, BasedPointer)

  NODE(parser, BasedPointerStmt)

  NODE(parser, BindAttr)

  NODE(BindAttr, Deferred)

  NODE(BindAttr, Non_Overridable)

  NODE(parser, BindEntity)

  NODE_ENUM(BindEntity, Kind)

  NODE(parser, BindStmt)

  NODE(parser, Block)

  NODE(parser, BlockConstruct)

  NODE(parser, BlockData)

  NODE(parser, BlockDataStmt)

  NODE(parser, BlockSpecificationPart)

  NODE(parser, BlockStmt)

  NODE(parser, BoundsRemapping)

  NODE(parser, BoundsSpec)

  NODE(parser, Call)

  NODE(parser, CallStmt)

  NODE(CallStmt, Chevrons)

  NODE(CallStmt, StarOrExpr)

  NODE(parser, CaseConstruct)

  NODE(CaseConstruct, Case)

  NODE(parser, CaseSelector)

  NODE(parser, CaseStmt)

  NODE(parser, CaseValueRange)

  NODE(CaseValueRange, Range)

  NODE(parser, ChangeTeamConstruct)

  NODE(parser, ChangeTeamStmt)

  NODE(parser, CharLength)

  NODE(parser, CharLiteralConstant)

  NODE(parser, CharLiteralConstantSubstring)

  NODE(parser, CharSelector)

  NODE(CharSelector, LengthAndKind)

  NODE(parser, CloseStmt)

  NODE(CloseStmt, CloseSpec)

  NODE(parser, CoarrayAssociation)

  NODE(parser, CoarraySpec)

  NODE(parser, CodimensionDecl)

  NODE(parser, CodimensionStmt)

  NODE(parser, CoindexedNamedObject)

  NODE(parser, CommonBlockObject)

  NODE(parser, CommonStmt)

  NODE(CommonStmt, Block)

  NODE(parser, CompilerDirective)

  NODE(CompilerDirective, AssumeAligned)

  NODE(CompilerDirective, IgnoreTKR)

  NODE(CompilerDirective, Inline)

  NODE(CompilerDirective, IVDep)

  NODE(CompilerDirective, ForceInline)

  NODE(CompilerDirective, LoopCount)

  NODE(CompilerDirective, NameValue)

  NODE(CompilerDirective, NoInline)

  NODE(CompilerDirective, Unrecognized)

  NODE(CompilerDirective, VectorAlways)

  NODE_ENUM(CompilerDirective::VectorLength, VectorLength::Kind)

  NODE(CompilerDirective, VectorLength)

  NODE(CompilerDirective, Unroll)

  NODE(CompilerDirective, UnrollAndJam)

  NODE(CompilerDirective, NoVector)

  NODE(CompilerDirective, NoUnroll)

  NODE(CompilerDirective, NoUnrollAndJam)

  NODE(CompilerDirective, Prefetch)

  NODE(CompilerDirective, InlineAlways)

  NODE(CompilerDirective, Simd)

  NODE(parser, ComplexLiteralConstant)

  NODE(parser, ComplexPart)

  NODE(parser, ComponentArraySpec)

  NODE(parser, ComponentAttrSpec)

  NODE(parser, ComponentDataSource)

  NODE(parser, ComponentDecl)

  NODE(parser, FillDecl)

  NODE(parser, ComponentOrFill)

  NODE(parser, ComponentDefStmt)

  NODE(parser, ComponentSpec)

  NODE(parser, ComputedGotoStmt)

  NODE(parser, ConcurrentControl)

  NODE(parser, ConcurrentHeader)

  NODE(parser, ConditionalExpr)

  NODE(parser, ConditionalArg)

  NODE(ConditionalArg, Consequent)

  NODE(parser, ConditionalArgTail)

  NODE(parser, ConditionalArgNil)

  NODE(parser, ConnectSpec)

  NODE(ConnectSpec, CharExpr)

  NODE_ENUM(ConnectSpec::CharExpr, Kind)

  NODE(ConnectSpec, Newunit)

  NODE(ConnectSpec, Recl)

  NODE(parser, ContainsStmt)

  NODE(parser, Contiguous)

  NODE(parser, ContiguousStmt)

  NODE(parser, ContinueStmt)

  NODE(parser, CriticalConstruct)

  NODE(parser, CriticalStmt)

  NODE(parser, CUDAAttributesStmt)

  NODE(parser, CUFKernelDoConstruct)

  NODE(CUFKernelDoConstruct, StarOrExpr)

  NODE(CUFKernelDoConstruct, Directive)

  NODE(CUFKernelDoConstruct, LaunchConfiguration)

  NODE(parser, CUFReduction)

  NODE(parser, CycleStmt)

  NODE(parser, DataComponentDefStmt)

  NODE(parser, DataIDoObject)

  NODE(parser, DataImpliedDo)

  NODE(parser, DataRef)

  NODE(parser, DataStmt)

  NODE(parser, DataStmtConstant)

  NODE(parser, DataStmtObject)

  NODE(parser, DataStmtRepeat)

  NODE(parser, DataStmtSet)

  NODE(parser, DataStmtValue)

  NODE(parser, DeallocateStmt)

  NODE(parser, DeclarationConstruct)

  NODE(parser, DeclarationTypeSpec)

  NODE(DeclarationTypeSpec, Class)

  NODE(DeclarationTypeSpec, ClassOf)

  NODE(DeclarationTypeSpec, ClassStar)

  NODE(DeclarationTypeSpec, Record)

  NODE(DeclarationTypeSpec, Type)

  NODE(DeclarationTypeSpec, TypeOf)

  NODE(DeclarationTypeSpec, TypeStar)

  NODE(parser, Default)

  NODE(parser, DeferredCoshapeSpecList)

  NODE(parser, DeferredShapeSpecList)

  NODE(parser, DefinedOpName)

  NODE(parser, DefinedOperator)

  NODE_ENUM(DefinedOperator, IntrinsicOperator)

  NODE(parser, DerivedTypeDef)

  NODE(parser, DerivedTypeSpec)

  NODE(parser, DerivedTypeStmt)

  NODE(parser, Designator)

  NODE(parser, DimensionStmt)

  NODE(DimensionStmt, Declaration)

  NODE(parser, DoConstruct)

  NODE(parser, DummyArg)

  NODE(parser, ElseIfStmt)

  NODE(parser, ElseStmt)

  NODE(parser, ElsewhereStmt)

  NODE(parser, EndAssociateStmt)

  NODE(parser, EndBlockDataStmt)

  NODE(parser, EndBlockStmt)

  NODE(parser, EndChangeTeamStmt)

  NODE(parser, EndCriticalStmt)

  NODE(parser, EndDoStmt)

  NODE(parser, EndEnumerationTypeStmt)

  NODE(parser, EndEnumStmt)

  NODE(parser, EndForallStmt)

  NODE(parser, EndFunctionStmt)

  NODE(parser, EndIfStmt)

  NODE(parser, EndInterfaceStmt)

  NODE(parser, EndLabel)

  NODE(parser, EndModuleStmt)

  NODE(parser, EndMpSubprogramStmt)

  NODE(parser, EndProgramStmt)

  NODE(parser, EndSelectStmt)

  NODE(parser, EndSubmoduleStmt)

  NODE(parser, EndSubroutineStmt)

  NODE(parser, EndTypeStmt)

  NODE(parser, EndWhereStmt)

  NODE(parser, EndfileStmt)

  NODE(parser, EntityDecl)

  NODE(parser, EntryStmt)

  NODE(parser, EnumDef)

  NODE(parser, EnumDefStmt)

  NODE(parser, Enumerator)

  NODE(parser, EnumeratorDefStmt)

  NODE(parser, EnumerationEnumeratorStmt)

  NODE(parser, EnumerationTypeDef)

  NODE(parser, EnumerationTypeStmt)

  NODE(parser, EorLabel)

  NODE(parser, EquivalenceObject)

  NODE(parser, EquivalenceStmt)

  NODE(parser, ErrLabel)

  NODE(parser, ErrorRecovery)

  NODE(parser, EventPostStmt)

  NODE(parser, EventWaitSpec)

  NODE(parser, EventWaitStmt)

  NODE(parser, ExecutableConstruct)

  NODE(parser, ExecutionPart)

  NODE(parser, ExecutionPartConstruct)

  NODE(parser, ExitStmt)

  NODE(parser, ExplicitCoshapeSpec)

  NODE(parser, ExplicitShapeSpec)

  NODE(parser, ExplicitShapeBoundsSpec)

  NODE(parser, Expr)

  NODE(Expr, Parentheses)

  NODE(Expr, UnaryPlus)

  NODE(Expr, Negate)

  NODE(Expr, NOT)

  NODE(Expr, PercentLoc)

  NODE(Expr, DefinedUnary)

  NODE(Expr, Power)

  NODE(Expr, Multiply)

  NODE(Expr, Divide)

  NODE(Expr, Add)

  NODE(Expr, Subtract)

  NODE(Expr, Concat)

  NODE(Expr, LT)

  NODE(Expr, LE)

  NODE(Expr, EQ)

  NODE(Expr, NE)

  NODE(Expr, GE)

  NODE(Expr, GT)

  NODE(Expr, AND)

  NODE(Expr, OR)

  NODE(Expr, EQV)

  NODE(Expr, NEQV)

  NODE(Expr, DefinedBinary)

  NODE(Expr, ComplexConstructor)

  NODE(parser, External)

  NODE(parser, ExternalStmt)

  NODE(parser, FailImageStmt)

  NODE(parser, FileUnitNumber)

  NODE(parser, FinalProcedureStmt)

  NODE(parser, FlushStmt)

  NODE(parser, ForallAssignmentStmt)

  NODE(parser, ForallBodyConstruct)

  NODE(parser, ForallConstruct)

  NODE(parser, ForallConstructStmt)

  NODE(parser, ForallStmt)

  NODE(parser, FormTeamStmt)

  NODE(FormTeamStmt, FormTeamSpec)

  NODE(parser, Format)

  NODE(parser, FormatStmt)

  NODE(parser, FunctionReference)

  NODE(parser, FunctionStmt)

  NODE(parser, FunctionSubprogram)

  NODE(parser, GenericSpec)

  NODE(GenericSpec, Assignment)

  NODE(GenericSpec, ReadFormatted)

  NODE(GenericSpec, ReadUnformatted)

  NODE(GenericSpec, WriteFormatted)

  NODE(GenericSpec, WriteUnformatted)

  NODE(parser, GenericStmt)

  NODE(parser, GotoStmt)

  NODE(parser, HollerithLiteralConstant)

  NODE(parser, IdExpr)

  NODE(parser, IdVariable)

  NODE(parser, IfConstruct)

  NODE(IfConstruct, ElseBlock)

  NODE(IfConstruct, ElseIfBlock)

  NODE(parser, IfStmt)

  NODE(parser, IfThenStmt)

  NODE(parser, TeamValue)

  NODE(parser, ImageSelector)

  NODE(parser, ImageSelectorSpec)

  NODE(ImageSelectorSpec, Notify)

  NODE(ImageSelectorSpec, Stat)

  NODE(ImageSelectorSpec, Team_Number)

  NODE(parser, ImplicitPart)

  NODE(parser, ImplicitPartStmt)

  NODE(parser, ImplicitSpec)

  NODE(parser, ImplicitStmt)

  NODE_ENUM(ImplicitStmt, ImplicitNoneNameSpec)

  NODE(parser, ImpliedShapeSpec)

  NODE(parser, ImportStmt)

  NODE(parser, Initialization)

  NODE(parser, InputImpliedDo)

  NODE(parser, InputItem)

  NODE(parser, InquireSpec)

  NODE(InquireSpec, CharVar)

  NODE_ENUM(InquireSpec::CharVar, Kind)

  NODE(InquireSpec, IntVar)

  NODE_ENUM(InquireSpec::IntVar, Kind)

  NODE(InquireSpec, LogVar)

  NODE_ENUM(InquireSpec::LogVar, Kind)

  NODE(parser, InquireStmt)

  NODE(InquireStmt, Iolength)

  NODE(parser, IntegerTypeSpec)

  NODE(parser, IntentSpec)

  NODE_ENUM(IntentSpec, Intent)

  NODE(parser, IntentStmt)

  NODE(parser, InterfaceBlock)

  NODE(parser, InterfaceBody)

  NODE(InterfaceBody, Function)

  NODE(InterfaceBody, Subroutine)

  NODE(parser, InterfaceSpecification)

  NODE(parser, InterfaceStmt)

  NODE(parser, InternalSubprogram)

  NODE(parser, InternalSubprogramPart)

  NODE(parser, Intrinsic)

  NODE(parser, IntrinsicStmt)

  NODE(parser, IntrinsicTypeSpec)

  NODE(IntrinsicTypeSpec, Character)

  NODE(IntrinsicTypeSpec, Complex)

  NODE(IntrinsicTypeSpec, DoubleComplex)

  NODE(IntrinsicTypeSpec, DoublePrecision)

  NODE(IntrinsicTypeSpec, Logical)

  NODE(IntrinsicTypeSpec, Real)

  NODE(parser, IoControlSpec)

  NODE(IoControlSpec, Asynchronous)

  NODE(IoControlSpec, CharExpr)

  NODE_ENUM(IoControlSpec::CharExpr, Kind)

  NODE(IoControlSpec, Pos)

  NODE(IoControlSpec, Rec)

  NODE(IoControlSpec, Size)

  NODE(parser, IoUnit)

  NODE(parser, Keyword)

  NODE(parser, KindParam)

  NODE(parser, KindSelector)

  NODE(KindSelector, StarSize)

  NODE(parser, LabelDoStmt)

  NODE(parser, LanguageBindingSpec)

  NODE(parser, LengthSelector)

  NODE(parser, LetterSpec)

  NODE(parser, LiteralConstant)

  NODE(parser, IntLiteralConstant)

  NODE(parser, ReductionOperator)

  NODE_ENUM(parser::ReductionOperator, Operator)

  NODE(parser, LocalitySpec)

  NODE(LocalitySpec, DefaultNone)

  NODE(LocalitySpec, Local)

  NODE(LocalitySpec, LocalInit)

  NODE(LocalitySpec, Reduce)

  NODE(LocalitySpec, Shared)

  NODE(parser, LockStmt)

  NODE(LockStmt, LockStat)

  NODE(parser, LogicalLiteralConstant)

  NODE_NAME(LoopControl::Bounds, "LoopBounds")

  NODE_NAME(AcImpliedDoControl::Bounds, "LoopBounds")

  NODE_NAME(DataImpliedDo::Bounds, "LoopBounds")

  NODE(parser, LoopControl)

  NODE(LoopControl, Concurrent)

  NODE(parser, MainProgram)

  NODE(parser, Map)

  NODE(Map, EndMapStmt)

  NODE(Map, MapStmt)

  NODE(parser, MaskedElsewhereStmt)

  NODE(parser, Module)

  NODE(parser, ModuleStmt)

  NODE(parser, ModuleSubprogram)

  NODE(parser, ModuleSubprogramPart)

  NODE(parser, MpSubprogramStmt)

  NODE(parser, MsgVariable)

  NODE(parser, Name)

  NODE(parser, NamedConstant)

  NODE(parser, NamedConstantDef)

  NODE(parser, NamelistStmt)

  NODE(NamelistStmt, Group)

  NODE(parser, NonLabelDoStmt)

  NODE(parser, NoPass)

  NODE(parser, NotifyWaitStmt)

  NODE(parser, NullifyStmt)

  NODE(parser, NullInit)

  NODE(parser, ObjectDecl)

  NODE(parser, OldParameterStmt)


  static std::string GetNodeName(const llvm::omp::Directive &x) {

    return llvm::Twine("llvm::omp::Directive = ",

        llvm::omp::getOpenMPDirectiveName(x, llvm::omp::FallbackVersion))

        .str();

  }

  static std::string GetNodeName(const llvm::omp::Clause &x) {

    return llvm::Twine(

        "llvm::omp::Clause = ", llvm::omp::getOpenMPClauseName(x))

        .str();

  }

  NODE(parser, OmpAbsentClause)

  NODE(parser, OmpAccessGroup)

  NODE_ENUM(OmpAccessGroup, Value)

  NODE(parser, OmpAdjustArgsClause)

  NODE(OmpAdjustArgsClause, OmpAdjustOp)

  NODE_ENUM(OmpAdjustArgsClause::OmpAdjustOp, Value)

  NODE(parser, OmpAffinityClause)

  NODE(OmpAffinityClause, Modifier)

  NODE(parser, OmpAlignClause)

  NODE(parser, OmpAlignedClause)

  NODE(OmpAlignedClause, Modifier)

  NODE(parser, OmpAlignment)

  NODE(parser, OmpAlignModifier)

  NODE(parser, OmpAllocateClause)

  NODE(OmpAllocateClause, Modifier)

  NODE(parser, OmpAllocateDirective)

  NODE(parser, OmpAllocatorComplexModifier)

  NODE(parser, OmpAllocatorSimpleModifier)

  NODE(parser, OmpAlwaysModifier)

  NODE_ENUM(OmpAlwaysModifier, Value)

  NODE(parser, OmpAppendArgsClause)

  NODE(OmpAppendArgsClause, OmpAppendOp)

  NODE(parser, OmpLoopModifier)


  static std::string GetNodeName(const llvm::omp::LoopModifier &x) {

    return llvm::Twine(

        "llvm::omp::LoopModifier = ", llvm::omp::getLoopModifierName(x))

        .str();

  }

  NODE(parser, OmpApplyClause)

  NODE(OmpApplyClause, Modifier)

  NODE(parser, OmpArgument)

  NODE(parser, OmpArgumentList)

  NODE(parser, OmpAssumeDirective)

  NODE(parser, OmpAssumesDirective)

  NODE(parser, OmpAtClause)

  NODE_ENUM(OmpAtClause, ActionTime)

  NODE(parser, OmpAtomicDefaultMemOrderClause)

  NODE(parser, OmpAttachModifier)

  NODE_ENUM(OmpAttachModifier, Value)

  NODE(parser, OmpAutomapModifier)

  NODE_ENUM(OmpAutomapModifier, Value)

  NODE(parser, OmpBaseVariantNames)

  NODE(parser, OmpBeginDirective)

  NODE(parser, OmpBeginSectionsDirective)

  NODE(parser, OmpBindClause)

  NODE_ENUM(OmpBindClause, Binding)

  NODE(parser, OmpBlockConstruct)

  NODE(parser, OmpCancellationConstructTypeClause)

  NODE(parser, OmpChunkModifier)

  NODE_ENUM(OmpChunkModifier, Value)

  NODE(parser, OmpClause)

  NODE(parser, OmpClauseList)

  NODE(parser, OmpCloseModifier)

  NODE_ENUM(OmpCloseModifier, Value)

  NODE(parser, OmpCombinerClause)

  NODE(parser, OmpCombinerExpression)

  NODE(parser, OmpContainsClause)

  NODE(parser, OmpContextSelectorSpecification)

  NODE(parser, OmpDeclareMapperDirective)

  NODE(parser, OmpDeclareReductionDirective)

  NODE(parser, OmpDeclareSimdDirective)

  NODE(parser, OmpDeclareTargetDirective)

  NODE(parser, OmpDeclareVariantDirective)

  NODE(parser, OmpDefaultClause)

  NODE_ENUM(OmpDefaultClause, DataSharingAttribute)

  NODE(parser, OmpDefaultmapClause)

  NODE(OmpDefaultmapClause, Modifier)

  NODE_ENUM(OmpDefaultmapClause, ImplicitBehavior)

  NODE(parser, OmpDeleteModifier)

  NODE_ENUM(OmpDeleteModifier, Value)

  NODE(parser, OmpDelimitedMetadirectiveDirective)

  NODE(parser, OmpDependClause)

  NODE(OmpDependClause, TaskDep)

  NODE(OmpDependClause::TaskDep, Modifier)

  NODE(parser, OmpDependenceType)

  NODE_ENUM(OmpDependenceType, Value)

  NODE(parser, OmpDepinfoModifier)

  NODE(parser, OmpDestroyClause)

  NODE(parser, OmpDetachClause)

  NODE(parser, OmpDeviceClause)

  NODE(OmpDeviceClause, Modifier)

  NODE(parser, OmpDeviceModifier)

  NODE_ENUM(OmpDeviceModifier, Value)

  NODE(parser, OmpDeviceSafesyncClause)

  NODE(parser, OmpDeviceTypeClause)

  NODE(parser, OmpDimsModifier)

  NODE(parser, OmpDirectiveName)

  NODE(parser, OmpDirectiveSpecification)

  NODE_ENUM(OmpDirectiveSpecification, Flag)

  NODE_ENUMSET(OmpDirectiveSpecification, Flags)

  NODE(parser, OmpDoacross)

  NODE(OmpDoacross, Sink)

  NODE(OmpDoacross, Source)

  NODE(parser, OmpDoacrossClause)

  NODE(parser, OmpDynamicAllocatorsClause)

  NODE(parser, OmpDynGroupprivateClause)

  NODE(OmpDynGroupprivateClause, Modifier)

  NODE(parser, OmpEndDirective)

  NODE(parser, OmpEndSectionsDirective)

  NODE(parser, OmpEnterClause)

  NODE(OmpEnterClause, Modifier)

  NODE(parser, OmpErrorDirective)

  NODE(parser, OmpExpectation)

  NODE_ENUM(OmpExpectation, Value)

  NODE(parser, OmpFailClause)

  NODE(parser, OmpFallbackModifier)

  NODE_ENUM(OmpFallbackModifier, Value)

  NODE(parser, OmpFromClause)

  NODE(OmpFromClause, Modifier)

  NODE(parser, OmpGrainsizeClause)

  NODE(OmpGrainsizeClause, Modifier)

  NODE(parser, OmpGraphIdClause)

  NODE(parser, OmpGraphResetClause)

  NODE(parser, OmpGroupprivateDirective)

  NODE(parser, OmpHintClause)

  NODE(parser, OmpHoldsClause)

  NODE(parser, OmpIfClause)

  NODE(OmpIfClause, Modifier)

  NODE(parser, OmpIndirectClause)

  NODE(parser, OmpInitClause)

  NODE(OmpInitClause, Modifier)

  NODE(parser, OmpInitializerClause)

  NODE(parser, OmpInitializerExpression)

  NODE(parser, OmpInReductionClause)

  NODE(OmpInReductionClause, Modifier)

  NODE(parser, OmpInteropType)

  NODE_ENUM(OmpInteropType, Value)

  NODE(parser, OmpIteration)

  NODE(parser, OmpIterationOffset)

  NODE(parser, OmpIterationVector)

  NODE(parser, OmpIterator)

  NODE(parser, OmpIteratorSpecifier)

  NODE(parser, OmpLastprivateClause)

  NODE(OmpLastprivateClause, Modifier)

  NODE(parser, OmpLastprivateModifier)

  NODE_ENUM(OmpLastprivateModifier, Value)

  NODE(parser, OmpLinearClause)

  NODE(OmpLinearClause, Modifier)

  NODE(parser, OmpLinearModifier)

  NODE_ENUM(OmpLinearModifier, Value)

  NODE(parser, OmpLocator)

  NODE(parser, OmpLooprangeClause)

  NODE(parser, OmpLowerBound)

  NODE(parser, OmpMapClause)

  NODE(OmpMapClause, Modifier)

  NODE(parser, OmpMapper)

  NODE(parser, OmpMapperSpecifier)

  NODE(parser, OmpMapType)

  NODE_ENUM(OmpMapType, Value)

  NODE(parser, OmpMapTypeModifier)

  NODE_ENUM(OmpMapTypeModifier, Value)

  NODE(parser, OmpMatchClause)

  NODE(parser, OmpMessageClause)

  NODE(parser, OmpMetadirectiveDirective)

  NODE(parser, OmpNoOpenMPClause)

  NODE(parser, OmpNoOpenMPRoutinesClause)

  NODE(parser, OmpNoParallelismClause)

  NODE(parser, OmpNothingDirective)

  NODE(parser, OmpNumTasksClause)

  NODE(parser, OmpNumTeamsClause)

  NODE(OmpNumTeamsClause, Modifier)

  NODE(parser, OmpNumThreadsClause)

  NODE(OmpNumThreadsClause, Modifier)

  NODE(OmpNumTasksClause, Modifier)

  NODE(parser, OmpObject)

  NODE(OmpObject, Invalid)

  NODE_ENUM(OmpObject::Invalid, Kind)

  NODE(parser, OmpObjectList)

  NODE(parser, OmpOrderClause)

  NODE(OmpOrderClause, Modifier)

  NODE_ENUM(OmpOrderClause, Ordering)

  NODE(parser, OmpOrderingModifier)

  NODE_ENUM(OmpOrderingModifier, Value)

  NODE(parser, OmpOrderModifier)

  NODE_ENUM(OmpOrderModifier, Value)

  NODE(parser, OmpOtherwiseClause)

  NODE(parser, OmpPreferenceSelector)

  NODE(parser, OmpPreferenceSpecification)

  NODE(parser, OmpPreferType)

  NODE(parser, OmpPrescriptiveness)

  NODE_ENUM(OmpPrescriptiveness, Value)

  NODE(parser, OmpPresentModifier)

  NODE_ENUM(OmpPresentModifier, Value)

  NODE(parser, OmpProcBindClause)

  NODE_ENUM(OmpProcBindClause, AffinityPolicy)

  NODE(parser, OmpReductionClause)

  NODE(OmpReductionClause, Modifier)

  NODE(parser, OmpReductionIdentifier)

  NODE(parser, OmpReductionModifier)

  NODE_ENUM(OmpReductionModifier, Value)

  NODE(parser, OmpReductionSpecifier)

  NODE(parser, OmpRefModifier)

  NODE_ENUM(OmpRefModifier, Value)

  NODE(parser, OmpReplayableClause)

  NODE(parser, OmpRequiresDirective)

  NODE(parser, OmpReservedIdentifier)

  NODE(parser, OmpReverseOffloadClause)

  NODE(parser, OmpScheduleClause)

  NODE(OmpScheduleClause, Modifier)

  NODE_ENUM(OmpScheduleClause, Kind)

  NODE(parser, OmpSectionDirective)

  NODE(parser, OmpSelfMapsClause)

  NODE(parser, OmpSelfModifier)

  NODE_ENUM(OmpSelfModifier, Value)

  NODE(parser, OmpSeverityClause)

  NODE_ENUM(OmpSeverityClause, SevLevel)

  NODE(parser, OmpStepComplexModifier)

  NODE(parser, OmpStepSimpleModifier)

  NODE(parser, OmpStylizedDeclaration)

  NODE(parser, OmpStylizedExpression)

  NODE(parser, OmpStylizedInstance)

  NODE(OmpStylizedInstance, Instance)

  NODE(parser, OmpTaskDependenceType)

  NODE(parser, OmpTaskReductionClause)

  NODE(OmpTaskReductionClause, Modifier)

  NODE(parser, OmpThreadLimitClause)

  NODE(OmpThreadLimitClause, Modifier)

  NODE(parser, OmpThreadprivateDirective)

  NODE(parser, OmpThreadsetClause)

  NODE_ENUM(OmpThreadsetClause, ThreadsetPolicy)

  NODE(parser, OmpToClause)

  NODE(OmpToClause, Modifier)

  NODE(parser, OmpTraitProperty)

  NODE(parser, OmpTraitPropertyExtension)

  NODE(OmpTraitPropertyExtension, Complex)

  NODE(parser, OmpTraitPropertyName)

  NODE(parser, OmpTraitScore)

  NODE(parser, OmpTraitSelector)

  NODE(OmpTraitSelector, Properties)

  NODE(parser, OmpTraitSelectorName)

  NODE_ENUM(OmpTraitSelectorName, Value)

  NODE(parser, OmpTraitSetSelector)

  NODE(parser, OmpTraitSetSelectorName)

  NODE_ENUM(OmpTraitSetSelectorName, Value)

  NODE(parser, OmpTransparentClause)

  NODE(parser, OmpTypeName)

  NODE(parser, OmpTypeNameList)

  NODE(parser, OmpUnifiedAddressClause)

  NODE(parser, OmpUnifiedSharedMemoryClause)

  NODE(parser, OmpUpdateClause)

  NODE(parser, OmpUseClause)

  NODE(parser, OmpUtilityDirective)

  NODE(parser, OmpVariableCategory)

  NODE_ENUM(OmpVariableCategory, Value)

  NODE(parser, OmpWhenClause)

  NODE(OmpWhenClause, Modifier)

  NODE(parser, OmpxHoldModifier)

  NODE_ENUM(OmpxHoldModifier, Value)

#define GEN_FLANG_DUMP_PARSE_TREE_CLAUSES

#include "llvm/Frontend/OpenMP/OMP.inc"


  NODE(parser, Only)

  NODE(parser, OpenACCAtomicConstruct)

  NODE(parser, OpenACCBlockConstruct)

  NODE(parser, OpenACCCacheConstruct)

  NODE(parser, OpenACCCombinedConstruct)

  NODE(parser, OpenACCConstruct)

  NODE(parser, OpenACCDeclarativeConstruct)

  NODE(parser, OpenACCEndConstruct)

  NODE(parser, OpenACCLoopConstruct)

  NODE(parser, OpenMPInteropConstruct)

  NODE(parser, OpenACCRoutineConstruct)

  NODE(parser, OpenACCStandaloneDeclarativeConstruct)

  NODE(parser, OpenACCStandaloneConstruct)

  NODE(parser, OpenACCWaitConstruct)


  NODE(parser, OpenMPAllocatorsConstruct)

  NODE(parser, OpenMPAtomicConstruct)

  NODE(parser, OpenMPCancelConstruct)

  NODE(parser, OpenMPCancellationPointConstruct)

  NODE(parser, OpenMPConstruct)

  NODE(parser, OpenMPCriticalConstruct)

  NODE(parser, OpenMPDeclarativeConstruct)

  NODE(parser, OpenMPDepobjConstruct)

  NODE(parser, OpenMPDispatchConstruct)

  NODE(parser, OpenMPFlushConstruct)

  NODE(parser, OpenMPInvalidDirective)

  NODE(parser, OpenMPLoopConstruct)

  NODE(parser, OpenMPMisplacedEndDirective)

  NODE(parser, OpenMPSectionsConstruct)

  NODE(parser, OpenMPSimpleStandaloneConstruct)

  NODE(parser, OpenMPStandaloneConstruct)


  NODE(parser, OpenStmt)

  NODE(parser, Optional)

  NODE(parser, OptionalStmt)

  NODE(parser, OtherSpecificationStmt)

  NODE(parser, OutputImpliedDo)

  NODE(parser, OutputItem)

  NODE(parser, Parameter)

  NODE(parser, ParameterStmt)

  NODE(parser, ParentIdentifier)

  NODE(parser, Pass)

  NODE(parser, PauseStmt)

  NODE(parser, Pointer)

  NODE(parser, PointerAssignmentStmt)

  NODE(PointerAssignmentStmt, Bounds)

  NODE(parser, PointerDecl)

  NODE(parser, PointerObject)

  NODE(parser, PointerStmt)

  NODE(parser, PositionOrFlushSpec)

  NODE(parser, PrefixSpec)

  NODE(PrefixSpec, Elemental)

  NODE(PrefixSpec, Impure)

  NODE(PrefixSpec, Module)

  NODE(PrefixSpec, Non_Recursive)

  NODE(PrefixSpec, Pure)

  NODE(PrefixSpec, Recursive)

  NODE(PrefixSpec, Simple)

  NODE(PrefixSpec, Attributes)

  NODE(PrefixSpec, Launch_Bounds)

  NODE(PrefixSpec, Cluster_Dims)

  NODE(parser, PrintStmt)

  NODE(parser, PrivateStmt)

  NODE(parser, PrivateOrSequence)

  NODE(parser, ProcAttrSpec)

  NODE(parser, ProcComponentAttrSpec)

  NODE(parser, ProcComponentDefStmt)

  NODE(parser, ProcComponentRef)

  NODE(parser, ProcDecl)

  NODE(parser, ProcInterface)

  NODE(parser, ProcPointerInit)

  NODE(parser, ProcedureDeclarationStmt)

  NODE(parser, ProcedureDesignator)

  NODE(parser, ProcedureStmt)

  NODE_ENUM(ProcedureStmt, Kind)

  NODE(parser, Program)

  NODE(parser, ProgramStmt)

  NODE(parser, ProgramUnit)

  NODE(parser, Protected)

  NODE(parser, ProtectedStmt)

  NODE(parser, RankClause)

  NODE(parser, ReadStmt)

  NODE(parser, RealLiteralConstant)

  NODE(RealLiteralConstant, Real)

  NODE(parser, Rename)

  NODE(Rename, Names)

  NODE(Rename, Operators)

  NODE(parser, ReturnStmt)

  NODE(parser, RewindStmt)

  NODE(parser, Save)

  NODE(parser, SaveStmt)

  NODE(parser, SavedEntity)

  NODE_ENUM(SavedEntity, Kind)

  NODE(parser, SectionSubscript)

  NODE(parser, SelectCaseStmt)

  NODE(parser, SelectRankCaseStmt)

  NODE(SelectRankCaseStmt, Rank)

  NODE(parser, SelectRankConstruct)

  NODE(SelectRankConstruct, RankCase)

  NODE(parser, SelectRankStmt)

  NODE(parser, SelectTypeConstruct)

  NODE(SelectTypeConstruct, TypeCase)

  NODE(parser, SelectTypeStmt)

  NODE(parser, Selector)

  NODE(parser, SeparateModuleSubprogram)

  NODE(parser, SequenceStmt)

  NODE(parser, Sign)

  NODE(parser, SignedComplexLiteralConstant)

  NODE(parser, SignedIntLiteralConstant)

  NODE(parser, SignedRealLiteralConstant)

  NODE(parser, SpecificationConstruct)

  NODE(parser, SpecificationExpr)

  NODE(parser, SpecificationPart)

  NODE(parser, Star)

  NODE(parser, StatOrErrmsg)

  NODE(parser, StatVariable)

  NODE(parser, StatusExpr)

  NODE(parser, StmtFunctionStmt)

  NODE(parser, StopCode)

  NODE(parser, StopStmt)

  NODE_ENUM(StopStmt, Kind)

  NODE(parser, StructureComponent)

  NODE(parser, StructureConstructor)

  NODE(parser, StructureDef)

  NODE(StructureDef, EndStructureStmt)

  NODE(parser, StructureField)

  NODE(parser, StructureStmt)

  NODE(parser, Submodule)

  NODE(parser, SubmoduleStmt)

  NODE(parser, SubroutineStmt)

  NODE(parser, SubroutineSubprogram)

  NODE(parser, SubscriptTriplet)

  NODE(parser, Substring)

  NODE(parser, SubstringInquiry)

  NODE(parser, SubstringRange)

  NODE(parser, Suffix)

  NODE(parser, SyncAllStmt)

  NODE(parser, SyncImagesStmt)

  NODE(SyncImagesStmt, ImageSet)

  NODE(parser, SyncMemoryStmt)

  NODE(parser, SyncTeamStmt)

  NODE(parser, Target)

  NODE(parser, TargetStmt)

  NODE(parser, TypeAttrSpec)

  NODE(TypeAttrSpec, BindC)

  NODE(TypeAttrSpec, Extends)

  NODE(parser, TypeBoundGenericStmt)

  NODE(parser, TypeBoundProcBinding)

  NODE(parser, TypeBoundProcDecl)

  NODE(parser, TypeBoundProcedurePart)

  NODE(parser, TypeBoundProcedureStmt)

  NODE(TypeBoundProcedureStmt, WithInterface)

  NODE(TypeBoundProcedureStmt, WithoutInterface)

  NODE(parser, TypeDeclarationStmt)

  NODE(parser, TypeGuardStmt)

  NODE(TypeGuardStmt, Guard)

  NODE(parser, TypeParamDecl)

  NODE(parser, TypeParamDefStmt)

  NODE(common, TypeParamAttr)

  NODE(parser, TypeParamSpec)

  NODE(parser, TypeParamValue)

  NODE(TypeParamValue, Deferred)

  NODE(parser, TypeSpec)

  NODE(parser, Union)

  NODE(Union, EndUnionStmt)

  NODE(Union, UnionStmt)

  NODE(parser, UnlockStmt)

  NODE(parser, UnsignedLiteralConstant)

  NODE(parser, UnsignedTypeSpec)

  NODE(parser, UseStmt)

  NODE_ENUM(UseStmt, ModuleNature)

  NODE(parser, Value)

  NODE(parser, ValueStmt)

  NODE(parser, Variable)

  NODE(parser, VectorTypeSpec)

  NODE(VectorTypeSpec, PairVectorTypeSpec)

  NODE(VectorTypeSpec, QuadVectorTypeSpec)

  NODE(parser, IntrinsicVectorTypeSpec)

  NODE(parser, VectorElementType)

  NODE(parser, Verbatim)

  NODE(parser, Volatile)

  NODE(parser, VolatileStmt)

  NODE(parser, WaitSpec)

  NODE(parser, WaitStmt)

  NODE(parser, WhereBodyConstruct)

  NODE(parser, WhereConstruct)

  NODE(WhereConstruct, Elsewhere)

  NODE(WhereConstruct, MaskedElsewhere)

  NODE(parser, WhereConstructStmt)

  NODE(parser, WhereStmt)

  NODE(parser, WriteStmt)

#undef NODE

#undef NODE_NAME


  template <typename T> bool Pre(const T &x) {

    std::string fortran{AsFortran<T>(x)};

    if (fortran.empty() && (UnionTrait<T> || WrapperTrait<T>)) {

      Prefix(GetNodeName(x));

    } else {

      IndentEmptyLine();

      out_ << GetNodeName(x);

      if (!fortran.empty()) {

        out_ << " = '" << fortran << '\'';

      }

      EndLine();

      ++indent_;

    }

    return true;

  }


  template <typename T> void Post(const T &x) {

    if (AsFortran<T>(x).empty() && (UnionTrait<T> || WrapperTrait<T>)) {

      EndLineIfNonempty();

    } else {

      --indent_;

    }

  }


  // A few types we want to ignore


  bool Pre(const CharBlock &) { return true; }

  void Post(const CharBlock &) {}


  template <typename T> bool Pre(const Statement<T> &) { return true; }

  template <typename T> void Post(const Statement<T> &) {}

  template <typename T> bool Pre(const UnlabeledStatement<T> &) { return true; }

  template <typename T> void Post(const UnlabeledStatement<T> &) {}


  template <typename T> bool Pre(const common::Indirection<T> &) {

    return true;

  }

  template <typename T> void Post(const common::Indirection<T> &) {}


  template <typename A> bool Pre(const Scalar<A> &) {

    Prefix("Scalar");

    return true;

  }

  template <typename A> void Post(const Scalar<A> &) { EndLineIfNonempty(); }


  template <typename A> bool Pre(const Constant<A> &) {

    Prefix("Constant");

    return true;

  }

  template <typename A> void Post(const Constant<A> &) { EndLineIfNonempty(); }


  template <typename A> bool Pre(const Integer<A> &) {

    Prefix("Integer");

    return true;

  }

  template <typename A> void Post(const Integer<A> &) { EndLineIfNonempty(); }


  template <typename A> bool Pre(const Logical<A> &) {

    Prefix("Logical");

    return true;

  }

  template <typename A> void Post(const Logical<A> &) { EndLineIfNonempty(); }


  template <typename A> bool Pre(const DefaultChar<A> &) {

    Prefix("DefaultChar");

    return true;

  }

  template <typename A> void Post(const DefaultChar<A> &) {

    EndLineIfNonempty();

  }


  template <typename... A> bool Pre(const std::tuple<A...> &) { return true; }

  template <typename... A> void Post(const std::tuple<A...> &) {}


  template <typename... A> bool Pre(const std::variant<A...> &) { return true; }

  template <typename... A> void Post(const std::variant<A...> &) {}


protected:

  // Return a Fortran representation of this node to include in the dump

  template <typename T> std::string AsFortran(const T &x) {

    std::string buf;

    llvm::raw_string_ostream ss{buf};

    if constexpr (HasTypedExpr<T>::value) {

      if (asFortran_ && x.typedExpr) {

        asFortran_->expr(ss, *x.typedExpr);

      }

    } else if constexpr (std::is_same_v<T, AssignmentStmt> ||

        std::is_same_v<T, PointerAssignmentStmt>) {

      if (asFortran_ && x.typedAssignment) {

        asFortran_->assignment(ss, *x.typedAssignment);

      }

    } else if constexpr (std::is_same_v<T, CallStmt>) {

      if (asFortran_ && x.typedCall) {

        asFortran_->call(ss, *x.typedCall);

      }

    } else if constexpr (std::is_same_v<T, IntLiteralConstant> ||

        std::is_same_v<T, SignedIntLiteralConstant> ||

        std::is_same_v<T, UnsignedLiteralConstant>) {

      ss << std::get<CharBlock>(x.t);

    } else if constexpr (std::is_same_v<T, RealLiteralConstant::Real>) {

      ss << x.source;

    } else if constexpr (std::is_same_v<T, std::string> ||

        std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t>) {

      ss << x;

    }

    if (ss.tell()) {

      return buf;

    }

    if constexpr (std::is_same_v<T, Name>) {

      return x.source.ToString();

#ifdef SHOW_ALL_SOURCE_MEMBERS

    } else if constexpr (HasSource<T>::value) {

      return x.source.ToString();

#endif

    } else if constexpr (std::is_same_v<T, int>) {

      return std::to_string(x);

    } else if constexpr (std::is_same_v<T, bool>) {

      return x ? "true" : "false";

    } else {

      return "";

    }

  }


  void IndentEmptyLine() {

    if (emptyline_ && indent_ > 0) {

      for (int i{0}; i < indent_; ++i) {

        out_ << "| ";

      }

      emptyline_ = false;

    }

  }


  void Prefix(const char *str) {

    IndentEmptyLine();

    out_ << str << " -> ";

    emptyline_ = false;

  }


  void Prefix(const std::string &str) {

    IndentEmptyLine();

    out_ << str << " -> ";

    emptyline_ = false;

  }


  void EndLine() {

    out_ << '\n';

    emptyline_ = true;

  }


  void EndLineIfNonempty() {

    if (!emptyline_) {

      EndLine();

    }

  }


private:

  int indent_{0};

  llvm::raw_ostream &out_;

  const AnalyzedObjectsAsFortran *const asFortran_;

  bool emptyline_{false};

};


template <typename T>

llvm::raw_ostream &DumpTree(llvm::raw_ostream &out, const T &x,

    const AnalyzedObjectsAsFortran *asFortran = nullptr) {

  ParseTreeDumper dumper{out, asFortran};

  Walk(x, dumper);

  return out;

}


} // namespace Fortran::parser

#endif // FORTRAN_PARSER_DUMP_PARSE_TREE_H_

Fortran::common::EnumSet
Definition enum-set.h:28

Fortran::common::Indirection
Definition indirection.h:31

Fortran::parser::CharBlock
Definition char-block.h:26

Fortran::parser::ParseTreeDumper
Definition dump-parse-tree.h:33

Fortran::common
Definition bit-population-count.h:20

Fortran::parser
Definition check-expression.h:19

Fortran::format::ControlEditDesc
Definition format-specification.h:76

Fortran::format::IntrinsicTypeDataEditDesc
Definition format-specification.h:38

Fortran::parser::AcImpliedDoControl
Definition parse-tree.h:1309

Fortran::parser::AcImpliedDo
Definition parse-tree.h:1316

Fortran::parser::AcSpec
Definition parse-tree.h:1280

Fortran::parser::AcValue
Definition parse-tree.h:1268

Fortran::parser::AccAtomicCapture
Definition parse-tree.h:5778

Fortran::parser::AccAtomicRead
Definition parse-tree.h:5754

Fortran::parser::AccAtomicUpdate
Definition parse-tree.h:5770

Fortran::parser::AccAtomicWrite
Definition parse-tree.h:5762

Fortran::parser::AccBeginBlockDirective
Definition parse-tree.h:5739

Fortran::parser::AccBeginCombinedDirective
Definition parse-tree.h:5803

Fortran::parser::AccBeginLoopDirective
Definition parse-tree.h:5733

Fortran::parser::AccBindClause
Definition parse-tree.h:5609

Fortran::parser::AccBlockDirective
Definition parse-tree.h:5582

Fortran::parser::AccClauseList
Definition parse-tree.h:5710

Fortran::parser::AccClause
Definition parse-tree.h:5695

Fortran::parser::AccCollapseArg
Definition parse-tree.h:5690

Fortran::parser::AccCombinedDirective
Definition parse-tree.h:5598

Fortran::parser::AccDataModifier
Definition parse-tree.h:5620

Fortran::parser::AccDeclarativeDirective
Definition parse-tree.h:5603

Fortran::parser::AccDefaultClause
Definition parse-tree.h:5615

Fortran::parser::AccDeviceTypeExprList
Definition parse-tree.h:5647

Fortran::parser::AccDeviceTypeExpr
Definition parse-tree.h:5641

Fortran::parser::AccEndBlockDirective
Definition parse-tree.h:5745

Fortran::parser::AccEndCombinedDirective
Definition parse-tree.h:5809

Fortran::parser::AccGangArgList
Definition parse-tree.h:5686

Fortran::parser::AccGangArg
Definition parse-tree.h:5677

Fortran::parser::AccLoopDirective
Definition parse-tree.h:5587

Fortran::parser::AccObjectListWithModifier
Definition parse-tree.h:5626

Fortran::parser::AccObjectListWithReduction
Definition parse-tree.h:5631

Fortran::parser::AccObject
Definition parse-tree.h:5574

Fortran::parser::AccSelfClause
Definition parse-tree.h:5670

Fortran::parser::AccSizeExprList
Definition parse-tree.h:5666

Fortran::parser::AccSizeExpr
Definition parse-tree.h:5662

Fortran::parser::AccStandaloneDirective
Definition parse-tree.h:5592

Fortran::parser::AccTileExprList
Definition parse-tree.h:5658

Fortran::parser::AccTileExpr
Definition parse-tree.h:5652

Fortran::parser::AccWaitArgument
Definition parse-tree.h:5636

Fortran::parser::AccessSpec
Definition parse-tree.h:902

Fortran::parser::AccessStmt
Definition parse-tree.h:1446

Fortran::parser::ActionStmt
Definition parse-tree.h:500

Fortran::parser::ActualArgSpec
Definition parse-tree.h:3319

Fortran::parser::ActualArg
Definition parse-tree.h:3308

Fortran::parser::AllocOpt
Definition parse-tree.h:2008

Fortran::parser::AllocateCoarraySpec
Definition parse-tree.h:1973

Fortran::parser::AllocateObject
Definition parse-tree.h:1952

Fortran::parser::AllocateShapeSpec
Definition parse-tree.h:1964

Fortran::parser::AllocateStmt
Definition parse-tree.h:2019

Fortran::parser::Allocation
Definition parse-tree.h:1981

Fortran::parser::AnalyzedObjectsAsFortran
Definition unparse.h:41

Fortran::parser::ArithmeticIfStmt
Definition parse-tree.h:3541

Fortran::parser::ArrayElement
Definition parse-tree.h:1938

Fortran::parser::ArraySpec
Definition parse-tree.h:1371

Fortran::parser::AssignStmt
Definition parse-tree.h:3546

Fortran::parser::AssignedGotoStmt
Definition parse-tree.h:3551

Fortran::parser::AssignmentStmt
Definition parse-tree.h:2045

Fortran::parser::AssociateConstruct
Definition parse-tree.h:2200

Fortran::parser::AssociateStmt
Definition parse-tree.h:2191

Fortran::parser::Association
Definition parse-tree.h:2184

Fortran::parser::AssumedSizeSpec
Definition parse-tree.h:1346

Fortran::parser::AttrSpec
Definition parse-tree.h:1407

Fortran::parser::BasedPointer
Definition parse-tree.h:3491

Fortran::parser::BindAttr
Definition parse-tree.h:1120

Fortran::parser::BindEntity
Definition parse-tree.h:1468

Fortran::parser::BindStmt
Definition parse-tree.h:1475

Fortran::parser::BlockConstruct
Definition parse-tree.h:2222

Fortran::parser::BlockData
Definition parse-tree.h:3061

Fortran::parser::BoundsRemapping
Definition parse-tree.h:2055

Fortran::parser::CUDAAttributesStmt
Definition parse-tree.h:3485

Fortran::parser::CUFKernelDoConstruct
Definition parse-tree.h:5879

Fortran::parser::CUFReduction
Definition parse-tree.h:5873

Fortran::parser::CallStmt
Definition parse-tree.h:3343

Fortran::parser::Call
Definition parse-tree.h:3326

Fortran::parser::CaseConstruct
Definition parse-tree.h:2463

Fortran::parser::CaseSelector
Definition parse-tree.h:2445

Fortran::parser::CaseStmt
Definition parse-tree.h:2451

Fortran::parser::CaseValueRange
Definition parse-tree.h:2432

Fortran::parser::ChangeTeamConstruct
Definition parse-tree.h:2253

Fortran::parser::ChangeTeamStmt
Definition parse-tree.h:2238

Fortran::parser::CharLength
Definition parse-tree.h:674

Fortran::parser::CharLiteralConstantSubstring
Definition parse-tree.h:1870

Fortran::parser::CharLiteralConstant
Definition parse-tree.h:861

Fortran::parser::CharSelector
Definition parse-tree.h:690

Fortran::parser::CloseStmt
Definition parse-tree.h:2722

Fortran::parser::CoarrayAssociation
Definition parse-tree.h:2230

Fortran::parser::CoarraySpec
Definition parse-tree.h:977

Fortran::parser::CodimensionDecl
Definition parse-tree.h:1481

Fortran::parser::CoindexedNamedObject
Definition parse-tree.h:1932

Fortran::parser::CommonBlockObject
Definition parse-tree.h:1648

Fortran::parser::CommonStmt
Definition parse-tree.h:1656

Fortran::parser::CompilerDirective::VectorLength
Definition parse-tree.h:3444

Fortran::parser::CompilerDirective
Definition parse-tree.h:3430

Fortran::parser::ComplexLiteralConstant
Definition parse-tree.h:847

Fortran::parser::ComplexPart
Definition parse-tree.h:839

Fortran::parser::ComponentArraySpec
Definition parse-tree.h:988

Fortran::parser::ComponentAttrSpec
Definition parse-tree.h:1001

Fortran::parser::ComponentDecl
Definition parse-tree.h:1032

Fortran::parser::ComponentDefStmt
Definition parse-tree.h:1109

Fortran::parser::ComponentOrFill
Definition parse-tree.h:1054

Fortran::parser::ComponentSpec
Definition parse-tree.h:1204

Fortran::parser::ComputedGotoStmt
Definition parse-tree.h:2550

Fortran::parser::ConcurrentControl
Definition parse-tree.h:2278

Fortran::parser::ConcurrentHeader
Definition parse-tree.h:2287

Fortran::parser::ConditionalArgTail
Definition parse-tree.h:3300

Fortran::parser::ConditionalArg
Definition parse-tree.h:3287

Fortran::parser::ConditionalExpr
Definition parse-tree.h:1727

Fortran::parser::ConnectSpec::CharExpr
Definition parse-tree.h:2700

Fortran::parser::ConnectSpec
Definition parse-tree.h:2698

Fortran::parser::Constant
Definition parse-tree.h:305

Fortran::parser::CriticalConstruct
Definition parse-tree.h:2269

Fortran::parser::CriticalStmt
Definition parse-tree.h:2260

Fortran::parser::DataComponentDefStmt
Definition parse-tree.h:1062

Fortran::parser::DataIDoObject
Definition parse-tree.h:1538

Fortran::parser::DataImpliedDo
Definition parse-tree.h:1550

Fortran::parser::DataRef
Definition parse-tree.h:1848

Fortran::parser::DataStmtConstant
Definition parse-tree.h:1509

Fortran::parser::DataStmtObject
Definition parse-tree.h:1558

Fortran::parser::DataStmtRepeat
Definition parse-tree.h:1524

Fortran::parser::DataStmtSet
Definition parse-tree.h:1564

Fortran::parser::DataStmtValue
Definition parse-tree.h:1530

Fortran::parser::DeallocateStmt
Definition parse-tree.h:2039

Fortran::parser::DeclarationConstruct
Definition parse-tree.h:441

Fortran::parser::DeclarationTypeSpec
Definition parse-tree.h:769

Fortran::parser::DefaultChar
Definition parse-tree.h:329

Fortran::parser::DefinedOperator
Definition parse-tree.h:616

Fortran::parser::DerivedTypeDef
Definition parse-tree.h:1189

Fortran::parser::DerivedTypeSpec
Definition parse-tree.h:750

Fortran::parser::DerivedTypeStmt
Definition parse-tree.h:919

Fortran::parser::Designator
Definition parse-tree.h:1887

Fortran::parser::DimensionStmt
Definition parse-tree.h:1575

Fortran::parser::DoConstruct
Definition parse-tree.h:2365

Fortran::parser::DummyArg
Definition parse-tree.h:3192

Fortran::parser::ElseIfStmt
Definition parse-tree.h:2385

Fortran::parser::EndChangeTeamStmt
Definition parse-tree.h:2247

Fortran::parser::EntityDecl
Definition parse-tree.h:1422

Fortran::parser::EntryStmt
Definition parse-tree.h:3397

Fortran::parser::EnumDef
Definition parse-tree.h:1233

Fortran::parser::EnumerationTypeDef
Definition parse-tree.h:1259

Fortran::parser::EnumerationTypeStmt
Definition parse-tree.h:1242

Fortran::parser::Enumerator
Definition parse-tree.h:1219

Fortran::parser::EventPostStmt
Definition parse-tree.h:2604

Fortran::parser::EventWaitSpec
Definition parse-tree.h:2610

Fortran::parser::EventWaitStmt
Definition parse-tree.h:2618

Fortran::parser::ExecutableConstruct
Definition parse-tree.h:533

Fortran::parser::ExecutionPartConstruct
Definition parse-tree.h:558

Fortran::parser::ExplicitCoshapeSpec
Definition parse-tree.h:971

Fortran::parser::ExplicitShapeBoundsSpec
Definition parse-tree.h:1366

Fortran::parser::ExplicitShapeSpec
Definition parse-tree.h:958

Fortran::parser::Expr
Definition parse-tree.h:1735

Fortran::parser::FillDecl
Definition parse-tree.h:1048

Fortran::parser::ForallAssignmentStmt
Definition parse-tree.h:2141

Fortran::parser::ForallBodyConstruct
Definition parse-tree.h:2157

Fortran::parser::ForallConstructStmt
Definition parse-tree.h:2135

Fortran::parser::ForallConstruct
Definition parse-tree.h:2170

Fortran::parser::ForallStmt
Definition parse-tree.h:2147

Fortran::parser::FormTeamStmt
Definition parse-tree.h:2630

Fortran::parser::Format
Definition parse-tree.h:2734

Fortran::parser::FunctionReference
Definition parse-tree.h:3331

Fortran::parser::FunctionStmt
Definition parse-tree.h:3181

Fortran::parser::FunctionSubprogram
Definition parse-tree.h:3363

Fortran::parser::GenericSpec
Definition parse-tree.h:3074

Fortran::parser::GenericStmt
Definition parse-tree.h:3089

Fortran::parser::HasSource
Definition tools.h:135

Fortran::parser::HasTypedExpr
Definition tools.h:141

Fortran::parser::HollerithLiteralConstant
Definition parse-tree.h:868

Fortran::parser::IfConstruct
Definition parse-tree.h:2399

Fortran::parser::IfStmt
Definition parse-tree.h:2415

Fortran::parser::IfThenStmt
Definition parse-tree.h:2378

Fortran::parser::ImageSelectorSpec
Definition parse-tree.h:1708

Fortran::parser::ImageSelector
Definition parse-tree.h:1718

Fortran::parser::ImplicitPartStmt
Definition parse-tree.h:423

Fortran::parser::ImplicitSpec
Definition parse-tree.h:1632

Fortran::parser::ImplicitStmt
Definition parse-tree.h:1641

Fortran::parser::ImportStmt
Definition parse-tree.h:629

Fortran::parser::Initialization
Definition parse-tree.h:1019

Fortran::parser::InputImpliedDo
Definition parse-tree.h:2833

Fortran::parser::InputItem
Definition parse-tree.h:2777

Fortran::parser::InquireSpec::CharVar
Definition parse-tree.h:2921

Fortran::parser::InquireSpec::IntVar
Definition parse-tree.h:2930

Fortran::parser::InquireSpec::LogVar
Definition parse-tree.h:2935

Fortran::parser::InquireSpec
Definition parse-tree.h:2919

Fortran::parser::InquireStmt
Definition parse-tree.h:2948

Fortran::parser::IntLiteralConstant
Definition parse-tree.h:797

Fortran::parser::Integer
Definition parse-tree.h:313

Fortran::parser::IntentSpec
Definition parse-tree.h:1380

Fortran::parser::IntentStmt
Definition parse-tree.h:1584

Fortran::parser::InterfaceBlock
Definition parse-tree.h:3255

Fortran::parser::InterfaceBody
Definition parse-tree.h:3213

Fortran::parser::InterfaceSpecification
Definition parse-tree.h:3242

Fortran::parser::InterfaceStmt
Definition parse-tree.h:3095

Fortran::parser::InternalSubprogramPart
Definition parse-tree.h:479

Fortran::parser::InternalSubprogram
Definition parse-tree.h:467

Fortran::parser::IntrinsicTypeSpec
Definition parse-tree.h:708

Fortran::parser::IoControlSpec::CharExpr
Definition parse-tree.h:2760

Fortran::parser::IoControlSpec
Definition parse-tree.h:2758

Fortran::parser::IoUnit
Definition parse-tree.h:2669

Fortran::parser::KindParam
Definition parse-tree.h:784

Fortran::parser::KindSelector
Definition parse-tree.h:662

Fortran::parser::LabelDoStmt
Definition parse-tree.h:2342

Fortran::parser::LanguageBindingSpec
Definition parse-tree.h:1325

Fortran::parser::LengthSelector
Definition parse-tree.h:680

Fortran::parser::LetterSpec
Definition parse-tree.h:1626

Fortran::parser::LiteralConstant
Definition parse-tree.h:893

Fortran::parser::LocalitySpec
Definition parse-tree.h:2310

Fortran::parser::LockStmt
Definition parse-tree.h:2644

Fortran::parser::LogicalLiteralConstant
Definition parse-tree.h:875

Fortran::parser::Logical
Definition parse-tree.h:321

Fortran::parser::LoopControl
Definition parse-tree.h:2330

Fortran::parser::MainProgram
Definition parse-tree.h:2969

Fortran::parser::Map
Definition parse-tree.h:3507

Fortran::parser::MaskedElsewhereStmt
Definition parse-tree.h:2102

Fortran::parser::ModuleSubprogramPart
Definition parse-tree.h:2994

Fortran::parser::ModuleSubprogram
Definition parse-tree.h:2983

Fortran::parser::Module
Definition parse-tree.h:3005

Fortran::parser::Name
Definition parse-tree.h:591

Fortran::parser::NamedConstantDef
Definition parse-tree.h:1331

Fortran::parser::NamelistStmt
Definition parse-tree.h:642

Fortran::parser::NonLabelDoStmt
Definition parse-tree.h:2348

Fortran::parser::NotifyWaitStmt
Definition parse-tree.h:2572

Fortran::parser::ObjectDecl
Definition parse-tree.h:1455

Fortran::parser::OmpAbsentClause
Definition parse-tree.h:4391

Fortran::parser::OmpAdjustArgsClause::OmpAdjustOp
Definition parse-tree.h:4397

Fortran::parser::OmpAdjustArgsClause
Definition parse-tree.h:4395

Fortran::parser::OmpAffinityClause
Definition parse-tree.h:4410

Fortran::parser::OmpAlignClause
Definition parse-tree.h:4417

Fortran::parser::OmpAlignedClause
Definition parse-tree.h:4425

Fortran::parser::OmpAllocateClause
Definition parse-tree.h:4440

Fortran::parser::OmpAllocateDirective
Definition parse-tree.h:5397

Fortran::parser::OmpAppendArgsClause
Definition parse-tree.h:4447

Fortran::parser::OmpApplyClause
Definition parse-tree.h:4510

Fortran::parser::OmpAssumeDirective
Definition parse-tree.h:5255

Fortran::parser::OmpAssumesDirective
Definition parse-tree.h:5244

Fortran::parser::OmpAtClause
Definition parse-tree.h:4456

Fortran::parser::OmpAtomicDefaultMemOrderClause
Definition parse-tree.h:4468

Fortran::parser::OmpBeginDirective
Definition parse-tree.h:5186

Fortran::parser::OmpBeginSectionsDirective
Definition parse-tree.h:5261

Fortran::parser::OmpBindClause
Definition parse-tree.h:4479

Fortran::parser::OmpBlockConstruct
Definition parse-tree.h:5196

Fortran::parser::OmpCancellationConstructTypeClause
Definition parse-tree.h:4485

Fortran::parser::OmpClauseList
Definition parse-tree.h:5155

Fortran::parser::OmpClause
Definition parse-tree.h:5139

Fortran::parser::OmpCombinerClause
Definition parse-tree.h:4494

Fortran::parser::OmpCombinerExpression
Definition parse-tree.h:3686

Fortran::parser::OmpContainsClause
Definition parse-tree.h:4502

Fortran::parser::OmpDeclareMapperDirective
Definition parse-tree.h:5324

Fortran::parser::OmpDeclareReductionDirective
Definition parse-tree.h:5333

Fortran::parser::OmpDeclareSimdDirective
Definition parse-tree.h:5341

Fortran::parser::OmpDeclareTargetDirective
Definition parse-tree.h:5316

Fortran::parser::OmpDeclareVariantDirective
Definition parse-tree.h:5304

Fortran::parser::OmpDefaultClause
Definition parse-tree.h:4529

Fortran::parser::OmpDefaultmapClause
Definition parse-tree.h:4547

Fortran::parser::OmpDelimitedMetadirectiveDirective
Definition parse-tree.h:5214

Fortran::parser::OmpDependClause::TaskDep
Definition parse-tree.h:4606

Fortran::parser::OmpDependClause
Definition parse-tree.h:4604

Fortran::parser::OmpDestroyClause
Definition parse-tree.h:4628

Fortran::parser::OmpDetachClause
Definition parse-tree.h:4636

Fortran::parser::OmpDeviceClause
Definition parse-tree.h:4646

Fortran::parser::OmpDeviceSafesyncClause
Definition parse-tree.h:4656

Fortran::parser::OmpDeviceTypeClause
Definition parse-tree.h:4664

Fortran::parser::OmpDirectiveName
Definition parse-tree.h:3577

Fortran::parser::OmpDirectiveSpecification
Definition parse-tree.h:5162

Fortran::parser::OmpDoacrossClause
Definition parse-tree.h:4619

Fortran::parser::OmpDoacross
Definition parse-tree.h:4586

Fortran::parser::OmpDynGroupprivateClause
Definition parse-tree.h:4679

Fortran::parser::OmpDynamicAllocatorsClause
Definition parse-tree.h:4674

Fortran::parser::OmpEndDirective
Definition parse-tree.h:5191

Fortran::parser::OmpEndSectionsDirective
Definition parse-tree.h:5266

Fortran::parser::OmpEnterClause
Definition parse-tree.h:4690

Fortran::parser::OmpErrorDirective
Definition parse-tree.h:5229

Fortran::parser::OmpFailClause
Definition parse-tree.h:4698

Fortran::parser::OmpFromClause
Definition parse-tree.h:4711

Fortran::parser::OmpGrainsizeClause
Definition parse-tree.h:4722

Fortran::parser::OmpGraphIdClause
Definition parse-tree.h:4732

Fortran::parser::OmpGraphResetClause
Definition parse-tree.h:4740

Fortran::parser::OmpGroupprivateDirective
Definition parse-tree.h:5350

Fortran::parser::OmpHintClause
Definition parse-tree.h:4745

Fortran::parser::OmpHoldsClause
Definition parse-tree.h:4753

Fortran::parser::OmpIfClause
Definition parse-tree.h:4769

Fortran::parser::OmpInReductionClause
Definition parse-tree.h:4792

Fortran::parser::OmpIndirectClause
Definition parse-tree.h:4758

Fortran::parser::OmpInitClause
Definition parse-tree.h:4782

Fortran::parser::OmpInitializerClause
Definition parse-tree.h:4799

Fortran::parser::OmpInitializerExpression
Definition parse-tree.h:3698

Fortran::parser::OmpIterationOffset
Definition parse-tree.h:4559

Fortran::parser::OmpIterationVector
Definition parse-tree.h:4577

Fortran::parser::OmpIteration
Definition parse-tree.h:4568

Fortran::parser::OmpLastprivateClause
Definition parse-tree.h:4808

Fortran::parser::OmpLinearClause
Definition parse-tree.h:4823

Fortran::parser::OmpLocator
Definition parse-tree.h:3611

Fortran::parser::OmpLooprangeClause
Definition parse-tree.h:4834

Fortran::parser::OmpMapClause
Definition parse-tree.h:4859

Fortran::parser::OmpMatchClause
Definition parse-tree.h:4871

Fortran::parser::OmpMessageClause
Definition parse-tree.h:4880

Fortran::parser::OmpMetadirectiveDirective
Definition parse-tree.h:5209

Fortran::parser::OmpNothingDirective
Definition parse-tree.h:5223

Fortran::parser::OmpNumTasksClause
Definition parse-tree.h:4904

Fortran::parser::OmpNumTeamsClause
Definition parse-tree.h:4916

Fortran::parser::OmpNumThreadsClause
Definition parse-tree.h:4928

Fortran::parser::OmpObjectList
Definition parse-tree.h:3632

Fortran::parser::OmpObject::Invalid
Definition parse-tree.h:3623

Fortran::parser::OmpObject
Definition parse-tree.h:3620

Fortran::parser::OmpOrderClause
Definition parse-tree.h:4939

Fortran::parser::OmpOtherwiseClause
Definition parse-tree.h:4952

Fortran::parser::OmpProcBindClause
Definition parse-tree.h:4964

Fortran::parser::OmpReductionClause
Definition parse-tree.h:4975

Fortran::parser::OmpReductionIdentifier
Definition parse-tree.h:3676

Fortran::parser::OmpReplayableClause
Definition parse-tree.h:4985

Fortran::parser::OmpRequiresDirective
Definition parse-tree.h:5357

Fortran::parser::OmpReservedIdentifier
Definition parse-tree.h:3606

Fortran::parser::OmpReverseOffloadClause
Definition parse-tree.h:4994

Fortran::parser::OmpScheduleClause
Definition parse-tree.h:5006

Fortran::parser::OmpSectionDirective
Definition parse-tree.h:5275

Fortran::parser::OmpSelfMapsClause
Definition parse-tree.h:5017

Fortran::parser::OmpSeverityClause
Definition parse-tree.h:5024

Fortran::parser::OmpStylizedDeclaration
Definition parse-tree.h:3636

Fortran::parser::OmpStylizedExpression
Definition parse-tree.h:3658

Fortran::parser::OmpStylizedInstance
Definition parse-tree.h:3645

Fortran::parser::OmpTaskReductionClause
Definition parse-tree.h:5033

Fortran::parser::OmpThreadLimitClause
Definition parse-tree.h:5044

Fortran::parser::OmpThreadprivateDirective
Definition parse-tree.h:5363

Fortran::parser::OmpThreadsetClause
Definition parse-tree.h:5053

Fortran::parser::OmpToClause
Definition parse-tree.h:5068

Fortran::parser::OmpTransparentClause
Definition parse-tree.h:5078

Fortran::parser::OmpTypeNameList
Definition parse-tree.h:3602

Fortran::parser::OmpTypeName
Definition parse-tree.h:3595

Fortran::parser::OmpUnifiedAddressClause
Definition parse-tree.h:5087

Fortran::parser::OmpUnifiedSharedMemoryClause
Definition parse-tree.h:5096

Fortran::parser::OmpUpdateClause
Definition parse-tree.h:5112

Fortran::parser::OmpUseClause
Definition parse-tree.h:5134

Fortran::parser::OmpUtilityDirective
Definition parse-tree.h:5233

Fortran::parser::OmpWhenClause
Definition parse-tree.h:5123

Fortran::parser::Only
Definition parse-tree.h:3105

Fortran::parser::OpenACCAtomicConstruct
Definition parse-tree.h:5785

Fortran::parser::OpenACCBlockConstruct
Definition parse-tree.h:5792

Fortran::parser::OpenACCCacheConstruct
Definition parse-tree.h:5721

Fortran::parser::OpenACCCombinedConstruct
Definition parse-tree.h:5814

Fortran::parser::OpenACCConstruct
Definition parse-tree.h:5853

Fortran::parser::OpenACCDeclarativeConstruct
Definition parse-tree.h:5824

Fortran::parser::OpenACCEndConstruct
Definition parse-tree.h:5842

Fortran::parser::OpenACCLoopConstruct
Definition parse-tree.h:5833

Fortran::parser::OpenACCRoutineConstruct
Definition parse-tree.h:5715

Fortran::parser::OpenACCStandaloneConstruct
Definition parse-tree.h:5847

Fortran::parser::OpenACCStandaloneDeclarativeConstruct
Definition parse-tree.h:5797

Fortran::parser::OpenACCWaitConstruct
Definition parse-tree.h:5727

Fortran::parser::OpenMPAllocatorsConstruct
Definition parse-tree.h:5423

Fortran::parser::OpenMPAtomicConstruct
Definition parse-tree.h:5428

Fortran::parser::OpenMPCancelConstruct
Definition parse-tree.h:5465

Fortran::parser::OpenMPCancellationPointConstruct
Definition parse-tree.h:5458

Fortran::parser::OpenMPConstruct
Definition parse-tree.h:5549

Fortran::parser::OpenMPCriticalConstruct
Definition parse-tree.h:5413

Fortran::parser::OpenMPDeclarativeConstruct
Definition parse-tree.h:5401

Fortran::parser::OpenMPDepobjConstruct
Definition parse-tree.h:5476

Fortran::parser::OpenMPDispatchConstruct
Definition parse-tree.h:5490

Fortran::parser::OpenMPFlushConstruct
Definition parse-tree.h:5506

Fortran::parser::OpenMPInteropConstruct
Definition parse-tree.h:5514

Fortran::parser::OpenMPInvalidDirective
Definition parse-tree.h:5567

Fortran::parser::OpenMPLoopConstruct
Definition parse-tree.h:5535

Fortran::parser::OpenMPMisplacedEndDirective
Definition parse-tree.h:5561

Fortran::parser::OpenMPSectionsConstruct
Definition parse-tree.h:5281

Fortran::parser::OpenMPSimpleStandaloneConstruct
Definition parse-tree.h:5519

Fortran::parser::OpenMPStandaloneConstruct
Definition parse-tree.h:5525

Fortran::parser::OtherSpecificationStmt
Definition parse-tree.h:378

Fortran::parser::OutputImpliedDo
Definition parse-tree.h:2838

Fortran::parser::OutputItem
Definition parse-tree.h:2801

Fortran::parser::ParentIdentifier
Definition parse-tree.h:3030

Fortran::parser::PointerAssignmentStmt
Definition parse-tree.h:2067

Fortran::parser::PointerDecl
Definition parse-tree.h:1594

Fortran::parser::PointerObject
Definition parse-tree.h:2028

Fortran::parser::PositionOrFlushSpec
Definition parse-tree.h:2864

Fortran::parser::PrefixSpec
Definition parse-tree.h:3150

Fortran::parser::PrintStmt
Definition parse-tree.h:2822

Fortran::parser::PrivateOrSequence
Definition parse-tree.h:932

Fortran::parser::ProcAttrSpec
Definition parse-tree.h:3128

Fortran::parser::ProcComponentAttrSpec
Definition parse-tree.h:1073

Fortran::parser::ProcComponentDefStmt
Definition parse-tree.h:1101

Fortran::parser::ProcComponentRef
Definition parse-tree.h:1927

Fortran::parser::ProcDecl
Definition parse-tree.h:1093

Fortran::parser::ProcInterface
Definition parse-tree.h:1087

Fortran::parser::ProcPointerInit
Definition parse-tree.h:1080

Fortran::parser::ProcedureDeclarationStmt
Definition parse-tree.h:3138

Fortran::parser::ProcedureDesignator
Definition parse-tree.h:3270

Fortran::parser::ProcedureStmt
Definition parse-tree.h:3231

Fortran::parser::ProgramUnit
Definition parse-tree.h:575

Fortran::parser::ReadStmt
Definition parse-tree.h:2785

Fortran::parser::RealLiteralConstant
Definition parse-tree.h:816

Fortran::parser::ReductionOperator
Definition parse-tree.h:2299

Fortran::parser::Rename
Definition parse-tree.h:3016

Fortran::parser::SavedEntity
Definition parse-tree.h:1607

Fortran::parser::Scalar
Definition parse-tree.h:297

Fortran::parser::SectionSubscript
Definition parse-tree.h:1693

Fortran::parser::SelectCaseStmt
Definition parse-tree.h:2422

Fortran::parser::SelectRankCaseStmt
Definition parse-tree.h:2486

Fortran::parser::SelectRankConstruct
Definition parse-tree.h:2498

Fortran::parser::SelectRankStmt
Definition parse-tree.h:2477

Fortran::parser::SelectTypeConstruct
Definition parse-tree.h:2532

Fortran::parser::SelectTypeStmt
Definition parse-tree.h:2512

Fortran::parser::Selector
Definition parse-tree.h:2178

Fortran::parser::SeparateModuleSubprogram
Definition parse-tree.h:3389

Fortran::parser::SignedComplexLiteralConstant
Definition parse-tree.h:853

Fortran::parser::SignedIntLiteralConstant
Definition parse-tree.h:790

Fortran::parser::SignedRealLiteralConstant
Definition parse-tree.h:828

Fortran::parser::SpecificationConstruct
Definition parse-tree.h:401

Fortran::parser::SpecificationPart
Definition parse-tree.h:455

Fortran::parser::StatOrErrmsg
Definition parse-tree.h:1997

Fortran::parser::Statement
Definition parse-tree.h:361

Fortran::parser::StmtFunctionStmt
Definition parse-tree.h:3407

Fortran::parser::StopStmt
Definition parse-tree.h:2564

Fortran::parser::StructureComponent
Definition parse-tree.h:1917

Fortran::parser::StructureConstructor
Definition parse-tree.h:1210

Fortran::parser::StructureDef
Definition parse-tree.h:3528

Fortran::parser::StructureField
Definition parse-tree.h:3500

Fortran::parser::StructureStmt
Definition parse-tree.h:3523

Fortran::parser::SubmoduleStmt
Definition parse-tree.h:3036

Fortran::parser::Submodule
Definition parse-tree.h:3047

Fortran::parser::SubroutineStmt
Definition parse-tree.h:3200

Fortran::parser::SubroutineSubprogram
Definition parse-tree.h:3373

Fortran::parser::SubscriptTriplet
Definition parse-tree.h:1684

Fortran::parser::SubstringInquiry
Definition parse-tree.h:1879

Fortran::parser::SubstringRange
Definition parse-tree.h:1675

Fortran::parser::Substring
Definition parse-tree.h:1865

Fortran::parser::Suffix
Definition parse-tree.h:3170

Fortran::parser::SyncImagesStmt
Definition parse-tree.h:2582

Fortran::parser::SyncTeamStmt
Definition parse-tree.h:2595

Fortran::parser::TypeAttrSpec
Definition parse-tree.h:910

Fortran::parser::TypeBoundGenericStmt
Definition parse-tree.h:1153

Fortran::parser::TypeBoundProcBinding
Definition parse-tree.h:1166

Fortran::parser::TypeBoundProcDecl
Definition parse-tree.h:1128

Fortran::parser::TypeBoundProcedurePart
Definition parse-tree.h:1175

Fortran::parser::TypeBoundProcedureStmt
Definition parse-tree.h:1138

Fortran::parser::TypeDeclarationStmt
Definition parse-tree.h:1436

Fortran::parser::TypeGuardStmt
Definition parse-tree.h:2521

Fortran::parser::TypeParamDecl
Definition parse-tree.h:938

Fortran::parser::TypeParamDefStmt
Definition parse-tree.h:946

Fortran::parser::TypeParamSpec
Definition parse-tree.h:744

Fortran::parser::TypeParamValue
Definition parse-tree.h:653

Fortran::parser::TypeSpec
Definition parse-tree.h:757

Fortran::parser::Union
Definition parse-tree.h:3516

Fortran::parser::UnlabeledStatement
Definition parse-tree.h:356

Fortran::parser::UnlockStmt
Definition parse-tree.h:2654

Fortran::parser::UnsignedLiteralConstant
Definition parse-tree.h:803

Fortran::parser::UseStmt
Definition parse-tree.h:3114

Fortran::parser::Variable
Definition parse-tree.h:1895

Fortran::parser::VectorElementType
Definition parse-tree.h:730

Fortran::parser::VectorTypeSpec
Definition parse-tree.h:735

Fortran::parser::Verbatim
Definition parse-tree.h:284

Fortran::parser::WaitSpec
Definition parse-tree.h:2848

Fortran::parser::WhereBodyConstruct
Definition parse-tree.h:2093

Fortran::parser::WhereConstructStmt
Definition parse-tree.h:2086

Fortran::parser::WhereConstruct
Definition parse-tree.h:2117

Fortran::parser::WhereStmt
Definition parse-tree.h:2080

Fortran::parser::WriteStmt
Definition parse-tree.h:2807

Fortran::parser::OmpArgumentList
Definition parse-tree.h:3751

Fortran::parser::OmpArgument
Definition parse-tree.h:3742

Fortran::parser::OmpBaseVariantNames
Definition parse-tree.h:3712

Fortran::parser::OmpMapperSpecifier
Definition parse-tree.h:3722

Fortran::parser::OmpReductionSpecifier
Definition parse-tree.h:3735

Fortran::parser::OmpAccessGroup
Definition parse-tree.h:3906

Fortran::parser::OmpAlignModifier
Definition parse-tree.h:3923

Fortran::parser::OmpAlignment
Definition parse-tree.h:3915

Fortran::parser::OmpAllocatorComplexModifier
Definition parse-tree.h:3939

Fortran::parser::OmpAllocatorSimpleModifier
Definition parse-tree.h:3931

Fortran::parser::OmpAlwaysModifier
Definition parse-tree.h:3951

Fortran::parser::OmpAttachModifier
Definition parse-tree.h:3963

Fortran::parser::OmpAutomapModifier
Definition parse-tree.h:3973

Fortran::parser::OmpChunkModifier
Definition parse-tree.h:3984

Fortran::parser::OmpCloseModifier
Definition parse-tree.h:3997

Fortran::parser::OmpDeleteModifier
Definition parse-tree.h:4009

Fortran::parser::OmpDependenceType
Definition parse-tree.h:4030

Fortran::parser::OmpDepinfoModifier
Definition parse-tree.h:4041

Fortran::parser::OmpDeviceModifier
Definition parse-tree.h:4051

Fortran::parser::OmpDimsModifier
Definition parse-tree.h:4060

Fortran::parser::OmpExpectation
Definition parse-tree.h:4092

Fortran::parser::OmpFallbackModifier
Definition parse-tree.h:4103

Fortran::parser::OmpInteropType
Definition parse-tree.h:4114

Fortran::parser::OmpIteratorSpecifier
Definition parse-tree.h:4126

Fortran::parser::OmpIterator
Definition parse-tree.h:4136

Fortran::parser::OmpLastprivateModifier
Definition parse-tree.h:4144

Fortran::parser::OmpLinearModifier
Definition parse-tree.h:4153

Fortran::parser::OmpLoopModifier
Definition parse-tree.h:4168

Fortran::parser::OmpLowerBound
Definition parse-tree.h:4180

Fortran::parser::OmpMapTypeModifier
Definition parse-tree.h:4214

Fortran::parser::OmpMapType
Definition parse-tree.h:4201

Fortran::parser::OmpMapper
Definition parse-tree.h:4188

Fortran::parser::OmpOrderModifier
Definition parse-tree.h:4238

Fortran::parser::OmpOrderingModifier
Definition parse-tree.h:4229

Fortran::parser::OmpPreferType
Definition parse-tree.h:4272

Fortran::parser::OmpPreferenceSelector
Definition parse-tree.h:4248

Fortran::parser::OmpPreferenceSpecification
Definition parse-tree.h:4261

Fortran::parser::OmpPrescriptiveness
Definition parse-tree.h:4281

Fortran::parser::OmpPresentModifier
Definition parse-tree.h:4294

Fortran::parser::OmpReductionModifier
Definition parse-tree.h:4303

Fortran::parser::OmpRefModifier
Definition parse-tree.h:4313

Fortran::parser::OmpSelfModifier
Definition parse-tree.h:4323

Fortran::parser::OmpStepComplexModifier
Definition parse-tree.h:4332

Fortran::parser::OmpStepSimpleModifier
Definition parse-tree.h:4340

Fortran::parser::OmpTaskDependenceType
Definition parse-tree.h:4350

Fortran::parser::OmpVariableCategory
Definition parse-tree.h:4361

Fortran::parser::OmpxHoldModifier
Definition parse-tree.h:4374

Fortran::parser::OmpContextSelectorSpecification
Definition parse-tree.h:3882

Fortran::parser::OmpTraitPropertyExtension
Definition parse-tree.h:3789

Fortran::parser::OmpTraitPropertyName
Definition parse-tree.h:3772

Fortran::parser::OmpTraitProperty
Definition parse-tree.h:3813

Fortran::parser::OmpTraitScore
Definition parse-tree.h:3779

Fortran::parser::OmpTraitSelectorName
Definition parse-tree.h:3840

Fortran::parser::OmpTraitSelector
Definition parse-tree.h:3852

Fortran::parser::OmpTraitSetSelectorName
Definition parse-tree.h:3865

Fortran::parser::OmpTraitSetSelector
Definition parse-tree.h:3874