JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / runtime / NumericStrings.h

diff --git a/runtime/NumericStrings.h b/runtime/NumericStrings.h
index 7fa20c44d50edaa2afc184d43c04d5e76b9e0bb2..ac8d416039a2789509dc7b2a79924ed4dbec5c86 100644 (file)
--- a/runtime/NumericStrings.h
+++ b/runtime/NumericStrings.h
@@ -26,72 +26,72 @@
 #ifndef NumericStrings_h
 #define NumericStrings_h
 
 #ifndef NumericStrings_h
 #define NumericStrings_h
 

-#include "UString.h"
-#include <wtf/FixedArray.h>
+#include <array>

 #include <wtf/HashFunctions.h>
 #include <wtf/HashFunctions.h>

+#include <wtf/text/WTFString.h>

 
 namespace JSC {
 
 
 namespace JSC {
 

-    class NumericStrings {
-    public:
-        ALWAYS_INLINE UString add(double d)
-        {
-            CacheEntry<double>& entry = lookup(d);
-            if (d == entry.key && !entry.value.isNull())
-                return entry.value;
-            entry.key = d;
-            entry.value = UString::number(d);
+class NumericStrings {
+public:
+    ALWAYS_INLINE String add(double d)
+    {
+        CacheEntry<double>& entry = lookup(d);
+        if (d == entry.key && !entry.value.isNull())

             return entry.value;
             return entry.value;

-        }
+        entry.key = d;
+        entry.value = String::numberToStringECMAScript(d);
+        return entry.value;
+    }

 
 

-        ALWAYS_INLINE UString add(int i)
-        {
-            if (static_cast<unsigned>(i) < cacheSize)
-                return lookupSmallString(static_cast<unsigned>(i));
-            CacheEntry<int>& entry = lookup(i);
-            if (i == entry.key && !entry.value.isNull())
-                return entry.value;
-            entry.key = i;
-            entry.value = UString::number(i);
+    ALWAYS_INLINE String add(int i)
+    {
+        if (static_cast<unsigned>(i) < cacheSize)
+            return lookupSmallString(static_cast<unsigned>(i));
+        CacheEntry<int>& entry = lookup(i);
+        if (i == entry.key && !entry.value.isNull())

             return entry.value;
             return entry.value;

-        }
+        entry.key = i;
+        entry.value = String::number(i);
+        return entry.value;
+    }

 
 

-        ALWAYS_INLINE UString add(unsigned i)
-        {
-            if (i < cacheSize)
-                return lookupSmallString(static_cast<unsigned>(i));
-            CacheEntry<unsigned>& entry = lookup(i);
-            if (i == entry.key && !entry.value.isNull())
-                return entry.value;
-            entry.key = i;
-            entry.value = UString::number(i);
+    ALWAYS_INLINE String add(unsigned i)
+    {
+        if (i < cacheSize)
+            return lookupSmallString(static_cast<unsigned>(i));
+        CacheEntry<unsigned>& entry = lookup(i);
+        if (i == entry.key && !entry.value.isNull())

             return entry.value;
             return entry.value;

-        }
-    private:
-        static const size_t cacheSize = 64;
+        entry.key = i;
+        entry.value = String::number(i);
+        return entry.value;
+    }
+private:
+    static const size_t cacheSize = 64;

 
 

-        template<typename T>
-        struct CacheEntry {
-            T key;
-            UString value;
-        };
+    template<typename T>
+    struct CacheEntry {
+        T key;
+        String value;
+    };

 
 

-        CacheEntry<double>& lookup(double d) { return doubleCache[WTF::FloatHash<double>::hash(d) & (cacheSize - 1)]; }
-        CacheEntry<int>& lookup(int i) { return intCache[WTF::IntHash<int>::hash(i) & (cacheSize - 1)]; }
-        CacheEntry<unsigned>& lookup(unsigned i) { return unsignedCache[WTF::IntHash<unsigned>::hash(i) & (cacheSize - 1)]; }
-        ALWAYS_INLINE const UString& lookupSmallString(unsigned i)
-        {
-            ASSERT(i < cacheSize);
-            if (smallIntCache[i].isNull())
-                smallIntCache[i] = UString::number(i);
-            return smallIntCache[i];
-        }
+    CacheEntry<double>& lookup(double d) { return doubleCache[WTF::FloatHash<double>::hash(d) & (cacheSize - 1)]; }
+    CacheEntry<int>& lookup(int i) { return intCache[WTF::IntHash<int>::hash(i) & (cacheSize - 1)]; }
+    CacheEntry<unsigned>& lookup(unsigned i) { return unsignedCache[WTF::IntHash<unsigned>::hash(i) & (cacheSize - 1)]; }
+    ALWAYS_INLINE const String& lookupSmallString(unsigned i)
+    {
+        ASSERT(i < cacheSize);
+        if (smallIntCache[i].isNull())
+            smallIntCache[i] = String::number(i);
+        return smallIntCache[i];
+    }

 
 

-        FixedArray<CacheEntry<double>, cacheSize> doubleCache;
-        FixedArray<CacheEntry<int>, cacheSize> intCache;
-        FixedArray<CacheEntry<unsigned>, cacheSize> unsignedCache;
-        FixedArray<UString, cacheSize> smallIntCache;
-    };
+    std::array<CacheEntry<double>, cacheSize> doubleCache;
+    std::array<CacheEntry<int>, cacheSize> intCache;
+    std::array<CacheEntry<unsigned>, cacheSize> unsignedCache;
+    std::array<String, cacheSize> smallIntCache;
+};

 
 } // namespace JSC
 
 
 } // namespace JSC