JavaScriptCore/runtime/UString.h - platform/external/webkit - Git at Google

 /*
  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
  *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *  Copyright (c) 2009, Google Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  *
  */

 #ifndef UString_h
 #define UString_h

 #include "Collector.h"
 #include <stdint.h>
 #include <string.h>
 #include <wtf/Assertions.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/PtrAndFlags.h>
 #include <wtf/RefPtr.h>
 #include <wtf/Vector.h>
 #include <wtf/unicode/Unicode.h>

 namespace JSC {

     using WTF::PlacementNewAdoptType;
     using WTF::PlacementNewAdopt;

     class IdentifierTable;

     class CString {
     public:
         CString()
             : m_length(0)
             , m_data(0)
         {
         }

         CString(const char*);
         CString(const char*, size_t);
         CString(const CString&);

         ~CString();

         static CString adopt(char*, size_t); // buffer should be allocated with new[].

         CString& append(const CString&);
         CString& operator=(const char* c);
         CString& operator=(const CString&);
         CString& operator+=(const CString& c) { return append(c); }

         size_t size() const { return m_length; }
         const char* c_str() const { return m_data; }

     private:
         size_t m_length;
         char* m_data;
     };

     typedef Vector<char, 32> CStringBuffer;

     class UString {
         friend class JIT;

     public:
         struct BaseString;
         struct Rep : Noncopyable {
             friend class JIT;

             static PassRefPtr<Rep> create(UChar*, int);
             static PassRefPtr<Rep> createCopying(const UChar*, int);
             static PassRefPtr<Rep> create(PassRefPtr<Rep> base, int offset, int length);

             // Constructs a string from a UTF-8 string, using strict conversion (see comments in UTF8.h).
             // Returns UString::Rep::null for null input or conversion failure.
             static PassRefPtr<Rep> createFromUTF8(const char*);

             void destroy();

             bool baseIsSelf() const { return m_identifierTableAndFlags.isFlagSet(BaseStringFlag); }
             UChar* data() const;
             int size() const { return len; }

             unsigned hash() const { if (_hash == 0) _hash = computeHash(data(), len); return _hash; }
             unsigned computedHash() const { ASSERT(_hash); return _hash; } // fast path for Identifiers

             static unsigned computeHash(const UChar*, int length);
             static unsigned computeHash(const char*, int length);
             static unsigned computeHash(const char* s) { return computeHash(s, strlen(s)); }

             IdentifierTable* identifierTable() const { return m_identifierTableAndFlags.get(); }
             void setIdentifierTable(IdentifierTable* table) { ASSERT(!isStatic()); m_identifierTableAndFlags.set(table); }

             bool isStatic() const { return m_identifierTableAndFlags.isFlagSet(StaticFlag); }
             void setStatic(bool);
             void setBaseString(PassRefPtr<BaseString>);
             BaseString* baseString();
             const BaseString* baseString() const;

             Rep* ref() { ++rc; return this; }
             ALWAYS_INLINE void deref() { if (--rc == 0) destroy(); }

             void checkConsistency() const;
             enum UStringFlags {
                 StaticFlag,
                 BaseStringFlag
             };

             // unshared data
             int offset;
             int len;
             int rc; // For null and empty static strings, this field does not reflect a correct count, because ref/deref are not thread-safe. A special case in destroy() guarantees that these do not get deleted.
             mutable unsigned _hash;
             PtrAndFlags<IdentifierTable, UStringFlags> m_identifierTableAndFlags;
             void* m_baseString; // If "this" is a BaseString instance, it is 0. BaseString* otherwise.

             static BaseString& null() { return *nullBaseString; }
             static BaseString& empty() { return *emptyBaseString; }

         private:
             friend void initializeUString();
             static BaseString* nullBaseString;
             static BaseString* emptyBaseString;
         };

         struct BaseString : public Rep {
             BaseString()
             {
                 m_identifierTableAndFlags.setFlag(BaseStringFlag);
             }

             // potentially shared data.
             UChar* buf;
             int preCapacity;
             int usedPreCapacity;
             int capacity;
             int usedCapacity;

             size_t reportedCost;
         };

     public:
         UString();
         UString(const char*);
         UString(const UChar*, int length);
         UString(UChar*, int length, bool copy);

         UString(const UString& s)
             : m_rep(s.m_rep)
         {
         }

         UString(const Vector<UChar>& buffer);

         ~UString()
         {
         }

         // Special constructor for cases where we overwrite an object in place.
         UString(PlacementNewAdoptType)
             : m_rep(PlacementNewAdopt)
         {
         }

         static UString from(int);
         static UString from(unsigned int);
         static UString from(long);
         static UString from(double);

         struct Range {
         public:
             Range(int pos, int len)
                 : position(pos)
                 , length(len)
             {
             }

             Range()
             {
             }

             int position;
             int length;
         };

         UString spliceSubstringsWithSeparators(const Range* substringRanges, int rangeCount, const UString* separators, int separatorCount) const;

         UString& append(const UString&);
         UString& append(const char*);
         UString& append(UChar);
         UString& append(char c) { return append(static_cast<UChar>(static_cast<unsigned char>(c))); }
         UString& append(const UChar*, int size);

         bool getCString(CStringBuffer&) const;

         // NOTE: This method should only be used for *debugging* purposes as it
         // is neither Unicode safe nor free from side effects nor thread-safe.
         char* ascii() const;

         /**
          * Convert the string to UTF-8, assuming it is UTF-16 encoded.
          * In non-strict mode, this function is tolerant of badly formed UTF-16, it
          * can create UTF-8 strings that are invalid because they have characters in
          * the range U+D800-U+DDFF, U+FFFE, or U+FFFF, but the UTF-8 string is
          * guaranteed to be otherwise valid.
          * In strict mode, error is returned as null CString.
          */
         CString UTF8String(bool strict = false) const;

         UString& operator=(const char*c);

         UString& operator+=(const UString& s) { return append(s); }
         UString& operator+=(const char* s) { return append(s); }

         const UChar* data() const { return m_rep->data(); }

         bool isNull() const { return (m_rep == &Rep::null()); }
         bool isEmpty() const { return (!m_rep->len); }

         bool is8Bit() const;

         int size() const { return m_rep->size(); }

         UChar operator[](int pos) const;

         double toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const;
         double toDouble(bool tolerateTrailingJunk) const;
         double toDouble() const;

         uint32_t toUInt32(bool* ok = 0) const;
         uint32_t toUInt32(bool* ok, bool tolerateEmptyString) const;
         uint32_t toStrictUInt32(bool* ok = 0) const;

         unsigned toArrayIndex(bool* ok = 0) const;

         int find(const UString& f, int pos = 0) const;
         int find(UChar, int pos = 0) const;
         int rfind(const UString& f, int pos) const;
         int rfind(UChar, int pos) const;

         UString substr(int pos = 0, int len = -1) const;

         static const UString& null() { return *nullUString; }

         Rep* rep() const { return m_rep.get(); }
         static Rep* nullRep();

         UString(PassRefPtr<Rep> r)
             : m_rep(r)
         {
             ASSERT(m_rep);
         }

         size_t cost() const;

     private:
         void expandCapacity(int requiredLength);
         void expandPreCapacity(int requiredPreCap);
         void makeNull();

         RefPtr<Rep> m_rep;
         static UString* nullUString;

         friend void initializeUString();
         friend bool operator==(const UString&, const UString&);
         friend PassRefPtr<Rep> concatenate(Rep*, Rep*); // returns 0 if out of memory
     };
     PassRefPtr<UString::Rep> concatenate(UString::Rep*, UString::Rep*);
     PassRefPtr<UString::Rep> concatenate(UString::Rep*, int);
     PassRefPtr<UString::Rep> concatenate(UString::Rep*, double);

     bool operator==(const UString&, const UString&);

     inline bool operator!=(const UString& s1, const UString& s2)
     {
         return !JSC::operator==(s1, s2);
     }

     bool operator<(const UString& s1, const UString& s2);
     bool operator>(const UString& s1, const UString& s2);

     bool operator==(const UString& s1, const char* s2);

     inline bool operator!=(const UString& s1, const char* s2)
     {
         return !JSC::operator==(s1, s2);
     }

     inline bool operator==(const char *s1, const UString& s2)
     {
         return operator==(s2, s1);
     }

     inline bool operator!=(const char *s1, const UString& s2)
     {
         return !JSC::operator==(s1, s2);
     }

     bool operator==(const CString&, const CString&);

     inline UString operator+(const UString& s1, const UString& s2)
     {
         RefPtr<UString::Rep> result = concatenate(s1.rep(), s2.rep());
         return UString(result ? result.release() : UString::nullRep());
     }

     int compare(const UString&, const UString&);

     bool equal(const UString::Rep*, const UString::Rep*);

     inline UChar* UString::Rep::data() const
     {
         const BaseString* base = baseString();
         return base->buf + base->preCapacity + offset;
     }

     inline void UString::Rep::setStatic(bool v)
     {
         ASSERT(!identifierTable());
         if (v)
             m_identifierTableAndFlags.setFlag(StaticFlag);
         else
             m_identifierTableAndFlags.clearFlag(StaticFlag);
     }

     inline void UString::Rep::setBaseString(PassRefPtr<BaseString> base)
     {
         ASSERT(base != this);
         m_baseString = base.releaseRef();
     }

     inline UString::BaseString* UString::Rep::baseString()
     {
         return reinterpret_cast<BaseString*>(baseIsSelf() ? this : m_baseString);
     }

     inline const UString::BaseString* UString::Rep::baseString() const
     {
         return const_cast<const BaseString*>(const_cast<Rep*>(this)->baseString());
     }

 #ifdef NDEBUG
     inline void UString::Rep::checkConsistency() const
     {
     }
 #endif

     inline UString::UString()
         : m_rep(&Rep::null())
     {
     }

     // Rule from ECMA 15.2 about what an array index is.
     // Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
     inline unsigned UString::toArrayIndex(bool* ok) const
     {
         unsigned i = toStrictUInt32(ok);
         if (ok && i >= 0xFFFFFFFFU)
             *ok = false;
         return i;
     }

     // We'd rather not do shared substring append for small strings, since
     // this runs too much risk of a tiny initial string holding down a
     // huge buffer.
     // FIXME: this should be size_t but that would cause warnings until we
     // fix UString sizes to be size_t instead of int
     static const int minShareSize = Heap::minExtraCostSize / sizeof(UChar);

     inline size_t UString::cost() const
     {
         BaseString* base = m_rep->baseString();
         size_t capacity = (base->capacity + base->preCapacity) * sizeof(UChar);
         size_t reportedCost = base->reportedCost;
         ASSERT(capacity >= reportedCost);

         size_t capacityDelta = capacity - reportedCost;

         if (capacityDelta < static_cast<size_t>(minShareSize))
             return 0;

         base->reportedCost = capacity;

         return capacityDelta;
     }

     struct IdentifierRepHash : PtrHash<RefPtr<JSC::UString::Rep> > {
         static unsigned hash(const RefPtr<JSC::UString::Rep>& key) { return key->computedHash(); }
         static unsigned hash(JSC::UString::Rep* key) { return key->computedHash(); }
     };

     void initializeUString();
 } // namespace JSC

 namespace WTF {

     template<typename T> struct DefaultHash;
     template<typename T> struct StrHash;

     template<> struct StrHash<JSC::UString::Rep*> {
         static unsigned hash(const JSC::UString::Rep* key) { return key->hash(); }
         static bool equal(const JSC::UString::Rep* a, const JSC::UString::Rep* b) { return JSC::equal(a, b); }
         static const bool safeToCompareToEmptyOrDeleted = false;
     };

     template<> struct StrHash<RefPtr<JSC::UString::Rep> > : public StrHash<JSC::UString::Rep*> {
         using StrHash<JSC::UString::Rep*>::hash;
         static unsigned hash(const RefPtr<JSC::UString::Rep>& key) { return key->hash(); }
         using StrHash<JSC::UString::Rep*>::equal;
         static bool equal(const RefPtr<JSC::UString::Rep>& a, const RefPtr<JSC::UString::Rep>& b) { return JSC::equal(a.get(), b.get()); }
         static bool equal(const JSC::UString::Rep* a, const RefPtr<JSC::UString::Rep>& b) { return JSC::equal(a, b.get()); }
         static bool equal(const RefPtr<JSC::UString::Rep>& a, const JSC::UString::Rep* b) { return JSC::equal(a.get(), b); }

         static const bool safeToCompareToEmptyOrDeleted = false;
     };

     template<> struct DefaultHash<JSC::UString::Rep*> {
         typedef StrHash<JSC::UString::Rep*> Hash;
     };

     template<> struct DefaultHash<RefPtr<JSC::UString::Rep> > {
         typedef StrHash<RefPtr<JSC::UString::Rep> > Hash;

     };

 } // namespace WTF

 #endif
	/*
	* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
	* Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
	* Copyright (c) 2009, Google Inc. All rights reserved.
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public License
	* along with this library; see the file COPYING.LIB. If not, write to
	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	* Boston, MA 02110-1301, USA.
	*
	*/

	#ifndef UString_h
	#define UString_h

	#include "Collector.h"
	#include <stdint.h>
	#include <string.h>
	#include <wtf/Assertions.h>
	#include <wtf/PassRefPtr.h>
	#include <wtf/PtrAndFlags.h>
	#include <wtf/RefPtr.h>
	#include <wtf/Vector.h>
	#include <wtf/unicode/Unicode.h>

	namespace JSC {

	using WTF::PlacementNewAdoptType;
	using WTF::PlacementNewAdopt;

	class IdentifierTable;

	class CString {
	public:
	CString()
	: m_length(0)
	, m_data(0)
	{
	}

	CString(const char*);
	CString(const char*, size_t);
	CString(const CString&);

	~CString();

	static CString adopt(char*, size_t); // buffer should be allocated with new[].

	CString& append(const CString&);
	CString& operator=(const char* c);
	CString& operator=(const CString&);
	CString& operator+=(const CString& c) { return append(c); }

	size_t size() const { return m_length; }
	const char* c_str() const { return m_data; }

	private:
	size_t m_length;
	char* m_data;
	};

	typedef Vector<char, 32> CStringBuffer;

	class UString {
	friend class JIT;

	public:
	struct BaseString;
	struct Rep : Noncopyable {
	friend class JIT;

	static PassRefPtr<Rep> create(UChar*, int);
	static PassRefPtr<Rep> createCopying(const UChar*, int);
	static PassRefPtr<Rep> create(PassRefPtr<Rep> base, int offset, int length);

	// Constructs a string from a UTF-8 string, using strict conversion (see comments in UTF8.h).
	// Returns UString::Rep::null for null input or conversion failure.
	static PassRefPtr<Rep> createFromUTF8(const char*);

	void destroy();

	bool baseIsSelf() const { return m_identifierTableAndFlags.isFlagSet(BaseStringFlag); }
	UChar* data() const;
	int size() const { return len; }

	unsigned hash() const { if (_hash == 0) _hash = computeHash(data(), len); return _hash; }
	unsigned computedHash() const { ASSERT(_hash); return _hash; } // fast path for Identifiers

	static unsigned computeHash(const UChar*, int length);
	static unsigned computeHash(const char*, int length);
	static unsigned computeHash(const char* s) { return computeHash(s, strlen(s)); }

	IdentifierTable* identifierTable() const { return m_identifierTableAndFlags.get(); }
	void setIdentifierTable(IdentifierTable* table) { ASSERT(!isStatic()); m_identifierTableAndFlags.set(table); }

	bool isStatic() const { return m_identifierTableAndFlags.isFlagSet(StaticFlag); }
	void setStatic(bool);
	void setBaseString(PassRefPtr<BaseString>);
	BaseString* baseString();
	const BaseString* baseString() const;

	Rep* ref() { ++rc; return this; }
	ALWAYS_INLINE void deref() { if (--rc == 0) destroy(); }

	void checkConsistency() const;
	enum UStringFlags {
	StaticFlag,
	BaseStringFlag
	};

	// unshared data
	int offset;
	int len;
	int rc; // For null and empty static strings, this field does not reflect a correct count, because ref/deref are not thread-safe. A special case in destroy() guarantees that these do not get deleted.
	mutable unsigned _hash;
	PtrAndFlags<IdentifierTable, UStringFlags> m_identifierTableAndFlags;
	void* m_baseString; // If "this" is a BaseString instance, it is 0. BaseString* otherwise.

	static BaseString& null() { return *nullBaseString; }
	static BaseString& empty() { return *emptyBaseString; }

	private:
	friend void initializeUString();
	static BaseString* nullBaseString;
	static BaseString* emptyBaseString;
	};

	struct BaseString : public Rep {
	BaseString()
	{
	m_identifierTableAndFlags.setFlag(BaseStringFlag);
	}

	// potentially shared data.
	UChar* buf;
	int preCapacity;
	int usedPreCapacity;
	int capacity;
	int usedCapacity;

	size_t reportedCost;
	};

	public:
	UString();
	UString(const char*);
	UString(const UChar*, int length);
	UString(UChar*, int length, bool copy);

	UString(const UString& s)
	: m_rep(s.m_rep)
	{
	}

	UString(const Vector<UChar>& buffer);

	~UString()
	{
	}

	// Special constructor for cases where we overwrite an object in place.
	UString(PlacementNewAdoptType)
	: m_rep(PlacementNewAdopt)
	{
	}

	static UString from(int);
	static UString from(unsigned int);
	static UString from(long);
	static UString from(double);

	struct Range {
	public:
	Range(int pos, int len)
	: position(pos)
	, length(len)
	{
	}

	Range()
	{
	}

	int position;
	int length;
	};

	UString spliceSubstringsWithSeparators(const Range* substringRanges, int rangeCount, const UString* separators, int separatorCount) const;

	UString& append(const UString&);
	UString& append(const char*);
	UString& append(UChar);
	UString& append(char c) { return append(static_cast<UChar>(static_cast<unsigned char>(c))); }
	UString& append(const UChar*, int size);

	bool getCString(CStringBuffer&) const;

	// NOTE: This method should only be used for debugging purposes as it
	// is neither Unicode safe nor free from side effects nor thread-safe.
	char* ascii() const;

	/**
	* Convert the string to UTF-8, assuming it is UTF-16 encoded.
	* In non-strict mode, this function is tolerant of badly formed UTF-16, it
	* can create UTF-8 strings that are invalid because they have characters in
	* the range U+D800-U+DDFF, U+FFFE, or U+FFFF, but the UTF-8 string is
	* guaranteed to be otherwise valid.
	* In strict mode, error is returned as null CString.
	*/
	CString UTF8String(bool strict = false) const;

	UString& operator=(const char*c);

	UString& operator+=(const UString& s) { return append(s); }
	UString& operator+=(const char* s) { return append(s); }

	const UChar* data() const { return m_rep->data(); }

	bool isNull() const { return (m_rep == &Rep::null()); }
	bool isEmpty() const { return (!m_rep->len); }

	bool is8Bit() const;

	int size() const { return m_rep->size(); }

	UChar operator[](int pos) const;

	double toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const;
	double toDouble(bool tolerateTrailingJunk) const;
	double toDouble() const;

	uint32_t toUInt32(bool* ok = 0) const;
	uint32_t toUInt32(bool* ok, bool tolerateEmptyString) const;
	uint32_t toStrictUInt32(bool* ok = 0) const;

	unsigned toArrayIndex(bool* ok = 0) const;

	int find(const UString& f, int pos = 0) const;
	int find(UChar, int pos = 0) const;
	int rfind(const UString& f, int pos) const;
	int rfind(UChar, int pos) const;

	UString substr(int pos = 0, int len = -1) const;

	static const UString& null() { return *nullUString; }

	Rep* rep() const { return m_rep.get(); }
	static Rep* nullRep();

	UString(PassRefPtr<Rep> r)
	: m_rep(r)
	{
	ASSERT(m_rep);
	}

	size_t cost() const;

	private:
	void expandCapacity(int requiredLength);
	void expandPreCapacity(int requiredPreCap);
	void makeNull();

	RefPtr<Rep> m_rep;
	static UString* nullUString;

	friend void initializeUString();
	friend bool operator==(const UString&, const UString&);
	friend PassRefPtr<Rep> concatenate(Rep, Rep); // returns 0 if out of memory
	};
	PassRefPtr<UString::Rep> concatenate(UString::Rep, UString::Rep);
	PassRefPtr<UString::Rep> concatenate(UString::Rep*, int);
	PassRefPtr<UString::Rep> concatenate(UString::Rep*, double);

	bool operator==(const UString&, const UString&);

	inline bool operator!=(const UString& s1, const UString& s2)
	{
	return !JSC::operator==(s1, s2);
	}

	bool operator<(const UString& s1, const UString& s2);
	bool operator>(const UString& s1, const UString& s2);

	bool operator==(const UString& s1, const char* s2);

	inline bool operator!=(const UString& s1, const char* s2)
	{
	return !JSC::operator==(s1, s2);
	}

	inline bool operator==(const char *s1, const UString& s2)
	{
	return operator==(s2, s1);
	}

	inline bool operator!=(const char *s1, const UString& s2)
	{
	return !JSC::operator==(s1, s2);
	}

	bool operator==(const CString&, const CString&);

	inline UString operator+(const UString& s1, const UString& s2)
	{
	RefPtr<UString::Rep> result = concatenate(s1.rep(), s2.rep());
	return UString(result ? result.release() : UString::nullRep());
	}

	int compare(const UString&, const UString&);

	bool equal(const UString::Rep, const UString::Rep);

	inline UChar* UString::Rep::data() const
	{
	const BaseString* base = baseString();
	return base->buf + base->preCapacity + offset;
	}

	inline void UString::Rep::setStatic(bool v)
	{
	ASSERT(!identifierTable());
	if (v)
	m_identifierTableAndFlags.setFlag(StaticFlag);
	else
	m_identifierTableAndFlags.clearFlag(StaticFlag);
	}

	inline void UString::Rep::setBaseString(PassRefPtr<BaseString> base)
	{
	ASSERT(base != this);
	m_baseString = base.releaseRef();
	}

	inline UString::BaseString* UString::Rep::baseString()
	{
	return reinterpret_cast<BaseString*>(baseIsSelf() ? this : m_baseString);
	}

	inline const UString::BaseString* UString::Rep::baseString() const
	{
	return const_cast<const BaseString>(const_cast<Rep>(this)->baseString());
	}

	#ifdef NDEBUG
	inline void UString::Rep::checkConsistency() const
	{
	}
	#endif

	inline UString::UString()
	: m_rep(&Rep::null())
	{
	}

	// Rule from ECMA 15.2 about what an array index is.
	// Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
	inline unsigned UString::toArrayIndex(bool* ok) const
	{
	unsigned i = toStrictUInt32(ok);
	if (ok && i >= 0xFFFFFFFFU)
	*ok = false;
	return i;
	}

	// We'd rather not do shared substring append for small strings, since
	// this runs too much risk of a tiny initial string holding down a
	// huge buffer.
	// FIXME: this should be size_t but that would cause warnings until we
	// fix UString sizes to be size_t instead of int
	static const int minShareSize = Heap::minExtraCostSize / sizeof(UChar);

	inline size_t UString::cost() const
	{
	BaseString* base = m_rep->baseString();
	size_t capacity = (base->capacity + base->preCapacity) * sizeof(UChar);
	size_t reportedCost = base->reportedCost;
	ASSERT(capacity >= reportedCost);

	size_t capacityDelta = capacity - reportedCost;

	if (capacityDelta < static_cast<size_t>(minShareSize))
	return 0;

	base->reportedCost = capacity;

	return capacityDelta;
	}

	struct IdentifierRepHash : PtrHash<RefPtr<JSC::UString::Rep> > {
	static unsigned hash(const RefPtr<JSC::UString::Rep>& key) { return key->computedHash(); }
	static unsigned hash(JSC::UString::Rep* key) { return key->computedHash(); }
	};

	void initializeUString();
	} // namespace JSC

	namespace WTF {

	template<typename T> struct DefaultHash;
	template<typename T> struct StrHash;

	template<> struct StrHash<JSC::UString::Rep*> {
	static unsigned hash(const JSC::UString::Rep* key) { return key->hash(); }
	static bool equal(const JSC::UString::Rep* a, const JSC::UString::Rep* b) { return JSC::equal(a, b); }
	static const bool safeToCompareToEmptyOrDeleted = false;
	};

	template<> struct StrHash<RefPtr<JSC::UString::Rep> > : public StrHash<JSC::UString::Rep*> {
	using StrHash<JSC::UString::Rep*>::hash;
	static unsigned hash(const RefPtr<JSC::UString::Rep>& key) { return key->hash(); }
	using StrHash<JSC::UString::Rep*>::equal;
	static bool equal(const RefPtr<JSC::UString::Rep>& a, const RefPtr<JSC::UString::Rep>& b) { return JSC::equal(a.get(), b.get()); }
	static bool equal(const JSC::UString::Rep* a, const RefPtr<JSC::UString::Rep>& b) { return JSC::equal(a, b.get()); }
	static bool equal(const RefPtr<JSC::UString::Rep>& a, const JSC::UString::Rep* b) { return JSC::equal(a.get(), b); }

	static const bool safeToCompareToEmptyOrDeleted = false;
	};

	template<> struct DefaultHash<JSC::UString::Rep*> {
	typedef StrHash<JSC::UString::Rep*> Hash;
	};

	template<> struct DefaultHash<RefPtr<JSC::UString::Rep> > {
	typedef StrHash<RefPtr<JSC::UString::Rep> > Hash;

	};

	} // namespace WTF

	#endif