#include "config.h"
#include "StringImpl.h"
#include "AtomicString.h"
#include "StringBuffer.h"
#include "StringHash.h"
#include <wtf/StdLibExtras.h>
#include <wtf/WTFThreadData.h>
using namespace std;
namespace WTF {
using namespace Unicode;
COMPILE_ASSERT(sizeof(StringImpl) == 2 * sizeof(int) + 3 * sizeof(void*), StringImpl_should_stay_small);
StringImpl::~StringImpl()
{
ASSERT(!isStatic());
if (isAtomic())
AtomicString::remove(this);
#if USE(JSC)
if (isIdentifier()) {
if (!wtfThreadData().currentIdentifierTable()->remove(this))
CRASH();
}
#endif
BufferOwnership ownership = bufferOwnership();
if (has16BitShadow()) {
ASSERT(m_copyData16);
fastFree(m_copyData16);
}
if (ownership == BufferInternal)
return;
if (ownership == BufferOwned) {
ASSERT(m_data8);
fastFree(const_cast<LChar*>(m_data8));
return;
}
ASSERT(ownership == BufferSubstring);
ASSERT(m_substringBuffer);
m_substringBuffer->deref();
}
PassRefPtr<StringImpl> StringImpl::createUninitialized(unsigned length, LChar*& data)
{
if (!length) {
data = 0;
return empty();
}
if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(LChar)))
CRASH();
size_t size = sizeof(StringImpl) + length * sizeof(LChar);
StringImpl* string = static_cast<StringImpl*>(fastMalloc(size));
data = reinterpret_cast<LChar*>(string + 1);
return adoptRef(new (string) StringImpl(length, Force8BitConstructor));
}
PassRefPtr<StringImpl> StringImpl::createUninitialized(unsigned length, UChar*& data)
{
if (!length) {
data = 0;
return empty();
}
if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(UChar)))
CRASH();
size_t size = sizeof(StringImpl) + length * sizeof(UChar);
StringImpl* string = static_cast<StringImpl*>(fastMalloc(size));
data = reinterpret_cast<UChar*>(string + 1);
return adoptRef(new (string) StringImpl(length));
}
PassRefPtr<StringImpl> StringImpl::reallocate(PassRefPtr<StringImpl> originalString, unsigned length, LChar*& data)
{
ASSERT(originalString->is8Bit());
ASSERT(originalString->hasOneRef());
ASSERT(originalString->bufferOwnership() == BufferInternal);
if (!length) {
data = 0;
return empty();
}
if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(LChar)))
CRASH();
size_t size = sizeof(StringImpl) + length * sizeof(LChar);
originalString->~StringImpl();
StringImpl* string = static_cast<StringImpl*>(fastRealloc(originalString.leakRef(), size));
data = reinterpret_cast<LChar*>(string + 1);
return adoptRef(new (string) StringImpl(length, Force8BitConstructor));
}
PassRefPtr<StringImpl> StringImpl::reallocate(PassRefPtr<StringImpl> originalString, unsigned length, UChar*& data)
{
ASSERT(!originalString->is8Bit());
ASSERT(originalString->hasOneRef());
ASSERT(originalString->bufferOwnership() == BufferInternal);
if (!length) {
data = 0;
return empty();
}
if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(UChar)))
CRASH();
size_t size = sizeof(StringImpl) + length * sizeof(UChar);
originalString->~StringImpl();
StringImpl* string = static_cast<StringImpl*>(fastRealloc(originalString.leakRef(), size));
data = reinterpret_cast<UChar*>(string + 1);
return adoptRef(new (string) StringImpl(length));
}
PassRefPtr<StringImpl> StringImpl::create(const UChar* characters, unsigned length)
{
if (!characters || !length)
return empty();
UChar* data;
RefPtr<StringImpl> string = createUninitialized(length, data);
memcpy(data, characters, length * sizeof(UChar));
return string.release();
}
PassRefPtr<StringImpl> StringImpl::create(const LChar* characters, unsigned length)
{
if (!characters || !length)
return empty();
LChar* data;
RefPtr<StringImpl> string = createUninitialized(length, data);
memcpy(data, characters, length * sizeof(LChar));
return string.release();
}
PassRefPtr<StringImpl> StringImpl::create(const LChar* string)
{
if (!string)
return empty();
size_t length = strlen(reinterpret_cast<const char*>(string));
if (length > numeric_limits<unsigned>::max())
CRASH();
return create(string, length);
}
const UChar* StringImpl::getData16SlowCase() const
{
if (has16BitShadow())
return m_copyData16;
if (bufferOwnership() == BufferSubstring) {
unsigned offset = m_data8 - m_substringBuffer->characters8();
return m_substringBuffer->characters() + offset;
}
unsigned len = length();
if (hasTerminatingNullCharacter())
len++;
m_copyData16 = static_cast<UChar*>(fastMalloc(len * sizeof(UChar)));
m_hashAndFlags |= s_hashFlagHas16BitShadow;
upconvertCharacters(0, len);
return m_copyData16;
}
void StringImpl::upconvertCharacters(unsigned start, unsigned end) const
{
ASSERT(is8Bit());
ASSERT(has16BitShadow());
for (size_t i = start; i < end; i++)
m_copyData16[i] = m_data8[i];
}
bool StringImpl::containsOnlyWhitespace()
{
if (is8Bit()) {
for (unsigned i = 0; i < m_length; i++) {
UChar c = m_data8[i];
if (!isASCIISpace(c))
return false;
}
return true;
}
for (unsigned i = 0; i < m_length; i++) {
UChar c = m_data16[i];
if (!isASCIISpace(c))
return false;
}
return true;
}
PassRefPtr<StringImpl> StringImpl::substring(unsigned start, unsigned length)
{
if (start >= m_length)
return empty();
unsigned maxLength = m_length - start;
if (length >= maxLength) {
if (!start)
return this;
length = maxLength;
}
if (is8Bit())
return create(m_data8 + start, length);
return create(m_data16 + start, length);
}
UChar32 StringImpl::characterStartingAt(unsigned i)
{
if (is8Bit())
return m_data8[i];
if (U16_IS_SINGLE(m_data16[i]))
return m_data16[i];
if (i + 1 < m_length && U16_IS_LEAD(m_data16[i]) && U16_IS_TRAIL(m_data16[i + 1]))
return U16_GET_SUPPLEMENTARY(m_data16[i], m_data16[i + 1]);
return 0;
}
PassRefPtr<StringImpl> StringImpl::lower()
{
bool noUpper = true;
UChar ored = 0;
if (is8Bit()) {
const LChar* end = m_data8 + m_length;
for (const LChar* chp = m_data8; chp != end; chp++) {
if (UNLIKELY(isASCIIUpper(*chp)))
noUpper = false;
ored |= *chp;
}
if (noUpper && !(ored & ~0x7F))
return this;
if (m_length > static_cast<unsigned>(numeric_limits<int32_t>::max()))
CRASH();
int32_t length = m_length;
LChar* data8;
RefPtr<StringImpl> newImpl = createUninitialized(length, data8);
if (!(ored & ~0x7F)) {
for (int32_t i = 0; i < length; i++)
data8[i] = toASCIILower(m_data8[i]);
return newImpl.release();
}
for (int32_t i = 0; i < length; i++)
data8[i] = static_cast<LChar>(Unicode::toLower(m_data8[i]));
return newImpl.release();
}
const UChar *end = m_data16 + m_length;
for (const UChar* chp = m_data16; chp != end; chp++) {
if (UNLIKELY(isASCIIUpper(*chp)))
noUpper = false;
ored |= *chp;
}
if (noUpper && !(ored & ~0x7F))
return this;
if (m_length > static_cast<unsigned>(numeric_limits<int32_t>::max()))
CRASH();
int32_t length = m_length;
if (!(ored & ~0x7F)) {
UChar* data16;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
for (int32_t i = 0; i < length; i++) {
UChar c = m_data16[i];
data16[i] = toASCIILower(c);
}
return newImpl.release();
}
UChar* data16;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
bool error;
int32_t realLength = Unicode::toLower(data16, length, m_data16, m_length, &error);
if (!error && realLength == length)
return newImpl.release();
newImpl = createUninitialized(realLength, data16);
Unicode::toLower(data16, realLength, m_data16, m_length, &error);
if (error)
return this;
return newImpl.release();
}
PassRefPtr<StringImpl> StringImpl::upper()
{
if (m_length > static_cast<unsigned>(numeric_limits<int32_t>::max()))
CRASH();
int32_t length = m_length;
if (is8Bit()) {
LChar* data8;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data8);
LChar ored = 0;
for (int i = 0; i < length; i++) {
LChar c = m_data8[i];
ored |= c;
data8[i] = toASCIIUpper(c);
}
if (!(ored & ~0x7F))
return newImpl.release();
for (int32_t i = 0; i < length; i++)
data8[i] = static_cast<LChar>(Unicode::toUpper(m_data8[i]));
return newImpl.release();
}
UChar* data16;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
UChar ored = 0;
for (int i = 0; i < length; i++) {
UChar c = m_data16[i];
ored |= c;
data16[i] = toASCIIUpper(c);
}
if (!(ored & ~0x7F))
return newImpl.release();
bool error;
newImpl = createUninitialized(m_length, data16);
int32_t realLength = Unicode::toUpper(data16, length, m_data16, m_length, &error);
if (!error && realLength == length)
return newImpl;
newImpl = createUninitialized(realLength, data16);
Unicode::toUpper(data16, realLength, m_data16, m_length, &error);
if (error)
return this;
return newImpl.release();
}
PassRefPtr<StringImpl> StringImpl::secure(UChar character, LastCharacterBehavior behavior)
{
if (!m_length)
return this;
if (!(character & ~0x7F)) {
LChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
for (unsigned i = 0; i < m_length; ++i)
data[i] = character;
return newImpl.release();
}
UChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
unsigned lastCharacterIndex = m_length - 1;
for (unsigned i = 0; i < lastCharacterIndex; ++i)
data[i] = character;
data[lastCharacterIndex] = (behavior == ObscureLastCharacter) ? character : (is8Bit() ? m_data8[lastCharacterIndex] : m_data16[lastCharacterIndex]);
return newImpl.release();
}
PassRefPtr<StringImpl> StringImpl::foldCase()
{
if (m_length > static_cast<unsigned>(numeric_limits<int32_t>::max()))
CRASH();
int32_t length = m_length;
if (is8Bit()) {
LChar* data;
RefPtr <StringImpl>newImpl = createUninitialized(m_length, data);
LChar ored = 0;
for (int32_t i = 0; i < length; i++) {
LChar c = m_data8[i];
data[i] = toASCIILower(c);
ored |= c;
}
if (!(ored & ~0x7F))
return newImpl.release();
for (int32_t i = 0; i < length; i++)
data[i] = static_cast<LChar>(Unicode::toLower(m_data8[i]));
return newImpl.release();
}
UChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
UChar ored = 0;
for (int32_t i = 0; i < length; i++) {
UChar c = m_data16[i];
ored |= c;
data[i] = toASCIILower(c);
}
if (!(ored & ~0x7F))
return newImpl.release();
bool error;
int32_t realLength = Unicode::foldCase(data, length, m_data16, m_length, &error);
if (!error && realLength == length)
return newImpl.release();
newImpl = createUninitialized(realLength, data);
Unicode::foldCase(data, realLength, m_data16, m_length, &error);
if (error)
return this;
return newImpl.release();
}
template <class UCharPredicate>
inline PassRefPtr<StringImpl> StringImpl::stripMatchedCharacters(UCharPredicate predicate)
{
if (!m_length)
return empty();
unsigned start = 0;
unsigned end = m_length - 1;
while (start <= end && predicate(is8Bit() ? m_data8[start] : m_data16[start]))
start++;
if (start > end)
return empty();
while (end && predicate(is8Bit() ? m_data8[end] : m_data16[end]))
end--;
if (!start && end == m_length - 1)
return this;
if (is8Bit())
return create(m_data8 + start, end + 1 - start);
return create(m_data16 + start, end + 1 - start);
}
class UCharPredicate {
public:
inline UCharPredicate(CharacterMatchFunctionPtr function): m_function(function) { }
inline bool operator()(UChar ch) const
{
return m_function(ch);
}
private:
const CharacterMatchFunctionPtr m_function;
};
class SpaceOrNewlinePredicate {
public:
inline bool operator()(UChar ch) const
{
return isSpaceOrNewline(ch);
}
};
PassRefPtr<StringImpl> StringImpl::stripWhiteSpace()
{
return stripMatchedCharacters(SpaceOrNewlinePredicate());
}
PassRefPtr<StringImpl> StringImpl::stripWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace)
{
return stripMatchedCharacters(UCharPredicate(isWhiteSpace));
}
template <typename CharType>
ALWAYS_INLINE PassRefPtr<StringImpl> StringImpl::removeCharacters(const CharType* characters, CharacterMatchFunctionPtr findMatch)
{
const CharType* from = characters;
const CharType* fromend = from + m_length;
while (from != fromend && !findMatch(*from))
from++;
if (from == fromend)
return this;
StringBuffer<CharType> data(m_length);
CharType* to = data.characters();
unsigned outc = from - characters;
if (outc)
memcpy(to, characters, outc * sizeof(CharType));
while (true) {
while (from != fromend && findMatch(*from))
from++;
while (from != fromend && !findMatch(*from))
to[outc++] = *from++;
if (from == fromend)
break;
}
data.shrink(outc);
return adopt(data);
}
PassRefPtr<StringImpl> StringImpl::removeCharacters(CharacterMatchFunctionPtr findMatch)
{
if (is8Bit())
return removeCharacters(characters8(), findMatch);
return removeCharacters(characters16(), findMatch);
}
template <typename CharType, class UCharPredicate>
inline PassRefPtr<StringImpl> StringImpl::simplifyMatchedCharactersToSpace(UCharPredicate predicate)
{
StringBuffer<CharType> data(m_length);
const CharType* from = getCharacters<CharType>();
const CharType* fromend = from + m_length;
int outc = 0;
bool changedToSpace = false;
CharType* to = data.characters();
while (true) {
while (from != fromend && predicate(*from)) {
if (*from != ' ')
changedToSpace = true;
from++;
}
while (from != fromend && !predicate(*from))
to[outc++] = *from++;
if (from != fromend)
to[outc++] = ' ';
else
break;
}
if (outc > 0 && to[outc - 1] == ' ')
outc--;
if (static_cast<unsigned>(outc) == m_length && !changedToSpace)
return this;
data.shrink(outc);
return adopt(data);
}
PassRefPtr<StringImpl> StringImpl::simplifyWhiteSpace()
{
if (is8Bit())
return StringImpl::simplifyMatchedCharactersToSpace<LChar>(SpaceOrNewlinePredicate());
return StringImpl::simplifyMatchedCharactersToSpace<UChar>(SpaceOrNewlinePredicate());
}
PassRefPtr<StringImpl> StringImpl::simplifyWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace)
{
if (is8Bit())
return StringImpl::simplifyMatchedCharactersToSpace<LChar>(UCharPredicate(isWhiteSpace));
return StringImpl::simplifyMatchedCharactersToSpace<UChar>(UCharPredicate(isWhiteSpace));
}
int StringImpl::toIntStrict(bool* ok, int base)
{
if (is8Bit())
return charactersToIntStrict(characters8(), m_length, ok, base);
return charactersToIntStrict(characters16(), m_length, ok, base);
}
unsigned StringImpl::toUIntStrict(bool* ok, int base)
{
if (is8Bit())
return charactersToUIntStrict(characters8(), m_length, ok, base);
return charactersToUIntStrict(characters16(), m_length, ok, base);
}
int64_t StringImpl::toInt64Strict(bool* ok, int base)
{
if (is8Bit())
return charactersToInt64Strict(characters8(), m_length, ok, base);
return charactersToInt64Strict(characters16(), m_length, ok, base);
}
uint64_t StringImpl::toUInt64Strict(bool* ok, int base)
{
if (is8Bit())
return charactersToUInt64Strict(characters8(), m_length, ok, base);
return charactersToUInt64Strict(characters16(), m_length, ok, base);
}
intptr_t StringImpl::toIntPtrStrict(bool* ok, int base)
{
if (is8Bit())
return charactersToIntPtrStrict(characters8(), m_length, ok, base);
return charactersToIntPtrStrict(characters16(), m_length, ok, base);
}
int StringImpl::toInt(bool* ok)
{
if (is8Bit())
return charactersToInt(characters8(), m_length, ok);
return charactersToInt(characters16(), m_length, ok);
}
unsigned StringImpl::toUInt(bool* ok)
{
if (is8Bit())
return charactersToUInt(characters8(), m_length, ok);
return charactersToUInt(characters16(), m_length, ok);
}
int64_t StringImpl::toInt64(bool* ok)
{
if (is8Bit())
return charactersToInt64(characters8(), m_length, ok);
return charactersToInt64(characters16(), m_length, ok);
}
uint64_t StringImpl::toUInt64(bool* ok)
{
if (is8Bit())
return charactersToUInt64(characters8(), m_length, ok);
return charactersToUInt64(characters16(), m_length, ok);
}
intptr_t StringImpl::toIntPtr(bool* ok)
{
if (is8Bit())
return charactersToIntPtr(characters8(), m_length, ok);
return charactersToIntPtr(characters16(), m_length, ok);
}
double StringImpl::toDouble(bool* ok, bool* didReadNumber)
{
if (is8Bit())
return charactersToDouble(characters8(), m_length, ok, didReadNumber);
return charactersToDouble(characters16(), m_length, ok, didReadNumber);
}
float StringImpl::toFloat(bool* ok, bool* didReadNumber)
{
if (is8Bit())
return charactersToFloat(characters8(), m_length, ok, didReadNumber);
return charactersToFloat(characters16(), m_length, ok, didReadNumber);
}
bool equalIgnoringCase(const UChar* a, const LChar* b, unsigned length)
{
while (length--) {
LChar bc = *b++;
if (foldCase(*a++) != foldCase(bc))
return false;
}
return true;
}
static inline bool equalIgnoringCase(const UChar* a, const UChar* b, int length)
{
ASSERT(length >= 0);
return umemcasecmp(a, b, length) == 0;
}
int codePointCompare(const StringImpl* s1, const StringImpl* s2)
{
const unsigned l1 = s1 ? s1->length() : 0;
const unsigned l2 = s2 ? s2->length() : 0;
const unsigned lmin = l1 < l2 ? l1 : l2;
const UChar* c1 = s1 ? s1->characters() : 0;
const UChar* c2 = s2 ? s2->characters() : 0;
unsigned pos = 0;
while (pos < lmin && *c1 == *c2) {
c1++;
c2++;
pos++;
}
if (pos < lmin)
return (c1[0] > c2[0]) ? 1 : -1;
if (l1 == l2)
return 0;
return (l1 > l2) ? 1 : -1;
}
size_t StringImpl::find(UChar c, unsigned start)
{
if (is8Bit())
return WTF::find(characters8(), m_length, c, start);
return WTF::find(characters16(), m_length, c, start);
}
size_t StringImpl::find(CharacterMatchFunctionPtr matchFunction, unsigned start)
{
if (is8Bit())
return WTF::find(characters8(), m_length, matchFunction, start);
return WTF::find(characters16(), m_length, matchFunction, start);
}
size_t StringImpl::find(const LChar* matchString, unsigned index)
{
if (!matchString)
return notFound;
size_t matchStringLength = strlen(reinterpret_cast<const char*>(matchString));
if (matchStringLength > numeric_limits<unsigned>::max())
CRASH();
unsigned matchLength = matchStringLength;
if (!matchLength)
return min(index, length());
if (matchLength == 1)
return WTF::find(characters16(), length(), *matchString, index);
if (index > length())
return notFound;
unsigned searchLength = length() - index;
if (matchLength > searchLength)
return notFound;
unsigned delta = searchLength - matchLength;
const UChar* searchCharacters = characters() + index;
unsigned searchHash = 0;
unsigned matchHash = 0;
for (unsigned i = 0; i < matchLength; ++i) {
searchHash += searchCharacters[i];
matchHash += matchString[i];
}
unsigned i = 0;
while (searchHash != matchHash || !equal(searchCharacters + i, matchString, matchLength)) {
if (i == delta)
return notFound;
searchHash += searchCharacters[i + matchLength];
searchHash -= searchCharacters[i];
++i;
}
return index + i;
}
size_t StringImpl::findIgnoringCase(const LChar* matchString, unsigned index)
{
if (!matchString)
return notFound;
size_t matchStringLength = strlen(reinterpret_cast<const char*>(matchString));
if (matchStringLength > numeric_limits<unsigned>::max())
CRASH();
unsigned matchLength = matchStringLength;
if (!matchLength)
return min(index, length());
if (index > length())
return notFound;
unsigned searchLength = length() - index;
if (matchLength > searchLength)
return notFound;
unsigned delta = searchLength - matchLength;
const UChar* searchCharacters = characters() + index;
unsigned i = 0;
while (!equalIgnoringCase(searchCharacters + i, matchString, matchLength)) {
if (i == delta)
return notFound;
++i;
}
return index + i;
}
size_t StringImpl::find(StringImpl* matchString, unsigned index)
{
if (!matchString)
return notFound;
unsigned matchLength = matchString->length();
if (!matchLength)
return min(index, length());
if (matchLength == 1) {
if (is8Bit() && matchString->is8Bit())
return WTF::find(characters8(), length(), matchString->characters8()[0], index);
return WTF::find(characters(), length(), matchString->characters()[0], index);
}
if (index > length())
return notFound;
unsigned searchLength = length() - index;
if (matchLength > searchLength)
return notFound;
unsigned delta = searchLength - matchLength;
const UChar* searchCharacters = characters() + index;
const UChar* matchCharacters = matchString->characters();
unsigned searchHash = 0;
unsigned matchHash = 0;
for (unsigned i = 0; i < matchLength; ++i) {
searchHash += searchCharacters[i];
matchHash += matchCharacters[i];
}
unsigned i = 0;
while (searchHash != matchHash || memcmp(searchCharacters + i, matchCharacters, matchLength * sizeof(UChar))) {
if (i == delta)
return notFound;
searchHash += searchCharacters[i + matchLength];
searchHash -= searchCharacters[i];
++i;
}
return index + i;
}
size_t StringImpl::findIgnoringCase(StringImpl* matchString, unsigned index)
{
if (!matchString)
return notFound;
unsigned matchLength = matchString->length();
if (!matchLength)
return min(index, length());
if (index > length())
return notFound;
unsigned searchLength = length() - index;
if (matchLength > searchLength)
return notFound;
unsigned delta = searchLength - matchLength;
const UChar* searchCharacters = characters() + index;
const UChar* matchCharacters = matchString->characters();
unsigned i = 0;
while (!equalIgnoringCase(searchCharacters + i, matchCharacters, matchLength)) {
if (i == delta)
return notFound;
++i;
}
return index + i;
}
size_t StringImpl::reverseFind(UChar c, unsigned index)
{
if (is8Bit())
return WTF::reverseFind(characters8(), m_length, c, index);
return WTF::reverseFind(characters16(), m_length, c, index);
}
size_t StringImpl::reverseFind(StringImpl* matchString, unsigned index)
{
if (!matchString)
return notFound;
unsigned matchLength = matchString->length();
if (!matchLength)
return min(index, length());
if (matchLength == 1) {
if (is8Bit() && matchString->is8Bit())
return WTF::reverseFind(characters8(), length(), matchString->characters8()[0], index);
return WTF::reverseFind(characters(), length(), matchString->characters()[0], index);
}
if (matchLength > length())
return notFound;
unsigned delta = min(index, length() - matchLength);
const UChar *searchCharacters = characters();
const UChar *matchCharacters = matchString->characters();
unsigned searchHash = 0;
unsigned matchHash = 0;
for (unsigned i = 0; i < matchLength; ++i) {
searchHash += searchCharacters[delta + i];
matchHash += matchCharacters[i];
}
while (searchHash != matchHash || memcmp(searchCharacters + delta, matchCharacters, matchLength * sizeof(UChar))) {
if (!delta)
return notFound;
delta--;
searchHash -= searchCharacters[delta + matchLength];
searchHash += searchCharacters[delta];
}
return delta;
}
size_t StringImpl::reverseFindIgnoringCase(StringImpl* matchString, unsigned index)
{
if (!matchString)
return notFound;
unsigned matchLength = matchString->length();
if (!matchLength)
return min(index, length());
if (matchLength > length())
return notFound;
unsigned delta = min(index, length() - matchLength);
const UChar *searchCharacters = characters();
const UChar *matchCharacters = matchString->characters();
while (!equalIgnoringCase(searchCharacters + delta, matchCharacters, matchLength)) {
if (!delta)
return notFound;
delta--;
}
return delta;
}
bool StringImpl::endsWith(StringImpl* matchString, bool caseSensitive)
{
ASSERT(matchString);
if (m_length >= matchString->m_length) {
unsigned start = m_length - matchString->m_length;
return (caseSensitive ? find(matchString, start) : findIgnoringCase(matchString, start)) == start;
}
return false;
}
PassRefPtr<StringImpl> StringImpl::replace(UChar oldC, UChar newC)
{
if (oldC == newC)
return this;
unsigned i;
for (i = 0; i != m_length; ++i) {
UChar c = is8Bit() ? m_data8[i] : m_data16[i];
if (c == oldC)
break;
}
if (i == m_length)
return this;
if (is8Bit()) {
if (oldC > 0xff)
return this;
if (newC <= 0xff) {
LChar* data;
LChar oldChar = static_cast<LChar>(oldC);
LChar newChar = static_cast<LChar>(newC);
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
for (i = 0; i != m_length; ++i) {
LChar ch = m_data8[i];
if (ch == oldChar)
ch = newChar;
data[i] = ch;
}
return newImpl.release();
}
UChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
for (i = 0; i != m_length; ++i) {
UChar ch = m_data8[i];
if (ch == oldC)
ch = newC;
data[i] = ch;
}
return newImpl.release();
}
UChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
for (i = 0; i != m_length; ++i) {
UChar ch = m_data16[i];
if (ch == oldC)
ch = newC;
data[i] = ch;
}
return newImpl.release();
}
PassRefPtr<StringImpl> StringImpl::replace(unsigned position, unsigned lengthToReplace, StringImpl* str)
{
position = min(position, length());
lengthToReplace = min(lengthToReplace, length() - position);
unsigned lengthToInsert = str ? str->length() : 0;
if (!lengthToReplace && !lengthToInsert)
return this;
if ((length() - lengthToReplace) >= (numeric_limits<unsigned>::max() - lengthToInsert))
CRASH();
if (is8Bit() && (!str || str->is8Bit())) {
LChar* data;
RefPtr<StringImpl> newImpl =
createUninitialized(length() - lengthToReplace + lengthToInsert, data);
memcpy(data, m_data8, position * sizeof(LChar));
if (str)
memcpy(data + position, str->m_data8, lengthToInsert * sizeof(LChar));
memcpy(data + position + lengthToInsert, m_data8 + position + lengthToReplace,
(length() - position - lengthToReplace) * sizeof(LChar));
return newImpl.release();
}
UChar* data;
RefPtr<StringImpl> newImpl =
createUninitialized(length() - lengthToReplace + lengthToInsert, data);
if (is8Bit())
for (unsigned i = 0; i < position; i++)
data[i] = m_data8[i];
else
memcpy(data, m_data16, position * sizeof(UChar));
if (str) {
if (str->is8Bit())
for (unsigned i = 0; i < lengthToInsert; i++)
data[i + position] = str->m_data8[i];
else
memcpy(data + position, str->m_data16, lengthToInsert * sizeof(UChar));
}
if (is8Bit()) {
for (unsigned i = 0; i < length() - position - lengthToReplace; i++)
data[i + position + lengthToInsert] = m_data8[i + position + lengthToReplace];
} else {
memcpy(data + position + lengthToInsert, characters() + position + lengthToReplace,
(length() - position - lengthToReplace) * sizeof(UChar));
}
return newImpl.release();
}
PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, StringImpl* replacement)
{
if (!replacement)
return this;
unsigned repStrLength = replacement->length();
size_t srcSegmentStart = 0;
unsigned matchCount = 0;
while ((srcSegmentStart = find(pattern, srcSegmentStart)) != notFound) {
++matchCount;
++srcSegmentStart;
}
if (!matchCount)
return this;
if (repStrLength && matchCount > numeric_limits<unsigned>::max() / repStrLength)
CRASH();
unsigned replaceSize = matchCount * repStrLength;
unsigned newSize = m_length - matchCount;
if (newSize >= (numeric_limits<unsigned>::max() - replaceSize))
CRASH();
newSize += replaceSize;
size_t srcSegmentEnd;
unsigned srcSegmentLength;
srcSegmentStart = 0;
unsigned dstOffset = 0;
bool srcIs8Bit = is8Bit();
bool replacementIs8Bit = replacement->is8Bit();
if (srcIs8Bit && replacementIs8Bit) {
LChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
srcSegmentLength = srcSegmentEnd - srcSegmentStart;
memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
dstOffset += srcSegmentLength;
memcpy(data + dstOffset, replacement->m_data8, repStrLength * sizeof(LChar));
dstOffset += repStrLength;
srcSegmentStart = srcSegmentEnd + 1;
}
srcSegmentLength = m_length - srcSegmentStart;
memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
ASSERT(dstOffset + srcSegmentLength == newImpl->length());
return newImpl.release();
}
UChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
srcSegmentLength = srcSegmentEnd - srcSegmentStart;
if (srcIs8Bit) {
for (unsigned i = 0; i < srcSegmentLength; i++)
data[i + dstOffset] = m_data8[i + srcSegmentStart];
} else {
memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
}
dstOffset += srcSegmentLength;
if (replacementIs8Bit) {
for (unsigned i = 0; i < repStrLength; i++)
data[i + dstOffset] = replacement->m_data8[i];
} else {
memcpy(data + dstOffset, replacement->m_data16, repStrLength * sizeof(UChar));
}
dstOffset += repStrLength;
srcSegmentStart = srcSegmentEnd + 1;
}
srcSegmentLength = m_length - srcSegmentStart;
if (srcIs8Bit) {
for (unsigned i = 0; i < srcSegmentLength; i++)
data[i + dstOffset] = m_data8[i + srcSegmentStart];
} else {
memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
}
ASSERT(dstOffset + srcSegmentLength == newImpl->length());
return newImpl.release();
}
PassRefPtr<StringImpl> StringImpl::replace(StringImpl* pattern, StringImpl* replacement)
{
if (!pattern || !replacement)
return this;
unsigned patternLength = pattern->length();
if (!patternLength)
return this;
unsigned repStrLength = replacement->length();
size_t srcSegmentStart = 0;
unsigned matchCount = 0;
while ((srcSegmentStart = find(pattern, srcSegmentStart)) != notFound) {
++matchCount;
srcSegmentStart += patternLength;
}
if (!matchCount)
return this;
unsigned newSize = m_length - matchCount * patternLength;
if (repStrLength && matchCount > numeric_limits<unsigned>::max() / repStrLength)
CRASH();
if (newSize > (numeric_limits<unsigned>::max() - matchCount * repStrLength))
CRASH();
newSize += matchCount * repStrLength;
size_t srcSegmentEnd;
unsigned srcSegmentLength;
srcSegmentStart = 0;
unsigned dstOffset = 0;
bool srcIs8Bit = is8Bit();
bool replacementIs8Bit = replacement->is8Bit();
if (srcIs8Bit && replacementIs8Bit) {
LChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
srcSegmentLength = srcSegmentEnd - srcSegmentStart;
memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
dstOffset += srcSegmentLength;
memcpy(data + dstOffset, replacement->m_data8, repStrLength * sizeof(LChar));
dstOffset += repStrLength;
srcSegmentStart = srcSegmentEnd + patternLength;
}
srcSegmentLength = m_length - srcSegmentStart;
memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
ASSERT(dstOffset + srcSegmentLength == newImpl->length());
return newImpl.release();
}
UChar* data;
RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
srcSegmentLength = srcSegmentEnd - srcSegmentStart;
if (srcIs8Bit) {
for (unsigned i = 0; i < srcSegmentLength; i++)
data[i + dstOffset] = m_data8[i + srcSegmentStart];
} else {
memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
}
dstOffset += srcSegmentLength;
if (replacementIs8Bit) {
for (unsigned i = 0; i < repStrLength; i++)
data[i + dstOffset] = replacement->m_data8[i];
} else {
memcpy(data + dstOffset, replacement->m_data16, repStrLength * sizeof(UChar));
}
dstOffset += repStrLength;
srcSegmentStart = srcSegmentEnd + patternLength;
}
srcSegmentLength = m_length - srcSegmentStart;
if (srcIs8Bit) {
for (unsigned i = 0; i < srcSegmentLength; i++)
data[i + dstOffset] = m_data8[i + srcSegmentStart];
} else {
memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
}
ASSERT(dstOffset + srcSegmentLength == newImpl->length());
return newImpl.release();
}
bool equal(const StringImpl* a, const StringImpl* b)
{
return StringHash::equal(a, b);
}
bool equal(const StringImpl* a, const LChar* b, unsigned length)
{
if (!a)
return !b;
if (!b)
return !a;
if (length != a->length())
return false;
if (a->is8Bit())
return equal(a->characters8(), b, length);
return equal(a->characters16(), b, length);
}
bool equal(const StringImpl* a, const LChar* b)
{
if (!a)
return !b;
if (!b)
return !a;
unsigned length = a->length();
if (a->is8Bit()) {
const LChar* aPtr = a->characters8();
for (unsigned i = 0; i != length; ++i) {
LChar bc = b[i];
LChar ac = aPtr[i];
if (!bc)
return false;
if (ac != bc)
return false;
}
return !b[length];
}
const UChar* aPtr = a->characters16();
for (unsigned i = 0; i != length; ++i) {
LChar bc = b[i];
if (!bc)
return false;
if (aPtr[i] != bc)
return false;
}
return !b[length];
}
bool equal(const StringImpl* a, const UChar* b, unsigned length)
{
if (!a)
return !b;
if (!b)
return false;
if (a->length() != length)
return false;
if (a->is8Bit())
return equal(a->characters8(), b, length);
return equal(a->characters16(), b, length);
}
bool equalIgnoringCase(StringImpl* a, StringImpl* b)
{
return CaseFoldingHash::equal(a, b);
}
bool equalIgnoringCase(StringImpl* a, const LChar* b)
{
if (!a)
return !b;
if (!b)
return !a;
unsigned length = a->length();
UChar ored = 0;
bool equal = true;
if (a->is8Bit()) {
const LChar* as = a->characters8();
for (unsigned i = 0; i != length; ++i) {
LChar bc = b[i];
if (!bc)
return false;
UChar ac = as[i];
ored |= ac;
equal = equal && (toASCIILower(ac) == toASCIILower(bc));
}
if (ored & ~0x7F) {
equal = true;
for (unsigned i = 0; i != length; ++i)
equal = equal && (foldCase(as[i]) == foldCase(b[i]));
}
return equal && !b[length];
}
const UChar* as = a->characters16();
for (unsigned i = 0; i != length; ++i) {
LChar bc = b[i];
if (!bc)
return false;
UChar ac = as[i];
ored |= ac;
equal = equal && (toASCIILower(ac) == toASCIILower(bc));
}
if (ored & ~0x7F) {
equal = true;
for (unsigned i = 0; i != length; ++i) {
equal = equal && (foldCase(as[i]) == foldCase(b[i]));
}
}
return equal && !b[length];
}
bool equalIgnoringNullity(StringImpl* a, StringImpl* b)
{
if (StringHash::equal(a, b))
return true;
if (!a && b && !b->length())
return true;
if (!b && a && !a->length())
return true;
return false;
}
WTF::Unicode::Direction StringImpl::defaultWritingDirection(bool* hasStrongDirectionality)
{
for (unsigned i = 0; i < m_length; ++i) {
WTF::Unicode::Direction charDirection = WTF::Unicode::direction(is8Bit() ? m_data8[i] : m_data16[i]);
if (charDirection == WTF::Unicode::LeftToRight) {
if (hasStrongDirectionality)
*hasStrongDirectionality = true;
return WTF::Unicode::LeftToRight;
}
if (charDirection == WTF::Unicode::RightToLeft || charDirection == WTF::Unicode::RightToLeftArabic) {
if (hasStrongDirectionality)
*hasStrongDirectionality = true;
return WTF::Unicode::RightToLeft;
}
}
if (hasStrongDirectionality)
*hasStrongDirectionality = false;
return WTF::Unicode::LeftToRight;
}
PassRefPtr<StringImpl> StringImpl::adopt(StringBuffer<LChar>& buffer)
{
unsigned length = buffer.length();
if (!length)
return empty();
return adoptRef(new StringImpl(buffer.release(), length));
}
PassRefPtr<StringImpl> StringImpl::adopt(StringBuffer<UChar>& buffer)
{
unsigned length = buffer.length();
if (!length)
return empty();
return adoptRef(new StringImpl(buffer.release(), length));
}
PassRefPtr<StringImpl> StringImpl::createWithTerminatingNullCharacter(const StringImpl& string)
{
unsigned length = string.m_length;
if (length >= numeric_limits<unsigned>::max())
CRASH();
RefPtr<StringImpl> terminatedString;
if (string.is8Bit()) {
LChar* data;
terminatedString = createUninitialized(length + 1, data);
memcpy(data, string.m_data8, length * sizeof(LChar));
data[length] = 0;
} else {
UChar* data;
terminatedString = createUninitialized(length + 1, data);
memcpy(data, string.m_data16, length * sizeof(UChar));
data[length] = 0;
}
terminatedString->m_length--;
terminatedString->m_hashAndFlags = (string.m_hashAndFlags & (~s_flagMask | s_hashFlag8BitBuffer)) | s_hashFlagHasTerminatingNullCharacter;
return terminatedString.release();
}
}