#include "flang/Runtime/command.h"
#include "environment.h"
+#include "stat.h"
+#include "flang/Runtime/descriptor.h"
#include <limits>
namespace Fortran::runtime {
return 0;
}
-std::int64_t RTNAME(ArgumentLength)(std::int32_t n) {
- if (n < 0 || n >= executionEnvironment.argc) {
- return 0;
- }
-
+// Returns the length of the \p n'th argument. Assumes \p n is valid.
+static std::int64_t ArgumentLength(std::int32_t n) {
std::size_t length{std::strlen(executionEnvironment.argv[n])};
if constexpr (sizeof(std::size_t) <= sizeof(std::int64_t)) {
return static_cast<std::int64_t>(length);
: static_cast<std::int64_t>(length);
}
}
+
+std::int64_t RTNAME(ArgumentLength)(std::int32_t n) {
+ if (n < 0 || n >= executionEnvironment.argc) {
+ return 0;
+ }
+
+ return ArgumentLength(n);
+}
+
+static bool IsValidCharDescriptor(const Descriptor *value) {
+ return value && value->IsAllocated() &&
+ value->type() == TypeCode(TypeCategory::Character, 1) &&
+ value->rank() == 0;
+}
+
+static void FillWithSpaces(const Descriptor *value) {
+ std::memset(value->OffsetElement(), ' ', value->ElementBytes());
+}
+
+std::int32_t RTNAME(ArgumentValue)(
+ std::int32_t n, const Descriptor *value, const Descriptor *errmsg) {
+ if (IsValidCharDescriptor(value)) {
+ FillWithSpaces(value);
+ }
+
+ if (n < 0 || n >= executionEnvironment.argc) {
+ return ToErrmsg(errmsg, StatInvalidArgumentNumber);
+ }
+
+ if (IsValidCharDescriptor(value)) {
+ std::int64_t argLen{ArgumentLength(n)};
+ if (argLen <= 0) {
+ return ToErrmsg(errmsg, StatMissingArgument);
+ }
+
+ std::int64_t toCopy{
+ std::min(argLen, static_cast<std::int64_t>(value->ElementBytes()))};
+ std::memcpy(value->OffsetElement(), executionEnvironment.argv[n], toCopy);
+
+ if (argLen > toCopy) {
+ return ToErrmsg(errmsg, StatValueTooShort);
+ }
+ }
+
+ return StatOk;
+}
} // namespace Fortran::runtime
//===----------------------------------------------------------------------===//
#include "flang/Runtime/command.h"
+#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "flang/Runtime/descriptor.h"
#include "flang/Runtime/main.h"
using namespace Fortran::runtime;
+template <std::size_t n = 64>
+static OwningPtr<Descriptor> CreateEmptyCharDescriptor() {
+ OwningPtr<Descriptor> descriptor{Descriptor::Create(
+ sizeof(char), n, nullptr, 0, nullptr, CFI_attribute_allocatable)};
+ if (descriptor->Allocate() != 0) {
+ return nullptr;
+ }
+ return descriptor;
+}
+
class CommandFixture : public ::testing::Test {
protected:
CommandFixture(int argc, const char *argv[]) {
RTNAME(ProgramStart)(argc, argv, {});
}
+
+ std::string GetPaddedStr(const char *text, std::size_t len) const {
+ std::string res{text};
+ assert(res.length() <= len && "No room to pad");
+ res.append(len - res.length(), ' ');
+ return res;
+ }
+
+ void CheckDescriptorEqStr(
+ const Descriptor *value, const std::string &expected) const {
+ EXPECT_EQ(std::strncmp(value->OffsetElement(), expected.c_str(),
+ value->ElementBytes()),
+ 0);
+ }
+
+ void CheckArgumentValue(int n, const char *argv) const {
+ OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
+ ASSERT_NE(value, nullptr);
+
+ std::string expected{GetPaddedStr(argv, value->ElementBytes())};
+
+ EXPECT_EQ(RTNAME(ArgumentValue)(n, value.get(), nullptr), 0);
+ CheckDescriptorEqStr(value.get(), expected);
+ }
+
+ void CheckMissingArgumentValue(int n, const char *errStr = nullptr) const {
+ OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
+ ASSERT_NE(value, nullptr);
+
+ OwningPtr<Descriptor> err{errStr ? CreateEmptyCharDescriptor() : nullptr};
+
+ EXPECT_GT(RTNAME(ArgumentValue)(n, value.get(), err.get()), 0);
+
+ std::string spaces(value->ElementBytes(), ' ');
+ CheckDescriptorEqStr(value.get(), spaces);
+
+ if (errStr) {
+ std::string paddedErrStr(GetPaddedStr(errStr, err->ElementBytes()));
+ CheckDescriptorEqStr(err.get(), paddedErrStr);
+ }
+ }
};
static const char *commandOnlyArgv[]{"aProgram"};
EXPECT_EQ(0, RTNAME(ArgumentLength)(1));
}
+TEST_F(ZeroArguments, ArgumentValue) {
+ CheckArgumentValue(0, commandOnlyArgv[0]);
+}
+
static const char *oneArgArgv[]{"aProgram", "anArgumentOfLength20"};
class OneArgument : public CommandFixture {
protected:
EXPECT_EQ(0, RTNAME(ArgumentLength)(2));
}
+TEST_F(OneArgument, ArgumentValue) {
+ CheckArgumentValue(0, oneArgArgv[0]);
+ CheckArgumentValue(1, oneArgArgv[1]);
+}
+
static const char *severalArgsArgv[]{
"aProgram", "16-char-long-arg", "", "-22-character-long-arg", "o"};
class SeveralArguments : public CommandFixture {
EXPECT_EQ(1, RTNAME(ArgumentLength)(4));
EXPECT_EQ(0, RTNAME(ArgumentLength)(5));
}
+
+TEST_F(SeveralArguments, ArgumentValue) {
+ CheckArgumentValue(0, severalArgsArgv[0]);
+ CheckArgumentValue(1, severalArgsArgv[1]);
+ CheckArgumentValue(3, severalArgsArgv[3]);
+ CheckArgumentValue(4, severalArgsArgv[4]);
+}
+
+TEST_F(SeveralArguments, NoArgumentValue) {
+ // Make sure we don't crash if the 'value' and 'error' parameters aren't
+ // passed.
+ EXPECT_EQ(RTNAME(ArgumentValue)(2, nullptr, nullptr), 0);
+ EXPECT_GT(RTNAME(ArgumentValue)(-1, nullptr, nullptr), 0);
+}
+
+TEST_F(SeveralArguments, MissingArguments) {
+ CheckMissingArgumentValue(-1, "Invalid argument number");
+ CheckMissingArgumentValue(2, "Missing argument");
+ CheckMissingArgumentValue(5, "Invalid argument number");
+ CheckMissingArgumentValue(5);
+}
+
+TEST_F(SeveralArguments, ValueTooShort) {
+ OwningPtr<Descriptor> tooShort{CreateEmptyCharDescriptor<15>()};
+ ASSERT_NE(tooShort, nullptr);
+ EXPECT_EQ(RTNAME(ArgumentValue)(1, tooShort.get(), nullptr), -1);
+ CheckDescriptorEqStr(tooShort.get(), severalArgsArgv[1]);
+
+ OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor()};
+ ASSERT_NE(errMsg, nullptr);
+
+ EXPECT_EQ(RTNAME(ArgumentValue)(1, tooShort.get(), errMsg.get()), -1);
+
+ std::string expectedErrMsg{
+ GetPaddedStr("Value too short", errMsg->ElementBytes())};
+ CheckDescriptorEqStr(errMsg.get(), expectedErrMsg);
+}
+
+TEST_F(SeveralArguments, ErrMsgTooShort) {
+ OwningPtr<Descriptor> errMsg{CreateEmptyCharDescriptor<3>()};
+ EXPECT_GT(RTNAME(ArgumentValue)(-1, nullptr, errMsg.get()), 0);
+ CheckDescriptorEqStr(errMsg.get(), "Inv");
+}