forked from OSchip/llvm-project
97 lines
3.7 KiB
C++
97 lines
3.7 KiB
C++
//===-- lib/Evaluate/fold-character.cpp -----------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "fold-implementation.h"
|
|
|
|
namespace Fortran::evaluate {
|
|
|
|
template <int KIND>
|
|
Expr<Type<TypeCategory::Character, KIND>> FoldIntrinsicFunction(
|
|
FoldingContext &context,
|
|
FunctionRef<Type<TypeCategory::Character, KIND>> &&funcRef) {
|
|
using T = Type<TypeCategory::Character, KIND>;
|
|
auto *intrinsic{std::get_if<SpecificIntrinsic>(&funcRef.proc().u)};
|
|
CHECK(intrinsic);
|
|
std::string name{intrinsic->name};
|
|
if (name == "achar" || name == "char") {
|
|
using IntT = SubscriptInteger;
|
|
return FoldElementalIntrinsic<T, IntT>(context, std::move(funcRef),
|
|
ScalarFunc<T, IntT>([](const Scalar<IntT> &i) {
|
|
return CharacterUtils<KIND>::CHAR(i.ToUInt64());
|
|
}));
|
|
} else if (name == "adjustl") {
|
|
return FoldElementalIntrinsic<T, T>(
|
|
context, std::move(funcRef), CharacterUtils<KIND>::ADJUSTL);
|
|
} else if (name == "adjustr") {
|
|
return FoldElementalIntrinsic<T, T>(
|
|
context, std::move(funcRef), CharacterUtils<KIND>::ADJUSTR);
|
|
} else if (name == "max") {
|
|
return FoldMINorMAX(context, std::move(funcRef), Ordering::Greater);
|
|
} else if (name == "merge") {
|
|
return FoldMerge<T>(context, std::move(funcRef));
|
|
} else if (name == "min") {
|
|
return FoldMINorMAX(context, std::move(funcRef), Ordering::Less);
|
|
} else if (name == "new_line") {
|
|
return Expr<T>{Constant<T>{CharacterUtils<KIND>::NEW_LINE()}};
|
|
} else if (name == "repeat") { // not elemental
|
|
if (auto scalars{GetScalarConstantArguments<T, SubscriptInteger>(
|
|
context, funcRef.arguments())}) {
|
|
return Expr<T>{Constant<T>{
|
|
CharacterUtils<KIND>::REPEAT(std::get<Scalar<T>>(*scalars),
|
|
std::get<Scalar<SubscriptInteger>>(*scalars).ToInt64())}};
|
|
}
|
|
} else if (name == "trim") { // not elemental
|
|
if (auto scalar{
|
|
GetScalarConstantArguments<T>(context, funcRef.arguments())}) {
|
|
return Expr<T>{Constant<T>{
|
|
CharacterUtils<KIND>::TRIM(std::get<Scalar<T>>(*scalar))}};
|
|
}
|
|
}
|
|
// TODO: cshift, eoshift, maxval, minval, pack, reduce,
|
|
// spread, transfer, transpose, unpack
|
|
return Expr<T>{std::move(funcRef)};
|
|
}
|
|
|
|
template <int KIND>
|
|
Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
|
|
FoldingContext &context, Concat<KIND> &&x) {
|
|
if (auto array{ApplyElementwise(context, x)}) {
|
|
return *array;
|
|
}
|
|
using Result = Type<TypeCategory::Character, KIND>;
|
|
if (auto folded{OperandsAreConstants(x)}) {
|
|
return Expr<Result>{Constant<Result>{folded->first + folded->second}};
|
|
}
|
|
return Expr<Result>{std::move(x)};
|
|
}
|
|
|
|
template <int KIND>
|
|
Expr<Type<TypeCategory::Character, KIND>> FoldOperation(
|
|
FoldingContext &context, SetLength<KIND> &&x) {
|
|
if (auto array{ApplyElementwise(context, x)}) {
|
|
return *array;
|
|
}
|
|
using Result = Type<TypeCategory::Character, KIND>;
|
|
if (auto folded{OperandsAreConstants(x)}) {
|
|
auto oldLength{static_cast<ConstantSubscript>(folded->first.size())};
|
|
auto newLength{folded->second.ToInt64()};
|
|
if (newLength < oldLength) {
|
|
folded->first.erase(newLength);
|
|
} else {
|
|
folded->first.append(newLength - oldLength, ' ');
|
|
}
|
|
CHECK(static_cast<ConstantSubscript>(folded->first.size()) == newLength);
|
|
return Expr<Result>{Constant<Result>{std::move(folded->first)}};
|
|
}
|
|
return Expr<Result>{std::move(x)};
|
|
}
|
|
|
|
FOR_EACH_CHARACTER_KIND(template class ExpressionBase, )
|
|
template class ExpressionBase<SomeCharacter>;
|
|
} // namespace Fortran::evaluate
|