From 0165a2ca897598bb95baec031362921565e24f2b Mon Sep 17 00:00:00 2001
From: Daniel Dunbar <daniel@zuster.org>
Date: Thu, 30 Jul 2009 03:47:15 +0000
Subject: [PATCH] Twine: Provide [u]int{32,64} conversions via implicit
 constructors instead of explicitly.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77576 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/ADT/Twine.h    | 47 +++++++++++++++++++++++++------------
 lib/Support/Twine.cpp       | 24 ++++++++++++++-----
 unittests/ADT/TwineTest.cpp | 13 +++++-----
 3 files changed, 57 insertions(+), 27 deletions(-)

diff --git a/include/llvm/ADT/Twine.h b/include/llvm/ADT/Twine.h
index 66a4ad33110..30228123318 100644
--- a/include/llvm/ADT/Twine.h
+++ b/include/llvm/ADT/Twine.h
@@ -101,14 +101,21 @@ namespace llvm {
 
       /// A pointer to a uint64_t value, to render as an unsigned decimal
       /// integer.
-      UDecKind,
+      UDec32Kind,
+
+      /// A pointer to a uint64_t value, to render as a signed decimal integer.
+      SDec32Kind,
+
+      /// A pointer to a uint64_t value, to render as an unsigned decimal
+      /// integer.
+      UDec64Kind,
+
+      /// A pointer to a uint64_t value, to render as a signed decimal integer.
+      SDec64Kind,
 
       /// A pointer to a uint64_t value, to render as an unsigned hexadecimal
       /// integer.
-      UHexKind,
-
-      /// A pointer to a uint64_t value, to render as a signed decimal integer.
-      SDecKind
+      UHexKind
     };
 
   private:
@@ -244,6 +251,26 @@ namespace llvm {
       assert(isValid() && "Invalid twine!");
     }
 
+    /// Construct a twine to print \arg Val as an unsigned decimal integer.
+    Twine(const uint32_t &Val) 
+      : LHS(&Val), LHSKind(UDec32Kind), RHSKind(EmptyKind) {
+    }
+
+    /// Construct a twine to print \arg Val as a signed decimal integer.
+    Twine(const int32_t &Val) 
+      : LHS(&Val), LHSKind(SDec32Kind), RHSKind(EmptyKind) {
+    }
+
+    /// Construct a twine to print \arg Val as an unsigned decimal integer.
+    Twine(const uint64_t &Val) 
+      : LHS(&Val), LHSKind(UDec64Kind), RHSKind(EmptyKind) {
+    }
+
+    /// Construct a twine to print \arg Val as a signed decimal integer.
+    Twine(const int64_t &Val) 
+      : LHS(&Val), LHSKind(SDec64Kind), RHSKind(EmptyKind) {
+    }
+
     // FIXME: Unfortunately, to make sure this is as efficient as possible we
     // need extra binary constructors from particular types. We can't rely on
     // the compiler to be smart enough to fold operator+()/concat() down to the
@@ -271,16 +298,6 @@ namespace llvm {
     /// @name Numeric Conversions
     /// @{
 
-    /// Construct a twine to print \arg Val as an unsigned decimal integer.
-    static Twine utostr(const uint64_t &Val) {
-      return Twine(&Val, UDecKind, 0, EmptyKind);
-    }
-
-    /// Construct a twine to print \arg Val as a signed decimal integer.
-    static Twine itostr(const int64_t &Val) {
-      return Twine(&Val, SDecKind, 0, EmptyKind);
-    }
-
     // Construct a twine to print \arg Val as an unsigned hexadecimal integer.
     static Twine utohexstr(const uint64_t &Val) {
       return Twine(&Val, UHexKind, 0, EmptyKind);
diff --git a/lib/Support/Twine.cpp b/lib/Support/Twine.cpp
index c9e5f2401ec..2b0cf062ec8 100644
--- a/lib/Support/Twine.cpp
+++ b/lib/Support/Twine.cpp
@@ -47,10 +47,16 @@ void Twine::printOneChild(raw_ostream &OS, const void *Ptr,
   case Twine::StringRefKind:
     OS << *static_cast<const StringRef*>(Ptr); 
     break;
-  case Twine::UDecKind:
+  case Twine::UDec32Kind:
+    OS << *static_cast<const uint32_t*>(Ptr);
+    break;
+  case Twine::SDec32Kind:
+    OS << *static_cast<const int32_t*>(Ptr);
+    break;
+  case Twine::UDec64Kind:
     OS << *static_cast<const uint64_t*>(Ptr);
     break;
-  case Twine::SDecKind:
+  case Twine::SDec64Kind:
     OS << *static_cast<const int64_t*>(Ptr);
     break;
   case Twine::UHexKind:
@@ -83,11 +89,17 @@ void Twine::printOneChildRepr(raw_ostream &OS, const void *Ptr,
     OS << "stringref:\""
        << static_cast<const StringRef*>(Ptr) << "\"";
     break;
-  case Twine::UDecKind:
-    OS << "udec:" << static_cast<const uint64_t*>(Ptr) << "\"";
+  case Twine::UDec32Kind:
+    OS << "udec32:" << static_cast<const uint64_t*>(Ptr) << "\"";
     break;
-  case Twine::SDecKind:
-    OS << "sdec:" << static_cast<const int64_t*>(Ptr) << "\"";
+  case Twine::SDec32Kind:
+    OS << "sdec32:" << static_cast<const int64_t*>(Ptr) << "\"";
+    break;
+  case Twine::UDec64Kind:
+    OS << "udec64:" << static_cast<const uint64_t*>(Ptr) << "\"";
+    break;
+  case Twine::SDec64Kind:
+    OS << "sdec64:" << static_cast<const int64_t*>(Ptr) << "\"";
     break;
   case Twine::UHexKind:
     OS << "uhex:" << static_cast<const uint64_t*>(Ptr) << "\"";
diff --git a/unittests/ADT/TwineTest.cpp b/unittests/ADT/TwineTest.cpp
index 2f874769507..9a31901864e 100644
--- a/unittests/ADT/TwineTest.cpp
+++ b/unittests/ADT/TwineTest.cpp
@@ -31,12 +31,13 @@ TEST(TwineTest, Construction) {
 }
 
 TEST(TwineTest, Numbers) {
-  EXPECT_EQ("123", Twine::utostr(123).str());
-  EXPECT_EQ("-123", Twine::itostr(-123).str());
-  EXPECT_EQ("123", Twine::utostr(123).str());
-  EXPECT_EQ("-123", Twine::itostr(-123).str());
-  EXPECT_EQ("123", Twine::utostr((char) 123).str());
-  EXPECT_EQ("-123", Twine::itostr((signed char) -123).str());
+  EXPECT_EQ("123", Twine(123U).str());
+  EXPECT_EQ("123", Twine(123).str());
+  EXPECT_EQ("-123", Twine(-123).str());
+  EXPECT_EQ("123", Twine(123).str());
+  EXPECT_EQ("-123", Twine(-123).str());
+  EXPECT_EQ("123", Twine((char) 123).str());
+  EXPECT_EQ("-123", Twine((signed char) -123).str());
 
   EXPECT_EQ("7B", Twine::utohexstr(123).str());
   EXPECT_EQ("FFFFFFFFFFFFFF85", Twine::itohexstr(-123).str());