1//===-- lib/Parser/tools.cpp ----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "flang/Parser/tools.h"
10
11namespace Fortran::parser {
12
13const Name &GetLastName(const Name &x) { return x; }
14
15const Name &GetLastName(const StructureComponent &x) {
16 return GetLastName(x.component);
17}
18
19const Name &GetLastName(const DataRef &x) {
20 return common::visit(
21 common::visitors{
22 [](const Name &name) -> const Name & { return name; },
23 [](const common::Indirection<StructureComponent> &sc)
24 -> const Name & { return GetLastName(sc.value()); },
25 [](const common::Indirection<ArrayElement> &sc) -> const Name & {
26 return GetLastName(sc.value().base);
27 },
28 [](const common::Indirection<CoindexedNamedObject> &ci)
29 -> const Name & { return GetLastName(ci.value().base); },
30 },
31 x.u);
32}
33
34const Name &GetLastName(const Substring &x) {
35 return GetLastName(std::get<DataRef>(x.t));
36}
37
38const Name &GetLastName(const Designator &x) {
39 return common::visit(
40 [](const auto &y) -> const Name & { return GetLastName(y); }, x.u);
41}
42
43const Name &GetLastName(const ProcComponentRef &x) {
44 return GetLastName(x.v.thing);
45}
46
47const Name &GetLastName(const ProcedureDesignator &x) {
48 return common::visit(
49 [](const auto &y) -> const Name & { return GetLastName(y); }, x.u);
50}
51
52const Name &GetLastName(const Call &x) {
53 return GetLastName(std::get<ProcedureDesignator>(x.t));
54}
55
56const Name &GetLastName(const FunctionReference &x) { return GetLastName(x.v); }
57
58const Name &GetLastName(const Variable &x) {
59 return common::visit(
60 [](const auto &indirection) -> const Name & {
61 return GetLastName(indirection.value());
62 },
63 x.u);
64}
65
66const Name &GetLastName(const AllocateObject &x) {
67 return common::visit(
68 [](const auto &y) -> const Name & { return GetLastName(y); }, x.u);
69}
70
71const Name &GetFirstName(const Name &x) { return x; }
72
73const Name &GetFirstName(const StructureComponent &x) {
74 return GetFirstName(x.base);
75}
76
77const Name &GetFirstName(const DataRef &x) {
78 return common::visit(
79 common::visitors{
80 [](const Name &name) -> const Name & { return name; },
81 [](const common::Indirection<StructureComponent> &sc)
82 -> const Name & { return GetFirstName(sc.value()); },
83 [](const common::Indirection<ArrayElement> &sc) -> const Name & {
84 return GetFirstName(sc.value().base);
85 },
86 [](const common::Indirection<CoindexedNamedObject> &ci)
87 -> const Name & { return GetFirstName(ci.value().base); },
88 },
89 x.u);
90}
91
92const Name &GetFirstName(const Substring &x) {
93 return GetFirstName(std::get<DataRef>(x.t));
94}
95
96const Name &GetFirstName(const Designator &x) {
97 return common::visit(
98 [](const auto &y) -> const Name & { return GetFirstName(y); }, x.u);
99}
100
101const Name &GetFirstName(const ProcComponentRef &x) {
102 return GetFirstName(x.v.thing);
103}
104
105const Name &GetFirstName(const ProcedureDesignator &x) {
106 return common::visit(
107 [](const auto &y) -> const Name & { return GetFirstName(y); }, x.u);
108}
109
110const Name &GetFirstName(const Call &x) {
111 return GetFirstName(std::get<ProcedureDesignator>(x.t));
112}
113
114const Name &GetFirstName(const FunctionReference &x) {
115 return GetFirstName(x.v);
116}
117
118const Name &GetFirstName(const Variable &x) {
119 return common::visit(
120 [](const auto &indirect) -> const Name & {
121 return GetFirstName(indirect.value());
122 },
123 x.u);
124}
125
126const Name &GetFirstName(const EntityDecl &x) {
127 return std::get<ObjectName>(x.t);
128}
129
130const CoindexedNamedObject *GetCoindexedNamedObject(const DataRef &base) {
131 return common::visit(
132 common::visitors{
133 [](const Name &) -> const CoindexedNamedObject * { return nullptr; },
134 [](const common::Indirection<CoindexedNamedObject> &x)
135 -> const CoindexedNamedObject * { return &x.value(); },
136 [](const auto &x) -> const CoindexedNamedObject * {
137 return GetCoindexedNamedObject(x.value().base);
138 },
139 },
140 base.u);
141}
142const CoindexedNamedObject *GetCoindexedNamedObject(
143 const Designator &designator) {
144 return common::visit(
145 common::visitors{
146 [](const DataRef &x) -> const CoindexedNamedObject * {
147 return GetCoindexedNamedObject(x);
148 },
149 [](const Substring &x) -> const CoindexedNamedObject * {
150 return GetCoindexedNamedObject(std::get<DataRef>(x.t));
151 },
152 },
153 designator.u);
154}
155const CoindexedNamedObject *GetCoindexedNamedObject(const Variable &variable) {
156 return common::visit(
157 common::visitors{
158 [](const common::Indirection<Designator> &designator)
159 -> const CoindexedNamedObject * {
160 return GetCoindexedNamedObject(designator.value());
161 },
162 [](const auto &) -> const CoindexedNamedObject * { return nullptr; },
163 },
164 variable.u);
165}
166const CoindexedNamedObject *GetCoindexedNamedObject(
167 const AllocateObject &allocateObject) {
168 return common::visit(
169 common::visitors{
170 [](const StructureComponent &x) -> const CoindexedNamedObject * {
171 return GetCoindexedNamedObject(x.base);
172 },
173 [](const auto &) -> const CoindexedNamedObject * { return nullptr; },
174 },
175 allocateObject.u);
176}
177
178bool CheckForSingleVariableOnRHS(const AssignmentStmt &assignmentStmt) {
179 return Unwrap<Designator>(std::get<Expr>(assignmentStmt.t)) != nullptr;
180}
181
182} // namespace Fortran::parser
183

source code of flang/lib/Parser/tools.cpp