9#ifndef FORTRAN_PARSER_PARSE_TREE_H_
10#define FORTRAN_PARSER_PARSE_TREE_H_
20#include "char-block.h"
21#include "characters.h"
22#include "format-specification.h"
24#include "provenance.h"
25#include "flang/Common/idioms.h"
26#include "flang/Common/indirection.h"
27#include "flang/Support/Fortran.h"
28#include "llvm/Frontend/OpenACC/ACC.h.inc"
29#include "llvm/Frontend/OpenMP/OMP.h"
30#include "llvm/Frontend/OpenMP/OMPConstants.h"
51CLASS_TRAIT(EmptyTrait)
52CLASS_TRAIT(WrapperTrait)
53CLASS_TRAIT(UnionTrait)
54CLASS_TRAIT(TupleTrait)
55CLASS_TRAIT(ConstraintTrait)
60namespace Fortran::semantics {
69struct GenericExprWrapper;
70struct GenericAssignmentWrapper;
77#define COPY_AND_ASSIGN_BOILERPLATE(classname) \
78 classname(classname &&) = default; \
79 classname &operator=(classname &&) = default; \
80 classname(const classname &) = delete; \
81 classname &operator=(const classname &) = delete
84#define BOILERPLATE(classname) \
85 COPY_AND_ASSIGN_BOILERPLATE(classname); \
90#define EMPTY_CLASS(classname) \
93 classname(const classname &) {} \
94 classname(classname &&) {} \
95 classname &operator=(const classname &) { return *this; }; \
96 classname &operator=(classname &&) { return *this; }; \
97 using EmptyTrait = std::true_type; \
102#define UNION_CLASS_BOILERPLATE(classname) \
103 template <typename A, typename = common::NoLvalue<A>> \
104 classname(A &&x) : u(std::move(x)) {} \
105 using UnionTrait = std::true_type; \
106 BOILERPLATE(classname)
110#define TUPLE_CLASS_BOILERPLATE(classname) \
111 template <typename... Ts, typename = common::NoLvalue<Ts...>> \
112 classname(Ts &&...args) : t(std::move(args)...) {} \
113 using TupleTrait = std::true_type; \
114 BOILERPLATE(classname)
118#define WRAPPER_CLASS_BOILERPLATE(classname, type) \
119 BOILERPLATE(classname); \
120 classname(type &&x) : v(std::move(x)) {} \
121 using WrapperTrait = std::true_type; \
124#define WRAPPER_CLASS(classname, type) \
126 WRAPPER_CLASS_BOILERPLATE(classname, type); \
135struct SpecificationPart;
136struct ExecutableConstruct;
143struct WhereConstruct;
144struct ForallConstruct;
145struct InputImpliedDo;
146struct OutputImpliedDo;
147struct FunctionReference;
148struct FunctionSubprogram;
149struct SubroutineSubprogram;
154struct DerivedTypeDef;
156struct TypeDeclarationStmt;
158struct AllocatableStmt;
159struct AsynchronousStmt;
161struct CodimensionStmt;
162struct ContiguousStmt;
169struct OldParameterStmt;
179struct EquivalenceStmt;
182struct CharLiteralConstantSubstring;
183struct SubstringInquiry;
185struct StructureComponent;
186struct CoindexedNamedObject;
190struct DeallocateStmt;
191struct AssignmentStmt;
192struct PointerAssignmentStmt;
195struct AssociateConstruct;
196struct BlockConstruct;
197struct ChangeTeamConstruct;
198struct CriticalConstruct;
201struct ConcurrentHeader;
207struct SelectRankConstruct;
208struct SelectTypeConstruct;
211struct ComputedGotoStmt;
213struct NotifyWaitStmt;
215struct SyncImagesStmt;
216struct SyncMemoryStmt;
241struct InterfaceBlock;
245struct ProcedureDeclarationStmt;
249struct ProcedureDesignator;
251struct SeparateModuleSubprogram;
254struct StmtFunctionStmt;
257struct CompilerDirective;
258struct BasedPointerStmt;
259struct CUDAAttributesStmt;
261struct ArithmeticIfStmt;
263struct AssignedGotoStmt;
265struct OpenACCConstruct;
266struct AccEndCombinedDirective;
267struct OpenACCDeclarativeConstruct;
268struct OpenACCRoutineConstruct;
269struct OpenMPConstruct;
270struct OpenMPLoopConstruct;
271struct OpenMPDeclarativeConstruct;
272struct OmpEndLoopDirective;
273struct CUFKernelDoConstruct;
276using Location =
const char *;
282 COPY_AND_ASSIGN_BOILERPLATE(
Verbatim);
283 using EmptyTrait = std::true_type;
293 using ConstraintTrait = std::true_type;
295 Scalar(A &&that) : thing(std::move(that)) {}
301 using ConstraintTrait = std::true_type;
303 Constant(A &&that) : thing(std::move(that)) {}
309 using ConstraintTrait = std::true_type;
311 Integer(A &&that) : thing(std::move(that)) {}
317 using ConstraintTrait = std::true_type;
319 Logical(A &&that) : thing(std::move(that)) {}
325 using ConstraintTrait = std::true_type;
346using Label = common::Label;
356 Statement(std::optional<long> &&lab, A &&s)
358 std::optional<Label> label;
362EMPTY_CLASS(ErrorRecovery);
374 std::variant<common::Indirection<AccessStmt>,
396 std::variant<common::Indirection<DerivedTypeDef>,
415 std::variant<Statement<common::Indirection<ImplicitStmt>>,
426WRAPPER_CLASS(ImplicitPart, std::list<ImplicitPartStmt>);
433 std::variant<SpecificationConstruct, Statement<common::Indirection<DataStmt>>,
447 std::tuple<std::list<OpenACCDeclarativeConstruct>,
448 std::list<OpenMPDeclarativeConstruct>,
449 std::list<common::Indirection<CompilerDirective>>,
450 std::list<Statement<common::Indirection<UseStmt>>>,
451 std::list<Statement<common::Indirection<ImportStmt>>>, ImplicitPart,
452 std::list<DeclarationConstruct>>
459 std::variant<common::Indirection<FunctionSubprogram>,
466EMPTY_CLASS(ContainsStmt);
471 std::tuple<Statement<ContainsStmt>, std::list<InternalSubprogram>> t;
475EMPTY_CLASS(ContinueStmt);
478EMPTY_CLASS(FailImageStmt);
492 std::variant<common::Indirection<AllocateStmt>,
549 std::variant<ExecutableConstruct, Statement<common::Indirection<FormatStmt>>,
558using Block = std::list<ExecutionPartConstruct>;
559WRAPPER_CLASS(ExecutionPart, Block);
566 std::variant<common::Indirection<MainProgram>,
577WRAPPER_CLASS(Program, std::list<ProgramUnit>);
581 std::string ToString()
const {
return source.ToString(); }
587WRAPPER_CLASS(Keyword,
Name);
590WRAPPER_CLASS(NamedConstant,
Name);
597WRAPPER_CLASS(DefinedOpName,
Name);
607 ENUM_CLASS(IntrinsicOperator, Power, Multiply, Divide, Add, Subtract, Concat,
608 LT, LE, EQ, NE, GE, GT, NOT, AND, OR, EQV, NEQV)
609 std::variant<DefinedOpName, IntrinsicOperator> u;
620 ImportStmt(common::ImportKind &&k) : kind{k} {}
621 ImportStmt(std::list<Name> &&n) : names(std::move(n)) {}
622 ImportStmt(common::ImportKind &&, std::list<Name> &&);
623 common::ImportKind kind{common::ImportKind::Default};
624 std::list<Name> names;
633 TUPLE_CLASS_BOILERPLATE(
Group);
634 std::tuple<Name, std::list<Name>> t;
636 WRAPPER_CLASS_BOILERPLATE(
NamelistStmt, std::list<Group>);
644 EMPTY_CLASS(Deferred);
645 std::variant<ScalarIntExpr, Star, Deferred> u;
653 WRAPPER_CLASS(StarSize, std::uint64_t);
654 std::variant<ScalarIntConstantExpr, StarSize> u;
658WRAPPER_CLASS(IntegerTypeSpec, std::optional<KindSelector>);
660WRAPPER_CLASS(UnsignedTypeSpec, std::optional<KindSelector>);
665 std::variant<TypeParamValue, std::uint64_t> u;
671 std::variant<TypeParamValue, CharLength> u;
684 : length(std::move(l)), kind(std::move(k)) {}
685 std::optional<TypeParamValue> length;
689 : u{
LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
691 : u{LengthAndKind{std::move(l), std::move(k)}} {}
692 std::variant<LengthSelector, LengthAndKind> u;
704 Real(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
705 std::optional<KindSelector> kind;
707 EMPTY_CLASS(DoublePrecision);
710 Complex(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
711 std::optional<KindSelector> kind;
715 Character(std::optional<CharSelector> &&s) : selector{std::move(s)} {}
716 std::optional<CharSelector> selector;
720 Logical(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
721 std::optional<KindSelector> kind;
723 EMPTY_CLASS(DoubleComplex);
724 std::variant<IntegerTypeSpec, UnsignedTypeSpec,
Real, DoublePrecision,
732 std::variant<IntegerTypeSpec, IntrinsicTypeSpec::Real, UnsignedTypeSpec> u;
737 EMPTY_CLASS(PairVectorTypeSpec);
738 EMPTY_CLASS(QuadVectorTypeSpec);
739 std::variant<IntrinsicVectorTypeSpec, PairVectorTypeSpec, QuadVectorTypeSpec>
753 std::tuple<Name, std::list<TypeParamSpec>> t;
760 std::variant<IntrinsicTypeSpec, DerivedTypeSpec> u;
780 EMPTY_CLASS(ClassStar);
781 EMPTY_CLASS(TypeStar);
782 WRAPPER_CLASS(Record,
Name);
791 std::variant<std::uint64_t, Scalar<Integer<Constant<Name>>>> u;
798 std::tuple<CharBlock, std::optional<KindParam>> t;
804 std::tuple<CharBlock, std::optional<KindParam>> t;
810 std::tuple<CharBlock, std::optional<KindParam>> t;
814enum class Sign { Positive, Negative };
824 COPY_AND_ASSIGN_BOILERPLATE(
Real);
829 : real{std::move(r)}, kind{std::move(k)} {}
831 std::optional<KindParam> kind;
856 std::tuple<ComplexPart, ComplexPart> t;
862 std::tuple<Sign, ComplexLiteralConstant> t;
870 std::tuple<std::optional<KindParam>, std::string> t;
871 std::string GetString()
const {
return std::get<std::string>(t); }
877 std::string GetString()
const {
return v; }
884 std::tuple<bool, std::optional<KindParam>> t;
894WRAPPER_CLASS(BOZLiteralConstant, std::string);
910 ENUM_CLASS(Kind, Public, Private)
916EMPTY_CLASS(Abstract);
920 WRAPPER_CLASS(Extends,
Name);
921 std::variant<Abstract, AccessSpec, BindC, Extends> u;
928 std::tuple<std::list<TypeAttrSpec>,
Name, std::list<Name>> t;
932EMPTY_CLASS(SequenceStmt);
936EMPTY_CLASS(PrivateStmt);
941 std::variant<PrivateStmt, SequenceStmt> u;
947 std::tuple<Name, std::optional<ScalarIntConstantExpr>> t;
955 std::tuple<IntegerTypeSpec, common::TypeParamAttr, std::list<TypeParamDecl>>
967 std::tuple<std::optional<SpecificationExpr>, SpecificationExpr> t;
972WRAPPER_CLASS(DeferredCoshapeSpecList,
int);
980 std::tuple<std::list<ExplicitShapeSpec>, std::optional<SpecificationExpr>> t;
986 std::variant<DeferredCoshapeSpecList, ExplicitCoshapeSpec> u;
991WRAPPER_CLASS(DeferredShapeSpecList,
int);
997 std::variant<std::list<ExplicitShapeSpec>, DeferredShapeSpecList> u;
1005EMPTY_CLASS(Allocatable);
1006EMPTY_CLASS(Pointer);
1007EMPTY_CLASS(Contiguous);
1029 std::list<common::Indirection<DataStmtValue>>>
1042 std::optional<ComponentArraySpec> &&aSpec,
1043 std::optional<CoarraySpec> &&coaSpec,
1044 std::optional<Initialization> &&init)
1045 : t{std::move(name), std::move(aSpec), std::move(coaSpec),
1046 std::move(length), std::move(init)} {}
1047 std::tuple<Name, std::optional<ComponentArraySpec>,
1048 std::optional<CoarraySpec>, std::optional<CharLength>,
1049 std::optional<Initialization>>
1057 std::tuple<Name, std::optional<ComponentArraySpec>, std::optional<CharLength>>
1063 std::variant<ComponentDecl, FillDecl> u;
1071 std::tuple<DeclarationTypeSpec, std::list<ComponentAttrSpec>,
1072 std::list<ComponentOrFill>>
1079WRAPPER_CLASS(Pass, std::optional<Name>);
1082 std::variant<AccessSpec, NoPass, Pass, Pointer> u;
1089 std::variant<NullInit, Name> u;
1096 std::variant<Name, DeclarationTypeSpec> u;
1102 std::tuple<Name, std::optional<ProcPointerInit>> t;
1110 std::tuple<std::optional<ProcInterface>, std::list<ProcComponentAttrSpec>,
1111 std::list<ProcDecl>>
1129 EMPTY_CLASS(Deferred);
1130 EMPTY_CLASS(Non_Overridable);
1131 std::variant<AccessSpec, Deferred, Non_Overridable, NoPass, Pass> u;
1137 std::tuple<Name, std::optional<Name>> t;
1150 std::list<BindAttr> &&as, std::list<TypeBoundProcDecl> &&ds)
1151 : attributes(std::move(as)), declarations(std::move(ds)) {}
1152 std::list<BindAttr> attributes;
1153 std::list<TypeBoundProcDecl> declarations;
1158 : interfaceName(std::move(n)), attributes(std::move(as)),
1159 bindingNames(std::move(bs)) {}
1161 std::list<BindAttr> attributes;
1162 std::list<Name> bindingNames;
1164 std::variant<WithoutInterface, WithInterface> u;
1177WRAPPER_CLASS(FinalProcedureStmt, std::list<Name>);
1193 std::tuple<Statement<ContainsStmt>, std::optional<Statement<PrivateStmt>>,
1194 std::list<Statement<TypeBoundProcBinding>>>
1199WRAPPER_CLASS(EndTypeStmt, std::optional<Name>);
1207 std::tuple<Statement<DerivedTypeStmt>, std::list<Statement<TypeParamDefStmt>>,
1208 std::list<Statement<PrivateOrSequence>>,
1209 std::list<Statement<ComponentDefStmt>>,
1222 std::tuple<std::optional<Keyword>, ComponentDataSource> t;
1228 std::tuple<DerivedTypeSpec, std::list<ComponentSpec>> t;
1232EMPTY_CLASS(EnumDefStmt);
1237 std::tuple<NamedConstant, std::optional<ScalarIntConstantExpr>> t;
1241WRAPPER_CLASS(EnumeratorDefStmt, std::list<Enumerator>);
1244EMPTY_CLASS(EndEnumStmt);
1250 TUPLE_CLASS_BOILERPLATE(
EnumDef);
1251 std::tuple<Statement<EnumDefStmt>, std::list<Statement<EnumeratorDefStmt>>,
1259 TUPLE_CLASS_BOILERPLATE(
Triplet);
1260 std::tuple<ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>> t;
1262 UNION_CLASS_BOILERPLATE(
AcValue);
1263 std::variant<Triplet, common::Indirection<Expr>,
1271 AcSpec(std::optional<TypeSpec> &&ts, std::list<AcValue> &&xs)
1272 : type(std::move(ts)), values(std::move(xs)) {}
1274 std::optional<TypeSpec> type;
1275 std::list<AcValue> values;
1279WRAPPER_CLASS(ArrayConstructor,
AcSpec);
1287 VAR &&name, BOUND &&lower, BOUND &&upper, std::optional<BOUND> &&step)
1288 : name{std::move(name)}, lower{std::move(lower)}, upper{std::move(upper)},
1289 step{std::move(step)} {}
1293 std::optional<BOUND> step;
1306 std::tuple<std::optional<IntegerTypeSpec>,
Bounds> t;
1321 std::tuple<std::optional<ScalarDefaultCharConstantExpr>,
bool> t;
1327 std::tuple<NamedConstant, ConstantExpr> t;
1331WRAPPER_CLASS(ParameterStmt, std::list<NamedConstantDef>);
1334WRAPPER_CLASS(AssumedShapeSpec, std::optional<SpecificationExpr>);
1337WRAPPER_CLASS(AssumedImpliedSpec, std::optional<SpecificationExpr>);
1342 std::tuple<std::list<ExplicitShapeSpec>, AssumedImpliedSpec> t;
1349WRAPPER_CLASS(ImpliedShapeSpec, std::list<AssumedImpliedSpec>);
1352EMPTY_CLASS(AssumedRankSpec);
1360 std::variant<std::list<ExplicitShapeSpec>, std::list<AssumedShapeSpec>,
1361 DeferredShapeSpecList,
AssumedSizeSpec, ImpliedShapeSpec, AssumedRankSpec>
1367 ENUM_CLASS(Intent, In, Out, InOut)
1368 WRAPPER_CLASS_BOILERPLATE(
IntentSpec, Intent);
1378EMPTY_CLASS(Asynchronous);
1379EMPTY_CLASS(External);
1380EMPTY_CLASS(Intrinsic);
1381EMPTY_CLASS(Optional);
1382EMPTY_CLASS(Parameter);
1383EMPTY_CLASS(Protected);
1387EMPTY_CLASS(Volatile);
1392 Parameter, Pointer, Protected, Save, Target, Value, Volatile,
1393 common::CUDADataAttr>
1406 std::optional<ArraySpec> &&aSpec, std::optional<CoarraySpec> &&coaSpec,
1407 std::optional<Initialization> &&init)
1408 : t{std::move(name), std::move(aSpec), std::move(coaSpec),
1409 std::move(length), std::move(init)} {}
1410 std::tuple<ObjectName, std::optional<ArraySpec>, std::optional<CoarraySpec>,
1411 std::optional<CharLength>, std::optional<Initialization>>
1419 std::tuple<DeclarationTypeSpec, std::list<AttrSpec>, std::list<EntityDecl>> t;
1429 std::tuple<AccessSpec, std::list<AccessId>> t;
1438 std::tuple<ObjectName, std::optional<ArraySpec>, std::optional<CoarraySpec>>
1443WRAPPER_CLASS(AllocatableStmt, std::list<ObjectDecl>);
1446WRAPPER_CLASS(AsynchronousStmt, std::list<ObjectName>);
1451 ENUM_CLASS(Kind, Object, Common)
1452 std::tuple<Kind, Name> t;
1458 std::tuple<LanguageBindingSpec, std::list<BindEntity>> t;
1464 std::tuple<Name, CoarraySpec> t;
1468WRAPPER_CLASS(CodimensionStmt, std::list<CodimensionDecl>);
1471WRAPPER_CLASS(ContiguousStmt, std::list<ObjectName>);
1491 std::variant<common::Indirection<CharLiteralConstantSubstring>,
1504 std::variant<IntLiteralConstant, Scalar<Integer<ConstantSubobject>>> u;
1510 mutable std::int64_t repetitions{1};
1518 std::variant<Scalar<common::Indirection<Designator>>,
1531 std::tuple<std::list<DataIDoObject>, std::optional<IntegerTypeSpec>,
Bounds>
1538 std::variant<common::Indirection<Variable>,
DataImpliedDo> u;
1544 std::tuple<std::list<DataStmtObject>, std::list<DataStmtValue>> t;
1548WRAPPER_CLASS(DataStmt, std::list<DataStmtSet>);
1556 std::tuple<Name, ArraySpec> t;
1558 WRAPPER_CLASS_BOILERPLATE(
DimensionStmt, std::list<Declaration>);
1564 std::tuple<IntentSpec, std::list<Name>> t;
1568WRAPPER_CLASS(OptionalStmt, std::list<Name>);
1574 std::tuple<Name, std::optional<DeferredShapeSpecList>> t;
1578WRAPPER_CLASS(PointerStmt, std::list<PointerDecl>);
1581WRAPPER_CLASS(ProtectedStmt, std::list<Name>);
1587 ENUM_CLASS(Kind, Entity, Common)
1588 std::tuple<Kind, Name> t;
1592WRAPPER_CLASS(SaveStmt, std::list<SavedEntity>);
1595WRAPPER_CLASS(TargetStmt, std::list<ObjectDecl>);
1598WRAPPER_CLASS(ValueStmt, std::list<Name>);
1601WRAPPER_CLASS(VolatileStmt, std::list<ObjectName>);
1606 std::tuple<Location, std::optional<Location>> t;
1612 std::tuple<DeclarationTypeSpec, std::list<LetterSpec>> t;
1621 ENUM_CLASS(ImplicitNoneNameSpec, External, Type)
1622 std::variant<std::list<ImplicitSpec>, std::list<ImplicitNoneNameSpec>> u;
1628 std::tuple<Name, std::optional<ArraySpec>> t;
1636 TUPLE_CLASS_BOILERPLATE(
Block);
1637 std::tuple<std::optional<Name>, std::list<CommonBlockObject>> t;
1640 CommonStmt(std::optional<Name> &&, std::list<CommonBlockObject> &&,
1641 std::list<Block> &&);
1642 std::list<Block> blocks;
1650WRAPPER_CLASS(EquivalenceStmt, std::list<std::list<EquivalenceObject>>);
1655 std::tuple<std::optional<ScalarIntExpr>, std::optional<ScalarIntExpr>> t;
1664 std::tuple<std::optional<Subscript>, std::optional<Subscript>,
1665 std::optional<Subscript>>
1673 std::variant<IntExpr, SubscriptTriplet> u;
1689 std::variant<Stat, TeamValue, Team_Number> u;
1696 std::tuple<std::list<Cosubscript>, std::list<ImageSelectorSpec>> t;
1701 UNION_CLASS_BOILERPLATE(
Expr);
1705 using IntrinsicUnary::IntrinsicUnary;
1708 using IntrinsicUnary::IntrinsicUnary;
1711 using IntrinsicUnary::IntrinsicUnary;
1713 struct NOT :
public IntrinsicUnary {
1714 using IntrinsicUnary::IntrinsicUnary;
1721 std::tuple<DefinedOpName, common::Indirection<Expr>> t;
1729 using IntrinsicBinary::IntrinsicBinary;
1732 using IntrinsicBinary::IntrinsicBinary;
1735 using IntrinsicBinary::IntrinsicBinary;
1738 using IntrinsicBinary::IntrinsicBinary;
1741 using IntrinsicBinary::IntrinsicBinary;
1744 using IntrinsicBinary::IntrinsicBinary;
1747 using IntrinsicBinary::IntrinsicBinary;
1750 using IntrinsicBinary::IntrinsicBinary;
1753 using IntrinsicBinary::IntrinsicBinary;
1756 using IntrinsicBinary::IntrinsicBinary;
1759 using IntrinsicBinary::IntrinsicBinary;
1762 using IntrinsicBinary::IntrinsicBinary;
1765 using IntrinsicBinary::IntrinsicBinary;
1768 using IntrinsicBinary::IntrinsicBinary;
1771 using IntrinsicBinary::IntrinsicBinary;
1774 using IntrinsicBinary::IntrinsicBinary;
1779 using IntrinsicBinary::IntrinsicBinary;
1784 std::tuple<DefinedOpName, common::Indirection<Expr>,
1796 std::variant<common::Indirection<CharLiteralConstantSubstring>,
1800 Add,
Subtract,
Concat,
LT,
LE,
EQ,
NE,
GE,
GT,
AND,
OR,
EQV,
NEQV,
1808 PartRef(
Name &&n, std::list<SectionSubscript> &&ss,
1809 std::optional<ImageSelector> &&is)
1810 : name{std::move(n)}, subscripts(std::move(ss)),
1811 imageSelector{std::move(is)} {}
1813 std::list<SectionSubscript> subscripts;
1814 std::optional<ImageSelector> imageSelector;
1819 UNION_CLASS_BOILERPLATE(
DataRef);
1820 explicit DataRef(std::list<PartRef> &&);
1821 std::variant<Name, common::Indirection<StructureComponent>,
1837 std::tuple<DataRef, SubstringRange> t;
1842 std::tuple<CharLiteralConstant, SubstringRange> t;
1859 bool EndsInBareName()
const;
1861 std::variant<DataRef, Substring> u;
1869 std::variant<common::Indirection<Designator>,
1890 : base{std::move(dr)}, component(std::move(n)) {}
1905 : base{std::move(dr)}, imageSelector{std::move(is)} {}
1914 : base{std::move(dr)}, subscripts(std::move(ss)) {}
1919 std::list<SectionSubscript> subscripts;
1926 std::variant<Name, StructureComponent> u;
1937 std::tuple<std::optional<BoundExpr>,
BoundExpr> t;
1946 std::tuple<std::list<AllocateCoshapeSpec>, std::optional<BoundExpr>> t;
1954 std::tuple<AllocateObject, std::list<AllocateShapeSpec>,
1955 std::optional<AllocateCoarraySpec>>
1970 std::variant<StatVariable, MsgVariable> u;
1985 std::variant<Mold, Source, StatOrErrmsg, Stream, Pinned> u;
1992 std::tuple<std::optional<TypeSpec>, std::list<Allocation>,
1993 std::list<AllocOpt>>
2002 std::variant<Name, StructureComponent> u;
2006WRAPPER_CLASS(NullifyStmt, std::list<PointerObject>);
2012 std::tuple<std::list<AllocateObject>, std::list<StatOrErrmsg>> t;
2021 std::tuple<Variable, Expr> t;
2030 std::tuple<BoundExpr, BoundExpr> t;
2042 UNION_CLASS_BOILERPLATE(
Bounds);
2043 std::variant<std::list<BoundsRemapping>, std::list<BoundsSpec>> u;
2047 std::tuple<DataRef, Bounds, Expr> t;
2055 std::tuple<LogicalExpr, AssignmentStmt> t;
2077 std::tuple<LogicalExpr, std::optional<Name>> t;
2081WRAPPER_CLASS(ElsewhereStmt, std::optional<Name>);
2084WRAPPER_CLASS(EndWhereStmt, std::optional<Name>);
2093 std::tuple<Statement<MaskedElsewhereStmt>, std::list<WhereBodyConstruct>> t;
2097 std::tuple<Statement<ElsewhereStmt>, std::list<WhereBodyConstruct>> t;
2100 std::tuple<Statement<WhereConstructStmt>, std::list<WhereBodyConstruct>,
2101 std::list<MaskedElsewhere>, std::optional<Elsewhere>,
2116 std::variant<AssignmentStmt, PointerAssignmentStmt> u;
2122 std::tuple<common::Indirection<ConcurrentHeader>,
2139WRAPPER_CLASS(EndForallStmt, std::optional<Name>);
2145 std::tuple<Statement<ForallConstructStmt>, std::list<ForallBodyConstruct>,
2153 std::variant<Expr, Variable> u;
2159 std::tuple<Name, Selector> t;
2166 std::tuple<std::optional<Name>, std::list<Association>> t;
2170WRAPPER_CLASS(EndAssociateStmt, std::optional<Name>);
2179WRAPPER_CLASS(BlockStmt, std::optional<Name>);
2182WRAPPER_CLASS(EndBlockStmt, std::optional<Name>);
2197 std::tuple<Statement<BlockStmt>, BlockSpecificationPart, Block,
2205 std::tuple<CodimensionDecl, Selector> t;
2213 std::tuple<std::optional<Name>, TeamValue, std::list<CoarrayAssociation>,
2214 std::list<StatOrErrmsg>>
2222 std::tuple<std::list<StatOrErrmsg>, std::optional<Name>> t;
2235 std::tuple<std::optional<Name>, std::list<StatOrErrmsg>> t;
2239WRAPPER_CLASS(EndCriticalStmt, std::optional<Name>);
2253 std::tuple<Name, ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>>
2262 std::tuple<std::optional<IntegerTypeSpec>, std::list<ConcurrentControl>,
2263 std::optional<ScalarLogicalExpr>>
2274 Operator, Plus, Multiply, Max, Min, Iand, Ior, Ieor, And, Or, Eqv, Neqv)
2285 WRAPPER_CLASS(Local, std::list<Name>);
2286 WRAPPER_CLASS(LocalInit, std::list<Name>);
2288 TUPLE_CLASS_BOILERPLATE(
Reduce);
2290 std::tuple<Operator, std::list<Name>> t;
2292 WRAPPER_CLASS(Shared, std::list<Name>);
2293 EMPTY_CLASS(DefaultNone);
2294 std::variant<Local, LocalInit, Reduce, Shared, DefaultNone> u;
2307 std::tuple<ConcurrentHeader, std::list<LocalitySpec>> t;
2310 std::variant<Bounds, ScalarLogicalExpr, Concurrent> u;
2317 std::tuple<Label, std::optional<LoopControl>> t;
2323 std::tuple<std::optional<Name>, std::optional<Label>,
2324 std::optional<LoopControl>>
2329WRAPPER_CLASS(EndDoStmt, std::optional<Name>);
2340 const std::optional<LoopControl> &GetLoopControl()
const;
2341 bool IsDoNormal()
const;
2342 bool IsDoWhile()
const;
2343 bool IsDoConcurrent()
const;
2348WRAPPER_CLASS(CycleStmt, std::optional<Name>);
2360 std::tuple<ScalarLogicalExpr, std::optional<Name>> t;
2364WRAPPER_CLASS(ElseStmt, std::optional<Name>);
2367WRAPPER_CLASS(EndIfStmt, std::optional<Name>);
2375 std::tuple<Statement<ElseIfStmt>, Block> t;
2379 std::tuple<Statement<ElseStmt>, Block> t;
2382 std::tuple<Statement<IfThenStmt>, Block, std::list<ElseIfBlock>,
2389 TUPLE_CLASS_BOILERPLATE(
IfStmt);
2390 std::tuple<ScalarLogicalExpr, UnlabeledStatement<ActionStmt>> t;
2409 Range(std::optional<CaseValue> &&l, std::optional<CaseValue> &&u)
2410 : lower{std::move(l)}, upper{std::move(u)} {}
2411 std::optional<CaseValue> lower, upper;
2413 std::variant<CaseValue, Range> u;
2417EMPTY_CLASS(Default);
2421 std::variant<std::list<CaseValueRange>, Default> u;
2427 std::tuple<CaseSelector, std::optional<Name>> t;
2433WRAPPER_CLASS(EndSelectStmt, std::optional<Name>);
2439 TUPLE_CLASS_BOILERPLATE(
Case);
2440 std::tuple<Statement<CaseStmt>, Block> t;
2443 std::tuple<Statement<SelectCaseStmt>, std::list<Case>,
2453 std::tuple<std::optional<Name>, std::optional<Name>,
Selector> t;
2462 UNION_CLASS_BOILERPLATE(
Rank);
2463 std::variant<ScalarIntConstantExpr, Star, Default> u;
2466 std::tuple<Rank, std::optional<Name>> t;
2476 std::tuple<Statement<SelectRankCaseStmt>, Block> t;
2478 std::tuple<Statement<SelectRankStmt>, std::list<RankCase>,
2488 std::tuple<std::optional<Name>, std::optional<Name>,
Selector> t;
2497 UNION_CLASS_BOILERPLATE(
Guard);
2498 std::variant<TypeSpec, DerivedTypeSpec, Default> u;
2501 std::tuple<Guard, std::optional<Name>> t;
2510 std::tuple<Statement<TypeGuardStmt>, Block> t;
2512 std::tuple<Statement<SelectTypeStmt>, std::list<TypeCase>,
2518WRAPPER_CLASS(ExitStmt, std::optional<Name>);
2521WRAPPER_CLASS(GotoStmt, Label);
2539 ENUM_CLASS(Kind, Stop, ErrorStop)
2541 std::tuple<Kind, std::optional<StopCode>, std::optional<ScalarLogicalExpr>> t;
2548 std::tuple<Scalar<Variable>, std::list<EventWaitSpec>> t;
2552WRAPPER_CLASS(SyncAllStmt, std::list<StatOrErrmsg>);
2559 std::variant<IntExpr, Star> u;
2562 std::tuple<ImageSet, std::list<StatOrErrmsg>> t;
2566WRAPPER_CLASS(SyncMemoryStmt, std::list<StatOrErrmsg>);
2571 std::tuple<TeamValue, std::list<StatOrErrmsg>> t;
2580 std::tuple<EventVariable, std::list<StatOrErrmsg>> t;
2586 std::variant<ScalarIntExpr, StatOrErrmsg> u;
2594 std::tuple<EventVariable, std::list<EventWaitSpec>> t;
2607 std::variant<ScalarIntExpr, StatOrErrmsg> u;
2610 std::tuple<ScalarIntExpr, TeamVariable, std::list<FormTeamSpec>> t;
2621 std::variant<Scalar<Logical<Variable>>,
StatOrErrmsg> u;
2624 std::tuple<LockVariable, std::list<LockStat>> t;
2630 std::tuple<LockVariable, std::list<StatOrErrmsg>> t;
2644 UNION_CLASS_BOILERPLATE(
IoUnit);
2645 std::variant<Variable, common::Indirection<Expr>, Star> u;
2669WRAPPER_CLASS(ErrLabel, Label);
2674 ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
2675 Encoding, Form, Pad, Position, Round, Sign,
2676 Carriagecontrol, Convert, Dispose)
2678 std::tuple<Kind, ScalarDefaultCharExpr> t;
2683 StatVariable, Recl, Newunit, ErrLabel, StatusExpr>
2688WRAPPER_CLASS(OpenStmt, std::list<ConnectSpec>);
2698 std::variant<FileUnitNumber, StatVariable, MsgVariable, ErrLabel,
2702 WRAPPER_CLASS_BOILERPLATE(
CloseStmt, std::list<CloseSpec>);
2708 UNION_CLASS_BOILERPLATE(
Format);
2709 std::variant<Expr, Label, Star> u;
2727WRAPPER_CLASS(EndLabel, Label);
2728WRAPPER_CLASS(EorLabel, Label);
2732 ENUM_CLASS(Kind, Advance, Blank, Decimal, Delim, Pad, Round, Sign)
2734 std::tuple<Kind, ScalarDefaultCharExpr> t;
2741 ErrLabel, IdVariable, MsgVariable, StatVariable, Pos, Rec, Size>
2748 std::variant<Variable, common::Indirection<InputImpliedDo>> u;
2756 ReadStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
2757 std::list<IoControlSpec> &&cs, std::list<InputItem> &&its)
2758 : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
2759 items(std::move(its)) {}
2760 std::optional<IoUnit> iounit;
2762 std::optional<Format> format;
2765 std::list<IoControlSpec> controls;
2766 std::list<InputItem> items;
2772 std::variant<Expr, common::Indirection<OutputImpliedDo>> u;
2778 WriteStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
2779 std::list<IoControlSpec> &&cs, std::list<OutputItem> &&its)
2780 : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
2781 items(std::move(its)) {}
2782 std::optional<IoUnit> iounit;
2784 std::optional<Format> format;
2786 std::list<IoControlSpec> controls;
2787 std::list<OutputItem> items;
2793 std::tuple<Format, std::list<OutputItem>> t;
2819 std::variant<FileUnitNumber, EndLabel, EorLabel, ErrLabel, IdExpr,
2820 MsgVariable, StatVariable>
2825WRAPPER_CLASS(WaitStmt, std::list<WaitSpec>);
2835 std::variant<FileUnitNumber, MsgVariable, StatVariable, ErrLabel> u;
2840WRAPPER_CLASS(BackspaceStmt, std::list<PositionOrFlushSpec>);
2844WRAPPER_CLASS(EndfileStmt, std::list<PositionOrFlushSpec>);
2847WRAPPER_CLASS(RewindStmt, std::list<PositionOrFlushSpec>);
2850WRAPPER_CLASS(FlushStmt, std::list<PositionOrFlushSpec>);
2890 ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
2891 Direct, Encoding, Form, Formatted, Iomsg,
Name, Pad, Position, Read,
2892 Readwrite, Round, Sequential, Sign, Stream, Status, Unformatted, Write,
2893 Carriagecontrol, Convert, Dispose)
2894 TUPLE_CLASS_BOILERPLATE(
CharVar);
2895 std::tuple<Kind, ScalarDefaultCharVariable> t;
2898 ENUM_CLASS(Kind, Iostat, Nextrec, Number, Pos, Recl, Size)
2899 TUPLE_CLASS_BOILERPLATE(
IntVar);
2900 std::tuple<Kind, ScalarIntVariable> t;
2903 ENUM_CLASS(Kind, Exist, Named, Opened, Pending)
2904 TUPLE_CLASS_BOILERPLATE(
LogVar);
2905 std::tuple<Kind, Scalar<Logical<Variable>>> t;
2919 std::tuple<ScalarIntVariable, std::list<OutputItem>> t;
2921 std::variant<std::list<InquireSpec>,
Iolength> u;
2928WRAPPER_CLASS(ProgramStmt,
Name);
2931WRAPPER_CLASS(EndProgramStmt, std::optional<Name>);
2939 ExecutionPart, std::optional<InternalSubprogramPart>,
2945WRAPPER_CLASS(ModuleStmt,
Name);
2952 std::variant<common::Indirection<FunctionSubprogram>,
2962 std::tuple<Statement<ContainsStmt>, std::list<ModuleSubprogram>> t;
2966WRAPPER_CLASS(EndModuleStmt, std::optional<Name>);
2972 TUPLE_CLASS_BOILERPLATE(
Module);
2983 UNION_CLASS_BOILERPLATE(
Rename);
2985 TUPLE_CLASS_BOILERPLATE(
Names);
2986 std::tuple<Name, Name> t;
2990 std::tuple<DefinedOpName, DefinedOpName> t;
2992 std::variant<Names, Operators> u;
2998 std::tuple<Name, std::optional<Name>> t;
3004 std::tuple<ParentIdentifier, Name> t;
3008WRAPPER_CLASS(EndSubmoduleStmt, std::optional<Name>);
3021WRAPPER_CLASS(BlockDataStmt, std::optional<Name>);
3024WRAPPER_CLASS(EndBlockDataStmt, std::optional<Name>);
3042 EMPTY_CLASS(Assignment);
3043 EMPTY_CLASS(ReadFormatted);
3044 EMPTY_CLASS(ReadUnformatted);
3045 EMPTY_CLASS(WriteFormatted);
3046 EMPTY_CLASS(WriteUnformatted);
3049 ReadUnformatted, WriteFormatted, WriteUnformatted>
3057 std::tuple<std::optional<AccessSpec>,
GenericSpec, std::list<Name>> t;
3066 std::variant<std::optional<GenericSpec>, Abstract> u;
3072 UNION_CLASS_BOILERPLATE(
Only);
3073 std::variant<common::Indirection<GenericSpec>,
Name,
Rename> u;
3082 ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic)
3083 template <
typename A>
3084 UseStmt(std::optional<ModuleNature> &&nat,
Name &&n, std::list<A> &&x)
3085 : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
3086 std::optional<ModuleNature> nature;
3088 std::variant<std::list<Rename>, std::list<Only>> u;
3106 std::tuple<std::optional<ProcInterface>, std::list<ProcAttrSpec>,
3107 std::list<ProcDecl>>
3118 EMPTY_CLASS(Elemental);
3119 EMPTY_CLASS(Impure);
3121 EMPTY_CLASS(Non_Recursive);
3123 EMPTY_CLASS(Recursive);
3124 WRAPPER_CLASS(Attributes, std::list<common::CUDASubprogramAttrs>);
3125 WRAPPER_CLASS(Launch_Bounds, std::list<ScalarIntConstantExpr>);
3126 WRAPPER_CLASS(Cluster_Dims, std::list<ScalarIntConstantExpr>);
3128 Pure, Recursive, Attributes, Launch_Bounds, Cluster_Dims>
3138 : binding(std::move(lbs)), resultName(std::move(rn)) {}
3139 Suffix(
Name &&rn, std::optional<LanguageBindingSpec> &&lbs)
3140 : binding(std::move(lbs)), resultName(std::move(rn)) {}
3141 std::optional<LanguageBindingSpec> binding;
3142 std::optional<Name> resultName;
3151 std::tuple<std::list<PrefixSpec>,
Name, std::list<Name>,
3152 std::optional<Suffix>>
3157WRAPPER_CLASS(EndFunctionStmt, std::optional<Name>);
3162 std::variant<Name, Star> u;
3170 std::tuple<std::list<PrefixSpec>,
Name, std::list<DummyArg>,
3171 std::optional<LanguageBindingSpec>>
3176WRAPPER_CLASS(EndSubroutineStmt, std::optional<Name>);
3191 std::tuple<Statement<SubroutineStmt>,
3195 std::variant<Function, Subroutine> u;
3200 ENUM_CLASS(Kind, ModuleProcedure, Procedure)
3202 std::tuple<Kind, std::list<Name>> t;
3208 std::variant<InterfaceBody, Statement<ProcedureStmt>> u;
3212WRAPPER_CLASS(EndInterfaceStmt, std::optional<GenericSpec>);
3218 std::tuple<Statement<InterfaceStmt>, std::list<InterfaceSpecification>,
3224WRAPPER_CLASS(ExternalStmt, std::list<Name>);
3227WRAPPER_CLASS(IntrinsicStmt, std::list<Name>);
3233 std::variant<Name, ProcComponentRef> u;
3237WRAPPER_CLASS(AltReturnSpec, Label);
3243 WRAPPER_CLASS(PercentRef,
Expr);
3244 WRAPPER_CLASS(PercentVal,
Expr);
3247 std::variant<common::Indirection<Expr>, AltReturnSpec, PercentRef, PercentVal>
3254 std::tuple<std::optional<Keyword>,
ActualArg> t;
3260 TUPLE_CLASS_BOILERPLATE(
Call);
3261 std::tuple<ProcedureDesignator, std::list<ActualArgSpec>> t;
3278 WRAPPER_CLASS(StarOrExpr, std::optional<ScalarExpr>);
3281 std::tuple<StarOrExpr, ScalarExpr, std::optional<ScalarIntExpr>,
3282 std::optional<ScalarIntExpr>>
3286 std::list<ActualArgSpec> &&args)
3287 : call{std::move(pd), std::move(args)}, chevrons{std::move(ch)} {}
3289 std::optional<Chevrons> chevrons;
3316WRAPPER_CLASS(MpSubprogramStmt,
Name);
3319WRAPPER_CLASS(EndMpSubprogramStmt, std::optional<Name>);
3334 std::tuple<Name, std::list<DummyArg>, std::optional<Suffix>> t;
3338WRAPPER_CLASS(ReturnStmt, std::optional<ScalarIntExpr>);
3362 std::tuple<std::optional<std::list<const char *>>,
Name> t;
3365 WRAPPER_CLASS_BOILERPLATE(
LoopCount, std::list<std::uint64_t>);
3369 std::tuple<common::Indirection<Designator>, uint64_t> t;
3371 EMPTY_CLASS(VectorAlways);
3374 std::tuple<Name, std::optional<std::uint64_t>> t;
3377 WRAPPER_CLASS_BOILERPLATE(
Unroll, std::optional<std::uint64_t>);
3380 WRAPPER_CLASS_BOILERPLATE(
UnrollAndJam, std::optional<std::uint64_t>);
3382 EMPTY_CLASS(NoVector);
3383 EMPTY_CLASS(NoUnroll);
3384 EMPTY_CLASS(NoUnrollAndJam);
3385 EMPTY_CLASS(Unrecognized);
3387 std::variant<std::list<IgnoreTKR>,
LoopCount, std::list<AssumeAligned>,
3389 NoVector, NoUnroll, NoUnrollAndJam>
3396 std::tuple<common::CUDADataAttr, std::list<Name>> t;
3402 std::tuple<ObjectName, ObjectName, std::optional<ArraySpec>> t;
3404WRAPPER_CLASS(BasedPointerStmt, std::list<BasedPointer>);
3411 std::variant<Statement<DataComponentDefStmt>,
3417 EMPTY_CLASS(MapStmt);
3418 EMPTY_CLASS(EndMapStmt);
3419 TUPLE_CLASS_BOILERPLATE(
Map);
3420 std::tuple<Statement<MapStmt>, std::list<StructureField>,
3426 EMPTY_CLASS(UnionStmt);
3427 EMPTY_CLASS(EndUnionStmt);
3428 TUPLE_CLASS_BOILERPLATE(
Union);
3434 std::tuple<std::optional<Name>, std::list<EntityDecl>> t;
3438 EMPTY_CLASS(EndStructureStmt);
3440 std::tuple<Statement<StructureStmt>, std::list<StructureField>,
3447WRAPPER_CLASS(OldParameterStmt, std::list<NamedConstantDef>);
3452 std::tuple<Expr, Label, Label, Label> t;
3457 std::tuple<Label, Name> t;
3462 std::tuple<Name, std::list<Label>> t;
3465WRAPPER_CLASS(PauseStmt, std::optional<StopCode>);
3471#define INHERITED_TUPLE_CLASS_BOILERPLATE(classname, basename) \
3472 using basename::basename; \
3473 classname(basename &&b) : basename(std::move(b)) {} \
3474 using TupleTrait = std::true_type; \
3475 BOILERPLATE(classname)
3477#define INHERITED_WRAPPER_CLASS_BOILERPLATE(classname, basename) \
3478 BOILERPLATE(classname); \
3479 using basename::basename; \
3480 classname(basename &&base) : basename(std::move(base)) {} \
3481 using WrapperTrait = std::true_type
3495 using WrapperTrait = std::true_type;
3497 bool IsExecutionPart()
const;
3500 llvm::omp::Directive v{llvm::omp::Directive::OMPD_unknown};
3512WRAPPER_CLASS(OmpObjectList, std::list<OmpObject>);
3523 std::variant<DefinedOperator, ProcedureDesignator> u;
3533 std::variant<AssignmentStmt, FunctionReference> u;
3536inline namespace arguments {
3539 std::variant<TypeSpec, DeclarationTypeSpec> u;
3542WRAPPER_CLASS(OmpTypeNameList, std::list<OmpTypeSpecifier>);
3546 std::variant<OmpObject, FunctionReference> u;
3549WRAPPER_CLASS(OmpLocatorList, std::list<OmpLocator>);
3559 std::tuple<std::string, TypeSpec, Name> t;
3572 std::optional<OmpReductionCombiner>>
3590inline namespace traits {
3627 TUPLE_CLASS_BOILERPLATE(
Complex);
3629 std::list<common::Indirection<OmpTraitPropertyExtension>>>
3633 std::variant<OmpTraitPropertyName, ScalarExpr, Complex> u;
3649 std::variant<OmpTraitPropertyName, common::Indirection<OmpClause>,
3674 std::string ToString()
const;
3677 ENUM_CLASS(Value, Arch, Atomic_Default_Mem_Order, Condition, Device_Num,
3678 Extension, Isa, Kind, Requires, Simd, Uid, Vendor)
3679 std::variant<Value, llvm::omp::Directive, std::string> u;
3690 std::tuple<std::optional<OmpTraitScore>, std::list<OmpTraitProperty>> t;
3692 std::tuple<OmpTraitSelectorName, std::optional<Properties>> t;
3699 std::string ToString()
const;
3701 ENUM_CLASS(Value, Construct, Device, Implementation, Target_Device, User)
3710 std::tuple<OmpTraitSetSelectorName, std::list<OmpTraitSelector>> t;
3717 WRAPPER_CLASS_BOILERPLATE(
3722#define MODIFIER_BOILERPLATE(...) \
3724 using Variant = std::variant<__VA_ARGS__>; \
3725 UNION_CLASS_BOILERPLATE(Modifier); \
3730#define MODIFIERS() std::optional<std::list<Modifier>>
3732inline namespace modifier {
3740 ENUM_CLASS(Value, Cgroup);
3785 ENUM_CLASS(Value, Always)
3795 ENUM_CLASS(Value, Automap);
3806 ENUM_CLASS(Value, Simd)
3819 ENUM_CLASS(Value, Close)
3831 ENUM_CLASS(Value, Delete)
3852 ENUM_CLASS(Value, Sink, Source);
3861 ENUM_CLASS(Value, Ancestor, Device_Num)
3879 INHERITED_WRAPPER_CLASS_BOILERPLATE(
3894 ENUM_CLASS(Value, Present);
3904 std::variant<CharLiteralConstant, ScalarIntConstantExpr> u;
3912 WRAPPER_CLASS_BOILERPLATE(
3921 ENUM_CLASS(Value, Target, TargetSync)
3935 std::tuple<TypeDeclarationStmt, SubscriptTriplet> t;
3943 WRAPPER_CLASS_BOILERPLATE(
OmpIterator, std::list<OmpIteratorSpecifier>);
3951 ENUM_CLASS(Value, Conditional)
3960 ENUM_CLASS(Value, Ref, Uval, Val);
3982 ENUM_CLASS(Value, Alloc, Delete, From, Release, Storage, To, Tofrom);
3983 WRAPPER_CLASS_BOILERPLATE(
OmpMapType, Value);
3995 ENUM_CLASS(Value, Always, Close, Present, Ompx_Hold)
4010 ENUM_CLASS(Value, Monotonic, Nonmonotonic, Simd)
4019 ENUM_CLASS(Value, Reproducible, Unconstrained)
4029 ENUM_CLASS(Value, Strict, Fallback)
4042 ENUM_CLASS(Value, Present)
4051 ENUM_CLASS(Value, Default, Inscan, Task);
4061 ENUM_CLASS(Value, Ref_Ptee, Ref_Ptr, Ref_Ptr_Ptee)
4071 ENUM_CLASS(Value, Self)
4098 ENUM_CLASS(Value, In, Out, Inout, Inoutset, Mutexinoutset, Depobj)
4109 ENUM_CLASS(Value, Aggregate, All, Allocatable, Pointer,
Scalar)
4122 ENUM_CLASS(Value, Ompx_Hold)
4132using OmpDirectiveList = std::list<llvm::omp::Directive>;
4145 ENUM_CLASS(Value, Nothing, Need_Device_Ptr)
4148 std::tuple<OmpAdjustOp, OmpObjectList> t;
4160 std::tuple<MODIFIERS(), OmpObjectList> t;
4175 std::tuple<OmpObjectList, MODIFIERS()> t;
4191 std::tuple<MODIFIERS(), OmpObjectList> t;
4196 WRAPPER_CLASS_BOILERPLATE(
OmpAppendOp, std::list<OmpInteropType>);
4204 ENUM_CLASS(ActionTime, Compilation, Execution);
4205 WRAPPER_CLASS_BOILERPLATE(
OmpAtClause, ActionTime);
4216 using MemoryOrder = common::OmpMemoryOrderType;
4227 ENUM_CLASS(Binding, Parallel, Teams, Thread)
4234 std::tuple<OmpDirectiveName, std::optional<ScalarLogicalExpr>> t;
4259 ENUM_CLASS(DataSharingAttribute, Private, Firstprivate, Shared, None)
4261 std::variant<DataSharingAttribute,
4278 ENUM_CLASS(ImplicitBehavior, Alloc, To, From, Tofrom, Firstprivate, None,
4281 std::tuple<ImplicitBehavior, MODIFIERS()> t;
4290 std::tuple<DefinedOperator, ScalarIntConstantExpr> t;
4299 std::tuple<Name, std::optional<OmpIterationOffset>> t;
4306WRAPPER_CLASS(OmpIterationVector, std::list<OmpIteration>);
4314 OmpDependenceType::Value GetDepType()
const;
4316 WRAPPER_CLASS(Sink, OmpIterationVector);
4317 EMPTY_CLASS(Source);
4319 std::variant<Sink, Source> u;
4334 OmpTaskDependenceType::Value GetTaskDepType()
const;
4335 TUPLE_CLASS_BOILERPLATE(
TaskDep);
4337 std::tuple<MODIFIERS(), OmpObjectList> t;
4339 std::variant<TaskDep, OmpDoacross> u;
4353WRAPPER_CLASS(OmpDestroyClause,
OmpObject);
4380 ENUM_CLASS(DeviceTypeDescription, Any, Host, Nohost)
4398 std::tuple<MODIFIERS(), OmpObjectList> t;
4404 using MemoryOrder = common::OmpMemoryOrderType;
4419 std::tuple<MODIFIERS(), OmpObjectList,
bool> t;
4448 WRAPPER_CLASS_BOILERPLATE(
4471 std::tuple<MODIFIERS(), OmpObjectList> t;
4478 std::tuple<ProcedureDesignator, std::list<ActualArgSpec>> t;
4483 std::variant<OmpInitializerProc, AssignmentStmt> u;
4494 std::tuple<MODIFIERS(), OmpObjectList> t;
4508 MODIFIER_BOILERPLATE(
4510 std::tuple<OmpObjectList, MODIFIERS(),
bool> t;
4537 std::tuple<MODIFIERS(), OmpObjectList,
bool> t;
4546 WRAPPER_CLASS_BOILERPLATE(
4560EMPTY_CLASS(OmpNoOpenMPClause);
4565EMPTY_CLASS(OmpNoOpenMPRoutinesClause);
4570EMPTY_CLASS(OmpNoParallelismClause);
4590 ENUM_CLASS(Ordering, Concurrent)
4592 std::tuple<MODIFIERS(), Ordering> t;
4614 ENUM_CLASS(AffinityPolicy, Close, Master, Spread, Primary)
4627 std::tuple<MODIFIERS(), OmpObjectList> t;
4640 ENUM_CLASS(Kind, Static, Dynamic, Guided, Auto, Runtime)
4642 std::tuple<MODIFIERS(), Kind, std::optional<ScalarIntExpr>> t;
4649 ENUM_CLASS(Severity, Fatal, Warning);
4660 std::tuple<MODIFIERS(), OmpObjectList> t;
4676 std::tuple<MODIFIERS(), OmpObjectList,
bool> t;
4693 std::variant<OmpDependenceType, OmpTaskDependenceType> u;
4703 MODIFIER_BOILERPLATE(OmpContextSelector);
4704 std::tuple<MODIFIERS(),
4705 std::optional<common::Indirection<OmpDirectiveSpecification>>>
4731 llvm::omp::Clause Id()
const;
4733#define GEN_FLANG_CLAUSE_PARSER_CLASSES
4734#include "llvm/Frontend/OpenMP/OMP.inc"
4739#define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
4740#include "llvm/Frontend/OpenMP/OMP.inc"
4746 WRAPPER_CLASS_BOILERPLATE(
OmpClauseList, std::list<OmpClause>);
4753 ENUM_CLASS(Flags, None, DeprecatedSyntax);
4756 return std::get<OmpDirectiveName>(t);
4758 llvm::omp::Directive DirId()
const {
4765 std::tuple<OmpDirectiveName, std::optional<OmpArgumentList>,
4766 std::optional<OmpClauseList>, Flags>
4775 INHERITED_TUPLE_CLASS_BOILERPLATE(
4787 return std::get<OmpBeginDirective>(t);
4789 const std::optional<OmpEndDirective> &EndDir()
const {
4790 return std::get<std::optional<OmpEndDirective>>(t);
4794 std::tuple<OmpBeginDirective, Block, std::optional<OmpEndDirective>> t;
4799 std::tuple<Verbatim, OmpClauseList> t;
4808 using EmptyTrait = std::true_type;
4818 std::tuple<Verbatim, OmpClauseList> t;
4824 std::variant<OmpErrorDirective, OmpNothingDirective> u;
4834 std::tuple<Verbatim, OmpClauseList> t;
4857 std::tuple<OmpSectionsDirective, OmpClauseList> t;
4862 std::tuple<OmpSectionsDirective, OmpClauseList> t;
4873 std::tuple<std::optional<OmpDirectiveSpecification>, Block> t;
4885 std::tuple<OmpBeginSectionsDirective, std::list<OpenMPConstruct>,
4886 std::optional<OmpEndSectionsDirective>>
4911 std::variant<OmpDeclareTargetWithList, OmpDeclareTargetWithClause> u;
4917 std::tuple<Verbatim, OmpDeclareTargetSpecifier> t;
4925 std::tuple<Verbatim, OmpMapperSpecifier, OmpClauseList> t;
4934 std::tuple<Verbatim, common::Indirection<OmpReductionSpecifier>,
4935 std::optional<OmpClauseList>>
4960 std::tuple<Verbatim, OmpClauseList> t;
4967 std::tuple<Verbatim, OmpObjectList> t;
4974 std::tuple<Verbatim, OmpObjectList, OmpClauseList> t;
5000 std::tuple<Verbatim, std::optional<OmpObjectList>,
OmpClauseList,
5001 std::optional<std::list<OpenMPDeclarativeAllocate>>,
5013 INHERITED_TUPLE_CLASS_BOILERPLATE(
5018 llvm::omp::Clause GetKind()
const;
5019 bool IsCapture()
const;
5020 bool IsCompare()
const;
5026 static constexpr int None = 0;
5027 static constexpr int Read = 1;
5028 static constexpr int Write = 2;
5029 static constexpr int Update = Read | Write;
5030 static constexpr int Action = 3;
5031 static constexpr int IfTrue = 4;
5032 static constexpr int IfFalse = 8;
5033 static constexpr int Condition = 12;
5054 WRAPPER_CLASS_BOILERPLATE(
5115 WRAPPER_CLASS_BOILERPLATE(
5131 std::tuple<OmpLoopDirective, OmpClauseList> t;
5137 std::tuple<OmpLoopDirective, OmpClauseList> t;
5142using NestedConstruct =
5143 std::variant<DoConstruct, common::Indirection<OpenMPLoopConstruct>>;
5147 : t({std::move(a), std::nullopt, std::nullopt}) {}
5148 std::tuple<OmpBeginLoopDirective, std::optional<NestedConstruct>,
5149 std::optional<OmpEndLoopDirective>>
5177WRAPPER_CLASS(AccObjectList, std::list<AccObject>);
5209 std::variant<Name, ScalarDefaultCharExpr> u;
5219 ENUM_CLASS(Modifier, ReadOnly, Zero)
5226 std::tuple<std::optional<AccDataModifier>, AccObjectList> t;
5231 std::tuple<ReductionOperator, AccObjectList> t;
5236 std::tuple<std::optional<ScalarIntExpr>, std::list<ScalarIntExpr>> t;
5240 WRAPPER_CLASS_BOILERPLATE(
5246 WRAPPER_CLASS_BOILERPLATE(
5253 std::tuple<std::optional<ScalarIntConstantExpr>> t;
5261 WRAPPER_CLASS_BOILERPLATE(
AccSizeExpr, std::optional<ScalarIntExpr>);
5270 std::variant<std::optional<ScalarLogicalExpr>, AccObjectList> u;
5280 std::variant<Num, Dim, Static> u;
5285 WRAPPER_CLASS_BOILERPLATE(
AccGangArgList, std::list<AccGangArg>);
5290 std::tuple<bool, ScalarIntConstantExpr> t;
5296#define GEN_FLANG_CLAUSE_PARSER_CLASSES
5297#include "llvm/Frontend/OpenACC/ACC.inc"
5302#define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
5303#include "llvm/Frontend/OpenACC/ACC.inc"
5309 WRAPPER_CLASS_BOILERPLATE(
AccClauseList, std::list<AccClause>);
5322 std::tuple<Verbatim, AccObjectListWithModifier> t;
5328 std::tuple<Verbatim, std::optional<AccWaitArgument>,
AccClauseList> t;
5333 std::tuple<AccLoopDirective, AccClauseList> t;
5340 std::tuple<AccBlockDirective, AccClauseList> t;
5349EMPTY_CLASS(AccEndAtomic);
5354 std::tuple<Verbatim, AccClauseList, Statement<AssignmentStmt>,
5355 std::optional<AccEndAtomic>>
5362 std::tuple<Verbatim, AccClauseList, Statement<AssignmentStmt>,
5363 std::optional<AccEndAtomic>>
5371 std::optional<AccEndAtomic>>
5380 std::tuple<Verbatim, AccClauseList, Stmt1, Stmt2, AccEndAtomic> t;
5385 std::variant<AccAtomicRead, AccAtomicWrite, AccAtomicCapture, AccAtomicUpdate>
5392 std::tuple<AccBeginBlockDirective, Block, AccEndBlockDirective> t;
5398 std::tuple<AccDeclarativeDirective, AccClauseList> t;
5404 std::tuple<AccCombinedDirective, AccClauseList> t;
5416 : t({std::move(a), std::nullopt, std::nullopt}) {}
5417 std::tuple<AccBeginCombinedDirective, std::optional<DoConstruct>,
5418 std::optional<AccEndCombinedDirective>>
5425 std::variant<OpenACCStandaloneDeclarativeConstruct, OpenACCRoutineConstruct>
5430EMPTY_CLASS(AccEndLoop);
5434 : t({std::move(a), std::nullopt, std::nullopt}) {}
5435 std::tuple<AccBeginLoopDirective, std::optional<DoConstruct>,
5436 std::optional<AccEndLoop>>
5448 std::tuple<AccStandaloneDirective, AccClauseList> t;
5474 std::tuple<Operator, std::list<Scalar<Variable>>> t;
5479 WRAPPER_CLASS(StarOrExpr, std::optional<ScalarIntExpr>);
5482 std::tuple<std::list<StarOrExpr>, std::list<StarOrExpr>,
5483 std::optional<ScalarIntExpr>>
5489 std::tuple<std::optional<ScalarIntConstantExpr>,
5490 std::optional<LaunchConfiguration>, std::list<CUFReduction>>
5493 std::tuple<Directive, std::optional<DoConstruct>> t;
Definition: indirection.h:31
Definition: char-block.h:28
Definition: check-expression.h:19
Definition: parse-tree.h:1303
Definition: parse-tree.h:1310
Definition: parse-tree.h:1269
Definition: parse-tree.h:1258
Definition: parse-tree.h:1257
Definition: parse-tree.h:5376
Definition: parse-tree.h:5352
Definition: parse-tree.h:5368
Definition: parse-tree.h:5360
Definition: parse-tree.h:5337
Definition: parse-tree.h:5401
Definition: parse-tree.h:5331
Definition: parse-tree.h:5207
Definition: parse-tree.h:5180
Definition: parse-tree.h:5308
Definition: parse-tree.h:5293
Definition: parse-tree.h:5288
Definition: parse-tree.h:5196
Definition: parse-tree.h:5218
Definition: parse-tree.h:5201
Definition: parse-tree.h:5213
Definition: parse-tree.h:5245
Definition: parse-tree.h:5239
Definition: parse-tree.h:5343
Definition: parse-tree.h:5407
Definition: parse-tree.h:5284
Definition: parse-tree.h:5275
Definition: parse-tree.h:5185
Definition: parse-tree.h:5224
Definition: parse-tree.h:5229
Definition: parse-tree.h:5172
Definition: parse-tree.h:5268
Definition: parse-tree.h:5264
Definition: parse-tree.h:5260
Definition: parse-tree.h:5190
Definition: parse-tree.h:5256
Definition: parse-tree.h:5250
Definition: parse-tree.h:5234
Definition: parse-tree.h:909
Definition: parse-tree.h:1427
Definition: parse-tree.h:490
Definition: parse-tree.h:3252
Definition: parse-tree.h:3242
Definition: parse-tree.h:1979
Definition: parse-tree.h:1944
Definition: parse-tree.h:1923
Definition: parse-tree.h:1935
Definition: parse-tree.h:1990
Definition: parse-tree.h:1952
Definition: parse-tree.h:3450
Definition: parse-tree.h:1911
Definition: parse-tree.h:1358
Definition: parse-tree.h:3455
Definition: parse-tree.h:3460
Definition: parse-tree.h:2016
Definition: parse-tree.h:2173
Definition: parse-tree.h:2164
Definition: parse-tree.h:2157
Definition: parse-tree.h:1340
Definition: parse-tree.h:1388
Definition: parse-tree.h:3400
Definition: parse-tree.h:1127
Definition: parse-tree.h:1449
Definition: parse-tree.h:1456
Definition: parse-tree.h:2195
Definition: parse-tree.h:3027
Definition: parse-tree.h:2028
Definition: parse-tree.h:3394
Definition: parse-tree.h:5486
Definition: parse-tree.h:5480
Definition: parse-tree.h:5477
Definition: parse-tree.h:5471
Definition: parse-tree.h:3279
Definition: parse-tree.h:3276
Definition: parse-tree.h:3259
Definition: parse-tree.h:2438
Definition: parse-tree.h:2437
Definition: parse-tree.h:2419
Definition: parse-tree.h:2425
Definition: parse-tree.h:2407
Definition: parse-tree.h:2405
Definition: parse-tree.h:2226
Definition: parse-tree.h:2211
Definition: parse-tree.h:663
Definition: parse-tree.h:1840
Definition: parse-tree.h:868
Definition: parse-tree.h:681
Definition: parse-tree.h:679
Definition: parse-tree.h:2696
Definition: parse-tree.h:2695
Definition: parse-tree.h:2203
Definition: parse-tree.h:984
Definition: parse-tree.h:1462
Definition: parse-tree.h:1902
Definition: parse-tree.h:1626
Definition: parse-tree.h:1635
Definition: parse-tree.h:1634
Definition: parse-tree.h:3367
Definition: parse-tree.h:3360
Definition: parse-tree.h:3364
Definition: parse-tree.h:3372
Definition: parse-tree.h:3379
Definition: parse-tree.h:3376
Definition: parse-tree.h:3358
Definition: parse-tree.h:854
Definition: parse-tree.h:846
Definition: parse-tree.h:995
Definition: parse-tree.h:1008
Definition: parse-tree.h:1039
Definition: parse-tree.h:1116
Definition: parse-tree.h:1061
Definition: parse-tree.h:1220
Definition: parse-tree.h:2524
Definition: parse-tree.h:2251
Definition: parse-tree.h:2673
Definition: parse-tree.h:2671
Definition: parse-tree.h:300
Definition: parse-tree.h:2242
Definition: parse-tree.h:2233
Definition: parse-tree.h:1069
Definition: parse-tree.h:1516
Definition: parse-tree.h:1528
Definition: parse-tree.h:1818
Definition: parse-tree.h:1487
Definition: parse-tree.h:1536
Definition: parse-tree.h:1502
Definition: parse-tree.h:1542
Definition: parse-tree.h:1508
Definition: parse-tree.h:2010
Definition: parse-tree.h:431
Definition: parse-tree.h:775
Definition: parse-tree.h:770
Definition: parse-tree.h:768
Definition: parse-tree.h:324
Definition: parse-tree.h:605
Definition: parse-tree.h:1205
Definition: parse-tree.h:750
Definition: parse-tree.h:926
Definition: parse-tree.h:1857
Definition: parse-tree.h:1554
Definition: parse-tree.h:1553
Definition: parse-tree.h:2338
Definition: parse-tree.h:3160
Definition: parse-tree.h:2358
Definition: parse-tree.h:2220
Definition: parse-tree.h:1403
Definition: parse-tree.h:3332
Definition: parse-tree.h:1249
Definition: parse-tree.h:1235
Definition: parse-tree.h:2578
Definition: parse-tree.h:2584
Definition: parse-tree.h:2592
Definition: parse-tree.h:523
Definition: parse-tree.h:547
Definition: parse-tree.h:978
Definition: parse-tree.h:965
Definition: parse-tree.h:1764
Definition: parse-tree.h:1737
Definition: parse-tree.h:1778
Definition: parse-tree.h:1743
Definition: parse-tree.h:1782
Definition: parse-tree.h:1719
Definition: parse-tree.h:1734
Definition: parse-tree.h:1770
Definition: parse-tree.h:1752
Definition: parse-tree.h:1758
Definition: parse-tree.h:1761
Definition: parse-tree.h:1724
Definition: parse-tree.h:1749
Definition: parse-tree.h:1746
Definition: parse-tree.h:1731
Definition: parse-tree.h:1773
Definition: parse-tree.h:1755
Definition: parse-tree.h:1713
Definition: parse-tree.h:1710
Definition: parse-tree.h:1767
Definition: parse-tree.h:1704
Definition: parse-tree.h:1728
Definition: parse-tree.h:1740
Definition: parse-tree.h:1707
Definition: parse-tree.h:1700
Definition: parse-tree.h:1055
Definition: parse-tree.h:2114
Definition: parse-tree.h:2130
Definition: parse-tree.h:2108
Definition: parse-tree.h:2143
Definition: parse-tree.h:2120
Definition: parse-tree.h:3264
Definition: parse-tree.h:3149
Definition: parse-tree.h:3298
Definition: parse-tree.h:3040
Definition: parse-tree.h:3055
Definition: parse-tree.h:875
Definition: parse-tree.h:2377
Definition: parse-tree.h:2373
Definition: parse-tree.h:2372
Definition: parse-tree.h:2388
Definition: parse-tree.h:2351
Definition: parse-tree.h:1685
Definition: parse-tree.h:1694
Definition: parse-tree.h:413
Definition: parse-tree.h:1610
Definition: parse-tree.h:1619
Definition: parse-tree.h:618
Definition: parse-tree.h:1026
Definition: parse-tree.h:2889
Definition: parse-tree.h:2897
Definition: parse-tree.h:2902
Definition: parse-tree.h:2887
Definition: parse-tree.h:2917
Definition: parse-tree.h:2915
Definition: parse-tree.h:802
Definition: parse-tree.h:308
Definition: parse-tree.h:1366
Definition: parse-tree.h:1562
Definition: parse-tree.h:3216
Definition: parse-tree.h:3183
Definition: parse-tree.h:3189
Definition: parse-tree.h:3181
Definition: parse-tree.h:3206
Definition: parse-tree.h:3061
Definition: parse-tree.h:469
Definition: parse-tree.h:457
Definition: parse-tree.h:713
Definition: parse-tree.h:708
Definition: parse-tree.h:718
Definition: parse-tree.h:702
Definition: parse-tree.h:700
Definition: parse-tree.h:2731
Definition: parse-tree.h:2729
Definition: parse-tree.h:2643
Definition: parse-tree.h:789
Definition: parse-tree.h:651
Definition: parse-tree.h:2315
Definition: parse-tree.h:1319
Definition: parse-tree.h:669
Definition: parse-tree.h:1604
Definition: parse-tree.h:900
Definition: parse-tree.h:2287
Definition: parse-tree.h:2283
Definition: parse-tree.h:2619
Definition: parse-tree.h:2618
Definition: parse-tree.h:882
Definition: parse-tree.h:316
Definition: parse-tree.h:1284
Definition: parse-tree.h:2305
Definition: parse-tree.h:2303
Definition: parse-tree.h:2936
Definition: parse-tree.h:3416
Definition: parse-tree.h:2075
Definition: parse-tree.h:2960
Definition: parse-tree.h:2950
Definition: parse-tree.h:2971
Definition: parse-tree.h:580
Definition: parse-tree.h:1325
Definition: parse-tree.h:632
Definition: parse-tree.h:631
Definition: parse-tree.h:2321
Definition: parse-tree.h:2546
Definition: parse-tree.h:1436
Definition: parse-tree.h:4138
Definition: parse-tree.h:4144
Definition: parse-tree.h:4142
Definition: parse-tree.h:4157
Definition: parse-tree.h:4164
Definition: parse-tree.h:4172
Definition: parse-tree.h:4187
Definition: parse-tree.h:4195
Definition: parse-tree.h:4194
Definition: parse-tree.h:4203
Definition: parse-tree.h:4215
Definition: parse-tree.h:4774
Definition: parse-tree.h:5129
Definition: parse-tree.h:4855
Definition: parse-tree.h:4226
Definition: parse-tree.h:4784
Definition: parse-tree.h:4232
Definition: parse-tree.h:4745
Definition: parse-tree.h:4729
Definition: parse-tree.h:4241
Definition: parse-tree.h:4909
Definition: parse-tree.h:4904
Definition: parse-tree.h:4899
Definition: parse-tree.h:4890
Definition: parse-tree.h:4258
Definition: parse-tree.h:4276
Definition: parse-tree.h:4333
Definition: parse-tree.h:4331
Definition: parse-tree.h:4359
Definition: parse-tree.h:4369
Definition: parse-tree.h:4379
Definition: parse-tree.h:3486
Definition: parse-tree.h:4752
Definition: parse-tree.h:4313
Definition: parse-tree.h:4384
Definition: parse-tree.h:4779
Definition: parse-tree.h:5135
Definition: parse-tree.h:4860
Definition: parse-tree.h:4395
Definition: parse-tree.h:4815
Definition: parse-tree.h:4403
Definition: parse-tree.h:4416
Definition: parse-tree.h:4427
Definition: parse-tree.h:4434
Definition: parse-tree.h:4442
Definition: parse-tree.h:4458
Definition: parse-tree.h:4468
Definition: parse-tree.h:4447
Definition: parse-tree.h:4717
Definition: parse-tree.h:4481
Definition: parse-tree.h:4476
Definition: parse-tree.h:4288
Definition: parse-tree.h:4297
Definition: parse-tree.h:4491
Definition: parse-tree.h:4506
Definition: parse-tree.h:5047
Definition: parse-tree.h:4532
Definition: parse-tree.h:4544
Definition: parse-tree.h:4553
Definition: parse-tree.h:4807
Definition: parse-tree.h:4577
Definition: parse-tree.h:3507
Definition: parse-tree.h:4588
Definition: parse-tree.h:4601
Definition: parse-tree.h:4613
Definition: parse-tree.h:4624
Definition: parse-tree.h:3531
Definition: parse-tree.h:3521
Definition: parse-tree.h:4638
Definition: parse-tree.h:4850
Definition: parse-tree.h:4648
Definition: parse-tree.h:4657
Definition: parse-tree.h:4673
Definition: parse-tree.h:4690
Definition: parse-tree.h:4701
Definition: parse-tree.h:3071
Definition: parse-tree.h:5383
Definition: parse-tree.h:5390
Definition: parse-tree.h:5319
Definition: parse-tree.h:5412
Definition: parse-tree.h:5451
Definition: parse-tree.h:5422
Definition: parse-tree.h:5440
Definition: parse-tree.h:5431
Definition: parse-tree.h:5313
Definition: parse-tree.h:5445
Definition: parse-tree.h:5395
Definition: parse-tree.h:5325
Definition: parse-tree.h:5012
Definition: parse-tree.h:4844
Definition: parse-tree.h:5035
Definition: parse-tree.h:5025
Definition: parse-tree.h:5017
Definition: parse-tree.h:5060
Definition: parse-tree.h:5053
Definition: parse-tree.h:5160
Definition: parse-tree.h:4989
Definition: parse-tree.h:4971
Definition: parse-tree.h:4832
Definition: parse-tree.h:4977
Definition: parse-tree.h:4922
Definition: parse-tree.h:4931
Definition: parse-tree.h:4941
Definition: parse-tree.h:4914
Definition: parse-tree.h:5071
Definition: parse-tree.h:5085
Definition: parse-tree.h:5155
Definition: parse-tree.h:4997
Definition: parse-tree.h:5101
Definition: parse-tree.h:4951
Definition: parse-tree.h:5109
Definition: parse-tree.h:5144
Definition: parse-tree.h:4957
Definition: parse-tree.h:4871
Definition: parse-tree.h:4877
Definition: parse-tree.h:5114
Definition: parse-tree.h:5120
Definition: parse-tree.h:4964
Definition: parse-tree.h:4821
Definition: parse-tree.h:372
Definition: parse-tree.h:2807
Definition: parse-tree.h:2770
Definition: parse-tree.h:2996
Definition: parse-tree.h:1806
Definition: parse-tree.h:2041
Definition: parse-tree.h:2040
Definition: parse-tree.h:1572
Definition: parse-tree.h:1999
Definition: parse-tree.h:2833
Definition: parse-tree.h:3116
Definition: parse-tree.h:2791
Definition: parse-tree.h:939
Definition: parse-tree.h:3094
Definition: parse-tree.h:1080
Definition: parse-tree.h:1108
Definition: parse-tree.h:1897
Definition: parse-tree.h:1100
Definition: parse-tree.h:1094
Definition: parse-tree.h:1087
Definition: parse-tree.h:3104
Definition: parse-tree.h:3231
Definition: parse-tree.h:3199
Definition: parse-tree.h:564
Definition: parse-tree.h:2754
Definition: parse-tree.h:823
Definition: parse-tree.h:821
Definition: parse-tree.h:2272
Definition: parse-tree.h:2984
Definition: parse-tree.h:2988
Definition: parse-tree.h:2982
Definition: parse-tree.h:1585
Definition: parse-tree.h:292
Definition: parse-tree.h:1671
Definition: parse-tree.h:2395
Definition: parse-tree.h:2461
Definition: parse-tree.h:2460
Definition: parse-tree.h:2474
Definition: parse-tree.h:2472
Definition: parse-tree.h:2451
Definition: parse-tree.h:2508
Definition: parse-tree.h:2506
Definition: parse-tree.h:2486
Definition: parse-tree.h:2151
Definition: parse-tree.h:3324
Definition: parse-tree.h:860
Definition: parse-tree.h:795
Definition: parse-tree.h:835
Definition: parse-tree.h:394
Definition: parse-tree.h:445
Definition: parse-tree.h:1968
Definition: parse-tree.h:355
Definition: parse-tree.h:3342
Definition: parse-tree.h:2538
Definition: parse-tree.h:1887
Definition: parse-tree.h:1226
Definition: parse-tree.h:3437
Definition: parse-tree.h:3409
Definition: parse-tree.h:3432
Definition: parse-tree.h:3002
Definition: parse-tree.h:3013
Definition: parse-tree.h:3168
Definition: parse-tree.h:3308
Definition: parse-tree.h:1662
Definition: parse-tree.h:1849
Definition: parse-tree.h:1653
Definition: parse-tree.h:1835
Definition: parse-tree.h:3135
Definition: parse-tree.h:2557
Definition: parse-tree.h:2556
Definition: parse-tree.h:2569
Definition: parse-tree.h:917
Definition: parse-tree.h:1169
Definition: parse-tree.h:1182
Definition: parse-tree.h:1135
Definition: parse-tree.h:1191
Definition: parse-tree.h:1155
Definition: parse-tree.h:1147
Definition: parse-tree.h:1145
Definition: parse-tree.h:1417
Definition: parse-tree.h:2496
Definition: parse-tree.h:2495
Definition: parse-tree.h:945
Definition: parse-tree.h:953
Definition: parse-tree.h:744
Definition: parse-tree.h:642
Definition: parse-tree.h:757
Definition: parse-tree.h:3425
Definition: parse-tree.h:350
Definition: parse-tree.h:2628
Definition: parse-tree.h:808
Definition: parse-tree.h:3080
Definition: parse-tree.h:1865
Definition: parse-tree.h:730
Definition: parse-tree.h:735
Definition: parse-tree.h:279
Definition: parse-tree.h:2817
Definition: parse-tree.h:2066
Definition: parse-tree.h:2059
Definition: parse-tree.h:2095
Definition: parse-tree.h:2091
Definition: parse-tree.h:2090
Definition: parse-tree.h:2053
Definition: parse-tree.h:2776
Definition: parse-tree.h:3584
Definition: parse-tree.h:3576
Definition: parse-tree.h:3544
Definition: parse-tree.h:3556
Definition: parse-tree.h:3569
Definition: parse-tree.h:3537
Definition: parse-tree.h:3739
Definition: parse-tree.h:3756
Definition: parse-tree.h:3748
Definition: parse-tree.h:3772
Definition: parse-tree.h:3764
Definition: parse-tree.h:3784
Definition: parse-tree.h:3794
Definition: parse-tree.h:3805
Definition: parse-tree.h:3818
Definition: parse-tree.h:3830
Definition: parse-tree.h:3851
Definition: parse-tree.h:3860
Definition: parse-tree.h:3878
Definition: parse-tree.h:3893
Definition: parse-tree.h:3911
Definition: parse-tree.h:3902
Definition: parse-tree.h:3920
Definition: parse-tree.h:3932
Definition: parse-tree.h:3942
Definition: parse-tree.h:3950
Definition: parse-tree.h:3959
Definition: parse-tree.h:3994
Definition: parse-tree.h:3981
Definition: parse-tree.h:3968
Definition: parse-tree.h:4018
Definition: parse-tree.h:4009
Definition: parse-tree.h:4028
Definition: parse-tree.h:4041
Definition: parse-tree.h:4050
Definition: parse-tree.h:4060
Definition: parse-tree.h:4070
Definition: parse-tree.h:4079
Definition: parse-tree.h:4087
Definition: parse-tree.h:4097
Definition: parse-tree.h:4108
Definition: parse-tree.h:4121
Definition: parse-tree.h:3715
Definition: parse-tree.h:3625
Definition: parse-tree.h:3622
Definition: parse-tree.h:3605
Definition: parse-tree.h:3646
Definition: parse-tree.h:3612
Definition: parse-tree.h:3673
Definition: parse-tree.h:3688
Definition: parse-tree.h:3685
Definition: parse-tree.h:3698
Definition: parse-tree.h:3707