[flang] GET_COMMAND_ARGUMENT(ERRMSG) runtime implementation

[rovka]

Summary

Implement the final part of GET_COMMAND_ARGUMENT, i.e. the handling of
ERRMSG. This uses some of the infrastructure in stat.h and gets rid of
the magic numbers that we were using for return codes.

[rovka]

Rebase.

[rovka]

Rebase again.

flang/include/flang/Runtime/magic-numbers.h

 #define FORTRAN_RUNTIME_IOSTAT_INQUIRE_INTERNAL_UNIT 256
 
 #define FORTRAN_RUNTIME_STAT_FAILED_IMAGE 101
 #define FORTRAN_RUNTIME_STAT_LOCKED 102
 #define FORTRAN_RUNTIME_STAT_LOCKED_OTHER_IMAGE 103
 #define FORTRAN_RUNTIME_STAT_STOPPED_IMAGE 104
 #define FORTRAN_RUNTIME_STAT_UNLOCKED 105
 #define FORTRAN_RUNTIME_STAT_UNLOCKED_FAILED_IMAGE 106
+
+#if 0
+Status codes for GET_COMMAND_ARGUMENT. The status for 'value too short' needs
+to be -1, the others must be positive.
+#endif
+#define FORTRAN_RUNTIME_STAT_INVALID_ARG_NUMBER 107
+#define FORTRAN_RUNTIME_STAT_MISSING_ARG 108
+#define FORTRAN_RUNTIME_STAT_VALUE_TOO_SHORT -1
 #endif

flang/runtime/command.cpp

 //===-- runtime/command.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 "flang/Runtime/command.h"
 #include "environment.h"
+#include "stat.h"
 #include "flang/Runtime/descriptor.h"
 #include <limits>
 
 namespace Fortran::runtime {
 std::int32_t RTNAME(ArgumentCount)() {
   int argc{executionEnvironment.argc};
   if (argc > 1) {
     // C counts the command name as one of the arguments, but Fortran doesn't.

 
 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 1;
+    return ToErrmsg(errmsg, StatInvalidArgumentNumber);
   }
 
   if (IsValidCharDescriptor(value)) {
     std::int64_t argLen{ArgumentLength(n)};
     if (argLen <= 0) {
-      return 2;
+      return ToErrmsg(errmsg, StatMissingArgument);
     }
 
     std::int64_t toCopy{
         std::min(argLen, static_cast<std::int64_t>(value->ElementBytes()))};
     std::strncpy(value->OffsetElement(), executionEnvironment.argv[n], toCopy);
 
     if (argLen > toCopy) {
-      return -1;
+      return ToErrmsg(errmsg, StatValueTooShort);
     }
   }
-  return 0;
+
+  return StatOk;
 }
 } // namespace Fortran::runtime

flang/runtime/stat.h

enum Stat {
   StatFailedImage = FORTRAN_RUNTIME_STAT_FAILED_IMAGE,
   StatLocked = FORTRAN_RUNTIME_STAT_LOCKED,
   StatLockedOtherImage = FORTRAN_RUNTIME_STAT_LOCKED_OTHER_IMAGE,
   StatStoppedImage = FORTRAN_RUNTIME_STAT_STOPPED_IMAGE,
   StatUnlocked = FORTRAN_RUNTIME_STAT_UNLOCKED,
   StatUnlockedFailedImage = FORTRAN_RUNTIME_STAT_UNLOCKED_FAILED_IMAGE,
 
   // Additional "processor-defined" STAT= values
+  StatInvalidArgumentNumber = FORTRAN_RUNTIME_STAT_INVALID_ARG_NUMBER,
+  StatMissingArgument = FORTRAN_RUNTIME_STAT_MISSING_ARG,
+  StatValueTooShort = FORTRAN_RUNTIME_STAT_VALUE_TOO_SHORT,
 };
 
 const char *StatErrorString(int);
 int ToErrmsg(const Descriptor *errmsg, int stat); // returns stat
 int ReturnError(Terminator &, int stat, const Descriptor *errmsg = nullptr,
     bool hasStat = false);
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_STAT_H

flang/runtime/stat.cpp

case StatLockedOtherImage:
     return "Other image locked";
   case StatStoppedImage:
     return "Image stopped";
   case StatUnlocked:
     return "Unlocked";
   case StatUnlockedFailedImage:
     return "Failed image unlocked";
 
+  case StatInvalidArgumentNumber:
+    return "Invalid argument number";
+  case StatMissingArgument:
+    return "Missing argument";
+  case StatValueTooShort:
+    return "Value too short";
+
   default:
     return nullptr;
   }
 }
 
 int ToErrmsg(const Descriptor *errmsg, int stat) {
   if (stat != StatOk && errmsg && errmsg->raw().base_addr &&
       errmsg->type() == TypeCode(TypeCategory::Character, 1) &&

flang/unittests/Runtime/CommandTest.cpp

 //===-- flang/unittests/RuntimeGTest/CommandTest.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 "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() {
void CheckArgumentValue(int n, const char *argv) const {
     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 {
+  void CheckMissingArgumentValue(int n, const char *errStr = nullptr) const {
     OwningPtr<Descriptor> value{CreateEmptyCharDescriptor()};
     ASSERT_NE(value, nullptr);
 
-    EXPECT_GT(RTNAME(ArgumentValue)(n, value.get(), nullptr), 0);
+    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"};
 class ZeroArguments : public CommandFixture {
 protected:
   ZeroArguments() : CommandFixture(1, commandOnlyArgv) {}
 };
TEST_F(SeveralArguments, ArgumentLength) {
   EXPECT_EQ(22, RTNAME(ArgumentLength)(3));
   EXPECT_EQ(1, RTNAME(ArgumentLength)(4));
   EXPECT_EQ(0, RTNAME(ArgumentLength)(5));
 }
 
 TEST_F(SeveralArguments, ArgumentValue) {
   CheckArgumentValue(0, severalArgsArgv[0]);
   CheckArgumentValue(1, severalArgsArgv[1]);
-  CheckMissingArgumentValue(2);
   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, ArgumentValueErrors) {
-  CheckMissingArgumentValue(-1);
+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");
 }