/*
* 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 "UStringImpl.h"
#include <stdint.h>
#include <string.h>
#include <wtf/Assertions.h>
#include <wtf/CrossThreadRefCounted.h>
#include <wtf/OwnFastMallocPtr.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 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;
};
bool operator==(const CString&, const CString&);
typedef Vector<char, 32> CStringBuffer;
class UString {
friend class JIT;
public:
typedef UStringImpl Rep;
public:
UString();
UString(const char*); // Constructor for null-terminated string.
UString(const char*, int length);
UString(const UChar*, int length);
UString(const Vector<UChar>& buffer);
UString(const UString& s)
: m_rep(s.m_rep)
{
}
// Special constructor for cases where we overwrite an object in place.
UString(PlacementNewAdoptType)
: m_rep(PlacementNewAdopt)
{
}
~UString()
{
}
template<size_t inlineCapacity>
static PassRefPtr<UStringImpl> adopt(Vector<UChar, inlineCapacity>& vector)
{
return Rep::adopt(vector);
}
static UString from(int);
static UString from(long long);
static UString from(unsigned int);
static UString from(long);
static UString from(double);
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;
const UChar* data() const { return m_rep->data(); }
bool isNull() const { return m_rep == s_nullRep; }
bool isEmpty() const { return !m_rep->size(); }
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 *s_nullUString; }
Rep* rep() const { return m_rep.get(); }
UString(PassRefPtr<Rep> r)
: m_rep(r)
{
ASSERT(m_rep);
}
size_t cost() const { return m_rep->cost(); }
private:
RefPtr<Rep> m_rep;
JS_EXPORTDATA static Rep* s_nullRep;
static UString* s_nullUString;
friend void initializeUString();
friend bool operator==(const UString&, const UString&);
};
ALWAYS_INLINE bool operator==(const UString& s1, const UString& s2)
{
int size = s1.size();
switch (size) {
case 0:
return !s2.size();
case 1:
return s2.size() == 1 && s1.data()[0] == s2.data()[0];
case 2: {
if (s2.size() != 2)
return false;
const UChar* d1 = s1.data();
const UChar* d2 = s2.data();
return (d1[0] == d2[0]) & (d1[1] == d2[1]);
}
default:
return s2.size() == size && memcmp(s1.data(), s2.data(), size * sizeof(UChar)) == 0;
}
}
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);
}
int compare(const UString&, const UString&);
inline UString::UString()
: m_rep(s_nullRep)
{
}
// 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::minExtraCost / sizeof(UChar);
struct IdentifierRepHash : PtrHash<RefPtr<JSC::UString::Rep> > {
static unsigned hash(const RefPtr<JSC::UString::Rep>& key) { return key->existingHash(); }
static unsigned hash(JSC::UString::Rep* key) { return key->existingHash(); }
};
void initializeUString();
template<typename StringType>
class StringTypeAdapter {
};
template<>
class StringTypeAdapter<char*> {
public:
StringTypeAdapter<char*>(char* buffer)
: m_buffer((unsigned char*)buffer)
, m_length(strlen(buffer))
{
}
unsigned length() { return m_length; }
void writeTo(UChar* destination)
{
for (unsigned i = 0; i < m_length; ++i)
destination[i] = m_buffer[i];
}
private:
const unsigned char* m_buffer;
unsigned m_length;
};
template<>
class StringTypeAdapter<const char*> {
public:
StringTypeAdapter<const char*>(const char* buffer)
: m_buffer((unsigned char*)buffer)
, m_length(strlen(buffer))
{
}
unsigned length() { return m_length; }
void writeTo(UChar* destination)
{
for (unsigned i = 0; i < m_length; ++i)
destination[i] = m_buffer[i];
}
private:
const unsigned char* m_buffer;
unsigned m_length;
};
template<>
class StringTypeAdapter<UString> {
public:
StringTypeAdapter<UString>(UString& string)
: m_data(string.data())
, m_length(string.size())
{
}
unsigned length() { return m_length; }
void writeTo(UChar* destination)
{
for (unsigned i = 0; i < m_length; ++i)
destination[i] = m_data[i];
}
private:
const UChar* m_data;
unsigned m_length;
};
template<typename StringType1, typename StringType2>
PassRefPtr<UStringImpl> tryMakeString(StringType1 string1, StringType2 string2)
{
StringTypeAdapter<StringType1> adapter1(string1);
StringTypeAdapter<StringType2> adapter2(string2);
UChar* buffer;
unsigned length = adapter1.length() + adapter2.length();
PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
if (!resultImpl)
return 0;
UChar* result = buffer;
adapter1.writeTo(result);
result += adapter1.length();
adapter2.writeTo(result);
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3>
PassRefPtr<UStringImpl> tryMakeString(StringType1 string1, StringType2 string2, StringType3 string3)
{
StringTypeAdapter<StringType1> adapter1(string1);
StringTypeAdapter<StringType2> adapter2(string2);
StringTypeAdapter<StringType3> adapter3(string3);
UChar* buffer;
unsigned length = adapter1.length() + adapter2.length() + adapter3.length();
PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
if (!resultImpl)
return 0;
UChar* result = buffer;
adapter1.writeTo(result);
result += adapter1.length();
adapter2.writeTo(result);
result += adapter2.length();
adapter3.writeTo(result);
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4>
PassRefPtr<UStringImpl> tryMakeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4)
{
StringTypeAdapter<StringType1> adapter1(string1);
StringTypeAdapter<StringType2> adapter2(string2);
StringTypeAdapter<StringType3> adapter3(string3);
StringTypeAdapter<StringType4> adapter4(string4);
UChar* buffer;
unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length();
PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
if (!resultImpl)
return 0;
UChar* result = buffer;
adapter1.writeTo(result);
result += adapter1.length();
adapter2.writeTo(result);
result += adapter2.length();
adapter3.writeTo(result);
result += adapter3.length();
adapter4.writeTo(result);
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5>
PassRefPtr<UStringImpl> tryMakeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5)
{
StringTypeAdapter<StringType1> adapter1(string1);
StringTypeAdapter<StringType2> adapter2(string2);
StringTypeAdapter<StringType3> adapter3(string3);
StringTypeAdapter<StringType4> adapter4(string4);
StringTypeAdapter<StringType5> adapter5(string5);
UChar* buffer;
unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length();
PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
if (!resultImpl)
return 0;
UChar* result = buffer;
adapter1.writeTo(result);
result += adapter1.length();
adapter2.writeTo(result);
result += adapter2.length();
adapter3.writeTo(result);
result += adapter3.length();
adapter4.writeTo(result);
result += adapter4.length();
adapter5.writeTo(result);
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5, typename StringType6>
PassRefPtr<UStringImpl> tryMakeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5, StringType6 string6)
{
StringTypeAdapter<StringType1> adapter1(string1);
StringTypeAdapter<StringType2> adapter2(string2);
StringTypeAdapter<StringType3> adapter3(string3);
StringTypeAdapter<StringType4> adapter4(string4);
StringTypeAdapter<StringType5> adapter5(string5);
StringTypeAdapter<StringType6> adapter6(string6);
UChar* buffer;
unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length() + adapter6.length();
PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
if (!resultImpl)
return 0;
UChar* result = buffer;
adapter1.writeTo(result);
result += adapter1.length();
adapter2.writeTo(result);
result += adapter2.length();
adapter3.writeTo(result);
result += adapter3.length();
adapter4.writeTo(result);
result += adapter4.length();
adapter5.writeTo(result);
result += adapter5.length();
adapter6.writeTo(result);
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5, typename StringType6, typename StringType7>
PassRefPtr<UStringImpl> tryMakeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5, StringType6 string6, StringType7 string7)
{
StringTypeAdapter<StringType1> adapter1(string1);
StringTypeAdapter<StringType2> adapter2(string2);
StringTypeAdapter<StringType3> adapter3(string3);
StringTypeAdapter<StringType4> adapter4(string4);
StringTypeAdapter<StringType5> adapter5(string5);
StringTypeAdapter<StringType6> adapter6(string6);
StringTypeAdapter<StringType7> adapter7(string7);
UChar* buffer;
unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length() + adapter6.length() + adapter7.length();
PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
if (!resultImpl)
return 0;
UChar* result = buffer;
adapter1.writeTo(result);
result += adapter1.length();
adapter2.writeTo(result);
result += adapter2.length();
adapter3.writeTo(result);
result += adapter3.length();
adapter4.writeTo(result);
result += adapter4.length();
adapter5.writeTo(result);
result += adapter5.length();
adapter6.writeTo(result);
result += adapter6.length();
adapter7.writeTo(result);
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5, typename StringType6, typename StringType7, typename StringType8>
PassRefPtr<UStringImpl> tryMakeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5, StringType6 string6, StringType7 string7, StringType8 string8)
{
StringTypeAdapter<StringType1> adapter1(string1);
StringTypeAdapter<StringType2> adapter2(string2);
StringTypeAdapter<StringType3> adapter3(string3);
StringTypeAdapter<StringType4> adapter4(string4);
StringTypeAdapter<StringType5> adapter5(string5);
StringTypeAdapter<StringType6> adapter6(string6);
StringTypeAdapter<StringType7> adapter7(string7);
StringTypeAdapter<StringType8> adapter8(string8);
UChar* buffer;
unsigned length = adapter1.length() + adapter2.length() + adapter3.length() + adapter4.length() + adapter5.length() + adapter6.length() + adapter7.length() + adapter8.length();
PassRefPtr<UStringImpl> resultImpl = UStringImpl::tryCreateUninitialized(length, buffer);
if (!resultImpl)
return 0;
UChar* result = buffer;
adapter1.writeTo(result);
result += adapter1.length();
adapter2.writeTo(result);
result += adapter2.length();
adapter3.writeTo(result);
result += adapter3.length();
adapter4.writeTo(result);
result += adapter4.length();
adapter5.writeTo(result);
result += adapter5.length();
adapter6.writeTo(result);
result += adapter6.length();
adapter7.writeTo(result);
result += adapter7.length();
adapter8.writeTo(result);
return resultImpl;
}
template<typename StringType1, typename StringType2>
UString makeString(StringType1 string1, StringType2 string2)
{
PassRefPtr<UStringImpl> resultImpl = tryMakeString(string1, string2);
if (!resultImpl)
CRASH();
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3>
UString makeString(StringType1 string1, StringType2 string2, StringType3 string3)
{
PassRefPtr<UStringImpl> resultImpl = tryMakeString(string1, string2, string3);
if (!resultImpl)
CRASH();
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4>
UString makeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4)
{
PassRefPtr<UStringImpl> resultImpl = tryMakeString(string1, string2, string3, string4);
if (!resultImpl)
CRASH();
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5>
UString makeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5)
{
PassRefPtr<UStringImpl> resultImpl = tryMakeString(string1, string2, string3, string4, string5);
if (!resultImpl)
CRASH();
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5, typename StringType6>
UString makeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5, StringType6 string6)
{
PassRefPtr<UStringImpl> resultImpl = tryMakeString(string1, string2, string3, string4, string5, string6);
if (!resultImpl)
CRASH();
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5, typename StringType6, typename StringType7>
UString makeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5, StringType6 string6, StringType7 string7)
{
PassRefPtr<UStringImpl> resultImpl = tryMakeString(string1, string2, string3, string4, string5, string6, string7);
if (!resultImpl)
CRASH();
return resultImpl;
}
template<typename StringType1, typename StringType2, typename StringType3, typename StringType4, typename StringType5, typename StringType6, typename StringType7, typename StringType8>
UString makeString(StringType1 string1, StringType2 string2, StringType3 string3, StringType4 string4, StringType5 string5, StringType6 string6, StringType7 string7, StringType8 string8)
{
PassRefPtr<UStringImpl> resultImpl = tryMakeString(string1, string2, string3, string4, string5, string6, string7, string8);
if (!resultImpl)
CRASH();
return resultImpl;
}
} // 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