include_directories(${LLVM_INCLUDE_DIRS})
add_definitions(${LLVM_DEFINITIONS})
-llvm_map_components_to_libnames(LLVM_COMMON_LIBS support target option)
+llvm_map_components_to_libnames(LLVM_COMMON_LIBS support target option)
if(CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
typedef signed char CFI_type_t;
/* These codes are required to be macros (i.e., #ifdef will work).
- * They are not required to be either distinct nor to have had their
- * synonyms combined.
+ * They are not required to be distinct, but neither are they required
+ * to have had their synonyms combined.
+ * Extension: 128-bit integers are anticipated
*/
#define CFI_type_signed_char 1
#define CFI_type_short 2
#define CFI_type_int16_t 8
#define CFI_type_int32_t 9
#define CFI_type_int64_t 10
-#define CFI_type_int_least8_t 11
-#define CFI_type_int_least16_t 12
-#define CFI_type_int_least32_t 13
-#define CFI_type_int_least64_t 14
-#define CFI_type_int_fast8_t 15
-#define CFI_type_int_fast16_t 16
-#define CFI_type_int_fast32_t 17
-#define CFI_type_int_fast64_t 18
-#define CFI_type_intmax_t 19
-#define CFI_type_intptr_t 20
-#define CFI_type_ptrdiff_t 21
-#define CFI_type_float 22
-#define CFI_type_double 23
-#define CFI_type_long_double 24
-#define CFI_type_float_Complex 25
-#define CFI_type_double_Complex 26
-#define CFI_type_long_double_Complex 27
-#define CFI_type_Bool 28
-#define CFI_type_char 29
-#define CFI_type_cptr 30
-#define CFI_type_struct 31
-#define CFI_type_other (-1) /* must be negative */
+#define CFI_type_int128_t 11
+#define CFI_type_int_least8_t 12
+#define CFI_type_int_least16_t 13
+#define CFI_type_int_least32_t 14
+#define CFI_type_int_least64_t 15
+#define CFI_type_int_least128_t 16
+#define CFI_type_int_fast8_t 17
+#define CFI_type_int_fast16_t 18
+#define CFI_type_int_fast32_t 19
+#define CFI_type_int_fast64_t 20
+#define CFI_type_int_fast128_t 21
+#define CFI_type_intmax_t 22
+#define CFI_type_intptr_t 23
+#define CFI_type_ptrdiff_t 24
+#define CFI_type_float 25
+#define CFI_type_double 26
+#define CFI_type_long_double 27
+#define CFI_type_float_Complex 28
+#define CFI_type_double_Complex 29
+#define CFI_type_long_double_Complex 30
+#define CFI_type_Bool 31
+#define CFI_type_char 32
+#define CFI_type_cptr 33
+#define CFI_type_struct 34
+#define CFI_type_other (-1) // must be negative
/* Error code macros */
-#define CFI_SUCCESS 0
+#define CFI_SUCCESS 0 /* must be zero */
#define CFI_ERROR_BASE_ADDR_NULL 1
#define CFI_ERROR_BASE_ADDR_NOT_NULL 2
#define CFI_INVALID_ELEM_LEN 3
# See the License for the specific language governing permissions and
# limitations under the License.
-
+add_subdirectory(common)
add_subdirectory(evaluate)
add_subdirectory(parser)
add_subdirectory(semantics)
--- /dev/null
+# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+add_library(FortranCommon
+ idioms.cc
+)
+
// Implements a set of enums as a std::bitset<>. APIs from bitset<> and set<>
// can be used on these sets, whichever might be more clear to the user.
+// This class template facilitates the use of the more type-safe C++ "enum
+// class" feature without loss of convenience.
#include <bitset>
#include <cstddef>
private:
bitsetType bitset_;
};
-
} // namespace Fortran::common
template<typename ENUM, std::size_t values>
#include <cstdio>
#include <cstdlib>
-namespace Fortran::parser {
+namespace Fortran::common {
[[noreturn]] void die(const char *msg, ...) {
va_list ap;
}
return std::string(p, q - p);
}
-
-} // namespace Fortran::parser
+} // namespace Fortran::common
// See the License for the specific language governing permissions and
// limitations under the License.
-// TODO: move to lib/common
-#ifndef FORTRAN_PARSER_IDIOMS_H_
-#define FORTRAN_PARSER_IDIOMS_H_
+#ifndef FORTRAN_COMMON_IDIOMS_H_
+#define FORTRAN_COMMON_IDIOMS_H_
// Defines anything that might ever be useful in more than one source file
// or that is too weird or too specific to the host C++ compiler to be
// enable "this is a std::string"s with the 's' suffix
using namespace std::literals::string_literals;
-namespace Fortran::parser {
+namespace Fortran::common {
// Helper templates for combining a list of lambdas into an anonymous
// struct for use with std::visit() on a std::variant<> sum type.
// Calls std::fprintf(stderr, ...), then abort().
[[noreturn]] void die(const char *, ...);
-// Treat operator! as if it were a Boolean context, i.e. like if() and ? :,
-// when its operand is std::optional<>.
-template<typename A> bool operator!(const std::optional<A> &x) {
- return !x.has_value();
-}
-
// For switch statements without default: labels.
#define CRASH_NO_CASE \
- Fortran::parser::die("no case at " __FILE__ "(%d)", __LINE__)
+ Fortran::common::die("no case at " __FILE__ "(%d)", __LINE__)
// For cheap assertions that should be applied in production.
// To disable, compile with '-DCHECK=(void)'
#ifndef CHECK
#define CHECK(x) \
((x) || \
- (Fortran::parser::die( \
+ (Fortran::common::die( \
"CHECK(" #x ") failed at " __FILE__ "(%d)", __LINE__), \
false))
#endif
enum class NAME { __VA_ARGS__ }; \
static constexpr std::size_t NAME##_enumSize{[] { \
enum { __VA_ARGS__ }; \
- return Fortran::parser::ListItemCount{__VA_ARGS__}.value; \
+ return Fortran::common::ListItemCount{__VA_ARGS__}.value; \
}()}; \
static inline std::string EnumToString(NAME e) { \
- return Fortran::parser::EnumIndexToString( \
+ return Fortran::common::EnumIndexToString( \
static_cast<int>(e), #__VA_ARGS__); \
}
-} // namespace Fortran::parser
-#endif // FORTRAN_PARSER_IDIOMS_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_IDIOMS_H_
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef FORTRAN_PARSER_INDIRECTION_H_
-#define FORTRAN_PARSER_INDIRECTION_H_
+#ifndef FORTRAN_COMMON_INDIRECTION_H_
+#define FORTRAN_COMMON_INDIRECTION_H_
// Defines a smart pointer class template that's rather like std::unique_ptr<>
// but further restricted, like a C++ reference, to be non-null when constructed
// or assigned. Users need not check whether these pointers are null.
// Intended to be as invisible as possible.
-#include "idioms.h"
+#include "../common/idioms.h"
#include <utility>
-namespace Fortran::parser {
+namespace Fortran::common {
template<typename A> class Indirection {
public:
private:
A *p_{nullptr};
};
-
-} // namespace Fortran::parser
-#endif // FORTRAN_PARSER_INDIRECTION_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_INDIRECTION_H_
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef FORTRAN_PARSER_INTERVAL_H_
-#define FORTRAN_PARSER_INTERVAL_H_
+#ifndef FORTRAN_COMMON_INTERVAL_H_
+#define FORTRAN_COMMON_INTERVAL_H_
// Defines a generalized template class Interval<A> to represent
// the half-open interval [x .. x+n).
#include <cstddef>
#include <utility>
-namespace Fortran::parser {
+namespace Fortran::common {
template<typename A> class Interval {
public:
std::size_t size_{0};
};
-} // namespace Fortran::parser
-#endif // FORTRAN_PARSER_INTERVAL_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_INTERVAL_H_
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef FORTRAN_PARSER_REFERENCE_COUNTED_H_
-#define FORTRAN_PARSER_REFERENCE_COUNTED_H_
+#ifndef FORTRAN_COMMON_REFERENCE_COUNTED_H_
+#define FORTRAN_COMMON_REFERENCE_COUNTED_H_
// A class template of smart pointers to objects with their own
// reference counting object lifetimes that's lighter weight
// than std::shared_ptr<>. Not thread-safe.
-namespace Fortran::parser {
+namespace Fortran::common {
+// A base class for reference-counted objects.
template<typename A> class ReferenceCounted {
public:
ReferenceCounted() {}
int references_{0};
};
+// A reference to a reference-counted object.
template<typename A> class CountedReference {
public:
using type = A;
type *p_{nullptr};
};
-} // namespace Fortran::parser
-#endif // FORTRAN_PARSER_REFERENCE_COUNTED_H_
+} // namespace Fortran::common
+#endif // FORTRAN_COMMON_REFERENCE_COUNTED_H_
return {word_.IBCLR(bits - 1)};
}
- constexpr Real Negate() const {
- return {word_.IEOR(word_.MASKL(1))};
- }
+ constexpr Real Negate() const { return {word_.IEOR(word_.MASKL(1))}; }
Relation Compare(const Real &) const;
ValueWithRealFlags<Real> Add(
#include "integer.h"
#include "logical.h"
#include "real.h"
+#include <string>
namespace Fortran::evaluate::type {
static constexpr Classification classification{Classification::Character};
static constexpr int kind{KIND};
static constexpr bool hasLen{true};
- using ValueType = std::uint8_t[kind]; // TODO: ?
+ using ValueType = std::string;
};
// Default REAL just simply has to be IEEE-754 single precision today.
char-set.cc
characters.cc
debug-parser.cc
- idioms.cc
instrumented-parser.cc
message.cc
parse-tree.cc
unparse.cc
user-state.cc
)
+
+target_link_libraries(FortranParser
+ FortranCommon
+)
// template functions. See parser-combinators.txt for documentation.
#include "char-block.h"
-#include "idioms.h"
-#include "indirection.h"
#include "message.h"
#include "parse-state.h"
#include "provenance.h"
+#include "../common/idioms.h"
+#include "../common/indirection.h"
#include <cstring>
#include <functional>
#include <list>
// For a parser p, indirect(p) returns a parser that builds an indirect
// reference to p's return type.
template<typename PA> inline constexpr auto indirect(const PA &p) {
- return construct<Indirection<typename PA::resultType>>(p);
+ return construct<common::Indirection<typename PA::resultType>>(p);
}
// If a and b are parsers, then nonemptySeparated(a, b) returns a parser
// Describes a contiguous block of characters; does not own their storage.
-#include "interval.h"
+#include "../common/interval.h"
#include <algorithm>
#include <cstddef>
#include <cstring>
return size() < that.size() ? -1 : size() > that.size();
}
- Interval<const char *> interval_{nullptr, 0};
+ common::Interval<const char *> interval_{nullptr, 0};
};
} // namespace Fortran::parser
// limitations under the License.
#include "char-buffer.h"
-#include "idioms.h"
+#include "../common/idioms.h"
#include <algorithm>
#include <cstddef>
#include <cstring>
#include "message.h"
#include "char-set.h"
-#include "idioms.h"
+#include "../common/idioms.h"
#include <algorithm>
#include <cstdarg>
#include <cstddef>
std::string MessageExpectedText::ToString() const {
return std::visit(
- visitors{[](const CharBlock &cb) {
- return MessageFormattedText("expected '%s'"_err_en_US,
- cb.NULTerminatedToString().data())
- .MoveString();
- },
+ common::visitors{[](const CharBlock &cb) {
+ return MessageFormattedText("expected '%s'"_err_en_US,
+ cb.NULTerminatedToString().data())
+ .MoveString();
+ },
[](const SetOfChars &set) {
SetOfChars expect{set};
if (expect.Has('\n')) {
}
void MessageExpectedText::Incorporate(const MessageExpectedText &that) {
- std::visit(
- visitors{[&](SetOfChars &s1, const SetOfChars &s2) { s1 = s1.Union(s2); },
- [](const auto &, const auto &) {}},
+ std::visit(common::visitors{[&](SetOfChars &s1, const SetOfChars &s2) {
+ s1 = s1.Union(s2);
+ },
+ [](const auto &, const auto &) {}},
u_, that.u_);
}
// are speculative. Messages with ProvenanceRange locations are ordered
// before others for sorting.
return std::visit(
- visitors{[](const CharBlock &cb1, const CharBlock &cb2) {
- return cb1.begin() < cb2.begin();
- },
+ common::visitors{[](const CharBlock &cb1, const CharBlock &cb2) {
+ return cb1.begin() < cb2.begin();
+ },
[](const CharBlock &, const ProvenanceRange &) { return false; },
[](const ProvenanceRange &pr1, const ProvenanceRange &pr2) {
return pr1.start() < pr2.start();
bool Message::IsFatal() const {
return std::visit(
- visitors{[](const MessageExpectedText &) { return true; },
+ common::visitors{[](const MessageExpectedText &) { return true; },
[](const MessageFixedText &x) { return x.isFatal(); },
[](const MessageFormattedText &x) { return x.isFatal(); }},
text_);
std::string Message::ToString() const {
return std::visit(
- visitors{[](const MessageFixedText &t) {
- return t.text().NULTerminatedToString();
- },
+ common::visitors{[](const MessageFixedText &t) {
+ return t.text().NULTerminatedToString();
+ },
[](const MessageFormattedText &t) { return t.string(); },
[](const MessageExpectedText &e) { return e.ToString(); }},
text_);
}
ProvenanceRange Message::GetProvenanceRange(const CookedSource &cooked) const {
- return std::visit(visitors{[&](const CharBlock &cb) {
- return cooked.GetProvenanceRange(cb);
- },
+ return std::visit(common::visitors{[&](const CharBlock &cb) {
+ return cooked.GetProvenanceRange(cb);
+ },
[](const ProvenanceRange &pr) { return pr; }},
location_);
}
}
void Message::Incorporate(Message &that) {
- std::visit(
- visitors{[&](MessageExpectedText &e1, const MessageExpectedText &e2) {
- e1.Incorporate(e2);
- },
- [](const auto &, const auto &) {}},
+ std::visit(common::visitors{[&](MessageExpectedText &e1,
+ const MessageExpectedText &e2) {
+ e1.Incorporate(e2);
+ },
+ [](const auto &, const auto &) {}},
text_, that.text_);
}
bool Message::AtSameLocation(const Message &that) const {
return std::visit(
- visitors{[](const CharBlock &cb1, const CharBlock &cb2) {
- return cb1.begin() == cb2.begin();
- },
+ common::visitors{[](const CharBlock &cb1, const CharBlock &cb2) {
+ return cb1.begin() == cb2.begin();
+ },
[](const ProvenanceRange &pr1, const ProvenanceRange &pr2) {
return pr1.start() == pr2.start();
},
#include "char-block.h"
#include "char-set.h"
-#include "idioms.h"
#include "provenance.h"
-#include "reference-counted.h"
+#include "../common/idioms.h"
+#include "../common/reference-counted.h"
#include <cstddef>
#include <cstring>
#include <forward_list>
std::variant<CharBlock, SetOfChars> u_;
};
-class Message : public ReferenceCounted<Message> {
+class Message : public common::ReferenceCounted<Message> {
public:
- using Reference = CountedReference<Message>;
+ using Reference = common::CountedReference<Message>;
Message(const Message &) = default;
Message(Message &&) = default;
// and recovery during parsing!
#include "characters.h"
-#include "idioms.h"
#include "message.h"
#include "provenance.h"
+#include "../common/idioms.h"
#include <cstddef>
#include <cstring>
#include <list>
}
template<typename T, typename V>
-void Walk(const Indirection<T> &x, V &visitor) {
+void Walk(const common::Indirection<T> &x, V &visitor) {
Walk(*x, visitor);
}
-template<typename T, typename M> void Walk(Indirection<T> &x, M &mutator) {
+template<typename T, typename M>
+void Walk(common::Indirection<T> &x, M &mutator) {
Walk(*x, mutator);
}
// limitations under the License.
#include "parse-tree.h"
-#include "idioms.h"
-#include "indirection.h"
#include "user-state.h"
+#include "../common/idioms.h"
+#include "../common/indirection.h"
#include <algorithm>
namespace Fortran::parser {
// R901 designator
bool Designator::EndsInBareName() const {
return std::visit(
- visitors{[](const ObjectName &) { return true; },
+ common::visitors{[](const ObjectName &) { return true; },
[](const DataRef &dr) {
return std::holds_alternative<Name>(dr.u) ||
- std::holds_alternative<Indirection<StructureComponent>>(dr.u);
+ std::holds_alternative<common::Indirection<StructureComponent>>(
+ dr.u);
},
[](const Substring &) { return false; }},
u);
for (bool first{true}; !prl.empty(); first = false, prl.pop_front()) {
PartRef &pr{prl.front()};
if (!first) {
- u = Indirection<StructureComponent>{std::move(*this), std::move(pr.name)};
+ u = common::Indirection<StructureComponent>{
+ std::move(*this), std::move(pr.name)};
}
if (!pr.subscripts.empty()) {
- u = Indirection<ArrayElement>{std::move(*this), std::move(pr.subscripts)};
+ u = common::Indirection<ArrayElement>{
+ std::move(*this), std::move(pr.subscripts)};
}
if (pr.imageSelector.has_value()) {
- u = Indirection<CoindexedNamedObject>{
+ u = common::Indirection<CoindexedNamedObject>{
std::move(*this), std::move(*pr.imageSelector)};
}
}
}
// R1001 - R1022 expression
-Expr::Expr(Designator &&x) : u{Indirection<Designator>(std::move(x))} {}
+Expr::Expr(Designator &&x) : u{common::Indirection<Designator>(std::move(x))} {}
Expr::Expr(FunctionReference &&x)
- : u{Indirection<FunctionReference>(std::move(x))} {}
+ : u{common::Indirection<FunctionReference>(std::move(x))} {}
static Designator MakeArrayElementRef(Name &name, std::list<Expr> &subscripts) {
ArrayElement arrayElement{name, std::list<SectionSubscript>{}};
for (Expr &expr : subscripts) {
- arrayElement.subscripts.push_back(
- SectionSubscript{Scalar{Integer{Indirection{std::move(expr)}}}});
+ arrayElement.subscripts.push_back(SectionSubscript{
+ Scalar{Integer{common::Indirection{std::move(expr)}}}});
}
- return Designator{DataRef{Indirection{std::move(arrayElement)}}};
+ return Designator{DataRef{common::Indirection{std::move(arrayElement)}}};
}
Designator FunctionReference::ConvertToArrayElementRef() {
std::list<Expr> args;
for (auto &arg : std::get<std::list<ActualArgSpec>>(v.t)) {
std::visit(
- visitors{
- [&](Indirection<Expr> &y) { args.push_back(std::move(*y)); },
- [&](Indirection<Variable> &y) {
+ common::visitors{
+ [&](common::Indirection<Expr> &y) {
+ args.push_back(std::move(*y));
+ },
+ [&](common::Indirection<Variable> &y) {
args.push_back(std::visit(
- visitors{
- [&](Indirection<Designator> &z) {
+ common::visitors{
+ [&](common::Indirection<Designator> &z) {
return Expr{std::move(*z)};
},
- [&](Indirection<FunctionReference> &z) {
+ [&](common::Indirection<FunctionReference> &z) {
return Expr{std::move(*z)};
},
},
auto &funcExpr = std::get<Scalar<Expr>>(t).thing;
std::list<Expr> subscripts;
for (Name &arg : funcArgs) {
- subscripts.push_back(Expr{Indirection{Designator{arg}}});
+ subscripts.push_back(Expr{common::Indirection{Designator{arg}}});
}
auto &&variable =
- Variable{Indirection{MakeArrayElementRef(funcName, subscripts)}};
+ Variable{common::Indirection{MakeArrayElementRef(funcName, subscripts)}};
return Statement{std::nullopt,
- ActionStmt{Indirection{
+ ActionStmt{common::Indirection{
AssignmentStmt{std::move(variable), std::move(funcExpr)}}}};
}
#include "char-block.h"
#include "characters.h"
#include "format-specification.h"
-#include "idioms.h"
-#include "indirection.h"
#include "message.h"
#include "provenance.h"
+#include "../common/idioms.h"
+#include "../common/indirection.h"
#include <cinttypes>
#include <list>
#include <optional>
A thing;
};
-using LogicalExpr = Logical<Indirection<Expr>>; // R1024
-using DefaultCharExpr = DefaultChar<Indirection<Expr>>; // R1025
-using IntExpr = Integer<Indirection<Expr>>; // R1026
-using ConstantExpr = Constant<Indirection<Expr>>; // R1029
+using LogicalExpr = Logical<common::Indirection<Expr>>; // R1024
+using DefaultCharExpr = DefaultChar<common::Indirection<Expr>>; // R1025
+using IntExpr = Integer<common::Indirection<Expr>>; // R1026
+using ConstantExpr = Constant<common::Indirection<Expr>>; // R1029
using IntConstantExpr = Integer<ConstantExpr>; // R1031
using ScalarLogicalExpr = Scalar<LogicalExpr>;
using ScalarIntExpr = Scalar<IntExpr>;
// Extension: (Cray) based POINTER statement
struct OtherSpecificationStmt {
UNION_CLASS_BOILERPLATE(OtherSpecificationStmt);
- std::variant<Indirection<AccessStmt>, Indirection<AllocatableStmt>,
- Indirection<AsynchronousStmt>, Indirection<BindStmt>,
- Indirection<CodimensionStmt>, Indirection<ContiguousStmt>,
- Indirection<DimensionStmt>, Indirection<ExternalStmt>,
- Indirection<IntentStmt>, Indirection<IntrinsicStmt>,
- Indirection<NamelistStmt>, Indirection<OptionalStmt>,
- Indirection<PointerStmt>, Indirection<ProtectedStmt>,
- Indirection<SaveStmt>, Indirection<TargetStmt>, Indirection<ValueStmt>,
- Indirection<VolatileStmt>, Indirection<CommonStmt>,
- Indirection<EquivalenceStmt>, Indirection<BasedPointerStmt>>
+ std::variant<common::Indirection<AccessStmt>,
+ common::Indirection<AllocatableStmt>,
+ common::Indirection<AsynchronousStmt>, common::Indirection<BindStmt>,
+ common::Indirection<CodimensionStmt>, common::Indirection<ContiguousStmt>,
+ common::Indirection<DimensionStmt>, common::Indirection<ExternalStmt>,
+ common::Indirection<IntentStmt>, common::Indirection<IntrinsicStmt>,
+ common::Indirection<NamelistStmt>, common::Indirection<OptionalStmt>,
+ common::Indirection<PointerStmt>, common::Indirection<ProtectedStmt>,
+ common::Indirection<SaveStmt>, common::Indirection<TargetStmt>,
+ common::Indirection<ValueStmt>, common::Indirection<VolatileStmt>,
+ common::Indirection<CommonStmt>, common::Indirection<EquivalenceStmt>,
+ common::Indirection<BasedPointerStmt>>
u;
};
// other-specification-stmt | type-declaration-stmt
struct SpecificationConstruct {
UNION_CLASS_BOILERPLATE(SpecificationConstruct);
- std::variant<Indirection<DerivedTypeDef>, Indirection<EnumDef>,
- Statement<Indirection<GenericStmt>>, Indirection<InterfaceBlock>,
- Statement<Indirection<ParameterStmt>>,
- Statement<Indirection<OldParameterStmt>>,
- Statement<Indirection<ProcedureDeclarationStmt>>,
+ std::variant<common::Indirection<DerivedTypeDef>,
+ common::Indirection<EnumDef>, Statement<common::Indirection<GenericStmt>>,
+ common::Indirection<InterfaceBlock>,
+ Statement<common::Indirection<ParameterStmt>>,
+ Statement<common::Indirection<OldParameterStmt>>,
+ Statement<common::Indirection<ProcedureDeclarationStmt>>,
Statement<OtherSpecificationStmt>,
- Statement<Indirection<TypeDeclarationStmt>>, Indirection<StructureDef>,
- Indirection<OpenMPConstruct>, Indirection<CompilerDirective>>
+ Statement<common::Indirection<TypeDeclarationStmt>>,
+ common::Indirection<StructureDef>, common::Indirection<OpenMPConstruct>,
+ common::Indirection<CompilerDirective>>
u;
};
// implicit-stmt | parameter-stmt | format-stmt | entry-stmt
struct ImplicitPartStmt {
UNION_CLASS_BOILERPLATE(ImplicitPartStmt);
- std::variant<Statement<Indirection<ImplicitStmt>>,
- Statement<Indirection<ParameterStmt>>,
- Statement<Indirection<OldParameterStmt>>,
- Statement<Indirection<FormatStmt>>, Statement<Indirection<EntryStmt>>>
+ std::variant<Statement<common::Indirection<ImplicitStmt>>,
+ Statement<common::Indirection<ParameterStmt>>,
+ Statement<common::Indirection<OldParameterStmt>>,
+ Statement<common::Indirection<FormatStmt>>,
+ Statement<common::Indirection<EntryStmt>>>
u;
};
// entry-stmt | stmt-function-stmt
struct DeclarationConstruct {
UNION_CLASS_BOILERPLATE(DeclarationConstruct);
- std::variant<SpecificationConstruct, Statement<Indirection<DataStmt>>,
- Statement<Indirection<FormatStmt>>, Statement<Indirection<EntryStmt>>,
- Statement<Indirection<StmtFunctionStmt>>, ErrorRecovery>
+ std::variant<SpecificationConstruct, Statement<common::Indirection<DataStmt>>,
+ Statement<common::Indirection<FormatStmt>>,
+ Statement<common::Indirection<EntryStmt>>,
+ Statement<common::Indirection<StmtFunctionStmt>>, ErrorRecovery>
u;
};
// from the implicit part to the declaration constructs
struct SpecificationPart {
TUPLE_CLASS_BOILERPLATE(SpecificationPart);
- std::tuple<std::list<Statement<Indirection<UseStmt>>>,
- std::list<Statement<Indirection<ImportStmt>>>, ImplicitPart,
+ std::tuple<std::list<Statement<common::Indirection<UseStmt>>>,
+ std::list<Statement<common::Indirection<ImportStmt>>>, ImplicitPart,
std::list<DeclarationConstruct>>
t;
};
// R512 internal-subprogram -> function-subprogram | subroutine-subprogram
struct InternalSubprogram {
UNION_CLASS_BOILERPLATE(InternalSubprogram);
- std::variant<Indirection<FunctionSubprogram>,
- Indirection<SubroutineSubprogram>>
+ std::variant<common::Indirection<FunctionSubprogram>,
+ common::Indirection<SubroutineSubprogram>>
u;
};
// wait-stmt | where-stmt | write-stmt | computed-goto-stmt | forall-stmt
struct ActionStmt {
UNION_CLASS_BOILERPLATE(ActionStmt);
- std::variant<Indirection<AllocateStmt>, Indirection<AssignmentStmt>,
- Indirection<BackspaceStmt>, Indirection<CallStmt>, Indirection<CloseStmt>,
- ContinueStmt, Indirection<CycleStmt>, Indirection<DeallocateStmt>,
- Indirection<EndfileStmt>, Indirection<EventPostStmt>,
- Indirection<EventWaitStmt>, Indirection<ExitStmt>, FailImageStmt,
- Indirection<FlushStmt>, Indirection<FormTeamStmt>, Indirection<GotoStmt>,
- Indirection<IfStmt>, Indirection<InquireStmt>, Indirection<LockStmt>,
- Indirection<NullifyStmt>, Indirection<OpenStmt>,
- Indirection<PointerAssignmentStmt>, Indirection<PrintStmt>,
- Indirection<ReadStmt>, Indirection<ReturnStmt>, Indirection<RewindStmt>,
- Indirection<StopStmt>, Indirection<SyncAllStmt>,
- Indirection<SyncImagesStmt>, Indirection<SyncMemoryStmt>,
- Indirection<SyncTeamStmt>, Indirection<UnlockStmt>, Indirection<WaitStmt>,
- Indirection<WhereStmt>, Indirection<WriteStmt>,
- Indirection<ComputedGotoStmt>, Indirection<ForallStmt>,
- Indirection<ArithmeticIfStmt>, Indirection<AssignStmt>,
- Indirection<AssignedGotoStmt>, Indirection<PauseStmt>>
+ std::variant<common::Indirection<AllocateStmt>,
+ common::Indirection<AssignmentStmt>, common::Indirection<BackspaceStmt>,
+ common::Indirection<CallStmt>, common::Indirection<CloseStmt>,
+ ContinueStmt, common::Indirection<CycleStmt>,
+ common::Indirection<DeallocateStmt>, common::Indirection<EndfileStmt>,
+ common::Indirection<EventPostStmt>, common::Indirection<EventWaitStmt>,
+ common::Indirection<ExitStmt>, FailImageStmt,
+ common::Indirection<FlushStmt>, common::Indirection<FormTeamStmt>,
+ common::Indirection<GotoStmt>, common::Indirection<IfStmt>,
+ common::Indirection<InquireStmt>, common::Indirection<LockStmt>,
+ common::Indirection<NullifyStmt>, common::Indirection<OpenStmt>,
+ common::Indirection<PointerAssignmentStmt>,
+ common::Indirection<PrintStmt>, common::Indirection<ReadStmt>,
+ common::Indirection<ReturnStmt>, common::Indirection<RewindStmt>,
+ common::Indirection<StopStmt>, common::Indirection<SyncAllStmt>,
+ common::Indirection<SyncImagesStmt>, common::Indirection<SyncMemoryStmt>,
+ common::Indirection<SyncTeamStmt>, common::Indirection<UnlockStmt>,
+ common::Indirection<WaitStmt>, common::Indirection<WhereStmt>,
+ common::Indirection<WriteStmt>, common::Indirection<ComputedGotoStmt>,
+ common::Indirection<ForallStmt>, common::Indirection<ArithmeticIfStmt>,
+ common::Indirection<AssignStmt>, common::Indirection<AssignedGotoStmt>,
+ common::Indirection<PauseStmt>>
u;
};
// select-type-construct | where-construct | forall-construct
struct ExecutableConstruct {
UNION_CLASS_BOILERPLATE(ExecutableConstruct);
- std::variant<Statement<ActionStmt>, Indirection<AssociateConstruct>,
- Indirection<BlockConstruct>, Indirection<CaseConstruct>,
- Indirection<ChangeTeamConstruct>, Indirection<CriticalConstruct>,
- Statement<Indirection<LabelDoStmt>>, Statement<Indirection<EndDoStmt>>,
- Indirection<DoConstruct>, Indirection<IfConstruct>,
- Indirection<SelectRankConstruct>, Indirection<SelectTypeConstruct>,
- Indirection<WhereConstruct>, Indirection<ForallConstruct>,
- Indirection<CompilerDirective>, Indirection<OpenMPConstruct>>
+ std::variant<Statement<ActionStmt>, common::Indirection<AssociateConstruct>,
+ common::Indirection<BlockConstruct>, common::Indirection<CaseConstruct>,
+ common::Indirection<ChangeTeamConstruct>,
+ common::Indirection<CriticalConstruct>,
+ Statement<common::Indirection<LabelDoStmt>>,
+ Statement<common::Indirection<EndDoStmt>>,
+ common::Indirection<DoConstruct>, common::Indirection<IfConstruct>,
+ common::Indirection<SelectRankConstruct>,
+ common::Indirection<SelectTypeConstruct>,
+ common::Indirection<WhereConstruct>, common::Indirection<ForallConstruct>,
+ common::Indirection<CompilerDirective>,
+ common::Indirection<OpenMPConstruct>>
u;
};
// Extension (PGI/Intel): also accept NAMELIST in execution part
struct ExecutionPartConstruct {
UNION_CLASS_BOILERPLATE(ExecutionPartConstruct);
- std::variant<ExecutableConstruct, Statement<Indirection<FormatStmt>>,
- Statement<Indirection<EntryStmt>>, Statement<Indirection<DataStmt>>,
- Statement<Indirection<NamelistStmt>>, ErrorRecovery>
+ std::variant<ExecutableConstruct, Statement<common::Indirection<FormatStmt>>,
+ Statement<common::Indirection<EntryStmt>>,
+ Statement<common::Indirection<DataStmt>>,
+ Statement<common::Indirection<NamelistStmt>>, ErrorRecovery>
u;
};
// R503 external-subprogram -> function-subprogram | subroutine-subprogram
struct ProgramUnit {
UNION_CLASS_BOILERPLATE(ProgramUnit);
- std::variant<Indirection<MainProgram>, Indirection<FunctionSubprogram>,
- Indirection<SubroutineSubprogram>, Indirection<Module>,
- Indirection<Submodule>, Indirection<BlockData>>
+ std::variant<common::Indirection<MainProgram>,
+ common::Indirection<FunctionSubprogram>,
+ common::Indirection<SubroutineSubprogram>, common::Indirection<Module>,
+ common::Indirection<Submodule>, common::Indirection<BlockData>>
u;
};
EMPTY_CLASS(NullInit);
// R744 initial-data-target -> designator
-using InitialDataTarget = Indirection<Designator>;
+using InitialDataTarget = common::Indirection<Designator>;
// R743 component-initialization ->
// = constant-expr | => null-init | => initial-data-target
struct Initialization {
UNION_CLASS_BOILERPLATE(Initialization);
std::variant<ConstantExpr, NullInit, InitialDataTarget,
- std::list<Indirection<DataStmtValue>>>
+ std::list<common::Indirection<DataStmtValue>>>
u;
};
// GENERIC [, access-spec] :: generic-spec => binding-name-list
struct TypeBoundGenericStmt {
TUPLE_CLASS_BOILERPLATE(TypeBoundGenericStmt);
- std::tuple<std::optional<AccessSpec>, Indirection<GenericSpec>,
+ std::tuple<std::optional<AccessSpec>, common::Indirection<GenericSpec>,
std::list<Name>>
t;
};
// R758 component-data-source -> expr | data-target | proc-target
// R1037 data-target -> expr
// R1040 proc-target -> expr | procedure-name | proc-component-ref
-WRAPPER_CLASS(ComponentDataSource, Indirection<Expr>);
+WRAPPER_CLASS(ComponentDataSource, common::Indirection<Expr>);
// R757 component-spec -> [keyword =] component-data-source
struct ComponentSpec {
std::tuple<ScalarIntExpr, ScalarIntExpr, std::optional<ScalarIntExpr>> t;
};
UNION_CLASS_BOILERPLATE(AcValue);
- std::variant<Triplet, Indirection<Expr>, Indirection<AcImpliedDo>> u;
+ std::variant<Triplet, common::Indirection<Expr>,
+ common::Indirection<AcImpliedDo>>
+ u;
};
// R770 ac-spec -> type-spec :: | [type-spec ::] ac-value-list
// R828 access-id -> access-name | generic-spec
struct AccessId {
UNION_CLASS_BOILERPLATE(AccessId);
- std::variant<Name, Indirection<GenericSpec>> u;
+ std::variant<Name, common::Indirection<GenericSpec>> u;
};
// R827 access-stmt -> access-spec [[::] access-id-list]
// R847 constant-subobject -> designator
// R846 int-constant-subobject -> constant-subobject
-using ConstantSubobject = Constant<Indirection<Designator>>;
+using ConstantSubobject = Constant<common::Indirection<Designator>>;
// R845 data-stmt-constant ->
// scalar-constant | scalar-constant-subobject |
// array-element | scalar-structure-component | data-implied-do
struct DataIDoObject {
UNION_CLASS_BOILERPLATE(DataIDoObject);
- std::variant<Scalar<Indirection<Designator>>, Indirection<DataImpliedDo>> u;
+ std::variant<Scalar<common::Indirection<Designator>>,
+ common::Indirection<DataImpliedDo>>
+ u;
};
// R840 data-implied-do ->
// R839 data-stmt-object -> variable | data-implied-do
struct DataStmtObject {
UNION_CLASS_BOILERPLATE(DataStmtObject);
- std::variant<Indirection<Variable>, DataImpliedDo> u;
+ std::variant<common::Indirection<Variable>, DataImpliedDo> u;
};
// R838 data-stmt-set -> data-stmt-object-list / data-stmt-value-list /
};
// R872 equivalence-object -> variable-name | array-element | substring
-WRAPPER_CLASS(EquivalenceObject, Indirection<Designator>);
+WRAPPER_CLASS(EquivalenceObject, common::Indirection<Designator>);
// R870 equivalence-stmt -> EQUIVALENCE equivalence-set-list
// R871 equivalence-set -> ( equivalence-object , equivalence-object-list )
using Cosubscript = ScalarIntExpr;
// R1115 team-variable -> scalar-variable
-using TeamVariable = Scalar<Indirection<Variable>>;
+using TeamVariable = Scalar<common::Indirection<Variable>>;
// R926 image-selector-spec ->
// STAT = stat-variable | TEAM = team-variable |
// TEAM_NUMBER = scalar-int-expr
struct ImageSelectorSpec {
- WRAPPER_CLASS(Stat, Scalar<Integer<Indirection<Variable>>>);
+ WRAPPER_CLASS(Stat, Scalar<Integer<common::Indirection<Variable>>>);
WRAPPER_CLASS(Team, TeamVariable);
WRAPPER_CLASS(Team_Number, ScalarIntExpr);
UNION_CLASS_BOILERPLATE(ImageSelectorSpec);
struct Expr {
UNION_CLASS_BOILERPLATE(Expr);
- WRAPPER_CLASS(IntrinsicUnary, Indirection<Expr>);
+ WRAPPER_CLASS(IntrinsicUnary, common::Indirection<Expr>);
struct Parentheses : public IntrinsicUnary {
using IntrinsicUnary::IntrinsicUnary;
};
using IntrinsicUnary::IntrinsicUnary;
};
- WRAPPER_CLASS(PercentLoc, Indirection<Variable>); // %LOC(v) extension
+ WRAPPER_CLASS(
+ PercentLoc, common::Indirection<Variable>); // %LOC(v) extension
struct DefinedUnary {
TUPLE_CLASS_BOILERPLATE(DefinedUnary);
- std::tuple<DefinedOpName, Indirection<Expr>> t;
+ std::tuple<DefinedOpName, common::Indirection<Expr>> t;
};
struct IntrinsicBinary {
TUPLE_CLASS_BOILERPLATE(IntrinsicBinary);
- std::tuple<Indirection<Expr>, Indirection<Expr>> t;
+ std::tuple<common::Indirection<Expr>, common::Indirection<Expr>> t;
};
struct Power : public IntrinsicBinary {
using IntrinsicBinary::IntrinsicBinary;
struct GT : public IntrinsicBinary {
using IntrinsicBinary::IntrinsicBinary;
};
+ // TODO: .UN. unordered comparisons?
struct AND : public IntrinsicBinary {
using IntrinsicBinary::IntrinsicBinary;
};
struct DefinedBinary {
TUPLE_CLASS_BOILERPLATE(DefinedBinary);
- std::tuple<DefinedOpName, Indirection<Expr>, Indirection<Expr>> t;
+ std::tuple<DefinedOpName, common::Indirection<Expr>,
+ common::Indirection<Expr>>
+ t;
};
explicit Expr(Designator &&);
explicit Expr(FunctionReference &&);
- std::variant<Indirection<CharLiteralConstantSubstring>, LiteralConstant,
- Indirection<Designator>, ArrayConstructor, StructureConstructor,
- Indirection<TypeParamInquiry>, Indirection<FunctionReference>,
- Parentheses, UnaryPlus, Negate, NOT, PercentLoc, DefinedUnary, Power,
- Multiply, Divide, Add, Subtract, Concat, LT, LE, EQ, NE, GE, GT, AND, OR,
- EQV, NEQV, XOR, DefinedBinary, ComplexConstructor>
+ std::variant<common::Indirection<CharLiteralConstantSubstring>,
+ LiteralConstant, common::Indirection<Designator>, ArrayConstructor,
+ StructureConstructor, common::Indirection<TypeParamInquiry>,
+ common::Indirection<FunctionReference>, Parentheses, UnaryPlus, Negate,
+ NOT, PercentLoc, DefinedUnary, Power, Multiply, Divide, Add, Subtract,
+ Concat, LT, LE, EQ, NE, GE, GT, AND, OR, EQV, NEQV, XOR, DefinedBinary,
+ ComplexConstructor>
u;
};
struct DataRef {
UNION_CLASS_BOILERPLATE(DataRef);
explicit DataRef(std::list<PartRef> &&);
- std::variant<Name, Indirection<StructureComponent>, Indirection<ArrayElement>,
- Indirection<CoindexedNamedObject>>
+ std::variant<Name, common::Indirection<StructureComponent>,
+ common::Indirection<ArrayElement>,
+ common::Indirection<CoindexedNamedObject>>
u;
};
// R902 variable -> designator | function-reference
struct Variable {
UNION_CLASS_BOILERPLATE(Variable);
- std::variant<Indirection<Designator>, Indirection<FunctionReference>> u;
+ std::variant<common::Indirection<Designator>,
+ common::Indirection<FunctionReference>>
+ u;
};
// R904 logical-variable -> variable
// R931 source-expr -> expr
struct AllocOpt {
UNION_CLASS_BOILERPLATE(AllocOpt);
- WRAPPER_CLASS(Mold, Indirection<Expr>);
- WRAPPER_CLASS(Source, Indirection<Expr>);
+ WRAPPER_CLASS(Mold, common::Indirection<Expr>);
+ WRAPPER_CLASS(Source, common::Indirection<Expr>);
std::variant<Mold, Source, StatOrErrmsg> u;
};
struct WhereBodyConstruct {
UNION_CLASS_BOILERPLATE(WhereBodyConstruct);
std::variant<Statement<AssignmentStmt>, Statement<WhereStmt>,
- Indirection<WhereConstruct>>
+ common::Indirection<WhereConstruct>>
u;
};
// [forall-construct-name :] FORALL concurrent-header
struct ForallConstructStmt {
TUPLE_CLASS_BOILERPLATE(ForallConstructStmt);
- std::tuple<std::optional<Name>, Indirection<ConcurrentHeader>> t;
+ std::tuple<std::optional<Name>, common::Indirection<ConcurrentHeader>> t;
};
// R1053 forall-assignment-stmt -> assignment-stmt | pointer-assignment-stmt
// R1055 forall-stmt -> FORALL concurrent-header forall-assignment-stmt
struct ForallStmt {
TUPLE_CLASS_BOILERPLATE(ForallStmt);
- std::tuple<Indirection<ConcurrentHeader>, ForallAssignmentStmt> t;
+ std::tuple<common::Indirection<ConcurrentHeader>, ForallAssignmentStmt> t;
};
// R1052 forall-body-construct ->
struct ForallBodyConstruct {
UNION_CLASS_BOILERPLATE(ForallBodyConstruct);
std::variant<Statement<ForallAssignmentStmt>, Statement<WhereStmt>,
- WhereConstruct, Indirection<ForallConstruct>, Statement<ForallStmt>>
+ WhereConstruct, common::Indirection<ForallConstruct>,
+ Statement<ForallStmt>>
u;
};
// R1216 input-item -> variable | io-implied-do
struct InputItem {
UNION_CLASS_BOILERPLATE(InputItem);
- std::variant<Variable, Indirection<InputImpliedDo>> u;
+ std::variant<Variable, common::Indirection<InputImpliedDo>> u;
};
// R1210 read-stmt ->
// R1217 output-item -> expr | io-implied-do
struct OutputItem {
UNION_CLASS_BOILERPLATE(OutputItem);
- std::variant<Expr, Indirection<OutputImpliedDo>> u;
+ std::variant<Expr, common::Indirection<OutputImpliedDo>> u;
};
// R1211 write-stmt -> WRITE ( io-control-spec-list ) [output-item-list]
// separate-module-subprogram
struct ModuleSubprogram {
UNION_CLASS_BOILERPLATE(ModuleSubprogram);
- std::variant<Indirection<FunctionSubprogram>,
- Indirection<SubroutineSubprogram>, Indirection<SeparateModuleSubprogram>>
+ std::variant<common::Indirection<FunctionSubprogram>,
+ common::Indirection<SubroutineSubprogram>,
+ common::Indirection<SeparateModuleSubprogram>>
u;
};
// R1413 only-use-name -> use-name
struct Only {
UNION_CLASS_BOILERPLATE(Only);
- std::variant<Indirection<GenericSpec>, Name, Rename> u;
+ std::variant<common::Indirection<GenericSpec>, Name, Rename> u;
};
// R1409 use-stmt ->
UNION_CLASS_BOILERPLATE(InterfaceBody);
struct Function {
TUPLE_CLASS_BOILERPLATE(Function);
- std::tuple<Statement<FunctionStmt>, Indirection<SpecificationPart>,
+ std::tuple<Statement<FunctionStmt>, common::Indirection<SpecificationPart>,
Statement<EndFunctionStmt>>
t;
};
struct Subroutine {
TUPLE_CLASS_BOILERPLATE(Subroutine);
- std::tuple<Statement<SubroutineStmt>, Indirection<SpecificationPart>,
- Statement<EndSubroutineStmt>>
+ std::tuple<Statement<SubroutineStmt>,
+ common::Indirection<SpecificationPart>, Statement<EndSubroutineStmt>>
t;
};
std::variant<Function, Subroutine> u;
WRAPPER_CLASS(PercentRef, Variable); // %REF(v) extension
WRAPPER_CLASS(PercentVal, Expr); // %VAL(x) extension
UNION_CLASS_BOILERPLATE(ActualArg);
- ActualArg(Expr &&x) : u{Indirection<Expr>(std::move(x))} {}
- ActualArg(Variable &&x) : u{Indirection<Variable>(std::move(x))} {}
- std::variant<Indirection<Expr>, Indirection<Variable>, Name, ProcComponentRef,
- AltReturnSpec, PercentRef, PercentVal>
+ ActualArg(Expr &&x) : u{common::Indirection<Expr>(std::move(x))} {}
+ ActualArg(Variable &&x) : u{common::Indirection<Variable>(std::move(x))} {}
+ std::variant<common::Indirection<Expr>, common::Indirection<Variable>, Name,
+ ProcComponentRef, AltReturnSpec, PercentRef, PercentVal>
u;
};
struct StructureField {
UNION_CLASS_BOILERPLATE(StructureField);
- std::variant<Statement<DataComponentDefStmt>, Indirection<StructureDef>,
- Indirection<Union>>
+ std::variant<Statement<DataComponentDefStmt>,
+ common::Indirection<StructureDef>, common::Indirection<Union>>
u;
};
struct OmpDependSinkVecLength {
TUPLE_CLASS_BOILERPLATE(OmpDependSinkVecLength);
- std::tuple<Indirection<DefinedOperator>, ScalarIntConstantExpr> t;
+ std::tuple<common::Indirection<DefinedOperator>, ScalarIntConstantExpr> t;
};
struct OmpDependSinkVec {
struct OpenMPConstruct {
UNION_CLASS_BOILERPLATE(OpenMPConstruct);
- std::variant<Indirection<OpenMPStandaloneConstruct>,
- Indirection<OpenMPLoopConstruct>>
+ std::variant<common::Indirection<OpenMPStandaloneConstruct>,
+ common::Indirection<OpenMPLoopConstruct>>
u;
};
#include "preprocessor.h"
#include "characters.h"
-#include "idioms.h"
#include "message.h"
#include "prescan.h"
+#include "../common/idioms.h"
#include <algorithm>
#include <cinttypes>
#include <cstddef>
#include "prescan.h"
#include "characters.h"
-#include "idioms.h"
#include "message.h"
#include "preprocessor.h"
#include "source.h"
#include "token-sequence.h"
+#include "../common/idioms.h"
#include <cstddef>
#include <cstring>
#include <sstream>
// limitations under the License.
#include "provenance.h"
-#include "idioms.h"
+#include "../common/idioms.h"
#include <utility>
namespace Fortran::parser {
CHECK(IsValid(range));
const Origin &origin{MapToOrigin(range.start())};
std::visit(
- visitors{
+ common::visitors{
[&](const Inclusion &inc) {
o << inc.source.path();
std::size_t offset{origin.covers.MemberOffset(range.start())};
const SourceFile *AllSources::GetSourceFile(
Provenance at, std::size_t *offset) const {
const Origin &origin{MapToOrigin(at)};
- return std::visit(visitors{[&](const Inclusion &inc) {
- if (offset != nullptr) {
- *offset = origin.covers.MemberOffset(at);
- }
- return &inc.source;
- },
+ return std::visit(common::visitors{[&](const Inclusion &inc) {
+ if (offset != nullptr) {
+ *offset =
+ origin.covers.MemberOffset(at);
+ }
+ return &inc.source;
+ },
[&](const Macro &mac) {
return GetSourceFile(origin.replaces.start(), offset);
},
const char &AllSources::Origin::operator[](std::size_t n) const {
return std::visit(
- visitors{[n](const Inclusion &inc) -> const char & {
- return inc.source.content()[n];
- },
+ common::visitors{[n](const Inclusion &inc) -> const char & {
+ return inc.source.content()[n];
+ },
[n](const Macro &mac) -> const char & { return mac.expansion[n]; },
[n](const CompilerInsertion &ins) -> const char & {
return ins.text[n];
o << " ";
DumpRange(o, m.covers);
o << " -> ";
- std::visit(visitors{[&](const Inclusion &inc) {
- if (inc.isModule) {
- o << "module ";
- }
- o << "file " << inc.source.path();
- },
+ std::visit(common::visitors{[&](const Inclusion &inc) {
+ if (inc.isModule) {
+ o << "module ";
+ }
+ o << "file " << inc.source.path();
+ },
[&](const Macro &mac) { o << "macro " << mac.expansion; },
[&](const CompilerInsertion &ins) {
o << "compiler '" << ins.text << '\'';
#include "char-block.h"
#include "char-buffer.h"
-#include "idioms.h"
-#include "interval.h"
#include "source.h"
+#include "../common/idioms.h"
+#include "../common/interval.h"
#include <cstddef>
#include <map>
#include <memory>
std::size_t offset_{0};
};
-using ProvenanceRange = Interval<Provenance>;
+using ProvenanceRange =
common::Interval<Provenance>;
// Maps 0-based local offsets in some contiguous range (e.g., a token
// sequence) to their provenances. Lookup time is on the order of
#include "source.h"
#include "char-buffer.h"
-#include "idioms.h"
+#include "../common/idioms.h"
#include <algorithm>
#include <cerrno>
#include <cstddef>
#include "basic-parsers.h"
#include "char-set.h"
#include "characters.h"
-#include "idioms.h"
#include "instrumented-parser.h"
#include "provenance.h"
#include "type-parsers.h"
+#include "../common/idioms.h"
#include <cstddef>
#include <cstring>
#include <functional>
content += **at;
}
- if (!shift) {
+ if (!shift.has_value()) {
// extension: base allowed to appear as suffix, too
- if (!IsNonstandardUsageOk(state) || !(at = nextCh.Parse(state)) ||
- !baseChar(**at)) {
+ if (!IsNonstandardUsageOk(state) ||
+ !(at = nextCh.Parse(state)).has_value() || !baseChar(**at)) {
return {};
}
spaceCheck.Parse(state);
bool negate{false};
if (minus.Parse(state)) {
negate = true;
- } else if (!plus.Parse(state)) {
+ } else if (!plus.Parse(state).has_value()) {
return {};
}
return SignedInteger(digitString.Parse(state), at, negate, state);
const char *start{state.GetLocation()};
std::optional<std::uint64_t> charCount{
DigitStringIgnoreSpaces{}.Parse(state)};
- if (!charCount || *charCount < 1) {
+ if (!charCount.has_value() || *charCount < 1) {
return {};
}
static constexpr auto letterH = "h"_ch;
#include "unparse.h"
#include "characters.h"
-#include "idioms.h"
-#include "indirection.h"
#include "parse-tree-visitor.h"
#include "parse-tree.h"
+#include "../common/idioms.h"
+#include "../common/indirection.h"
#include <algorithm>
#include <cinttypes>
#include <cstddef>
}
void Unparse(const KindSelector &x) { // R706
std::visit(
- visitors{[&](const ScalarIntConstantExpr &y) {
- Put('('), Word("KIND="), Walk(y), Put(')');
- },
+ common::visitors{[&](const ScalarIntConstantExpr &y) {
+ Put('('), Word("KIND="), Walk(y), Put(')');
+ },
[&](const KindSelector::StarSize &y) { Put('*'), Walk(y.v); }},
x.u);
}
Walk(", LEN=", x.length), Put(')');
}
void Unparse(const LengthSelector &x) { // R722
- std::visit(visitors{[&](const TypeParamValue &y) {
- Put('('), Word("LEN="), Walk(y), Put(')');
- },
+ std::visit(common::visitors{[&](const TypeParamValue &y) {
+ Put('('), Word("LEN="), Walk(y), Put(')');
+ },
[&](const CharLength &y) { Put('*'), Walk(y); }},
x.u);
}
void Unparse(const CharLength &x) { // R723
- std::visit(
- visitors{[&](const TypeParamValue &y) { Put('('), Walk(y), Put(')'); },
- [&](const std::int64_t &y) { Walk(y); }},
+ std::visit(common::visitors{[&](const TypeParamValue &y) {
+ Put('('), Walk(y), Put(')');
+ },
+ [&](const std::int64_t &y) { Walk(y); }},
x.u);
}
void Unparse(const CharLiteralConstant &x) { // R724
std::get<std::optional<Initialization>>(d.t);
return init.has_value() &&
std::holds_alternative<
- std::list<Indirection<DataStmtValue>>>(init->u);
+ std::list<common::Indirection<DataStmtValue>>>(
+ init->u);
}))) {
Put(" ::");
}
void Unparse(const Pointer &x) { Word("POINTER"); }
void Unparse(const Contiguous &x) { Word("CONTIGUOUS"); }
void Before(const ComponentAttrSpec &x) {
- std::visit(visitors{[&](const CoarraySpec &) { Word("CODIMENSION["); },
- [&](const ComponentArraySpec &) { Word("DIMENSION("); },
- [](const auto &) {}},
+ std::visit(
+ common::visitors{[&](const CoarraySpec &) { Word("CODIMENSION["); },
+ [&](const ComponentArraySpec &) { Word("DIMENSION("); },
+ [](const auto &) {}},
x.u);
}
void Post(const ComponentAttrSpec &x) {
std::visit(
- visitors{[&](const CoarraySpec &) { Put(']'); },
+ common::visitors{[&](const CoarraySpec &) { Put(']'); },
[&](const ComponentArraySpec &) { Put(')'); }, [](const auto &) {}},
x.u);
}
Walk(std::get<std::optional<Initialization>>(x.t));
}
void Unparse(const ComponentArraySpec &x) { // R740
- std::visit(
- visitors{[&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
- [&](const DeferredShapeSpecList &y) { Walk(y); }},
+ std::visit(common::visitors{[&](const std::list<ExplicitShapeSpec> &y) {
+ Walk(y, ",");
+ },
+ [&](const DeferredShapeSpecList &y) { Walk(y); }},
x.u);
}
void Unparse(const ProcComponentDefStmt &x) { // R741
}
void Unparse(const Pass &x) { Word("PASS"), Walk("(", x.v, ")"); }
void Unparse(const Initialization &x) { // R743 & R805
- std::visit(visitors{[&](const ConstantExpr &y) { Put(" = "), Walk(y); },
- [&](const NullInit &y) { Put(" => "), Walk(y); },
- [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
- [&](const std::list<Indirection<DataStmtValue>> &y) {
- Walk("/", y, ", ", "/");
- }},
+ std::visit(
+ common::visitors{[&](const ConstantExpr &y) { Put(" = "), Walk(y); },
+ [&](const NullInit &y) { Put(" => "), Walk(y); },
+ [&](const InitialDataTarget &y) { Put(" => "), Walk(y); },
+ [&](const std::list<common::Indirection<DataStmtValue>> &y) {
+ Walk("/", y, ", ", "/");
+ }},
x.u);
}
void Unparse(const PrivateStmt &x) { // R745
}
void Unparse(const TypeBoundGenericStmt &x) { // R751
Word("GENERIC"), Walk(", ", std::get<std::optional<AccessSpec>>(x.t));
- Put(" :: "), Walk(std::get<Indirection<GenericSpec>>(x.t));
+ Put(" :: "), Walk(std::get<common::Indirection<GenericSpec>>(x.t));
Put(" => "), Walk(std::get<std::list<Name>>(x.t), ", ");
}
void Post(const BindAttr::Deferred &) { Word("DEFERRED"); } // R752
Walk(dts), Walk(", ", attrs, ", ");
static const auto isInitializerOldStyle = [](const Initialization &i) {
- return std::holds_alternative<std::list<Indirection<DataStmtValue>>>(i.u);
+ return std::holds_alternative<
+ std::list<common::Indirection<DataStmtValue>>>(i.u);
};
static const auto hasAssignmentInitializer = [](const EntityDecl &d) {
// Does a declaration have a new-style =x initializer?
Put(' '), Walk(std::get<std::list<EntityDecl>>(x.t), ", ");
}
void Before(const AttrSpec &x) { // R802
- std::visit(visitors{[&](const CoarraySpec &y) { Word("CODIMENSION["); },
- [&](const ArraySpec &y) { Word("DIMENSION("); },
- [](const auto &) {}},
+ std::visit(
+ common::visitors{[&](const CoarraySpec &y) { Word("CODIMENSION["); },
+ [&](const ArraySpec &y) { Word("DIMENSION("); },
+ [](const auto &) {}},
x.u);
}
void Post(const AttrSpec &x) {
- std::visit(visitors{[&](const CoarraySpec &y) { Put(']'); },
+ std::visit(common::visitors{[&](const CoarraySpec &y) { Put(']'); },
[&](const ArraySpec &y) { Put(')'); }, [](const auto &) {}},
x.u);
}
Word("BIND(C"), Walk(", NAME=", x.v), Put(')');
}
void Unparse(const CoarraySpec &x) { // R809
- std::visit(visitors{[&](const DeferredCoshapeSpecList &y) { Walk(y); },
- [&](const ExplicitCoshapeSpec &y) { Walk(y); }},
+ std::visit(
+ common::visitors{[&](const DeferredCoshapeSpecList &y) { Walk(y); },
+ [&](const ExplicitCoshapeSpec &y) { Walk(y); }},
x.u);
}
void Unparse(const DeferredCoshapeSpecList &x) { // R810
Walk(std::get<SpecificationExpr>(x.t));
}
void Unparse(const ArraySpec &x) { // R815
- std::visit(
- visitors{[&](const std::list<ExplicitShapeSpec> &y) { Walk(y, ","); },
- [&](const std::list<AssumedShapeSpec> &y) { Walk(y, ","); },
- [&](const DeferredShapeSpecList &y) { Walk(y); },
- [&](const AssumedSizeSpec &y) { Walk(y); },
- [&](const ImpliedShapeSpec &y) { Walk(y); },
- [&](const AssumedRankSpec &y) { Walk(y); }},
+ std::visit(common::visitors{[&](const std::list<ExplicitShapeSpec> &y) {
+ Walk(y, ",");
+ },
+ [&](const std::list<AssumedShapeSpec> &y) { Walk(y, ","); },
+ [&](const DeferredShapeSpecList &y) { Walk(y); },
+ [&](const AssumedSizeSpec &y) { Walk(y); },
+ [&](const ImpliedShapeSpec &y) { Walk(y); },
+ [&](const AssumedRankSpec &y) { Walk(y); }},
x.u);
}
void Post(const AssumedShapeSpec &) { Put(':'); } // R819
}
void Unparse(const ImplicitStmt &x) { // R863
Word("IMPLICIT ");
- std::visit(
- visitors{[&](const std::list<ImplicitSpec> &y) { Walk(y, ", "); },
- [&](const std::list<ImplicitStmt::ImplicitNoneNameSpec> &y) {
- Word("NONE"), Walk(" (", y, ", ", ")");
- }},
+ std::visit(common::visitors{[&](const std::list<ImplicitSpec> &y) {
+ Walk(y, ", ");
+ },
+ [&](const std::list<ImplicitStmt::ImplicitNoneNameSpec> &y) {
+ Word("NONE"), Walk(" (", y, ", ", ")");
+ }},
x.u);
}
void Unparse(const ImplicitSpec &x) { // R864
Walk(", ", std::get<std::list<AllocOpt>>(x.t), ", "), Put(')');
}
void Before(const AllocOpt &x) { // R928, R931
- std::visit(visitors{[&](const AllocOpt::Mold &) { Word("MOLD="); },
+ std::visit(common::visitors{[&](const AllocOpt::Mold &) { Word("MOLD="); },
[&](const AllocOpt::Source &) { Word("SOURCE="); },
[](const StatOrErrmsg &) {}},
x.u);
Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
}
void Before(const StatOrErrmsg &x) { // R942 & R1165
- std::visit(visitors{[&](const StatVariable &) { Word("STAT="); },
+ std::visit(common::visitors{[&](const StatVariable &) { Word("STAT="); },
[&](const MsgVariable &) { Word("ERRMSG="); }},
x.u);
}
void Unparse(const PointerAssignmentStmt &x) { // R1033, R1034, R1038
Walk(std::get<DataRef>(x.t));
std::visit(
- visitors{[&](const std::list<BoundsRemapping> &y) {
- Put('('), Walk(y), Put(')');
- },
+ common::visitors{[&](const std::list<BoundsRemapping> &y) {
+ Put('('), Walk(y), Put(')');
+ },
[&](const std::list<BoundsSpec> &y) { Walk("(", y, ", ", ")"); }},
std::get<PointerAssignmentStmt::Bounds>(x.t).u);
Put(" => "), Walk(std::get<Expr>(x.t));
}
void Unparse(const ForallConstructStmt &x) { // R1051
Walk(std::get<std::optional<Name>>(x.t), ": ");
- Word("FORALL"), Walk(std::get<Indirection<ConcurrentHeader>>(x.t));
+ Word("FORALL"), Walk(std::get<common::Indirection<ConcurrentHeader>>(x.t));
Indent();
}
void Unparse(const EndForallStmt &x) { // R1054
Word("DO "), Walk(std::get<std::optional<LoopControl>>(x.t));
}
void Unparse(const LoopControl &x) { // R1123
- std::visit(visitors{[&](const ScalarLogicalExpr &y) {
- Word("WHILE ("), Walk(y), Put(')');
- },
+ std::visit(common::visitors{[&](const ScalarLogicalExpr &y) {
+ Word("WHILE ("), Walk(y), Put(')');
+ },
[&](const auto &y) { Walk(y); }},
x.u);
}
Outdent(), Word("END SELECT"), Walk(" ", x.v);
}
void Unparse(const CaseSelector &x) { // R1145
- std::visit(visitors{[&](const std::list<CaseValueRange> &y) {
- Put('('), Walk(y), Put(')');
- },
+ std::visit(common::visitors{[&](const std::list<CaseValueRange> &y) {
+ Put('('), Walk(y), Put(')');
+ },
[&](const Default &) { Word("DEFAULT"); }},
x.u);
}
}
void Unparse(const SelectRankCaseStmt &x) { // R1150
Outdent(), Word("RANK ");
- std::visit(visitors{[&](const ScalarIntConstantExpr &y) {
- Put('('), Walk(y), Put(')');
- },
+ std::visit(common::visitors{[&](const ScalarIntConstantExpr &y) {
+ Put('('), Walk(y), Put(')');
+ },
[&](const Star &) { Put("(*)"); },
[&](const Default &) { Word("DEFAULT"); }},
std::get<SelectRankCaseStmt::Rank>(x.t).u);
Walk(" ", std::get<std::optional<Name>>(x.t)), Indent();
}
void Unparse(const TypeGuardStmt::Guard &x) {
- std::visit(visitors{[&](const TypeSpec &y) {
- Word("TYPE IS ("), Walk(y), Put(')');
- },
+ std::visit(common::visitors{[&](const TypeSpec &y) {
+ Word("TYPE IS ("), Walk(y), Put(')');
+ },
[&](const DerivedTypeSpec &y) {
Word("CLASS IS ("), Walk(y), Put(')');
},
Walk(", ", std::get<std::list<StatOrErrmsg>>(x.t), ", "), Put(')');
}
void Before(const EventWaitStmt::EventWaitSpec &x) { // R1173, R1174
- std::visit(visitors{[&](const ScalarIntExpr &x) { Word("UNTIL_COUNT="); },
- [](const StatOrErrmsg &) {}},
+ std::visit(
+ common::visitors{[&](const ScalarIntExpr &x) { Word("UNTIL_COUNT="); },
+ [](const StatOrErrmsg &) {}},
x.u);
}
void Unparse(const EventWaitStmt &x) { // R1170
Put(')');
}
void Before(const FormTeamStmt::FormTeamSpec &x) { // R1176, R1177
- std::visit(visitors{[&](const ScalarIntExpr &x) { Word("NEW_INDEX="); },
- [](const StatOrErrmsg &) {}},
+ std::visit(
+ common::visitors{[&](const ScalarIntExpr &x) { Word("NEW_INDEX="); },
+ [](const StatOrErrmsg &) {}},
x.u);
}
void Unparse(const LockStmt &x) { // R1178
Put(')');
}
void Before(const LockStmt::LockStat &x) { // R1179
- std::visit(
- visitors{[&](const ScalarLogicalVariable &) { Word("ACQUIRED_LOCK="); },
- [](const StatOrErrmsg &y) {}},
+ std::visit(common::visitors{[&](const ScalarLogicalVariable &) {
+ Word("ACQUIRED_LOCK=");
+ },
+ [](const StatOrErrmsg &y) {}},
x.u);
}
void Unparse(const UnlockStmt &x) { // R1180
Word("OPEN ("), Walk(x.v, ", "), Put(')');
}
bool Pre(const ConnectSpec &x) { // R1205
- return std::visit(visitors{[&](const FileUnitNumber &) {
- Word("UNIT=");
- return true;
- },
+ return std::visit(common::visitors{[&](const FileUnitNumber &) {
+ Word("UNIT=");
+ return true;
+ },
[&](const FileNameExpr &) {
Word("FILE=");
return true;
Word("CLOSE ("), Walk(x.v, ", "), Put(')');
}
void Before(const CloseStmt::CloseSpec &x) { // R1209
- std::visit(visitors{[&](const FileUnitNumber &) { Word("UNIT="); },
+ std::visit(common::visitors{[&](const FileUnitNumber &) { Word("UNIT="); },
[&](const StatVariable &) { Word("IOSTAT="); },
[&](const MsgVariable &) { Word("IOMSG="); },
[&](const ErrLabel &) { Word("ERR="); },
Walk(", ", std::get<std::list<OutputItem>>(x.t), ", ");
}
bool Pre(const IoControlSpec &x) { // R1213
- return std::visit(visitors{[&](const IoUnit &) {
- Word("UNIT=");
- return true;
- },
+ return std::visit(common::visitors{[&](const IoUnit &) {
+ Word("UNIT=");
+ return true;
+ },
[&](const Format &) {
Word("FMT=");
return true;
Word("WAIT ("), Walk(x.v, ", "), Put(')');
}
void Before(const WaitSpec &x) { // R1223
- std::visit(visitors{[&](const FileUnitNumber &) { Word("UNIT="); },
+ std::visit(common::visitors{[&](const FileUnitNumber &) { Word("UNIT="); },
[&](const EndLabel &) { Word("END="); },
[&](const EorLabel &) { Word("EOR="); },
[&](const ErrLabel &) { Word("ERR="); },
Word("REWIND ("), Walk(x.v, ", "), Put(')');
}
void Before(const PositionOrFlushSpec &x) { // R1227 & R1229
- std::visit(visitors{[&](const FileUnitNumber &) { Word("UNIT="); },
+ std::visit(common::visitors{[&](const FileUnitNumber &) { Word("UNIT="); },
[&](const MsgVariable &) { Word("IOMSG="); },
[&](const StatVariable &) { Word("IOSTAT="); },
[&](const ErrLabel &) { Word("ERR="); }},
void Unparse(const InquireStmt &x) { // R1230
Word("INQUIRE (");
std::visit(
- visitors{[&](const InquireStmt::Iolength &y) {
- Word("IOLENGTH="), Walk(y.t, ") ");
- },
+ common::visitors{[&](const InquireStmt::Iolength &y) {
+ Word("IOLENGTH="), Walk(y.t, ") ");
+ },
[&](const std::list<InquireSpec> &y) { Walk(y, ", "), Put(')'); }},
x.u);
}
bool Pre(const InquireSpec &x) { // R1231
- return std::visit(visitors{[&](const FileUnitNumber &) {
- Word("UNIT=");
- return true;
- },
+ return std::visit(common::visitors{[&](const FileUnitNumber &) {
+ Word("UNIT=");
+ return true;
+ },
[&](const FileNameExpr &) {
Word("FILE=");
return true;
if (x.repeatCount.has_value()) {
Walk(*x.repeatCount);
}
- std::visit(visitors{[&](const std::string &y) { PutQuoted(y); },
+ std::visit(common::visitors{[&](const std::string &y) { PutQuoted(y); },
[&](const std::list<format::FormatItem> &y) {
Walk("(", y, ",", ")");
},
void Unparse(const UseStmt &x) { // R1409
Word("USE"), Walk(", ", x.nature), Put(" :: "), Walk(x.moduleName);
std::visit(
- visitors{[&](const std::list<Rename> &y) { Walk(", ", y, ", "); },
+ common::visitors{
+ [&](const std::list<Rename> &y) { Walk(", ", y, ", "); },
[&](const std::list<Only> &y) { Walk(", ONLY: ", y, ", "); }},
x.u);
}
void Unparse(const Rename &x) { // R1411
- std::visit(visitors{[&](const Rename::Names &y) { Walk(y.t, " => "); },
- [&](const Rename::Operators &y) {
- Word("OPERATOR("), Walk(y.t, ") => OPERATOR("), Put(")");
- }},
+ std::visit(
+ common::visitors{[&](const Rename::Names &y) { Walk(y.t, " => "); },
+ [&](const Rename::Operators &y) {
+ Word("OPERATOR("), Walk(y.t, ") => OPERATOR("), Put(")");
+ }},
x.u);
}
void Before(const SubmoduleStmt &x) { // R1417
}
void Unparse(const InterfaceStmt &x) { // R1503
- std::visit(visitors{[&](const std::optional<GenericSpec> &y) {
- Word("INTERFACE"), Walk(" ", y);
- },
+ std::visit(common::visitors{[&](const std::optional<GenericSpec> &y) {
+ Word("INTERFACE"), Walk(" ", y);
+ },
[&](const Abstract &) { Word("ABSTRACT INTERFACE"); }},
x.u);
Indent();
}
void Before(const GenericSpec &x) { // R1508, R1509
std::visit(
- visitors{[&](const DefinedOperator &x) { Word("OPERATOR("); },
+ common::visitors{[&](const DefinedOperator &x) { Word("OPERATOR("); },
[&](const GenericSpec::Assignment &) { Word("ASSIGNMENT(=)"); },
[&](const GenericSpec::ReadFormatted &) {
Word("READ(FORMATTED)");
x.u);
}
void Post(const GenericSpec &x) {
- std::visit(visitors{[&](const DefinedOperator &x) { Put(')'); },
+ std::visit(common::visitors{[&](const DefinedOperator &x) { Put(')'); },
[](const auto &) {}},
x.u);
}
// Directives, extensions, and deprecated constructs
void Unparse(const CompilerDirective &x) {
std::visit(
- visitors{[&](const std::list<CompilerDirective::IgnoreTKR> &tkr) {
- Word("!DIR$ IGNORE_TKR");
- Walk(" ", tkr, ", ");
- },
+ common::visitors{
+ [&](const std::list<CompilerDirective::IgnoreTKR> &tkr) {
+ Word("!DIR$ IGNORE_TKR");
+ Walk(" ", tkr, ", ");
+ },
[&](const CompilerDirective::IVDEP &) { Word("!DIR$ IVDEP\n"); }},
x.u);
Put('\n');
Put(")");
}
void Unparse(const OmpDependSinkVecLength &x) {
- Walk(std::get<Indirection<DefinedOperator>>(x.t));
+ Walk(std::get<common::Indirection<DefinedOperator>>(x.t));
Walk(std::get<ScalarIntConstantExpr>(x.t));
}
void Unparse(const OmpDependSinkVec &x) {
Walk(std::get<std::list<Designator>>(x.t), ",");
}
void Unparse(const OmpDependClause &x) {
- std::visit(visitors{[&](const OmpDependClause::Source &y) {
- Word("DEPEND(SOURCE)");
- },
+ std::visit(common::visitors{[&](const OmpDependClause::Source &y) {
+ Word("DEPEND(SOURCE)");
+ },
[&](const OmpDependClause::Sink &y) {
Word("DEPEND(SINK:");
Walk(y.v);
}
void Unparse(const OmpLoopDirective &x) {
std::visit(
- visitors{[&](const OmpLoopDirective::DistributeParallelDoSimd &y) {
- Word("DISTRIBUTE PARALLEL DO SIMD ");
- Walk(y.v, " ");
- },
+ common::visitors{
+ [&](const OmpLoopDirective::DistributeParallelDoSimd &y) {
+ Word("DISTRIBUTE PARALLEL DO SIMD ");
+ Walk(y.v, " ");
+ },
[&](const OmpLoopDirective::DistributeParallelDo &y) {
Word("DISTRIBUTE PARALLEL DO ");
Walk(y.v, " ");
Indent();
}
void Unparse(const OmpStandaloneDirective &x) {
- std::visit(visitors{[&](const OmpStandaloneDirective::Barrier &y) {
- Word("BARRIER ");
- Walk(y.v, " ");
- },
+ std::visit(common::visitors{[&](const OmpStandaloneDirective::Barrier &y) {
+ Word("BARRIER ");
+ Walk(y.v, " ");
+ },
[&](const OmpStandaloneDirective::CancellationPoint &y) {
Word("CANCELLATION POINT ");
Walk(y.v, " ");
}
void Unparse(const OmpEndDirective &x) {
Outdent();
- std::visit(visitors{[&](const OmpLoopDirective &y) {
+ std::visit(common::visitors{[&](const OmpLoopDirective &y) {
Word("!$OMP END ");
Walk(y);
}},
};
struct CapturedLabelDoStmt {
- using resultType = Statement<Indirection<LabelDoStmt>>;
+ using resultType = Statement<common::Indirection<LabelDoStmt>>;
static std::optional<resultType> Parse(ParseState &);
};
struct EndDoStmtForCapturedLabelDoStmt {
- using resultType = Statement<Indirection<EndDoStmt>>;
+ using resultType = Statement<common::Indirection<EndDoStmt>>;
static std::optional<resultType> Parse(ParseState &);
};
type.cc
)
-target_link_libraries( FlangSemantics
- clangBasic
+target_link_libraries(FlangSemantics
+ FortranCommon
+ clangBasic
)
// limitations under the License.
#include "attr.h"
-#include "../parser/idioms.h"
+#include "../common/idioms.h"
#include <stddef.h>
namespace Fortran::semantics {
void Attrs::CheckValid(const Attrs &allowed) const {
if (!allowed.HasAll(*this)) {
- parser::die("invalid attribute");
+ common::die("invalid attribute");
}
}
#define FORTRAN_SEMANTICS_ATTR_H_
#include "../common/enum-set.h"
-#include "../parser/idioms.h"
+#include "../common/idioms.h"
#include <cinttypes>
#include <iostream>
#include <string>
#define FORTRAN_SEMANTICS_DUMP_PARSE_TREE_H_
#include "symbol.h"
+#include "../common/idioms.h"
+#include "../common/indirection.h"
#include "../parser/format-specification.h"
-#include "../parser/idioms.h"
-#include "../parser/indirection.h"
#include "../parser/parse-tree-visitor.h"
#include "../parser/parse-tree.h"
#include <ostream>
template<typename T> void Post(const parser::Statement<T> &) {}
- template<typename T> bool Pre(const parser::Indirection<T> &) { return true; }
+ template<typename T> bool Pre(const common::Indirection<T> &) { return true; }
- template<typename T> void Post(const parser::Indirection<T> &) {}
+ template<typename T> void Post(const common::Indirection<T> &) {}
template<typename T> bool Pre(const parser::Integer<T> &) { return true; }
#include "scope.h"
#include "symbol.h"
#include "type.h"
-#include "../parser/indirection.h"
+#include "../common/indirection.h"
#include "../parser/parse-tree-visitor.h"
#include "../parser/parse-tree.h"
#include <list>
case parser::AccessSpec::Kind::Private: return Attr::PRIVATE;
}
// unnecessary but g++ warns "control reaches end of non-void function"
- parser::die("unreachable");
+ common::die("unreachable");
}
};
}
bool DeclTypeSpecVisitor::Pre(const parser::TypeParamValue &x) {
typeParamValue_ = std::make_unique<ParamValue>(std::visit(
- parser::visitors{
+ common::visitors{
// TODO: create IntExpr from ScalarIntExpr
[&](const parser::ScalarIntExpr &x) { return Bound{IntExpr{}}; },
[&](const parser::Star &x) { return Bound::ASSUMED; },
bool ImplicitRulesVisitor::Pre(const parser::ImplicitStmt &x) {
bool res = std::visit(
- parser::visitors{
+ common::visitors{
[&](const std::list<ImplicitNoneNameSpec> &x) {
return HandleImplicitNone(x);
},
bool ModuleVisitor::Pre(const parser::Only &x) {
std::visit(
- parser::visitors{
- [&](const
parser::Indirection<parser::GenericSpec> &generic) {
+ common::visitors{
+ [&](const
common::Indirection<parser::GenericSpec> &generic) {
std::visit(
- parser::visitors{
+ common::visitors{
[&](const parser::Name &name) { AddUse(name); },
- [](const auto &) { parser::die("TODO: GenericSpec"); },
+ [](const auto &) { common::die("TODO: GenericSpec"); },
},
generic->u);
},
[&](const parser::Name &name) { AddUse(name); },
[&](const parser::Rename &rename) {
std::visit(
- parser::visitors{
+ common::visitors{
[&](const parser::Rename::Names &names) { AddUse(names); },
[&](const parser::Rename::Operators &ops) {
- parser::die("TODO: Rename::Operators");
+ common::die("TODO: Rename::Operators");
},
},
rename.u);
std::set<SourceName> useNames;
for (const auto &rename : *list) {
std::visit(
- parser::visitors{
+ common::visitors{
[&](const parser::Rename::Names &names) {
useNames.insert(std::get<1>(names.t).source);
},
} else {
for (const auto &accessId : accessIds) {
std::visit(
- parser::visitors{
+ common::visitors{
[=](const parser::Name &y) { SetAccess(y, accessAttr); },
- [=](const
parser::Indirection<parser::GenericSpec> &y) {
+ [=](const
common::Indirection<parser::GenericSpec> &y) {
std::visit(
- parser::visitors{
+ common::visitors{
[=](const parser::Name &z) {
SetAccess(z, accessAttr);
},
- [](const auto &) { parser::die("TODO: GenericSpec"); },
+ [](const auto &) { common::die("TODO: GenericSpec"); },
},
y->u);
},
const parser::Name *ResolveNamesVisitor::GetVariableName(
const parser::Designator &x) {
return std::visit(
- parser::visitors{
+ common::visitors{
[&](const parser::ObjectName &x) { return &x; },
[&](const parser::DataRef &x) { return GetVariableName(x); },
[&](const auto &) {
const parser::Name *ResolveNamesVisitor::GetVariableName(
const parser::Expr &x) {
if (const auto *designator =
- std::get_if<
parser::Indirection<parser::Designator>>(&x.u)) {
+ std::get_if<
common::Indirection<parser::Designator>>(&x.u)) {
return GetVariableName(**designator);
} else {
return nullptr;
const parser::Name *ResolveNamesVisitor::GetVariableName(
const parser::Variable &x) {
if (const auto *designator =
- std::get_if<
parser::Indirection<parser::Designator>>(&x.u)) {
+ std::get_if<
common::Indirection<parser::Designator>>(&x.u)) {
return GetVariableName(**designator);
} else {
return nullptr;
// Map a parser::GenericSpec to a semantics::GenericSpec
static GenericSpec MapGenericSpec(const parser::GenericSpec &genericSpec) {
return std::visit(
- parser::visitors{
+ common::visitors{
[](const parser::Name &x) {
return GenericSpec::GenericName(x.source);
},
[](const parser::DefinedOperator &x) {
return std::visit(
- parser::visitors{
+ common::visitors{
[](const parser::DefinedOpName &name) {
return GenericSpec::DefinedOp(name.v.source);
},
#include "rewrite-parse-tree.h"
#include "scope.h"
#include "symbol.h"
-#include "../parser/indirection.h"
+#include "../common/indirection.h"
#include "../parser/parse-tree-visitor.h"
#include "../parser/parse-tree.h"
#include <list>
}
using stmtFuncType =
- parser::Statement<
parser::Indirection<parser::StmtFunctionStmt>>;
+ parser::Statement<
common::Indirection<parser::StmtFunctionStmt>>;
// Find mis-parsed statement functions and move to stmtFuncsToConvert list.
void Post(parser::SpecificationPart &x) {
// entity declaration, convert it.
template<typename T> void ConvertFunctionRef(T &x) {
auto *funcRef =
- std::get_if<
parser::Indirection<parser::FunctionReference>>(&x.u);
+ std::get_if<
common::Indirection<parser::FunctionReference>>(&x.u);
if (!funcRef) {
return;
}
if (!name || !name->symbol || !name->symbol->has<EntityDetails>()) {
return;
}
- x.u = parser::Indirection{(*funcRef)->ConvertToArrayElementRef()};
+ x.u = common::Indirection{(*funcRef)->ConvertToArrayElementRef()};
}
};
#include "attr.h"
#include "symbol.h"
-#include "../parser/idioms.h"
+#include "../common/idioms.h"
#include "../parser/parse-tree.h"
#include <list>
#include <map>
#include "symbol.h"
#include "scope.h"
-#include "../parser/idioms.h"
+#include "../common/idioms.h"
#include <memory>
namespace Fortran::semantics {
// This is primarily for debugging.
static std::string DetailsToString(const Details &details) {
return std::visit(
- parser::visitors{
+ common::visitors{
[](const UnknownDetails &) { return "Unknown"; },
[](const MainProgramDetails &) { return "MainProgram"; },
[](const ModuleDetails &) { return "Module"; },
return true; // can always replace UnknownDetails
} else {
return std::visit(
- parser::visitors{
+ common::visitors{
[](const UseErrorDetails &) { return true; },
[=](const ObjectEntityDetails &) { return has<EntityDetails>(); },
[=](const ProcEntityDetails &) { return has<EntityDetails>(); },
bool Symbol::isSubprogram() const {
return std::visit(
- parser::visitors{
+ common::visitors{
[](const SubprogramDetails &) { return true; },
[](const SubprogramNameDetails &) { return true; },
[](const GenericDetails &) { return true; },
bool Symbol::HasExplicitInterface() const {
return std::visit(
- parser::visitors{
+ common::visitors{
[](const SubprogramDetails &) { return true; },
[](const SubprogramNameDetails &) { return true; },
[](const ProcEntityDetails &x) { return x.HasExplicitInterface(); },
std::ostream &operator<<(std::ostream &os, const Details &details) {
os << DetailsToString(details);
std::visit(
- parser::visitors{
+ common::visitors{
[&](const UnknownDetails &x) {},
[&](const MainProgramDetails &x) {},
[&](const ModuleDetails &x) {},
if (const auto p = detailsIf<D>()) {
return *p;
} else {
- Fortran::parser::die("unexpected %s details at %s(%d)",
- GetDetailsName().c_str(), __FILE__, __LINE__);
+ common::die("unexpected %s details at %s(%d)", GetDetailsName().c_str(),
+ __FILE__, __LINE__);
}
}
#define FORTRAN_SEMANTICS_TYPE_H_
#include "attr.h"
+#include "../common/idioms.h"
#include "../parser/char-block.h"
-#include "../parser/idioms.h"
#include <list>
#include <map>
#include <memory>
const SourceName &binding)
: TypeBoundProc(interface, attrs, binding, binding) {
if (!attrs_.test(Attr::DEFERRED)) {
- parser::die(
+ common::die(
"DEFERRED attribute is required if interface name is specified");
}
}
const std::optional<SourceName> &procedure)
: TypeBoundProc({}, attrs, binding, procedure ? *procedure : binding) {
if (attrs_.test(Attr::DEFERRED)) {
- parser::die("DEFERRED attribute is only allowed with interface name");
+ common::die("DEFERRED attribute is only allowed with interface name");
}
}
namespace Fortran::runtime {
-// Fortran requires that default INTEGER values occupy a single numeric
-// storage unit, just like default REAL. Since there's no reasonable way
-// that default REAL can be anything but 32-bit IEEE-754 today, the default
-// INTEGER type is also forced; and default INTEGER is required to be the
-// type of the kind type parameters of the intrinsic types.
-using DefaultKindInteger = std::int32_t;
-
-class DerivedType;
class DerivedTypeSpecialization;
class DescriptorAddendum;
-// This next section implements a C++ view of the sole interoperable
-// descriptor (ISO_cdesc_t) and its type and per-dimension information.
+// A C++ view of the sole interoperable standard descriptor (ISO_cdesc_t)
+// and its type and per-dimension information.
class TypeCode {
public:
- enum class Form { Integer, Real, Complex, Logical, Character, DerivedType };
+ enum class Form { Integer, Real, Complex, Logical, Character, Derived };
TypeCode() {}
explicit TypeCode(ISO::CFI_type_t t) : raw_{t} {}
}
constexpr bool IsLogical() const { return raw_ == CFI_type_Bool; }
constexpr bool IsCharacter() const { return raw_ == CFI_type_cptr; }
- constexpr bool IsDerivedType() const { return raw_ == CFI_type_struct; }
+ constexpr bool IsDerived() const { return raw_ == CFI_type_struct; }
constexpr bool IsIntrinsic() const {
- return raw_ >= CFI_type_signed_char && raw_ <= CFI_type_cptr;
+ return IsValid() && !IsDerived();
}
constexpr Form GetForm() const {
if (IsCharacter()) {
return Form::Character;
}
- return Form::DerivedType;
+ return Form::Derived;
}
private:
projects / platform / upstream / llvm.git / commitdiff