[libc] Better IntegerToString API

This patch is an alternative to D155902. It provides the following benefits:
 - No buffer manual allocation and error handling for the general case
 - More flexible API : width specifier, sign and prefix handling
 - Simpler code

The more flexible API removes the need for manually tweaking the buffer afterwards, and so prevents relying on implementation details of IntegerToString.

Reviewed By: michaelrj, jhuber6

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

Author: gchatelet

libc/src/__support/CMakeLists.txt

@@ -90,10 +90,11 @@ add_header_library(
   HDRS
     integer_to_string.h
   DEPENDS
+    libc.src.__support.common
+    libc.src.__support.CPP.limits
     libc.src.__support.CPP.span
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.type_traits
-    libc.src.__support.common
 )
 
 

libc/src/__support/CPP/string.h

@@ -195,10 +195,8 @@ LIBC_INLINE string operator+(const char *lhs, const string &rhs) {
 
 namespace internal {
 template <typename T> string to_dec_string(T value) {
-  char dec_buf[IntegerToString::dec_bufsize<T>()];
-  auto maybe_string_view = IntegerToString::dec(value, dec_buf);
-  const auto &string_view = *maybe_string_view;
-  return string(string_view.data(), string_view.size());
+  const IntegerToString<T> buffer(value);
+  return buffer.view();
 }
 } // namespace internal
 

libc/src/__support/CPP/stringstream.h

@@ -9,8 +9,8 @@
 #ifndef LLVM_LIBC_SRC_SUPPORT_CPP_STRINGSTREAM_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_STRINGSTREAM_H
 
-#include "string_view.h"
 #include "span.h"
+#include "string_view.h"
 #include "type_traits.h"
 
 #include "src/__support/integer_to_string.h"
@@ -58,11 +58,8 @@ class StringStream {
   // Write the |val| as string.
   template <typename T, enable_if_t<is_integral_v<T>, int> = 0>
   StringStream &operator<<(T val) {
-    char buffer[IntegerToString::dec_bufsize<T>()];
-    auto int_to_str = IntegerToString::dec(val, buffer);
-    if (int_to_str)
-      return operator<<(*int_to_str);
-    return *this;
+    const IntegerToString<T> buffer(val);
+    return *this << buffer.view();
   }
 
   template <typename T, enable_if_t<is_floating_point_v<T>, int> = 0>

libc/src/__support/FPUtil/fpbits_str.h

@@ -18,6 +18,15 @@
 
 namespace __llvm_libc {
 
+namespace details {
+
+// Format T as uppercase hexadecimal number with leading zeros.
+template <typename T>
+using ZeroPaddedHexFmt = IntegerToString<
+    T, typename radix::Hex::WithWidth<(sizeof(T) * 2)>::WithPrefix::Uppercase>;
+
+} // namespace details
+
 // Converts the bits to a string in the following format:
 //    "0x<NNN...N> = S: N, E: 0xNNNN, M:0xNNN...N"
 // 1. N is a hexadecimal digit.
@@ -33,36 +42,31 @@ template <typename T> LIBC_INLINE cpp::string str(fputil::FPBits<T> x) {
   if (x.is_inf())
     return x.get_sign() ? "(-Infinity)" : "(+Infinity)";
 
-  auto zerofill = [](char *arr, size_t n) {
-    for (size_t i = 0; i < n; ++i)
-      arr[i] = '0';
-  };
+  const auto sign_char = [](bool sign) -> char { return sign ? '1' : '0'; };
+
+  cpp::string s;
 
-  cpp::string s("0x");
-  char bitsbuf[IntegerToString::hex_bufsize<UIntType>()];
-  zerofill(bitsbuf, sizeof(bitsbuf));
-  IntegerToString::hex(x.bits, bitsbuf, false);
-  s += cpp::string(bitsbuf, sizeof(bitsbuf));
+  const details::ZeroPaddedHexFmt<UIntType> bits(x.bits);
+  s += bits.view();
 
-  s += " = (";
-  s += cpp::string("S: ") + (x.get_sign() ? "1" : "0");
+  s += " = (S: ";
+  s += sign_char(x.get_sign());
 
-  char expbuf[IntegerToString::hex_bufsize<uint16_t>()];
-  zerofill(expbuf, sizeof(expbuf));
-  IntegerToString::hex(x.get_unbiased_exponent(), expbuf, false);
-  s += cpp::string(", E: 0x") + cpp::string(expbuf, sizeof(expbuf));
+  s += ", E: ";
+  const details::ZeroPaddedHexFmt<uint16_t> exponent(x.get_unbiased_exponent());
+  s += exponent.view();
 
   if constexpr (cpp::is_same_v<T, long double> &&
                 fputil::FloatProperties<long double>::MANTISSA_WIDTH == 63) {
-    s += cpp::string(", I: ") + (x.get_implicit_bit() ? "1" : "0");
+    s += ", I: ";
+    s += sign_char(x.get_implicit_bit());
   }
 
-  char mantbuf[IntegerToString::hex_bufsize<UIntType>()] = {'0'};
-  zerofill(mantbuf, sizeof(mantbuf));
-  IntegerToString::hex(x.get_mantissa(), mantbuf, false);
-  s += cpp::string(", M: 0x") + cpp::string(mantbuf, sizeof(mantbuf));
+  s += ", M: ";
+  const details::ZeroPaddedHexFmt<UIntType> mantissa(x.get_mantissa());
+  s += mantissa.view();
 
-  s += ")";
+  s += ')';
   return s;
 }
 

libc/src/__support/StringUtil/error_to_string.cpp

@@ -23,10 +23,9 @@ namespace internal {
 
 constexpr size_t max_buff_size() {
   constexpr size_t unknown_str_len = sizeof("Unknown error");
-  constexpr size_t max_num_len =
-      __llvm_libc::IntegerToString::dec_bufsize<int>();
   // the buffer should be able to hold "Unknown error" + ' ' + num_str
-  return (unknown_str_len + 1 + max_num_len) * sizeof(char);
+  return (unknown_str_len + 1 + IntegerToString<int>::buffer_size()) *
+         sizeof(char);
 }
 
 // This is to hold error strings that have to be custom built. It may be
@@ -51,7 +50,7 @@ cpp::string_view build_error_string(int err_num, cpp::span<char> buffer) {
   // if the buffer can't hold "Unknown error" + ' ' + num_str, then just
   // return "Unknown error".
   if (buffer.size() <
-      (sizeof("Unknown error") + 1 + IntegerToString::dec_bufsize<int>()))
+      (sizeof("Unknown error") + 1 + IntegerToString<int>::buffer_size()))
     return const_cast<char *>("Unknown error");
 
   cpp::StringStream buffer_stream(

libc/src/__support/StringUtil/signal_to_string.cpp

@@ -24,10 +24,9 @@ namespace internal {
 
 constexpr size_t max_buff_size() {
   constexpr size_t base_str_len = sizeof("Real-time signal");
-  constexpr size_t max_num_len =
-      __llvm_libc::IntegerToString::dec_bufsize<int>();
   // the buffer should be able to hold "Real-time signal" + ' ' + num_str
-  return (base_str_len + 1 + max_num_len) * sizeof(char);
+  return (base_str_len + 1 + IntegerToString<int>::buffer_size()) *
+         sizeof(char);
 }
 
 // This is to hold signal strings that have to be custom built. It may be
@@ -54,7 +53,7 @@ cpp::string_view build_signal_string(int sig_num, cpp::span<char> buffer) {
   // if the buffer can't hold "Unknown signal" + ' ' + num_str, then just
   // return "Unknown signal".
   if (buffer.size() <
-      (base_str.size() + 1 + IntegerToString::dec_bufsize<int>()))
+      (base_str.size() + 1 + IntegerToString<int>::buffer_size()))
     return base_str;
 
   cpp::StringStream buffer_stream(