[libc-commits] [libc] eb0715e - [libc][NFC] Make IntegerToString simpler to use at call-sites.

Siva Chandra Reddy via libc-commits libc-commits at lists.llvm.org
Wed Aug 17 00:57:50 PDT 2022


Author: Siva Chandra Reddy
Date: 2022-08-17T07:57:06Z
New Revision: eb0715e3c74f77eb981e74065b28bfdf581636be

URL: https://github.com/llvm/llvm-project/commit/eb0715e3c74f77eb981e74065b28bfdf581636be
DIFF: https://github.com/llvm/llvm-project/commit/eb0715e3c74f77eb981e74065b28bfdf581636be.diff

LOG: [libc][NFC] Make IntegerToString simpler to use at call-sites.

Reviewed By: michaelrj

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

Added: 
    

Modified: 
    libc/src/__support/CPP/stringstream.h
    libc/src/__support/integer_to_string.h
    libc/src/__support/threads/linux/thread.cpp
    libc/src/stdio/printf_core/int_converter.h
    libc/test/src/__support/integer_to_string_test.cpp

Removed: 
    


################################################################################
diff  --git a/libc/src/__support/CPP/stringstream.h b/libc/src/__support/CPP/stringstream.h
index fbd057226c31b..c9e276279d73b 100644
--- a/libc/src/__support/CPP/stringstream.h
+++ b/libc/src/__support/CPP/stringstream.h
@@ -58,8 +58,11 @@ class StringStream {
   // Write the |val| as string.
   template <typename T, enable_if_t<is_integral_v<T>, int> = 0>
   StringStream &operator<<(T val) {
-    const auto int_to_str = integer_to_string(val);
-    return operator<<(int_to_str.str());
+    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;
   }
 
   template <typename T, enable_if_t<is_floating_point_v<T>, int> = 0>

diff  --git a/libc/src/__support/integer_to_string.h b/libc/src/__support/integer_to_string.h
index d37ae1a41cd46..00bcbca6d22a6 100644
--- a/libc/src/__support/integer_to_string.h
+++ b/libc/src/__support/integer_to_string.h
@@ -16,42 +16,69 @@
 
 namespace __llvm_libc {
 
-template <typename T>
-inline constexpr cpp::StringView
-convert_alpha_numeric(T val, cpp::MutableArrayRef<char> &buffer, bool lowercase,
-                      const uint8_t conv_base) {
-  using UnsignedType = cpp::make_unsigned_t<T>;
-  UnsignedType uval = val < 0 ? UnsignedType(-val) : UnsignedType(val);
-
-  const char a = lowercase ? 'a' : 'A';
-
-  size_t len = 0;
-
-  size_t buffptr = buffer.size();
-  if (uval == 0) {
-    buffer[buffptr - 1] = '0';
-    --buffptr;
-  } else {
-    for (; uval > 0; --buffptr, uval /= conv_base) {
-      UnsignedType digit = (uval % conv_base);
-      buffer[buffptr - 1] = digit < 10 ? digit + '0' : digit + a - 10;
+// Convert integer values to their string representation.
+//
+// Example usage:
+//   int a = 1234567;
+//
+//   // Convert to hexadecimal string:
+//   char hexbuf[IntegerToString::hex_bufsize<int>()];
+//   auto str = IntegerToString::hex(
+//       a, hexbuf, false /* generate upper case characters */);
+//
+//   // Convert to decimal string:
+//   char decbuf[IntegerToString::dec_bufsize<int>()];
+//   auto str = IntegerToString::dec(a, decbuf);
+//
+//   // Convert to octal string:
+//   char octbuf[IntegerToString::oct_bufsize<int>(a)];
+//   auto str = IntegerToString::dec(a, octbuf);
+//
+//   // Convert to binary string:
+//   char binbuf[IntegerToString::bin_bufsize<int>(a)];
+//   auto str = IntegerToString::bin(a, binbuf);
+//
+//   // Convert to base 30 string:
+//   char b30buf[IntegerToString::bufsize<30, int>(a)];
+//   auto str = IntegerToString::convert<30>(a, b30buf);
+class IntegerToString {
+  static cpp::StringView convert_uintmax(uintmax_t uval,
+                                         cpp::MutableArrayRef<char> &buffer,
+                                         bool lowercase,
+                                         const uint8_t conv_base) {
+    const char a = lowercase ? 'a' : 'A';
+
+    size_t len = 0;
+
+    size_t buffptr = buffer.size();
+    if (uval == 0) {
+      buffer[buffptr - 1] = '0';
+      --buffptr;
+    } else {
+      for (; uval > 0; --buffptr, uval /= conv_base) {
+        uintmax_t digit = (uval % conv_base);
+        buffer[buffptr - 1] = digit < 10 ? digit + '0' : digit + a - 10;
+      }
     }
+    len = buffer.size() - buffptr;
+
+    return cpp::StringView(buffer.data() + buffer.size() - len, len);
   }
-  len = buffer.size() - buffptr;
 
-  if (val < 0) {
-    // This branch will be taken only for negative signed values.
+  static cpp::StringView convert_intmax(intmax_t val,
+                                        cpp::MutableArrayRef<char> &buffer,
+                                        bool lowercase,
+                                        const uint8_t conv_base) {
+    if (val >= 0)
+      return convert_uintmax(uintmax_t(val), buffer, lowercase, conv_base);
+    uintmax_t uval = uintmax_t(-val);
+    auto str_view = convert_uintmax(uval, buffer, lowercase, conv_base);
+    size_t len = str_view.size();
     ++len;
     buffer[buffer.size() - len] = '-';
+    return cpp::StringView(buffer.data() + buffer.size() - len, len);
   }
-  cpp::StringView buff_str(buffer.data() + buffer.size() - len, len);
-  return buff_str;
-}
 
-template <typename T, uint8_t BASE = 10,
-          cpp::enable_if_t<2 <= BASE && BASE <= 36, int> = 0>
-class IntegerToString {
-public:
   static constexpr inline size_t floor_log_2(size_t num) {
     size_t i = 0;
     for (; num > 1; num /= 2) {
@@ -59,11 +86,13 @@ class IntegerToString {
     }
     return i;
   }
+
+public:
   // We size the string buffer for base 10 using an approximation algorithm:
   //
   //   size = ceil(sizeof(T) * 5 / 2)
   //
-  // If sizeof(T) is 1, then size is 3 (actually 3)
+  // If sizeof(T) is 1, then size is 3 (actually need 3)
   // If sizeof(T) is 2, then size is 5 (actually need 5)
   // If sizeof(T) is 4, then size is 10 (actually need 10)
   // If sizeof(T) is 8, then size is 20 (actually need 20)
@@ -80,8 +109,7 @@ class IntegerToString {
   // For other bases, we approximate by rounding down to the nearest power of
   // two base, since the space needed is easy to calculate and it won't
   // overestimate by too much.
-
-  static constexpr size_t bufsize() {
+  template <uint8_t BASE, typename T> static constexpr size_t bufsize() {
     constexpr size_t BITS_PER_DIGIT = floor_log_2(BASE);
     constexpr size_t BUFSIZE_COMMON =
         ((sizeof(T) * 8 + (BITS_PER_DIGIT - 1)) / BITS_PER_DIGIT);
@@ -90,54 +118,60 @@ class IntegerToString {
            (BASE == 10 ? BUFSIZE_BASE10 : BUFSIZE_COMMON);
   }
 
-  static constexpr size_t BUFSIZE = bufsize();
-
-private:
-  static_assert(cpp::is_integral_v<T>,
-                "IntegerToString can only be used with integral types.");
+  template <typename T> static constexpr size_t dec_bufsize() {
+    return bufsize<10, T>();
+  }
 
-  using UnsignedType = cpp::make_unsigned_t<T>;
+  template <typename T> static constexpr size_t hex_bufsize() {
+    return bufsize<16, T>();
+  }
 
-  char strbuf[BUFSIZE] = {'\0'};
-  cpp::StringView str_view;
+  template <typename T> static constexpr size_t oct_bufsize() {
+    return bufsize<8, T>();
+  }
 
-  // This function exists to convert the templated call into a non-templated
-  // call. This allows the compiler to decide to do strength reduction and
-  // constant folding on the base or not, depending on if size or performance is
-  // required.
-  static inline constexpr cpp::StringView
-  convert_internal(T val, cpp::MutableArrayRef<char> &buffer, bool lowercase) {
-    return convert_alpha_numeric<T>(val, buffer, lowercase, BASE);
+  template <typename T> static constexpr size_t bin_bufsize() {
+    return bufsize<2, T>();
   }
 
-public:
-  static inline cpp::optional<cpp::StringView>
-  convert(T val, cpp::MutableArrayRef<char> &buffer, bool lowercase) {
-    if (buffer.size() < bufsize())
+  template <uint8_t BASE, typename T,
+            cpp::enable_if_t<2 <= BASE && BASE <= 36 && cpp::is_integral_v<T>,
+                             int> = 0>
+  static cpp::optional<cpp::StringView>
+  convert(T val, cpp::MutableArrayRef<char> buffer, bool lowercase = true) {
+    if (buffer.size() < bufsize<BASE, T>())
       return cpp::optional<cpp::StringView>();
-    return cpp::optional<cpp::StringView>(
-        convert_internal(val, buffer, lowercase));
+    if (cpp::is_signed_v<T>)
+      return convert_intmax(intmax_t(val), buffer, lowercase, BASE);
+    else
+      return convert_uintmax(uintmax_t(val), buffer, lowercase, BASE);
   }
 
-  constexpr explicit IntegerToString(T val) {
-    cpp::MutableArrayRef<char> bufref(strbuf, BUFSIZE);
-    str_view = convert_internal(val, bufref, true);
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  static cpp::optional<cpp::StringView> dec(T val,
+                                            cpp::MutableArrayRef<char> buffer) {
+    return convert<10>(val, buffer);
   }
 
-  constexpr explicit IntegerToString(T val, bool lowercase) {
-    cpp::MutableArrayRef<char> bufref(strbuf, BUFSIZE);
-    str_view = convert_internal(val, bufref, lowercase);
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  static cpp::optional<cpp::StringView>
+  hex(T val, cpp::MutableArrayRef<char> buffer, bool lowercase = true) {
+    return convert<16>(val, buffer, lowercase);
   }
 
-  cpp::StringView str() const { return str_view; }
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  static cpp::optional<cpp::StringView> oct(T val,
+                                            cpp::MutableArrayRef<char> buffer) {
+    return convert<8>(val, buffer);
+  }
 
-  operator cpp::StringView() const { return str(); }
+  template <typename T, cpp::enable_if_t<cpp::is_integral_v<T>, int> = 0>
+  static cpp::optional<cpp::StringView> bin(T val,
+                                            cpp::MutableArrayRef<char> buffer) {
+    return convert<2>(val, buffer);
+  }
 };
 
-template <typename T> IntegerToString<T> integer_to_string(T val) {
-  return IntegerToString<T>(val);
-}
-
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H

diff  --git a/libc/src/__support/threads/linux/thread.cpp b/libc/src/__support/threads/linux/thread.cpp
index c485276daf4d4..45fc7ac9222a2 100644
--- a/libc/src/__support/threads/linux/thread.cpp
+++ b/libc/src/__support/threads/linux/thread.cpp
@@ -276,8 +276,8 @@ bool Thread::operator==(const Thread &thread) const {
 static constexpr cpp::StringView THREAD_NAME_PATH_PREFIX("/proc/self/task/");
 static constexpr size_t THREAD_NAME_PATH_SIZE =
     THREAD_NAME_PATH_PREFIX.size() +
-    IntegerToString<int>::BUFSIZE + // Size of tid
-    1 +                             // For '/' character
+    IntegerToString::dec_bufsize<int>() + // Size of tid
+    1 +                                   // For '/' character
     5; // For the file name "comm" and the nullterminator.
 
 static void construct_thread_name_file_path(cpp::StringStream &stream,

diff  --git a/libc/src/stdio/printf_core/int_converter.h b/libc/src/stdio/printf_core/int_converter.h
index ee848bfd928c8..25f158e1c36b0 100644
--- a/libc/src/stdio/printf_core/int_converter.h
+++ b/libc/src/stdio/printf_core/int_converter.h
@@ -30,12 +30,11 @@ constexpr bool inline is_lower(char a) { return (a & 32) > 0; }
 cpp::optional<cpp::StringView> inline num_to_strview(
     uintmax_t num, cpp::MutableArrayRef<char> bufref, char conv_name) {
   if (to_lower(conv_name) == 'x') {
-    return IntegerToString<uintmax_t, 16>::convert(num, bufref,
-                                                   is_lower(conv_name));
+    return IntegerToString::hex(num, bufref, is_lower(conv_name));
   } else if (conv_name == 'o') {
-    return IntegerToString<uintmax_t, 8>::convert(num, bufref, true);
+    return IntegerToString::oct(num, bufref);
   } else {
-    return IntegerToString<uintmax_t, 10>::convert(num, bufref, true);
+    return IntegerToString::dec(num, bufref);
   }
 }
 
@@ -66,10 +65,8 @@ int inline convert_int(Writer *writer, const FormatSection &to_conv) {
 
   num = apply_length_modifier(num, to_conv.length_modifier);
 
-  static constexpr size_t BUFSIZE = IntegerToString<uintmax_t, 8>::BUFSIZE;
-  char buff[BUFSIZE];
-  cpp::MutableArrayRef<char> bufref(buff, BUFSIZE);
-  auto str = num_to_strview(num, bufref, to_conv.conv_name);
+  char buf[IntegerToString::oct_bufsize<intmax_t>()];
+  auto str = num_to_strview(num, buf, to_conv.conv_name);
   if (!str)
     return INT_CONVERSION_ERROR;
 

diff  --git a/libc/test/src/__support/integer_to_string_test.cpp b/libc/test/src/__support/integer_to_string_test.cpp
index ce61254443b0e..4345c04509628 100644
--- a/libc/test/src/__support/integer_to_string_test.cpp
+++ b/libc/test/src/__support/integer_to_string_test.cpp
@@ -1,4 +1,4 @@
-//===-- Unittests for integer_to_string -----------------------------------===//
+//===-- Unittests for IntegerToString -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -13,231 +13,237 @@
 
 #include "limits.h"
 
-using __llvm_libc::integer_to_string;
 using __llvm_libc::IntegerToString;
 using __llvm_libc::cpp::StringView;
 
 TEST(LlvmLibcIntegerToStringTest, UINT8) {
-  EXPECT_EQ(integer_to_string(uint8_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(uint8_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(uint8_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(uint8_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(uint8_t(UINT8_MAX)).str(), (StringView("255")));
-  EXPECT_EQ(integer_to_string(uint8_t(-1)).str(), (StringView("255")));
+  char buf[IntegerToString::dec_bufsize<uint8_t>()];
+  EXPECT_EQ(*IntegerToString::dec(uint8_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(uint8_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(uint8_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(uint8_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(uint8_t(UINT8_MAX), buf), StringView("255"));
+  EXPECT_EQ(*IntegerToString::dec(uint8_t(-1), buf), StringView("255"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, INT8) {
-  EXPECT_EQ(integer_to_string(int8_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(int8_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(int8_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(int8_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(int8_t(-12)).str(), (StringView("-12")));
-  EXPECT_EQ(integer_to_string(int8_t(-123)).str(), (StringView("-123")));
-  EXPECT_EQ(integer_to_string(int8_t(INT8_MAX)).str(), (StringView("127")));
-  EXPECT_EQ(integer_to_string(int8_t(INT8_MIN)).str(), (StringView("-128")));
+  char buf[IntegerToString::dec_bufsize<int8_t>()];
+  EXPECT_EQ(*IntegerToString::dec(int8_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(int8_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(int8_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(int8_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(int8_t(-12), buf), StringView("-12"));
+  EXPECT_EQ(*IntegerToString::dec(int8_t(-123), buf), StringView("-123"));
+  EXPECT_EQ(*IntegerToString::dec(int8_t(INT8_MAX), buf), StringView("127"));
+  EXPECT_EQ(*IntegerToString::dec(int8_t(INT8_MIN), buf), StringView("-128"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT16) {
-  EXPECT_EQ(integer_to_string(uint16_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(uint16_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(uint16_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(uint16_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(uint16_t(1234)).str(), (StringView("1234")));
-  EXPECT_EQ(integer_to_string(uint16_t(12345)).str(), (StringView("12345")));
-  EXPECT_EQ(integer_to_string(uint16_t(UINT16_MAX)).str(),
-            (StringView("65535")));
-  EXPECT_EQ(integer_to_string(uint16_t(-1)).str(), (StringView("65535")));
+  char buf[IntegerToString::dec_bufsize<uint16_t>()];
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(1234), buf), StringView("1234"));
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(12345), buf), StringView("12345"));
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(UINT16_MAX), buf),
+            StringView("65535"));
+  EXPECT_EQ(*IntegerToString::dec(uint16_t(-1), buf), StringView("65535"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, INT16) {
-  EXPECT_EQ(integer_to_string(int16_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(int16_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(int16_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(int16_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(int16_t(1234)).str(), (StringView("1234")));
-  EXPECT_EQ(integer_to_string(int16_t(12345)).str(), (StringView("12345")));
-  EXPECT_EQ(integer_to_string(int16_t(-1)).str(), (StringView("-1")));
-  EXPECT_EQ(integer_to_string(int16_t(-12)).str(), (StringView("-12")));
-  EXPECT_EQ(integer_to_string(int16_t(-123)).str(), (StringView("-123")));
-  EXPECT_EQ(integer_to_string(int16_t(-1234)).str(), (StringView("-1234")));
-  EXPECT_EQ(integer_to_string(int16_t(-12345)).str(), (StringView("-12345")));
-  EXPECT_EQ(integer_to_string(int16_t(INT16_MAX)).str(), (StringView("32767")));
-  EXPECT_EQ(integer_to_string(int16_t(INT16_MIN)).str(),
-            (StringView("-32768")));
+  char buf[IntegerToString::dec_bufsize<int16_t>()];
+  EXPECT_EQ(*IntegerToString::dec(int16_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(1234), buf), StringView("1234"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(12345), buf), StringView("12345"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(-1), buf), StringView("-1"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(-12), buf), StringView("-12"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(-123), buf), StringView("-123"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(-1234), buf), StringView("-1234"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(-12345), buf), StringView("-12345"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(INT16_MAX), buf),
+            StringView("32767"));
+  EXPECT_EQ(*IntegerToString::dec(int16_t(INT16_MIN), buf),
+            StringView("-32768"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT32) {
-  EXPECT_EQ(integer_to_string(uint32_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(uint32_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(uint32_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(uint32_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(uint32_t(1234)).str(), (StringView("1234")));
-  EXPECT_EQ(integer_to_string(uint32_t(12345)).str(), (StringView("12345")));
-  EXPECT_EQ(integer_to_string(uint32_t(123456)).str(), (StringView("123456")));
-  EXPECT_EQ(integer_to_string(uint32_t(1234567)).str(),
-            (StringView("1234567")));
-  EXPECT_EQ(integer_to_string(uint32_t(12345678)).str(),
-            (StringView("12345678")));
-  EXPECT_EQ(integer_to_string(uint32_t(123456789)).str(),
-            (StringView("123456789")));
-  EXPECT_EQ(integer_to_string(uint32_t(1234567890)).str(),
-            (StringView("1234567890")));
-  EXPECT_EQ(integer_to_string(uint32_t(UINT32_MAX)).str(),
-            (StringView("4294967295")));
-  EXPECT_EQ(integer_to_string(uint32_t(-1)).str(), (StringView("4294967295")));
+  char buf[IntegerToString::dec_bufsize<uint32_t>()];
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(1234), buf), StringView("1234"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(12345), buf), StringView("12345"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(123456), buf), StringView("123456"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(1234567), buf),
+            StringView("1234567"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(12345678), buf),
+            StringView("12345678"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(123456789), buf),
+            StringView("123456789"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(1234567890), buf),
+            StringView("1234567890"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(UINT32_MAX), buf),
+            StringView("4294967295"));
+  EXPECT_EQ(*IntegerToString::dec(uint32_t(-1), buf), StringView("4294967295"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, INT32) {
-  EXPECT_EQ(integer_to_string(int32_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(int32_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(int32_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(int32_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(int32_t(1234)).str(), (StringView("1234")));
-  EXPECT_EQ(integer_to_string(int32_t(12345)).str(), (StringView("12345")));
-  EXPECT_EQ(integer_to_string(int32_t(123456)).str(), (StringView("123456")));
-  EXPECT_EQ(integer_to_string(int32_t(1234567)).str(), (StringView("1234567")));
-  EXPECT_EQ(integer_to_string(int32_t(12345678)).str(),
-            (StringView("12345678")));
-  EXPECT_EQ(integer_to_string(int32_t(123456789)).str(),
-            (StringView("123456789")));
-  EXPECT_EQ(integer_to_string(int32_t(1234567890)).str(),
-            (StringView("1234567890")));
-  EXPECT_EQ(integer_to_string(int32_t(-1)).str(), (StringView("-1")));
-  EXPECT_EQ(integer_to_string(int32_t(-12)).str(), (StringView("-12")));
-  EXPECT_EQ(integer_to_string(int32_t(-123)).str(), (StringView("-123")));
-  EXPECT_EQ(integer_to_string(int32_t(-1234)).str(), (StringView("-1234")));
-  EXPECT_EQ(integer_to_string(int32_t(-12345)).str(), (StringView("-12345")));
-  EXPECT_EQ(integer_to_string(int32_t(-123456)).str(), (StringView("-123456")));
-  EXPECT_EQ(integer_to_string(int32_t(-1234567)).str(),
-            (StringView("-1234567")));
-  EXPECT_EQ(integer_to_string(int32_t(-12345678)).str(),
-            (StringView("-12345678")));
-  EXPECT_EQ(integer_to_string(int32_t(-123456789)).str(),
-            (StringView("-123456789")));
-  EXPECT_EQ(integer_to_string(int32_t(-1234567890)).str(),
-            (StringView("-1234567890")));
-  EXPECT_EQ(integer_to_string(int32_t(INT32_MAX)).str(),
-            (StringView("2147483647")));
-  EXPECT_EQ(integer_to_string(int32_t(INT32_MIN)).str(),
-            (StringView("-2147483648")));
+  char buf[IntegerToString::dec_bufsize<int32_t>()];
+  EXPECT_EQ(*IntegerToString::dec(int32_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(1234), buf), StringView("1234"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(12345), buf), StringView("12345"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(123456), buf), StringView("123456"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(1234567), buf),
+            StringView("1234567"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(12345678), buf),
+            StringView("12345678"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(123456789), buf),
+            StringView("123456789"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(1234567890), buf),
+            StringView("1234567890"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-1), buf), StringView("-1"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-12), buf), StringView("-12"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-123), buf), StringView("-123"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-1234), buf), StringView("-1234"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-12345), buf), StringView("-12345"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-123456), buf),
+            StringView("-123456"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-1234567), buf),
+            StringView("-1234567"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-12345678), buf),
+            StringView("-12345678"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-123456789), buf),
+            StringView("-123456789"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(-1234567890), buf),
+            StringView("-1234567890"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(INT32_MAX), buf),
+            StringView("2147483647"));
+  EXPECT_EQ(*IntegerToString::dec(int32_t(INT32_MIN), buf),
+            StringView("-2147483648"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64) {
-  EXPECT_EQ(integer_to_string(uint64_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(uint64_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(uint64_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(uint64_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(uint64_t(1234)).str(), (StringView("1234")));
-  EXPECT_EQ(integer_to_string(uint64_t(12345)).str(), (StringView("12345")));
-  EXPECT_EQ(integer_to_string(uint64_t(123456)).str(), (StringView("123456")));
-  EXPECT_EQ(integer_to_string(uint64_t(1234567)).str(),
-            (StringView("1234567")));
-  EXPECT_EQ(integer_to_string(uint64_t(12345678)).str(),
-            (StringView("12345678")));
-  EXPECT_EQ(integer_to_string(uint64_t(123456789)).str(),
-            (StringView("123456789")));
-  EXPECT_EQ(integer_to_string(uint64_t(1234567890)).str(),
-            (StringView("1234567890")));
-  EXPECT_EQ(integer_to_string(uint64_t(1234567890123456789)).str(),
-            (StringView("1234567890123456789")));
-  EXPECT_EQ(integer_to_string(uint64_t(UINT64_MAX)).str(),
-            (StringView("18446744073709551615")));
-  EXPECT_EQ(integer_to_string(uint64_t(-1)).str(),
-            (StringView("18446744073709551615")));
+  char buf[IntegerToString::dec_bufsize<uint64_t>()];
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(1234), buf), StringView("1234"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(12345), buf), StringView("12345"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(123456), buf), StringView("123456"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(1234567), buf),
+            StringView("1234567"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(12345678), buf),
+            StringView("12345678"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(123456789), buf),
+            StringView("123456789"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(1234567890), buf),
+            StringView("1234567890"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(1234567890123456789), buf),
+            StringView("1234567890123456789"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(UINT64_MAX), buf),
+            StringView("18446744073709551615"));
+  EXPECT_EQ(*IntegerToString::dec(uint64_t(-1), buf),
+            StringView("18446744073709551615"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, INT64) {
-  EXPECT_EQ(integer_to_string(int64_t(0)).str(), (StringView("0")));
-  EXPECT_EQ(integer_to_string(int64_t(1)).str(), (StringView("1")));
-  EXPECT_EQ(integer_to_string(int64_t(12)).str(), (StringView("12")));
-  EXPECT_EQ(integer_to_string(int64_t(123)).str(), (StringView("123")));
-  EXPECT_EQ(integer_to_string(int64_t(1234)).str(), (StringView("1234")));
-  EXPECT_EQ(integer_to_string(int64_t(12345)).str(), (StringView("12345")));
-  EXPECT_EQ(integer_to_string(int64_t(123456)).str(), (StringView("123456")));
-  EXPECT_EQ(integer_to_string(int64_t(1234567)).str(), (StringView("1234567")));
-  EXPECT_EQ(integer_to_string(int64_t(12345678)).str(),
-            (StringView("12345678")));
-  EXPECT_EQ(integer_to_string(int64_t(123456789)).str(),
-            (StringView("123456789")));
-  EXPECT_EQ(integer_to_string(int64_t(1234567890)).str(),
-            (StringView("1234567890")));
-  EXPECT_EQ(integer_to_string(int64_t(1234567890123456789)).str(),
-            (StringView("1234567890123456789")));
-  EXPECT_EQ(integer_to_string(int64_t(-1)).str(), (StringView("-1")));
-  EXPECT_EQ(integer_to_string(int64_t(-12)).str(), (StringView("-12")));
-  EXPECT_EQ(integer_to_string(int64_t(-123)).str(), (StringView("-123")));
-  EXPECT_EQ(integer_to_string(int64_t(-1234)).str(), (StringView("-1234")));
-  EXPECT_EQ(integer_to_string(int64_t(-12345)).str(), (StringView("-12345")));
-  EXPECT_EQ(integer_to_string(int64_t(-123456)).str(), (StringView("-123456")));
-  EXPECT_EQ(integer_to_string(int64_t(-1234567)).str(),
-            (StringView("-1234567")));
-  EXPECT_EQ(integer_to_string(int64_t(-12345678)).str(),
-            (StringView("-12345678")));
-  EXPECT_EQ(integer_to_string(int64_t(-123456789)).str(),
-            (StringView("-123456789")));
-  EXPECT_EQ(integer_to_string(int64_t(-1234567890)).str(),
-            (StringView("-1234567890")));
-  EXPECT_EQ(integer_to_string(int64_t(-1234567890123456789)).str(),
-            (StringView("-1234567890123456789")));
-  EXPECT_EQ(integer_to_string(int64_t(INT64_MAX)).str(),
-            (StringView("9223372036854775807")));
-  EXPECT_EQ(integer_to_string(int64_t(INT64_MIN)).str(),
-            (StringView("-9223372036854775808")));
-}
-
-TEST(LlvmLibcIntegerToStringTest, UINT64_Base_10) {
-  EXPECT_EQ((IntegerToString<uint64_t, 10>(int64_t(0)).str()), StringView("0"));
-  EXPECT_EQ((IntegerToString<uint64_t, 10>(int64_t(1234567890123456789)).str()),
+  char buf[IntegerToString::dec_bufsize<int64_t>()];
+  EXPECT_EQ(*IntegerToString::dec(int64_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(1), buf), StringView("1"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(12), buf), StringView("12"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(123), buf), StringView("123"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(1234), buf), StringView("1234"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(12345), buf), StringView("12345"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(123456), buf), StringView("123456"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(1234567), buf),
+            StringView("1234567"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(12345678), buf),
+            StringView("12345678"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(123456789), buf),
+            StringView("123456789"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(1234567890), buf),
+            StringView("1234567890"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(1234567890123456789), buf),
             StringView("1234567890123456789"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-1), buf), StringView("-1"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-12), buf), StringView("-12"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-123), buf), StringView("-123"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-1234), buf), StringView("-1234"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-12345), buf), StringView("-12345"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-123456), buf),
+            StringView("-123456"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-1234567), buf),
+            StringView("-1234567"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-12345678), buf),
+            StringView("-12345678"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-123456789), buf),
+            StringView("-123456789"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-1234567890), buf),
+            StringView("-1234567890"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(-1234567890123456789), buf),
+            StringView("-1234567890123456789"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(INT64_MAX), buf),
+            StringView("9223372036854775807"));
+  EXPECT_EQ(*IntegerToString::dec(int64_t(INT64_MIN), buf),
+            StringView("-9223372036854775808"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_8) {
-  EXPECT_EQ((IntegerToString<uint64_t, 8>(int64_t(0)).str()), StringView("0"));
-  EXPECT_EQ((IntegerToString<uint64_t, 8>(int64_t(012345)).str()),
+  char buf[IntegerToString::oct_bufsize<uint64_t>()];
+  EXPECT_EQ((*IntegerToString::oct(uint64_t(0), buf)), StringView("0"));
+  EXPECT_EQ((*IntegerToString::oct(uint64_t(012345), buf)),
             StringView("12345"));
-  EXPECT_EQ(
-      (IntegerToString<uint64_t, 8>(int64_t(0123456701234567012345)).str()),
-      StringView("123456701234567012345"));
-  EXPECT_EQ(
-      (IntegerToString<uint64_t, 8>(int64_t(01777777777777777777777)).str()),
-      StringView("1777777777777777777777"));
+  EXPECT_EQ((*IntegerToString::oct(uint64_t(0123456701234567012345), buf)),
+            StringView("123456701234567012345"));
+  EXPECT_EQ((*IntegerToString::oct(uint64_t(01777777777777777777777), buf)),
+            StringView("1777777777777777777777"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_16) {
-  EXPECT_EQ((IntegerToString<uint64_t, 16>(int64_t(0)).str()), StringView("0"));
-  EXPECT_EQ((IntegerToString<uint64_t, 16>(int64_t(0x12345)).str()),
-            StringView("12345"));
-  EXPECT_EQ((IntegerToString<uint64_t, 16>(int64_t(0x123456789abcdef)).str()),
+  char buf[IntegerToString::hex_bufsize<uint64_t>()];
+  EXPECT_EQ(*IntegerToString::hex(uint64_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::hex(uint64_t(0x12345), buf), StringView("12345"));
+  EXPECT_EQ((*IntegerToString::hex(uint64_t(0x123456789abcdef), buf)),
             StringView("123456789abcdef"));
-  EXPECT_EQ(
-      (IntegerToString<uint64_t, 16>(int64_t(0x123456789abcdef), false).str()),
-      StringView("123456789ABCDEF"));
-  EXPECT_EQ((IntegerToString<uint64_t, 16>(int64_t(0xffffffffffffffff)).str()),
+  EXPECT_EQ(*IntegerToString::hex(uint64_t(0x123456789abcdef), buf, false),
+            StringView("123456789ABCDEF"));
+  EXPECT_EQ(*IntegerToString::hex(uint64_t(0xffffffffffffffff), buf),
             StringView("ffffffffffffffff"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_2) {
-  EXPECT_EQ((IntegerToString<uint64_t, 2>(int64_t(0)).str()), StringView("0"));
-  EXPECT_EQ((IntegerToString<uint64_t, 2>(int64_t(0xf0c)).str()),
+  char buf[IntegerToString::bin_bufsize<uint64_t>()];
+  EXPECT_EQ(*IntegerToString::bin(uint64_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::bin(uint64_t(0xf0c), buf),
             StringView("111100001100"));
-  EXPECT_EQ((IntegerToString<uint64_t, 2>(int64_t(0x123abc)).str()),
+  EXPECT_EQ(*IntegerToString::bin(uint64_t(0x123abc), buf),
             StringView("100100011101010111100"));
   EXPECT_EQ(
-      (IntegerToString<uint64_t, 2>(int64_t(0xffffffffffffffff)).str()),
+      *IntegerToString::bin(uint64_t(0xffffffffffffffff), buf),
       StringView(
           "1111111111111111111111111111111111111111111111111111111111111111"));
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_36) {
-  EXPECT_EQ((IntegerToString<uint64_t, 36>(int64_t(0)).str()), StringView("0"));
-  EXPECT_EQ((IntegerToString<uint64_t, 36>(int64_t(12345)).str()),
+  char buf[IntegerToString::bufsize<36, uint64_t>()];
+  EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(0), buf), StringView("0"));
+  EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(12345), buf),
             StringView("9ix"));
-  EXPECT_EQ((IntegerToString<uint64_t, 36>(int64_t(1047601316295595)).str()),
+  EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(1047601316295595), buf),
             StringView("abcdefghij"));
-  EXPECT_EQ((IntegerToString<uint64_t, 36>(int64_t(2092218013456445)).str()),
+  EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(2092218013456445), buf),
             StringView("klmnopqrst"));
-  EXPECT_EQ((IntegerToString<uint64_t, 36>(int64_t(1867590395), false).str()),
+  EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(1867590395), buf, false),
             StringView("UVWXYZ"));
-  EXPECT_EQ((IntegerToString<uint64_t, 36>(int64_t(0xffffffffffffffff)).str()),
+  EXPECT_EQ(*IntegerToString::convert<36>(uint64_t(0xffffffffffffffff), buf),
             StringView("3w5e11264sgsf"));
 }


        


More information about the libc-commits mailing list