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 {
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); \
158struct AllocatableStmt;
159struct AsynchronousStmt;
161struct CodimensionStmt;
162struct ContiguousStmt;
169struct OldParameterStmt;
179struct EquivalenceStmt;
216struct SyncMemoryStmt;
258struct BasedPointerStmt;
276using Location =
const char *;
281 constexpr Verbatim() {}
282 COPY_AND_ASSIGN_BOILERPLATE(Verbatim);
283 using EmptyTrait = std::true_type;
292template <
typename A>
struct Scalar {
293 using ConstraintTrait = std::true_type;
294 Scalar(Scalar &&that) =
default;
295 Scalar(A &&that) : thing(std::move(that)) {}
296 Scalar &operator=(Scalar &&) =
default;
300template <
typename A>
struct Constant {
301 using ConstraintTrait = std::true_type;
302 Constant(Constant &&that) =
default;
303 Constant(A &&that) : thing(std::move(that)) {}
304 Constant &operator=(Constant &&) =
default;
308template <
typename A>
struct Integer {
309 using ConstraintTrait = std::true_type;
310 Integer(Integer &&that) =
default;
311 Integer(A &&that) : thing(std::move(that)) {}
312 Integer &operator=(Integer &&) =
default;
316template <
typename A>
struct Logical {
317 using ConstraintTrait = std::true_type;
318 Logical(Logical &&that) =
default;
319 Logical(A &&that) : thing(std::move(that)) {}
320 Logical &operator=(Logical &&) =
default;
324template <
typename A>
struct DefaultChar {
325 using ConstraintTrait = std::true_type;
326 DefaultChar(DefaultChar &&that) =
default;
327 DefaultChar(A &&that) : thing(std::move(that)) {}
328 DefaultChar &operator=(DefaultChar &&) =
default;
346using Label = common::Label;
350template <
typename A>
struct UnlabeledStatement {
351 explicit UnlabeledStatement(A &&s) : statement(std::move(s)) {}
355template <
typename A>
struct Statement :
public UnlabeledStatement<A> {
356 Statement(std::optional<long> &&lab, A &&s)
357 : UnlabeledStatement<A>{std::move(s)}, label(std::move(lab)) {}
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;
613using ObjectName =
Name;
619 BOILERPLATE(ImportStmt);
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;
680 UNION_CLASS_BOILERPLATE(CharSelector);
681 struct LengthAndKind {
682 BOILERPLATE(LengthAndKind);
683 LengthAndKind(std::optional<TypeParamValue> &&l, ScalarIntConstantExpr &&k)
684 : length(std::move(l)), kind(std::move(k)) {}
685 std::optional<TypeParamValue> length;
686 ScalarIntConstantExpr kind;
689 : u{
LengthAndKind{std::make_optional(std::move(l)), std::move(k)}} {}
690 CharSelector(ScalarIntConstantExpr &&k, std::optional<TypeParamValue> &&l)
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);
709 BOILERPLATE(Complex);
710 Complex(std::optional<KindSelector> &&k) : kind{std::move(k)} {}
711 std::optional<KindSelector> kind;
714 BOILERPLATE(Character);
715 Character(std::optional<CharSelector> &&s) : selector{std::move(s)} {}
716 std::optional<CharSelector> selector;
719 BOILERPLATE(Logical);
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 };
821struct RealLiteralConstant {
822 BOILERPLATE(RealLiteralConstant);
824 COPY_AND_ASSIGN_BOILERPLATE(Real);
828 RealLiteralConstant(
Real &&r, std::optional<KindParam> &&k)
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>>
960WRAPPER_CLASS(SpecificationExpr, ScalarIntExpr);
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);
1028 std::variant<ConstantExpr, NullInit, InitialDataTarget,
1029 std::list<common::Indirection<DataStmtValue>>>
1039struct ComponentDecl {
1040 TUPLE_CLASS_BOILERPLATE(ComponentDecl);
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;
1147 struct WithoutInterface {
1148 BOILERPLATE(WithoutInterface);
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;
1155 struct WithInterface {
1156 BOILERPLATE(WithInterface);
1157 WithInterface(
Name &&n, std::list<BindAttr> &&as, std::list<Name> &&bs)
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>,
1270 BOILERPLATE(AcSpec);
1271 AcSpec(std::optional<TypeSpec> &&ts, std::list<AcValue> &&xs)
1272 : type(std::move(ts)), values(std::move(xs)) {}
1273 explicit AcSpec(
TypeSpec &&ts) : type{std::move(ts)} {}
1274 std::optional<TypeSpec> type;
1275 std::list<AcValue> values;
1279WRAPPER_CLASS(ArrayConstructor,
AcSpec);
1284template <
typename VAR,
typename BOUND>
struct LoopBounds {
1285 LoopBounds(LoopBounds &&that) =
default;
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)} {}
1290 LoopBounds &operator=(LoopBounds &&) =
default;
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>
1404 TUPLE_CLASS_BOILERPLATE(EntityDecl);
1405 EntityDecl(ObjectName &&name,
CharLength &&length,
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>);
1490 mutable TypedExpr typedExpr;
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;
1639 BOILERPLATE(CommonStmt);
1640 CommonStmt(std::optional<Name> &&, std::list<CommonBlockObject> &&,
1641 std::list<Block> &&);
1643 std::list<Block> blocks;
1651WRAPPER_CLASS(EquivalenceStmt, std::list<std::list<EquivalenceObject>>);
1656 std::tuple<std::optional<ScalarIntExpr>, std::optional<ScalarIntExpr>> t;
1660using Subscript = ScalarIntExpr;
1665 std::tuple<std::optional<Subscript>, std::optional<Subscript>,
1666 std::optional<Subscript>>
1674 std::variant<IntExpr, SubscriptTriplet> u;
1678using Cosubscript = ScalarIntExpr;
1688 WRAPPER_CLASS(Team_Number, ScalarIntExpr);
1690 std::variant<Stat, TeamValue, Team_Number> u;
1697 std::tuple<std::list<Cosubscript>, std::list<ImageSelectorSpec>> t;
1702 UNION_CLASS_BOILERPLATE(Expr);
1706 using IntrinsicUnary::IntrinsicUnary;
1709 using IntrinsicUnary::IntrinsicUnary;
1712 using IntrinsicUnary::IntrinsicUnary;
1714 struct NOT :
public IntrinsicUnary {
1715 using IntrinsicUnary::IntrinsicUnary;
1722 std::tuple<DefinedOpName, common::Indirection<Expr>> t;
1730 using IntrinsicBinary::IntrinsicBinary;
1733 using IntrinsicBinary::IntrinsicBinary;
1736 using IntrinsicBinary::IntrinsicBinary;
1739 using IntrinsicBinary::IntrinsicBinary;
1742 using IntrinsicBinary::IntrinsicBinary;
1745 using IntrinsicBinary::IntrinsicBinary;
1748 using IntrinsicBinary::IntrinsicBinary;
1751 using IntrinsicBinary::IntrinsicBinary;
1754 using IntrinsicBinary::IntrinsicBinary;
1757 using IntrinsicBinary::IntrinsicBinary;
1760 using IntrinsicBinary::IntrinsicBinary;
1763 using IntrinsicBinary::IntrinsicBinary;
1766 using IntrinsicBinary::IntrinsicBinary;
1769 using IntrinsicBinary::IntrinsicBinary;
1772 using IntrinsicBinary::IntrinsicBinary;
1775 using IntrinsicBinary::IntrinsicBinary;
1780 using IntrinsicBinary::IntrinsicBinary;
1785 std::tuple<DefinedOpName, common::Indirection<Expr>,
1793 mutable TypedExpr typedExpr;
1797 std::variant<common::Indirection<CharLiteralConstantSubstring>,
1801 Add,
Subtract,
Concat,
LT,
LE,
EQ,
NE,
GE,
GT,
AND,
OR,
EQV,
NEQV,
1808 BOILERPLATE(PartRef);
1809 PartRef(
Name &&n, std::list<SectionSubscript> &&ss,
1810 std::optional<ImageSelector> &&is)
1811 : name{std::move(n)}, subscripts(std::move(ss)),
1812 imageSelector{std::move(is)} {}
1814 std::list<SectionSubscript> subscripts;
1815 std::optional<ImageSelector> imageSelector;
1820 UNION_CLASS_BOILERPLATE(DataRef);
1821 explicit DataRef(std::list<PartRef> &&);
1822 std::variant<Name, common::Indirection<StructureComponent>,
1838 std::tuple<DataRef, SubstringRange> t;
1843 std::tuple<CharLiteralConstant, SubstringRange> t;
1860 bool EndsInBareName()
const;
1862 std::variant<DataRef, Substring> u;
1868 mutable TypedExpr typedExpr;
1870 std::variant<common::Indirection<Designator>,
1888struct StructureComponent {
1889 BOILERPLATE(StructureComponent);
1891 : base{std::move(dr)}, component(std::move(n)) {}
1903struct CoindexedNamedObject {
1904 BOILERPLATE(CoindexedNamedObject);
1906 : base{std::move(dr)}, imageSelector{std::move(is)} {}
1912struct ArrayElement {
1913 BOILERPLATE(ArrayElement);
1914 ArrayElement(
DataRef &&dr, std::list<SectionSubscript> &&ss)
1915 : base{std::move(dr)}, subscripts(std::move(ss)) {}
1920 std::list<SectionSubscript> subscripts;
1926 mutable TypedExpr typedExpr;
1927 std::variant<Name, StructureComponent> u;
1932using BoundExpr = ScalarIntExpr;
1938 std::tuple<std::optional<BoundExpr>, BoundExpr> t;
1947 std::tuple<std::list<AllocateCoshapeSpec>, std::optional<BoundExpr>> t;
1955 std::tuple<AllocateObject, std::list<AllocateShapeSpec>,
1956 std::optional<AllocateCoarraySpec>>
1961WRAPPER_CLASS(StatVariable, ScalarIntVariable);
1965WRAPPER_CLASS(MsgVariable, ScalarDefaultCharVariable);
1971 std::variant<StatVariable, MsgVariable> u;
1986 std::variant<Mold, Source, StatOrErrmsg, Stream, Pinned> u;
1993 std::tuple<std::optional<TypeSpec>, std::list<Allocation>,
1994 std::list<AllocOpt>>
2002 mutable TypedExpr typedExpr;
2003 std::variant<Name, StructureComponent> u;
2007WRAPPER_CLASS(NullifyStmt, std::list<PointerObject>);
2013 std::tuple<std::list<AllocateObject>, std::list<StatOrErrmsg>> t;
2019 using TypedAssignment =
2021 mutable TypedAssignment typedAssignment;
2022 std::tuple<Variable, Expr> t;
2026WRAPPER_CLASS(BoundsSpec, BoundExpr);
2031 std::tuple<BoundExpr, BoundExpr> t;
2043 UNION_CLASS_BOILERPLATE(
Bounds);
2044 std::variant<std::list<BoundsRemapping>, std::list<BoundsSpec>> u;
2047 mutable AssignmentStmt::TypedAssignment typedAssignment;
2048 std::tuple<DataRef, Bounds, Expr> t;
2056 std::tuple<LogicalExpr, AssignmentStmt> t;
2062 std::tuple<std::optional<Name>, LogicalExpr> t;
2078 std::tuple<LogicalExpr, std::optional<Name>> t;
2082WRAPPER_CLASS(ElsewhereStmt, std::optional<Name>);
2085WRAPPER_CLASS(EndWhereStmt, std::optional<Name>);
2094 std::tuple<Statement<MaskedElsewhereStmt>, std::list<WhereBodyConstruct>> t;
2098 std::tuple<Statement<ElsewhereStmt>, std::list<WhereBodyConstruct>> t;
2101 std::tuple<Statement<WhereConstructStmt>, std::list<WhereBodyConstruct>,
2102 std::list<MaskedElsewhere>, std::optional<Elsewhere>,
2117 std::variant<AssignmentStmt, PointerAssignmentStmt> u;
2123 std::tuple<common::Indirection<ConcurrentHeader>,
2140WRAPPER_CLASS(EndForallStmt, std::optional<Name>);
2146 std::tuple<Statement<ForallConstructStmt>, std::list<ForallBodyConstruct>,
2154 std::variant<Expr, Variable> u;
2160 std::tuple<Name, Selector> t;
2167 std::tuple<std::optional<Name>, std::list<Association>> t;
2171WRAPPER_CLASS(EndAssociateStmt, std::optional<Name>);
2180WRAPPER_CLASS(BlockStmt, std::optional<Name>);
2183WRAPPER_CLASS(EndBlockStmt, std::optional<Name>);
2198 std::tuple<Statement<BlockStmt>, BlockSpecificationPart, Block,
2206 std::tuple<CodimensionDecl, Selector> t;
2214 std::tuple<std::optional<Name>, TeamValue, std::list<CoarrayAssociation>,
2215 std::list<StatOrErrmsg>>
2223 std::tuple<std::list<StatOrErrmsg>, std::optional<Name>> t;
2236 std::tuple<std::optional<Name>, std::list<StatOrErrmsg>> t;
2240WRAPPER_CLASS(EndCriticalStmt, std::optional<Name>);
2254 std::tuple<Name, ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>>
2263 std::tuple<std::optional<IntegerTypeSpec>, std::list<ConcurrentControl>,
2264 std::optional<ScalarLogicalExpr>>
2275 Operator, Plus, Multiply, Max, Min, Iand, Ior, Ieor, And, Or, Eqv, Neqv)
2286 WRAPPER_CLASS(Local, std::list<Name>);
2287 WRAPPER_CLASS(LocalInit, std::list<Name>);
2289 TUPLE_CLASS_BOILERPLATE(
Reduce);
2291 std::tuple<Operator, std::list<Name>> t;
2293 WRAPPER_CLASS(Shared, std::list<Name>);
2294 EMPTY_CLASS(DefaultNone);
2295 std::variant<Local, LocalInit, Reduce, Shared, DefaultNone> u;
2308 std::tuple<ConcurrentHeader, std::list<LocalitySpec>> t;
2311 std::variant<Bounds, ScalarLogicalExpr, Concurrent> u;
2318 std::tuple<Label, std::optional<LoopControl>> t;
2324 std::tuple<std::optional<Name>, std::optional<Label>,
2325 std::optional<LoopControl>>
2330WRAPPER_CLASS(EndDoStmt, std::optional<Name>);
2341 const std::optional<LoopControl> &GetLoopControl()
const;
2342 bool IsDoNormal()
const;
2343 bool IsDoWhile()
const;
2344 bool IsDoConcurrent()
const;
2349WRAPPER_CLASS(CycleStmt, std::optional<Name>);
2354 std::tuple<std::optional<Name>, ScalarLogicalExpr> t;
2361 std::tuple<ScalarLogicalExpr, std::optional<Name>> t;
2365WRAPPER_CLASS(ElseStmt, std::optional<Name>);
2368WRAPPER_CLASS(EndIfStmt, std::optional<Name>);
2376 std::tuple<Statement<ElseIfStmt>, Block> t;
2380 std::tuple<Statement<ElseStmt>, Block> t;
2383 std::tuple<Statement<IfThenStmt>, Block, std::list<ElseIfBlock>,
2390 TUPLE_CLASS_BOILERPLATE(
IfStmt);
2391 std::tuple<ScalarLogicalExpr, UnlabeledStatement<ActionStmt>> t;
2410 Range(std::optional<CaseValue> &&l, std::optional<CaseValue> &&u)
2411 : lower{std::move(l)}, upper{std::move(u)} {}
2412 std::optional<CaseValue> lower, upper;
2414 std::variant<CaseValue, Range> u;
2418EMPTY_CLASS(Default);
2422 std::variant<std::list<CaseValueRange>, Default> u;
2428 std::tuple<CaseSelector, std::optional<Name>> t;
2434WRAPPER_CLASS(EndSelectStmt, std::optional<Name>);
2440 TUPLE_CLASS_BOILERPLATE(
Case);
2441 std::tuple<Statement<CaseStmt>, Block> t;
2444 std::tuple<Statement<SelectCaseStmt>, std::list<Case>,
2454 std::tuple<std::optional<Name>, std::optional<Name>,
Selector> t;
2463 UNION_CLASS_BOILERPLATE(
Rank);
2464 std::variant<ScalarIntConstantExpr, Star, Default> u;
2467 std::tuple<Rank, std::optional<Name>> t;
2477 std::tuple<Statement<SelectRankCaseStmt>, Block> t;
2479 std::tuple<Statement<SelectRankStmt>, std::list<RankCase>,
2489 std::tuple<std::optional<Name>, std::optional<Name>,
Selector> t;
2498 UNION_CLASS_BOILERPLATE(
Guard);
2499 std::variant<TypeSpec, DerivedTypeSpec, Default> u;
2502 std::tuple<Guard, std::optional<Name>> t;
2511 std::tuple<Statement<TypeGuardStmt>, Block> t;
2513 std::tuple<Statement<SelectTypeStmt>, std::list<TypeCase>,
2519WRAPPER_CLASS(ExitStmt, std::optional<Name>);
2522WRAPPER_CLASS(GotoStmt, Label);
2527 std::tuple<std::list<Label>, ScalarIntExpr> t;
2540 ENUM_CLASS(Kind, Stop, ErrorStop)
2542 std::tuple<Kind, std::optional<StopCode>, std::optional<ScalarLogicalExpr>> t;
2549 std::tuple<Scalar<Variable>, std::list<EventWaitSpec>> t;
2553WRAPPER_CLASS(SyncAllStmt, std::list<StatOrErrmsg>);
2560 std::variant<IntExpr, Star> u;
2563 std::tuple<ImageSet, std::list<StatOrErrmsg>> t;
2567WRAPPER_CLASS(SyncMemoryStmt, std::list<StatOrErrmsg>);
2572 std::tuple<TeamValue, std::list<StatOrErrmsg>> t;
2581 std::tuple<EventVariable, std::list<StatOrErrmsg>> t;
2587 std::variant<ScalarIntExpr, StatOrErrmsg> u;
2595 std::tuple<EventVariable, std::list<EventWaitSpec>> t;
2608 std::variant<ScalarIntExpr, StatOrErrmsg> u;
2611 std::tuple<ScalarIntExpr, TeamVariable, std::list<FormTeamSpec>> t;
2622 std::variant<Scalar<Logical<Variable>>,
StatOrErrmsg> u;
2625 std::tuple<LockVariable, std::list<LockStat>> t;
2631 std::tuple<LockVariable, std::list<StatOrErrmsg>> t;
2635WRAPPER_CLASS(FileUnitNumber, ScalarIntExpr);
2645 UNION_CLASS_BOILERPLATE(
IoUnit);
2646 std::variant<Variable, common::Indirection<Expr>, Star> u;
2650using FileNameExpr = ScalarDefaultCharExpr;
2669WRAPPER_CLASS(StatusExpr, ScalarDefaultCharExpr);
2670WRAPPER_CLASS(ErrLabel, Label);
2675 ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
2676 Encoding, Form, Pad, Position, Round, Sign,
2677 Carriagecontrol, Convert, Dispose)
2679 std::tuple<Kind, ScalarDefaultCharExpr> t;
2681 WRAPPER_CLASS(Recl, ScalarIntExpr);
2682 WRAPPER_CLASS(Newunit, ScalarIntVariable);
2683 std::variant<FileUnitNumber, FileNameExpr,
CharExpr, MsgVariable,
2684 StatVariable, Recl, Newunit, ErrLabel, StatusExpr>
2689WRAPPER_CLASS(OpenStmt, std::list<ConnectSpec>);
2699 std::variant<FileUnitNumber, StatVariable, MsgVariable, ErrLabel,
2703 WRAPPER_CLASS_BOILERPLATE(
CloseStmt, std::list<CloseSpec>);
2709 UNION_CLASS_BOILERPLATE(
Format);
2710 std::variant<Expr, Label, Star> u;
2714WRAPPER_CLASS(IdVariable, ScalarIntVariable);
2728WRAPPER_CLASS(EndLabel, Label);
2729WRAPPER_CLASS(EorLabel, Label);
2733 ENUM_CLASS(Kind, Advance, Blank, Decimal, Delim, Pad, Round, Sign)
2735 std::tuple<Kind, ScalarDefaultCharExpr> t;
2737 WRAPPER_CLASS(Asynchronous, ScalarDefaultCharConstantExpr);
2738 WRAPPER_CLASS(Pos, ScalarIntExpr);
2739 WRAPPER_CLASS(Rec, ScalarIntExpr);
2740 WRAPPER_CLASS(Size, ScalarIntVariable);
2742 ErrLabel, IdVariable, MsgVariable, StatVariable, Pos, Rec, Size>
2749 std::variant<Variable, common::Indirection<InputImpliedDo>> u;
2756 BOILERPLATE(ReadStmt);
2757 ReadStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
2758 std::list<IoControlSpec> &&cs, std::list<InputItem> &&its)
2759 : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
2760 items(std::move(its)) {}
2761 std::optional<IoUnit> iounit;
2763 std::optional<Format> format;
2766 std::list<IoControlSpec> controls;
2767 std::list<InputItem> items;
2773 std::variant<Expr, common::Indirection<OutputImpliedDo>> u;
2778 BOILERPLATE(WriteStmt);
2779 WriteStmt(std::optional<IoUnit> &&i, std::optional<Format> &&f,
2780 std::list<IoControlSpec> &&cs, std::list<OutputItem> &&its)
2781 : iounit{std::move(i)}, format{std::move(f)}, controls(std::move(cs)),
2782 items(std::move(its)) {}
2783 std::optional<IoUnit> iounit;
2785 std::optional<Format> format;
2787 std::list<IoControlSpec> controls;
2788 std::list<OutputItem> items;
2794 std::tuple<Format, std::list<OutputItem>> t;
2805 std::tuple<std::list<InputItem>, IoImpliedDoControl> t;
2810 std::tuple<std::list<OutputItem>, IoImpliedDoControl> t;
2817WRAPPER_CLASS(IdExpr, ScalarIntExpr);
2820 std::variant<FileUnitNumber, EndLabel, EorLabel, ErrLabel, IdExpr,
2821 MsgVariable, StatVariable>
2826WRAPPER_CLASS(WaitStmt, std::list<WaitSpec>);
2836 std::variant<FileUnitNumber, MsgVariable, StatVariable, ErrLabel> u;
2841WRAPPER_CLASS(BackspaceStmt, std::list<PositionOrFlushSpec>);
2845WRAPPER_CLASS(EndfileStmt, std::list<PositionOrFlushSpec>);
2848WRAPPER_CLASS(RewindStmt, std::list<PositionOrFlushSpec>);
2851WRAPPER_CLASS(FlushStmt, std::list<PositionOrFlushSpec>);
2891 ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
2892 Direct, Encoding, Form, Formatted, Iomsg,
Name, Pad, Position, Read,
2893 Readwrite, Round, Sequential, Sign, Stream, Status, Unformatted, Write,
2894 Carriagecontrol, Convert, Dispose)
2895 TUPLE_CLASS_BOILERPLATE(
CharVar);
2896 std::tuple<Kind, ScalarDefaultCharVariable> t;
2899 ENUM_CLASS(Kind, Iostat, Nextrec, Number, Pos, Recl, Size)
2900 TUPLE_CLASS_BOILERPLATE(
IntVar);
2901 std::tuple<Kind, ScalarIntVariable> t;
2904 ENUM_CLASS(Kind, Exist, Named, Opened, Pending)
2905 TUPLE_CLASS_BOILERPLATE(
LogVar);
2906 std::tuple<Kind, Scalar<Logical<Variable>>> t;
2920 std::tuple<ScalarIntVariable, std::list<OutputItem>> t;
2922 std::variant<std::list<InquireSpec>,
Iolength> u;
2929WRAPPER_CLASS(ProgramStmt,
Name);
2932WRAPPER_CLASS(EndProgramStmt, std::optional<Name>);
2940 ExecutionPart, std::optional<InternalSubprogramPart>,
2946WRAPPER_CLASS(ModuleStmt,
Name);
2953 std::variant<common::Indirection<FunctionSubprogram>,
2963 std::tuple<Statement<ContainsStmt>, std::list<ModuleSubprogram>> t;
2967WRAPPER_CLASS(EndModuleStmt, std::optional<Name>);
2973 TUPLE_CLASS_BOILERPLATE(
Module);
2984 UNION_CLASS_BOILERPLATE(
Rename);
2986 TUPLE_CLASS_BOILERPLATE(
Names);
2987 std::tuple<Name, Name> t;
2991 std::tuple<DefinedOpName, DefinedOpName> t;
2993 std::variant<Names, Operators> u;
2999 std::tuple<Name, std::optional<Name>> t;
3005 std::tuple<ParentIdentifier, Name> t;
3009WRAPPER_CLASS(EndSubmoduleStmt, std::optional<Name>);
3022WRAPPER_CLASS(BlockDataStmt, std::optional<Name>);
3025WRAPPER_CLASS(EndBlockDataStmt, std::optional<Name>);
3043 EMPTY_CLASS(Assignment);
3044 EMPTY_CLASS(ReadFormatted);
3045 EMPTY_CLASS(ReadUnformatted);
3046 EMPTY_CLASS(WriteFormatted);
3047 EMPTY_CLASS(WriteUnformatted);
3050 ReadUnformatted, WriteFormatted, WriteUnformatted>
3058 std::tuple<std::optional<AccessSpec>,
GenericSpec, std::list<Name>> t;
3062struct InterfaceStmt {
3063 UNION_CLASS_BOILERPLATE(InterfaceStmt);
3065 InterfaceStmt(Abstract x) : u{x} {}
3067 std::variant<std::optional<GenericSpec>, Abstract> u;
3073 UNION_CLASS_BOILERPLATE(
Only);
3074 std::variant<common::Indirection<GenericSpec>,
Name,
Rename> u;
3082 BOILERPLATE(UseStmt);
3083 ENUM_CLASS(ModuleNature, Intrinsic, Non_Intrinsic)
3084 template <
typename A>
3085 UseStmt(std::optional<ModuleNature> &&nat,
Name &&n, std::list<A> &&x)
3086 : nature(std::move(nat)), moduleName(std::move(n)), u(std::move(x)) {}
3087 std::optional<ModuleNature> nature;
3089 std::variant<std::list<Rename>, std::list<Only>> u;
3107 std::tuple<std::optional<ProcInterface>, std::list<ProcAttrSpec>,
3108 std::list<ProcDecl>>
3119 EMPTY_CLASS(Elemental);
3120 EMPTY_CLASS(Impure);
3122 EMPTY_CLASS(Non_Recursive);
3124 EMPTY_CLASS(Recursive);
3125 WRAPPER_CLASS(Attributes, std::list<common::CUDASubprogramAttrs>);
3126 WRAPPER_CLASS(Launch_Bounds, std::list<ScalarIntConstantExpr>);
3127 WRAPPER_CLASS(Cluster_Dims, std::list<ScalarIntConstantExpr>);
3129 Pure, Recursive, Attributes, Launch_Bounds, Cluster_Dims>
3137 BOILERPLATE(Suffix);
3139 : binding(std::move(lbs)), resultName(std::move(rn)) {}
3140 Suffix(
Name &&rn, std::optional<LanguageBindingSpec> &&lbs)
3141 : binding(std::move(lbs)), resultName(std::move(rn)) {}
3142 std::optional<LanguageBindingSpec> binding;
3143 std::optional<Name> resultName;
3152 std::tuple<std::list<PrefixSpec>,
Name, std::list<Name>,
3153 std::optional<Suffix>>
3158WRAPPER_CLASS(EndFunctionStmt, std::optional<Name>);
3163 std::variant<Name, Star> u;
3171 std::tuple<std::list<PrefixSpec>,
Name, std::list<DummyArg>,
3172 std::optional<LanguageBindingSpec>>
3177WRAPPER_CLASS(EndSubroutineStmt, std::optional<Name>);
3192 std::tuple<Statement<SubroutineStmt>,
3196 std::variant<Function, Subroutine> u;
3201 ENUM_CLASS(Kind, ModuleProcedure, Procedure)
3203 std::tuple<Kind, std::list<Name>> t;
3209 std::variant<InterfaceBody, Statement<ProcedureStmt>> u;
3213WRAPPER_CLASS(EndInterfaceStmt, std::optional<GenericSpec>);
3219 std::tuple<Statement<InterfaceStmt>, std::list<InterfaceSpecification>,
3225WRAPPER_CLASS(ExternalStmt, std::list<Name>);
3228WRAPPER_CLASS(IntrinsicStmt, std::list<Name>);
3234 std::variant<Name, ProcComponentRef> u;
3238WRAPPER_CLASS(AltReturnSpec, Label);
3244 WRAPPER_CLASS(PercentRef,
Expr);
3245 WRAPPER_CLASS(PercentVal,
Expr);
3246 UNION_CLASS_BOILERPLATE(ActualArg);
3248 std::variant<common::Indirection<Expr>, AltReturnSpec, PercentRef, PercentVal>
3255 std::tuple<std::optional<Keyword>,
ActualArg> t;
3261 TUPLE_CLASS_BOILERPLATE(
Call);
3262 std::tuple<ProcedureDesignator, std::list<ActualArgSpec>> t;
3278 BOILERPLATE(CallStmt);
3279 WRAPPER_CLASS(StarOrExpr, std::optional<ScalarExpr>);
3282 std::tuple<StarOrExpr, ScalarExpr, std::optional<ScalarIntExpr>,
3283 std::optional<ScalarIntExpr>>
3287 std::list<ActualArgSpec> &&args)
3288 : call{std::move(pd), std::move(args)}, chevrons{std::move(ch)} {}
3290 std::optional<Chevrons> chevrons;
3317WRAPPER_CLASS(MpSubprogramStmt,
Name);
3320WRAPPER_CLASS(EndMpSubprogramStmt, std::optional<Name>);
3335 std::tuple<Name, std::list<DummyArg>, std::optional<Suffix>> t;
3339WRAPPER_CLASS(ReturnStmt, std::optional<ScalarIntExpr>);
3363 std::tuple<std::optional<std::list<const char *>>,
Name> t;
3366 WRAPPER_CLASS_BOILERPLATE(
LoopCount, std::list<std::uint64_t>);
3370 std::tuple<common::Indirection<Designator>, uint64_t> t;
3372 EMPTY_CLASS(VectorAlways);
3375 std::tuple<Name, std::optional<std::uint64_t>> t;
3378 WRAPPER_CLASS_BOILERPLATE(
Unroll, std::optional<std::uint64_t>);
3381 WRAPPER_CLASS_BOILERPLATE(
UnrollAndJam, std::optional<std::uint64_t>);
3383 EMPTY_CLASS(NoVector);
3384 EMPTY_CLASS(NoUnroll);
3385 EMPTY_CLASS(NoUnrollAndJam);
3386 EMPTY_CLASS(Unrecognized);
3388 std::variant<std::list<IgnoreTKR>,
LoopCount, std::list<AssumeAligned>,
3390 NoVector, NoUnroll, NoUnrollAndJam>
3397 std::tuple<common::CUDADataAttr, std::list<Name>> t;
3403 std::tuple<ObjectName, ObjectName, std::optional<ArraySpec>> t;
3405WRAPPER_CLASS(BasedPointerStmt, std::list<BasedPointer>);
3412 std::variant<Statement<DataComponentDefStmt>,
3418 EMPTY_CLASS(MapStmt);
3419 EMPTY_CLASS(EndMapStmt);
3420 TUPLE_CLASS_BOILERPLATE(
Map);
3421 std::tuple<Statement<MapStmt>, std::list<StructureField>,
3427 EMPTY_CLASS(UnionStmt);
3428 EMPTY_CLASS(EndUnionStmt);
3429 TUPLE_CLASS_BOILERPLATE(
Union);
3435 std::tuple<std::optional<Name>, std::list<EntityDecl>> t;
3439 EMPTY_CLASS(EndStructureStmt);
3441 std::tuple<Statement<StructureStmt>, std::list<StructureField>,
3448WRAPPER_CLASS(OldParameterStmt, std::list<NamedConstantDef>);
3453 std::tuple<Expr, Label, Label, Label> t;
3458 std::tuple<Label, Name> t;
3463 std::tuple<Name, std::list<Label>> t;
3466WRAPPER_CLASS(PauseStmt, std::optional<StopCode>);
3472#define INHERITED_TUPLE_CLASS_BOILERPLATE(classname, basename) \
3473 using basename::basename; \
3474 classname(basename &&b) : basename(std::move(b)) {} \
3475 using TupleTrait = std::true_type; \
3476 BOILERPLATE(classname)
3478#define INHERITED_WRAPPER_CLASS_BOILERPLATE(classname, basename) \
3479 BOILERPLATE(classname); \
3480 using basename::basename; \
3481 classname(basename &&base) : basename(std::move(base)) {} \
3482 using WrapperTrait = std::true_type
3487struct OmpDirectiveName {
3489 constexpr OmpDirectiveName() =
default;
3490 constexpr OmpDirectiveName(
const OmpDirectiveName &) =
default;
3491 constexpr OmpDirectiveName(llvm::omp::Directive x) : v(x) {}
3495 OmpDirectiveName(
const Verbatim &name);
3496 using WrapperTrait = std::true_type;
3498 bool IsExecutionPart()
const;
3501 llvm::omp::Directive v{llvm::omp::Directive::OMPD_unknown};
3512 ENUM_CLASS(Kind, BlankCommonBlock);
3513 WRAPPER_CLASS_BOILERPLATE(
Invalid, Kind);
3520WRAPPER_CLASS(OmpObjectList, std::list<OmpObject>);
3531 std::variant<DefinedOperator, ProcedureDesignator> u;
3541 std::variant<AssignmentStmt, FunctionReference> u;
3544inline namespace arguments {
3547 std::variant<TypeSpec, DeclarationTypeSpec> u;
3550WRAPPER_CLASS(OmpTypeNameList, std::list<OmpTypeSpecifier>);
3554 std::variant<OmpObject, FunctionReference> u;
3557WRAPPER_CLASS(OmpLocatorList, std::list<OmpLocator>);
3568 std::tuple<OmpObject, OmpObject> t;
3579 std::tuple<std::string, TypeSpec, Name> t;
3592 std::optional<OmpReductionCombiner>>
3611inline namespace traits {
3648 TUPLE_CLASS_BOILERPLATE(
Complex);
3650 std::list<common::Indirection<OmpTraitPropertyExtension>>>
3654 std::variant<OmpTraitPropertyName, ScalarExpr, Complex> u;
3670 std::variant<OmpTraitPropertyName, common::Indirection<OmpClause>,
3695 std::string ToString()
const;
3698 ENUM_CLASS(Value, Arch, Atomic_Default_Mem_Order, Condition, Device_Num,
3699 Extension, Isa, Kind, Requires, Simd, Uid, Vendor)
3700 std::variant<Value, llvm::omp::Directive, std::string> u;
3711 std::tuple<std::optional<OmpTraitScore>, std::list<OmpTraitProperty>> t;
3713 std::tuple<OmpTraitSelectorName, std::optional<Properties>> t;
3720 std::string ToString()
const;
3722 ENUM_CLASS(Value, Construct, Device, Implementation, Target_Device, User)
3731 std::tuple<OmpTraitSetSelectorName, std::list<OmpTraitSelector>> t;
3738 WRAPPER_CLASS_BOILERPLATE(
3743#define MODIFIER_BOILERPLATE(...) \
3745 using Variant = std::variant<__VA_ARGS__>; \
3746 UNION_CLASS_BOILERPLATE(Modifier); \
3751#define MODIFIERS() std::optional<std::list<Modifier>>
3753inline namespace modifier {
3761 ENUM_CLASS(Value, Cgroup);
3770 WRAPPER_CLASS_BOILERPLATE(
OmpAlignment, ScalarIntExpr);
3806 ENUM_CLASS(Value, Always)
3816 ENUM_CLASS(Value, Automap);
3827 ENUM_CLASS(Value, Simd)
3840 ENUM_CLASS(Value, Close)
3852 ENUM_CLASS(Value, Delete)
3873 ENUM_CLASS(Value, Sink, Source);
3882 ENUM_CLASS(Value, Ancestor, Device_Num)
3900 INHERITED_WRAPPER_CLASS_BOILERPLATE(
3915 ENUM_CLASS(Value, Present);
3925 std::variant<CharLiteralConstant, ScalarIntConstantExpr> u;
3933 WRAPPER_CLASS_BOILERPLATE(
3942 ENUM_CLASS(Value, Target, TargetSync)
3956 std::tuple<TypeDeclarationStmt, SubscriptTriplet> t;
3964 WRAPPER_CLASS_BOILERPLATE(
OmpIterator, std::list<OmpIteratorSpecifier>);
3972 ENUM_CLASS(Value, Conditional)
3981 ENUM_CLASS(Value, Ref, Uval, Val);
4003 ENUM_CLASS(Value, Alloc, Delete, From, Release, Storage, To, Tofrom);
4004 WRAPPER_CLASS_BOILERPLATE(
OmpMapType, Value);
4016 ENUM_CLASS(Value, Always, Close, Present, Ompx_Hold)
4031 ENUM_CLASS(Value, Monotonic, Nonmonotonic, Simd)
4040 ENUM_CLASS(Value, Reproducible, Unconstrained)
4050 ENUM_CLASS(Value, Strict, Fallback)
4063 ENUM_CLASS(Value, Present)
4072 ENUM_CLASS(Value, Default, Inscan, Task);
4082 ENUM_CLASS(Value, Ref_Ptee, Ref_Ptr, Ref_Ptr_Ptee)
4092 ENUM_CLASS(Value, Self)
4119 ENUM_CLASS(Value, In, Out, Inout, Inoutset, Mutexinoutset, Depobj)
4130 ENUM_CLASS(Value, Aggregate, All, Allocatable, Pointer,
Scalar)
4143 ENUM_CLASS(Value, Ompx_Hold)
4153using OmpDirectiveList = std::list<llvm::omp::Directive>;
4166 ENUM_CLASS(Value, Nothing, Need_Device_Ptr)
4169 std::tuple<OmpAdjustOp, OmpObjectList> t;
4181 std::tuple<MODIFIERS(), OmpObjectList> t;
4196 std::tuple<OmpObjectList, MODIFIERS()> t;
4212 std::tuple<MODIFIERS(), OmpObjectList> t;
4217 WRAPPER_CLASS_BOILERPLATE(
OmpAppendOp, std::list<OmpInteropType>);
4225 ENUM_CLASS(ActionTime, Compilation, Execution);
4226 WRAPPER_CLASS_BOILERPLATE(
OmpAtClause, ActionTime);
4237 using MemoryOrder = common::OmpMemoryOrderType;
4248 ENUM_CLASS(Binding, Parallel, Teams, Thread)
4255 std::tuple<OmpDirectiveName, std::optional<ScalarLogicalExpr>> t;
4280 ENUM_CLASS(DataSharingAttribute, Private, Firstprivate, Shared, None)
4282 std::variant<DataSharingAttribute,
4299 ENUM_CLASS(ImplicitBehavior, Alloc, To, From, Tofrom, Firstprivate, None,
4302 std::tuple<ImplicitBehavior, MODIFIERS()> t;
4311 std::tuple<DefinedOperator, ScalarIntConstantExpr> t;
4320 std::tuple<Name, std::optional<OmpIterationOffset>> t;
4327WRAPPER_CLASS(OmpIterationVector, std::list<OmpIteration>);
4335 OmpDependenceType::Value GetDepType()
const;
4337 WRAPPER_CLASS(Sink, OmpIterationVector);
4338 EMPTY_CLASS(Source);
4340 std::variant<Sink, Source> u;
4355 OmpTaskDependenceType::Value GetTaskDepType()
const;
4356 TUPLE_CLASS_BOILERPLATE(
TaskDep);
4358 std::tuple<MODIFIERS(), OmpObjectList> t;
4360 std::variant<TaskDep, OmpDoacross> u;
4374WRAPPER_CLASS(OmpDestroyClause,
OmpObject);
4393 std::tuple<MODIFIERS(), ScalarIntExpr> t;
4401 ENUM_CLASS(DeviceTypeDescription, Any, Host, Nohost)
4408 std::tuple<MODIFIERS(), ScalarIntExpr> t;
4419 std::tuple<MODIFIERS(), OmpObjectList> t;
4425 using MemoryOrder = common::OmpMemoryOrderType;
4440 std::tuple<MODIFIERS(), OmpObjectList,
bool> t;
4451 std::tuple<MODIFIERS(), ScalarIntExpr> t;
4472 WRAPPER_CLASS_BOILERPLATE(
OmpHintClause, ScalarIntConstantExpr);
4485 WRAPPER_CLASS_BOILERPLATE(
4498 std::tuple<MODIFIERS(), ScalarLogicalExpr> t;
4508 std::tuple<MODIFIERS(), OmpObjectList> t;
4515 std::tuple<ProcedureDesignator, std::list<ActualArgSpec>> t;
4520 std::variant<OmpInitializerProc, AssignmentStmt> u;
4531 std::tuple<MODIFIERS(), OmpObjectList> t;
4545 MODIFIER_BOILERPLATE(
4547 std::tuple<OmpObjectList, MODIFIERS(),
bool> t;
4556 std::tuple<ScalarIntConstantExpr, ScalarIntConstantExpr> t;
4583 std::tuple<MODIFIERS(), OmpObjectList,
bool> t;
4592 WRAPPER_CLASS_BOILERPLATE(
4606EMPTY_CLASS(OmpNoOpenMPClause);
4611EMPTY_CLASS(OmpNoOpenMPRoutinesClause);
4616EMPTY_CLASS(OmpNoParallelismClause);
4626 std::tuple<MODIFIERS(), ScalarIntExpr> t;
4636 ENUM_CLASS(Ordering, Concurrent)
4638 std::tuple<MODIFIERS(), Ordering> t;
4660 ENUM_CLASS(AffinityPolicy, Close, Master, Spread, Primary)
4673 std::tuple<MODIFIERS(), OmpObjectList> t;
4694 ENUM_CLASS(Kind, Static, Dynamic, Guided, Auto, Runtime)
4696 std::tuple<MODIFIERS(), Kind, std::optional<ScalarIntExpr>> t;
4703 ENUM_CLASS(Severity, Fatal, Warning);
4714 std::tuple<MODIFIERS(), OmpObjectList> t;
4730 std::tuple<MODIFIERS(), OmpObjectList,
bool> t;
4755 std::variant<OmpDependenceType, OmpTaskDependenceType> u;
4765 MODIFIER_BOILERPLATE(OmpContextSelector);
4766 std::tuple<MODIFIERS(),
4767 std::optional<common::Indirection<OmpDirectiveSpecification>>>
4793 llvm::omp::Clause Id()
const;
4795#define GEN_FLANG_CLAUSE_PARSER_CLASSES
4796#include "llvm/Frontend/OpenMP/OMP.inc"
4801#define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
4802#include "llvm/Frontend/OpenMP/OMP.inc"
4808 WRAPPER_CLASS_BOILERPLATE(
OmpClauseList, std::list<OmpClause>);
4815 ENUM_CLASS(Flags, None, DeprecatedSyntax);
4818 return std::get<OmpDirectiveName>(t);
4820 llvm::omp::Directive DirId()
const {
4827 std::tuple<OmpDirectiveName, std::optional<OmpArgumentList>,
4828 std::optional<OmpClauseList>, Flags>
4837 INHERITED_TUPLE_CLASS_BOILERPLATE(
4849 return std::get<OmpBeginDirective>(t);
4851 const std::optional<OmpEndDirective> &EndDir()
const {
4852 return std::get<std::optional<OmpEndDirective>>(t);
4856 std::tuple<OmpBeginDirective, Block, std::optional<OmpEndDirective>> t;
4860 WRAPPER_CLASS_BOILERPLATE(
4881 std::variant<OmpErrorDirective, OmpNothingDirective> u;
4890 WRAPPER_CLASS_BOILERPLATE(
4908 INHERITED_TUPLE_CLASS_BOILERPLATE(
4923 std::tuple<std::optional<OmpDirectiveSpecification>, Block> t;
4931 return std::get<OmpBeginSectionsDirective>(t);
4933 const std::optional<OmpEndSectionsDirective> &EndDir()
const {
4934 return std::get<std::optional<OmpEndSectionsDirective>>(t);
4941 std::tuple<OmpBeginSectionsDirective, std::list<OpenMPConstruct>,
4942 std::optional<OmpEndSectionsDirective>>
4951 WRAPPER_CLASS_BOILERPLATE(
4963 WRAPPER_CLASS_BOILERPLATE(
4971 WRAPPER_CLASS_BOILERPLATE(
4980 WRAPPER_CLASS_BOILERPLATE(
4988 WRAPPER_CLASS_BOILERPLATE(
5018 std::tuple<Verbatim, OmpObjectList, OmpClauseList> t;
5044 std::tuple<Verbatim, std::optional<OmpObjectList>,
OmpClauseList,
5045 std::optional<std::list<OpenMPDeclarativeAllocate>>,
5057 INHERITED_TUPLE_CLASS_BOILERPLATE(
5062 llvm::omp::Clause GetKind()
const;
5063 bool IsCapture()
const;
5064 bool IsCompare()
const;
5070 static constexpr int None = 0;
5071 static constexpr int Read = 1;
5072 static constexpr int Write = 2;
5073 static constexpr int Update = Read | Write;
5074 static constexpr int Action = 3;
5075 static constexpr int IfTrue = 4;
5076 static constexpr int IfFalse = 8;
5077 static constexpr int Condition = 12;
5081 AssignmentStmt::TypedAssignment assign;
5083 TypedExpr atom, cond;
5092 WRAPPER_CLASS_BOILERPLATE(
5153 WRAPPER_CLASS_BOILERPLATE(
5176using NestedConstruct =
5177 std::variant<DoConstruct, common::Indirection<OpenMPLoopConstruct>>;
5178struct OpenMPLoopConstruct {
5179 TUPLE_CLASS_BOILERPLATE(OpenMPLoopConstruct);
5181 : t({std::move(a), std::nullopt, std::nullopt}) {}
5184 return std::get<OmpBeginLoopDirective>(t);
5186 const std::optional<OmpEndLoopDirective> &EndDir()
const {
5187 return std::get<std::optional<OmpEndLoopDirective>>(t);
5189 std::tuple<OmpBeginLoopDirective, std::optional<NestedConstruct>,
5190 std::optional<OmpEndLoopDirective>>
5218WRAPPER_CLASS(AccObjectList, std::list<AccObject>);
5250 std::variant<Name, ScalarDefaultCharExpr> u;
5260 ENUM_CLASS(Modifier, ReadOnly, Zero)
5267 std::tuple<std::optional<AccDataModifier>, AccObjectList> t;
5272 std::tuple<ReductionOperator, AccObjectList> t;
5277 std::tuple<std::optional<ScalarIntExpr>, std::list<ScalarIntExpr>> t;
5281 WRAPPER_CLASS_BOILERPLATE(
5287 WRAPPER_CLASS_BOILERPLATE(
5294 std::tuple<std::optional<ScalarIntConstantExpr>> t;
5302 WRAPPER_CLASS_BOILERPLATE(
AccSizeExpr, std::optional<ScalarIntExpr>);
5311 std::variant<std::optional<ScalarLogicalExpr>, AccObjectList> u;
5318 WRAPPER_CLASS(Num, ScalarIntExpr);
5319 WRAPPER_CLASS(Dim, ScalarIntExpr);
5321 std::variant<Num, Dim, Static> u;
5326 WRAPPER_CLASS_BOILERPLATE(
AccGangArgList, std::list<AccGangArg>);
5331 std::tuple<bool, ScalarIntConstantExpr> t;
5337#define GEN_FLANG_CLAUSE_PARSER_CLASSES
5338#include "llvm/Frontend/OpenACC/ACC.inc"
5343#define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
5344#include "llvm/Frontend/OpenACC/ACC.inc"
5350 WRAPPER_CLASS_BOILERPLATE(
AccClauseList, std::list<AccClause>);
5363 std::tuple<Verbatim, AccObjectListWithModifier> t;
5369 std::tuple<Verbatim, std::optional<AccWaitArgument>,
AccClauseList> t;
5374 std::tuple<AccLoopDirective, AccClauseList> t;
5381 std::tuple<AccBlockDirective, AccClauseList> t;
5390EMPTY_CLASS(AccEndAtomic);
5395 std::tuple<Verbatim, AccClauseList, Statement<AssignmentStmt>,
5396 std::optional<AccEndAtomic>>
5403 std::tuple<Verbatim, AccClauseList, Statement<AssignmentStmt>,
5404 std::optional<AccEndAtomic>>
5412 std::optional<AccEndAtomic>>
5421 std::tuple<Verbatim, AccClauseList, Stmt1, Stmt2, AccEndAtomic> t;
5426 std::variant<AccAtomicRead, AccAtomicWrite, AccAtomicCapture, AccAtomicUpdate>
5433 std::tuple<AccBeginBlockDirective, Block, AccEndBlockDirective> t;
5439 std::tuple<AccDeclarativeDirective, AccClauseList> t;
5445 std::tuple<AccCombinedDirective, AccClauseList> t;
5453struct OpenACCCombinedConstruct {
5454 TUPLE_CLASS_BOILERPLATE(OpenACCCombinedConstruct);
5457 : t({std::move(a), std::nullopt, std::nullopt}) {}
5458 std::tuple<AccBeginCombinedDirective, std::optional<DoConstruct>,
5459 std::optional<AccEndCombinedDirective>>
5466 std::variant<OpenACCStandaloneDeclarativeConstruct, OpenACCRoutineConstruct>
5471EMPTY_CLASS(AccEndLoop);
5472struct OpenACCLoopConstruct {
5473 TUPLE_CLASS_BOILERPLATE(OpenACCLoopConstruct);
5475 : t({std::move(a), std::nullopt, std::nullopt}) {}
5476 std::tuple<AccBeginLoopDirective, std::optional<DoConstruct>,
5477 std::optional<AccEndLoop>>
5489 std::tuple<AccStandaloneDirective, AccClauseList> t;
5515 std::tuple<Operator, std::list<Scalar<Variable>>> t;
5520 WRAPPER_CLASS(StarOrExpr, std::optional<ScalarIntExpr>);
5523 std::tuple<std::list<StarOrExpr>, std::list<StarOrExpr>,
5524 std::optional<ScalarIntExpr>>
5530 std::tuple<std::optional<ScalarIntConstantExpr>,
5531 std::optional<LaunchConfiguration>, std::list<CUFReduction>>
5534 std::tuple<Directive, std::optional<DoConstruct>> t;
Definition indirection.h:127
Definition indirection.h:31
Definition char-block.h:28
Definition check-expression.h:19
Definition expression.h:906
Definition expression.h:896
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:5417
Definition parse-tree.h:5393
Definition parse-tree.h:5409
Definition parse-tree.h:5401
Definition parse-tree.h:5378
Definition parse-tree.h:5442
Definition parse-tree.h:5372
Definition parse-tree.h:5248
Definition parse-tree.h:5221
Definition parse-tree.h:5349
Definition parse-tree.h:5334
Definition parse-tree.h:5329
Definition parse-tree.h:5237
Definition parse-tree.h:5259
Definition parse-tree.h:5242
Definition parse-tree.h:5254
Definition parse-tree.h:5286
Definition parse-tree.h:5280
Definition parse-tree.h:5384
Definition parse-tree.h:5448
Definition parse-tree.h:5325
Definition parse-tree.h:5316
Definition parse-tree.h:5226
Definition parse-tree.h:5265
Definition parse-tree.h:5270
Definition parse-tree.h:5213
Definition parse-tree.h:5309
Definition parse-tree.h:5305
Definition parse-tree.h:5301
Definition parse-tree.h:5231
Definition parse-tree.h:5297
Definition parse-tree.h:5291
Definition parse-tree.h:5275
Definition parse-tree.h:909
Definition parse-tree.h:1427
Definition parse-tree.h:490
Definition parse-tree.h:3253
Definition parse-tree.h:3243
Definition parse-tree.h:1980
Definition parse-tree.h:1945
Definition parse-tree.h:1924
Definition parse-tree.h:1936
Definition parse-tree.h:1991
Definition parse-tree.h:1953
Definition parse-tree.h:3451
Definition parse-tree.h:1912
Definition parse-tree.h:1358
Definition parse-tree.h:3456
Definition parse-tree.h:3461
Definition parse-tree.h:2017
Definition parse-tree.h:2174
Definition parse-tree.h:2165
Definition parse-tree.h:2158
Definition parse-tree.h:1340
Definition parse-tree.h:1388
Definition parse-tree.h:3401
Definition parse-tree.h:1127
Definition parse-tree.h:1449
Definition parse-tree.h:1456
Definition parse-tree.h:2196
Definition parse-tree.h:3028
Definition parse-tree.h:2029
Definition parse-tree.h:3395
Definition parse-tree.h:5527
Definition parse-tree.h:5521
Definition parse-tree.h:5518
Definition parse-tree.h:5512
Definition parse-tree.h:3280
Definition parse-tree.h:3277
Definition parse-tree.h:3260
Definition parse-tree.h:2439
Definition parse-tree.h:2438
Definition parse-tree.h:2420
Definition parse-tree.h:2426
Definition parse-tree.h:2406
Definition parse-tree.h:2227
Definition parse-tree.h:2212
Definition parse-tree.h:663
Definition parse-tree.h:1841
Definition parse-tree.h:868
Definition parse-tree.h:681
Definition parse-tree.h:679
Definition parse-tree.h:2697
Definition parse-tree.h:2696
Definition parse-tree.h:2204
Definition parse-tree.h:984
Definition parse-tree.h:1462
Definition parse-tree.h:1903
Definition parse-tree.h:1626
Definition parse-tree.h:1635
Definition parse-tree.h:1634
Definition parse-tree.h:3368
Definition parse-tree.h:3361
Definition parse-tree.h:3365
Definition parse-tree.h:3373
Definition parse-tree.h:3380
Definition parse-tree.h:3377
Definition parse-tree.h:3359
Definition parse-tree.h:854
Definition parse-tree.h:846
Definition parse-tree.h:995
Definition parse-tree.h:1008
Definition parse-tree.h:1116
Definition parse-tree.h:1061
Definition parse-tree.h:1220
Definition parse-tree.h:2525
Definition parse-tree.h:2252
Definition parse-tree.h:2674
Definition parse-tree.h:2672
Definition parse-tree.h:300
Definition parse-tree.h:2243
Definition parse-tree.h:2234
Definition parse-tree.h:1069
Definition parse-tree.h:1516
Definition parse-tree.h:1528
Definition parse-tree.h:1819
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:2011
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:1858
Definition parse-tree.h:1554
Definition parse-tree.h:1553
Definition parse-tree.h:2339
Definition parse-tree.h:3161
Definition parse-tree.h:2359
Definition parse-tree.h:2221
Definition parse-tree.h:3333
Definition parse-tree.h:1249
Definition parse-tree.h:1235
Definition parse-tree.h:2579
Definition parse-tree.h:2585
Definition parse-tree.h:2593
Definition parse-tree.h:523
Definition parse-tree.h:547
Definition parse-tree.h:978
Definition parse-tree.h:965
Definition parse-tree.h:1765
Definition parse-tree.h:1738
Definition parse-tree.h:1779
Definition parse-tree.h:1744
Definition parse-tree.h:1783
Definition parse-tree.h:1720
Definition parse-tree.h:1735
Definition parse-tree.h:1771
Definition parse-tree.h:1753
Definition parse-tree.h:1759
Definition parse-tree.h:1762
Definition parse-tree.h:1725
Definition parse-tree.h:1750
Definition parse-tree.h:1747
Definition parse-tree.h:1732
Definition parse-tree.h:1774
Definition parse-tree.h:1756
Definition parse-tree.h:1714
Definition parse-tree.h:1711
Definition parse-tree.h:1768
Definition parse-tree.h:1705
Definition parse-tree.h:1729
Definition parse-tree.h:1741
Definition parse-tree.h:1708
Definition parse-tree.h:1701
Definition parse-tree.h:1055
Definition parse-tree.h:2115
Definition parse-tree.h:2131
Definition parse-tree.h:2109
Definition parse-tree.h:2144
Definition parse-tree.h:2121
Definition parse-tree.h:3265
Definition parse-tree.h:3150
Definition parse-tree.h:3299
Definition parse-tree.h:3041
Definition parse-tree.h:3056
Definition parse-tree.h:875
Definition parse-tree.h:2378
Definition parse-tree.h:2374
Definition parse-tree.h:2373
Definition parse-tree.h:2389
Definition parse-tree.h:2352
Definition parse-tree.h:1686
Definition parse-tree.h:1695
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:2890
Definition parse-tree.h:2898
Definition parse-tree.h:2903
Definition parse-tree.h:2888
Definition parse-tree.h:2918
Definition parse-tree.h:2916
Definition parse-tree.h:802
Definition parse-tree.h:308
Definition parse-tree.h:1366
Definition parse-tree.h:1562
Definition parse-tree.h:3217
Definition parse-tree.h:3184
Definition parse-tree.h:3190
Definition parse-tree.h:3182
Definition parse-tree.h:3207
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:2732
Definition parse-tree.h:2730
Definition parse-tree.h:2644
Definition parse-tree.h:789
Definition parse-tree.h:651
Definition parse-tree.h:2316
Definition parse-tree.h:1319
Definition parse-tree.h:669
Definition parse-tree.h:1604
Definition parse-tree.h:900
Definition parse-tree.h:2288
Definition parse-tree.h:2284
Definition parse-tree.h:2620
Definition parse-tree.h:2619
Definition parse-tree.h:882
Definition parse-tree.h:316
Definition parse-tree.h:1284
Definition parse-tree.h:2306
Definition parse-tree.h:2304
Definition parse-tree.h:2937
Definition parse-tree.h:3417
Definition parse-tree.h:2076
Definition parse-tree.h:2961
Definition parse-tree.h:2951
Definition parse-tree.h:2972
Definition parse-tree.h:580
Definition parse-tree.h:1325
Definition parse-tree.h:632
Definition parse-tree.h:631
Definition parse-tree.h:2322
Definition parse-tree.h:2547
Definition parse-tree.h:1436
Definition parse-tree.h:4159
Definition parse-tree.h:4165
Definition parse-tree.h:4163
Definition parse-tree.h:4178
Definition parse-tree.h:4185
Definition parse-tree.h:4193
Definition parse-tree.h:4208
Definition parse-tree.h:4216
Definition parse-tree.h:4215
Definition parse-tree.h:4224
Definition parse-tree.h:4236
Definition parse-tree.h:4836
Definition parse-tree.h:5167
Definition parse-tree.h:4907
Definition parse-tree.h:4247
Definition parse-tree.h:4846
Definition parse-tree.h:4253
Definition parse-tree.h:4807
Definition parse-tree.h:4791
Definition parse-tree.h:4262
Definition parse-tree.h:4950
Definition parse-tree.h:4279
Definition parse-tree.h:4297
Definition parse-tree.h:4354
Definition parse-tree.h:4352
Definition parse-tree.h:4380
Definition parse-tree.h:4390
Definition parse-tree.h:4400
Definition parse-tree.h:3487
Definition parse-tree.h:4814
Definition parse-tree.h:4334
Definition parse-tree.h:4405
Definition parse-tree.h:4841
Definition parse-tree.h:5171
Definition parse-tree.h:4912
Definition parse-tree.h:4416
Definition parse-tree.h:4874
Definition parse-tree.h:4424
Definition parse-tree.h:4437
Definition parse-tree.h:4448
Definition parse-tree.h:4458
Definition parse-tree.h:4466
Definition parse-tree.h:4471
Definition parse-tree.h:4479
Definition parse-tree.h:4495
Definition parse-tree.h:4505
Definition parse-tree.h:4484
Definition parse-tree.h:4779
Definition parse-tree.h:4518
Definition parse-tree.h:4513
Definition parse-tree.h:4309
Definition parse-tree.h:4318
Definition parse-tree.h:4528
Definition parse-tree.h:4543
Definition parse-tree.h:4554
Definition parse-tree.h:4578
Definition parse-tree.h:4590
Definition parse-tree.h:4599
Definition parse-tree.h:4868
Definition parse-tree.h:4623
Definition parse-tree.h:3511
Definition parse-tree.h:3508
Definition parse-tree.h:4634
Definition parse-tree.h:4647
Definition parse-tree.h:4659
Definition parse-tree.h:4670
Definition parse-tree.h:3539
Definition parse-tree.h:3529
Definition parse-tree.h:4680
Definition parse-tree.h:4692
Definition parse-tree.h:4702
Definition parse-tree.h:4711
Definition parse-tree.h:4727
Definition parse-tree.h:4737
Definition parse-tree.h:4752
Definition parse-tree.h:4763
Definition parse-tree.h:3072
Definition parse-tree.h:5424
Definition parse-tree.h:5431
Definition parse-tree.h:5360
Definition parse-tree.h:5453
Definition parse-tree.h:5492
Definition parse-tree.h:5463
Definition parse-tree.h:5481
Definition parse-tree.h:5472
Definition parse-tree.h:5354
Definition parse-tree.h:5486
Definition parse-tree.h:5436
Definition parse-tree.h:5366
Definition parse-tree.h:5056
Definition parse-tree.h:4901
Definition parse-tree.h:5079
Definition parse-tree.h:5069
Definition parse-tree.h:5061
Definition parse-tree.h:5098
Definition parse-tree.h:5091
Definition parse-tree.h:5201
Definition parse-tree.h:5033
Definition parse-tree.h:5015
Definition parse-tree.h:4889
Definition parse-tree.h:5021
Definition parse-tree.h:4970
Definition parse-tree.h:4979
Definition parse-tree.h:4987
Definition parse-tree.h:4962
Definition parse-tree.h:5109
Definition parse-tree.h:5123
Definition parse-tree.h:5196
Definition parse-tree.h:5041
Definition parse-tree.h:5139
Definition parse-tree.h:4997
Definition parse-tree.h:5147
Definition parse-tree.h:5178
Definition parse-tree.h:5003
Definition parse-tree.h:4921
Definition parse-tree.h:4927
Definition parse-tree.h:5152
Definition parse-tree.h:5158
Definition parse-tree.h:5009
Definition parse-tree.h:4878
Definition parse-tree.h:372
Definition parse-tree.h:2808
Definition parse-tree.h:2771
Definition parse-tree.h:2997
Definition parse-tree.h:2042
Definition parse-tree.h:2041
Definition parse-tree.h:1572
Definition parse-tree.h:2000
Definition parse-tree.h:2834
Definition parse-tree.h:3117
Definition parse-tree.h:2792
Definition parse-tree.h:939
Definition parse-tree.h:3095
Definition parse-tree.h:1080
Definition parse-tree.h:1108
Definition parse-tree.h:1898
Definition parse-tree.h:1100
Definition parse-tree.h:1094
Definition parse-tree.h:1087
Definition parse-tree.h:3105
Definition parse-tree.h:3232
Definition parse-tree.h:3200
Definition parse-tree.h:564
Definition parse-tree.h:2755
Definition parse-tree.h:823
Definition parse-tree.h:821
Definition parse-tree.h:2273
Definition parse-tree.h:2985
Definition parse-tree.h:2989
Definition parse-tree.h:2983
Definition parse-tree.h:1585
Definition parse-tree.h:292
Definition parse-tree.h:1672
Definition parse-tree.h:2396
Definition parse-tree.h:2462
Definition parse-tree.h:2461
Definition parse-tree.h:2475
Definition parse-tree.h:2473
Definition parse-tree.h:2452
Definition parse-tree.h:2509
Definition parse-tree.h:2507
Definition parse-tree.h:2487
Definition parse-tree.h:2152
Definition parse-tree.h:3325
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:1969
Definition parse-tree.h:355
Definition parse-tree.h:3343
Definition parse-tree.h:2539
Definition parse-tree.h:1888
Definition parse-tree.h:1226
Definition parse-tree.h:3438
Definition parse-tree.h:3410
Definition parse-tree.h:3433
Definition parse-tree.h:3003
Definition parse-tree.h:3014
Definition parse-tree.h:3169
Definition parse-tree.h:3309
Definition parse-tree.h:1663
Definition parse-tree.h:1850
Definition parse-tree.h:1654
Definition parse-tree.h:1836
Definition parse-tree.h:2558
Definition parse-tree.h:2557
Definition parse-tree.h:2570
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:1145
Definition parse-tree.h:1417
Definition parse-tree.h:2497
Definition parse-tree.h:2496
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:3426
Definition parse-tree.h:350
Definition parse-tree.h:2629
Definition parse-tree.h:808
Definition parse-tree.h:3081
Definition parse-tree.h:1866
Definition parse-tree.h:730
Definition parse-tree.h:735
Definition parse-tree.h:279
Definition parse-tree.h:2818
Definition parse-tree.h:2067
Definition parse-tree.h:2060
Definition parse-tree.h:2096
Definition parse-tree.h:2092
Definition parse-tree.h:2091
Definition parse-tree.h:2054
Definition parse-tree.h:2777
Definition parse-tree.h:3605
Definition parse-tree.h:3596
Definition parse-tree.h:3566
Definition parse-tree.h:3552
Definition parse-tree.h:3576
Definition parse-tree.h:3589
Definition parse-tree.h:3545
Definition parse-tree.h:3760
Definition parse-tree.h:3777
Definition parse-tree.h:3769
Definition parse-tree.h:3793
Definition parse-tree.h:3785
Definition parse-tree.h:3805
Definition parse-tree.h:3815
Definition parse-tree.h:3826
Definition parse-tree.h:3839
Definition parse-tree.h:3851
Definition parse-tree.h:3872
Definition parse-tree.h:3881
Definition parse-tree.h:3899
Definition parse-tree.h:3914
Definition parse-tree.h:3932
Definition parse-tree.h:3923
Definition parse-tree.h:3941
Definition parse-tree.h:3953
Definition parse-tree.h:3963
Definition parse-tree.h:3971
Definition parse-tree.h:3980
Definition parse-tree.h:4015
Definition parse-tree.h:4002
Definition parse-tree.h:3989
Definition parse-tree.h:4039
Definition parse-tree.h:4030
Definition parse-tree.h:4049
Definition parse-tree.h:4062
Definition parse-tree.h:4071
Definition parse-tree.h:4081
Definition parse-tree.h:4091
Definition parse-tree.h:4100
Definition parse-tree.h:4108
Definition parse-tree.h:4118
Definition parse-tree.h:4129
Definition parse-tree.h:4142
Definition parse-tree.h:3736
Definition parse-tree.h:3646
Definition parse-tree.h:3643
Definition parse-tree.h:3626
Definition parse-tree.h:3667
Definition parse-tree.h:3633
Definition parse-tree.h:3694
Definition parse-tree.h:3709
Definition parse-tree.h:3706
Definition parse-tree.h:3719
Definition parse-tree.h:3728