[flang] GET_COMMAND_ARGUMENT(ERRMSG) runtime implementation

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.

Differential Revision: https://reviews.llvm.org/D109814

Author: rovka

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

@@ -39,4 +39,12 @@ start at 100 so as to never conflict with those codes.
 #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

@@ -8,6 +8,7 @@
 
 #include "flang/Runtime/command.h"
 #include "environment.h"
+#include "stat.h"
 #include "flang/Runtime/descriptor.h"
 #include <limits>
 
@@ -58,23 +59,24 @@ std::int32_t RTNAME(ArgumentValue)(
   }
 
   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.cpp

@@ -50,6 +50,13 @@ const char *StatErrorString(int stat) {
   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;
   }

flang/runtime/stat.h

@@ -44,6 +44,9 @@ enum Stat {
   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);

flang/unittests/Runtime/CommandTest.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/command.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/main.h"
@@ -53,14 +54,21 @@ class CommandFixture : public ::testing::Test {
     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);
+    }
   }
 };
 
@@ -128,7 +136,6 @@ TEST_F(SeveralArguments, ArgumentLength) {
 TEST_F(SeveralArguments, ArgumentValue) {
   CheckArgumentValue(0, severalArgsArgv[0]);
   CheckArgumentValue(1, severalArgsArgv[1]);
-  CheckMissingArgumentValue(2);
   CheckArgumentValue(3, severalArgsArgv[3]);
   CheckArgumentValue(4, severalArgsArgv[4]);
 }
@@ -140,12 +147,31 @@ TEST_F(SeveralArguments, NoArgumentValue) {
   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");
 }