template<typename T>
std::ostream &ArrayConstructor<T>::Dump(std::ostream &o) const {
- o << '[' << Result::Dump() << "::";
+ o << '[' << result.Dump() << "::";
Emit(o, *this);
return o << ']';
}
return o;
}
+template<typename T> Expr<SubscriptInteger> ArrayConstructor<T>::LEN() const {
+ // TODO pmk: extract from type spec
+ return AsExpr(Constant<SubscriptInteger>{0}); // TODO placeholder
+}
+
template<int KIND>
Expr<SubscriptInteger> Expr<Type<TypeCategory::Character, KIND>>::LEN() const {
return std::visit(
return AsExpr(
Constant<SubscriptInteger>{c.value.size()});
},
+ [](const ArrayConstructor<Result> &a) { return a.LEN(); },
[](const Parentheses<Result> &x) { return x.left().LEN(); },
[](const Concat<KIND> &c) {
return c.left().LEN() + c.right().LEN();
Expr<SomeType>::~Expr() {}
+template<typename T> DynamicType ArrayConstructor<T>::GetType() const {
+ // TODO: pmk: parameterized derived types, CHARACTER length
+ return *result.GetType();
+}
+
template<typename A>
std::optional<DynamicType> ExpressionBase<A>::GetType() const {
if constexpr (Result::isSpecificIntrinsicType) {
struct ArrayConstructor : public ArrayConstructorValues<RESULT> {
using Result = RESULT;
using ArrayConstructorValues<Result>::ArrayConstructorValues;
+ Result result;
+ DynamicType GetType() const;
static constexpr int Rank() { return 1; }
+ Expr<SubscriptInteger> LEN() const;
std::ostream &Dump(std::ostream &) const;
};
using Operations = std::variant<ComplexComponent<KIND>, Parentheses<Result>,
Negate<Result>, Add<Result>, Subtract<Result>, Multiply<Result>,
Divide<Result>, Power<Result>, RealToIntPower<Result>, Extremum<Result>>;
- using Others =
- std::variant<Constant<Result>, Designator<Result>, FunctionRef<Result>>;
+ using Others = std::variant<Constant<Result>, ArrayConstructor<Result>,
+ Designator<Result>, FunctionRef<Result>>;
public:
common::CombineVariants<Operations, Conversions, Others> u;
using Operations =
std::variant<Parentheses<Result>, Multiply<Result>, Divide<Result>,
Power<Result>, RealToIntPower<Result>, ComplexConstructor<KIND>>;
- using Others =
- std::variant<Constant<Result>, Designator<Result>, FunctionRef<Result>>;
+ using Others = std::variant<Constant<Result>, ArrayConstructor<Result>,
+ Designator<Result>, FunctionRef<Result>>;
public:
common::CombineVariants<Operations, Others> u;
Expr<SubscriptInteger> LEN() const;
- std::variant<Constant<Result>, Designator<Result>, FunctionRef<Result>,
- Parentheses<Result>, Concat<KIND>, Extremum<Result>>
+ std::variant<Constant<Result>, ArrayConstructor<Result>, Designator<Result>,
+ FunctionRef<Result>, Parentheses<Result>, Concat<KIND>, Extremum<Result>>
u;
};
Parentheses<Result>, Not<KIND>, LogicalOperation<KIND>>;
using Relations = std::conditional_t<KIND == LogicalResult::kind,
std::variant<Relational<SomeType>>, std::variant<>>;
- using Others =
- std::variant<Constant<Result>, Designator<Result>, FunctionRef<Result>>;
+ using Others = std::variant<Constant<Result>, ArrayConstructor<Result>,
+ Designator<Result>, FunctionRef<Result>>;
public:
common::CombineVariants<Operations, Relations, Others> u;
FOR_EACH_LOGICAL_KIND(extern template class Expr)
+// An expression whose result has a derived type.
+template<> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
+public:
+ using Result = SomeDerived;
+ EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
+ // TODO: structure constructor
+ std::variant<Designator<Result>, ArrayConstructor<Result>,
+ FunctionRef<Result>>
+ u;
+};
+
// A polymorphic expression of known intrinsic type category, but dynamic
// kind, represented as a discriminated union over Expr<Type<CAT, K>>
// for each supported kind K in the category.
common::MapTemplate<Expr, CategoryTypes<CAT>> u;
};
-// An expression whose result has a derived type.
-template<> class Expr<SomeDerived> : public ExpressionBase<SomeDerived> {
-public:
- using Result = SomeDerived;
- EVALUATE_UNION_CLASS_BOILERPLATE(Expr)
- // TODO: array constructor, structure constructor
- std::variant<Designator<Result>, FunctionRef<Result>> u;
-};
-
// A completely generic expression, polymorphic across all of the intrinsic type
// categories and each of their kinds.
template<> class Expr<SomeType> : public ExpressionBase<SomeType> {