Add StringRef::getAsDouble

[zturner]

Summary

It's fairly cumbersome to figure out the correct way to do this if you're not familiar with the intricacies of APFloat, so hopefully this can help simplify the process, and it is in the same spirit as our getAsInteger set of functions.

I didn't add a detailed set of tests, because these are already pretty well tested in APFloatTest.cpp, only the most basic cases.

[mehdi_amini]

llvm/include/llvm/ADT/StringRef.h

517 ↗

(On Diff #88282)

doc for public API?

llvm/lib/Support/StringRef.cpp

604 ↗

(On Diff #88282)

fuse the two if?

[zturner]

llvm/lib/Support/StringRef.cpp

604 ↗

(On Diff #88282)

If I fuse the two if it's going to be wrapped by clang-format anyway, and I thought this made it clearer to read. But I can do it either way, LMK if you still want me to.

[mehdi_amini]

LGTM.

llvm/include/llvm/ADT/StringRef.h

567 ↗

(On Diff #88284)

I'd insert the declaration here, after all the integer related ones.

Also shouldn't we have a consumeDouble for symmetry with the integer case?

llvm/lib/Support/StringRef.cpp

604 ↗

(On Diff #88282)

Do as you prefer, I don't think we have an official guidelines on this (it'd save the braces though).

[zturner]

llvm/include/llvm/ADT/StringRef.h

567 ↗

(On Diff #88284)

Probably so, but it's a bit tricky. Right now the API does not have any means to return parse error information back up to the caller, which is why I documented in the doc comment "string must be a well-formed double". I'd like to fix that though, so that we can return false when the string contains invalid characters.

That kind of API change would be necessary before we can think about stopping at the first invalid character.

llvm/trunk/include/llvm/ADT/StringRef.h

public:
     ///
     /// \returns true if the string does not solely consist of a valid
     /// non-empty number in the appropriate base.
     ///
     /// APInt::fromString is superficially similar but assumes the
     /// string is well-formed in the given radix.
     bool getAsInteger(unsigned Radix, APInt &Result) const;
 
+    /// Parse the current string as an IEEE double-precision floating
+    /// point value.  The string must be a well-formed double.
+    ///
+    /// If \p AllowInexact is false, the function will fail if the string
+    /// cannot be represented exactly.  Otherwise, the function only fails
+    /// in case of an overflow or underflow.
+    bool getAsDouble(double &Result, bool AllowInexact = true) const;
+
     /// @}
     /// @name String Operations
     /// @{
 
     // Convert the given ASCII string to lowercase.
     LLVM_NODISCARD
     std::string lower() const;
 

llvm/trunk/lib/Support/StringRef.cpp

 //===-- StringRef.cpp - Lightweight String References ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/edit_distance.h"
 #include <bitset>
 
 using namespace llvm;
 
 // MSVC emits references to this into the translation units which reference it.
while (!Str.empty()) {
     }
 
     Str = Str.substr(1);
   }
 
   return false;
 }
 
+bool StringRef::getAsDouble(double &Result, bool AllowInexact) const {
+  APFloat F(0.0);
+  APFloat::opStatus Status =
+      F.convertFromString(*this, APFloat::rmNearestTiesToEven);
+  if (Status != APFloat::opOK) {
+    if (!AllowInexact || Status != APFloat::opInexact)
+      return true;
+  }
+
+  Result = F.convertToDouble();
+  return false;
+}
 
 // Implementation of StringRef hashing.
 hash_code llvm::hash_value(StringRef S) {
   return hash_combine_range(S.begin(), S.end());
 }

llvm/trunk/unittests/ADT/StringRefTest.cpp

if (static_cast<int64_t>(ConsumeSigned[i].Expected) ==
       EXPECT_EQ(S64, ConsumeSigned[i].Expected);
       EXPECT_EQ(Str, ConsumeSigned[i].Leftover);
     } else {
       ASSERT_TRUE(S64Success);
     }
   }
 }
 
+struct GetDoubleStrings {
+  const char *Str;
+  bool AllowInexact;
+  bool ShouldFail;
+  double D;
+} DoubleStrings[] = {{"0", false, false, 0.0},
+                     {"0.0", false, false, 0.0},
+                     {"-0.0", false, false, -0.0},
+                     {"123.45", false, true, 123.45},
+                     {"123.45", true, false, 123.45}};
+
+TEST(StringRefTest, getAsDouble) {
+  for (const auto &Entry : DoubleStrings) {
+    double Result;
+    StringRef S(Entry.Str);
+    EXPECT_EQ(Entry.ShouldFail, S.getAsDouble(Result, Entry.AllowInexact));
+    if (!Entry.ShouldFail)
+      EXPECT_EQ(Result, Entry.D);
+  }
+}
+
 static const char *join_input[] = { "a", "b", "c" };
 static const char join_result1[] = "a";
 static const char join_result2[] = "a:b:c";
 static const char join_result3[] = "a::b::c";
 
 TEST(StringRefTest, joinStrings) {
   std::vector<StringRef> v1;
   std::vector<std::string> v2;