| /* | |
| * (C) 1999 Lars Knoll (knoll@kde.org) | |
| * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2012 Apple Inc. All rights reserved. | |
| * Copyright (C) 2007-2009 Torch Mobile, Inc. | |
| * | |
| * 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. | |
| */ | |
| #include "config.h" | |
| #include "WTFString.h" | |
| #include "IntegerToStringConversion.h" | |
| #include <stdarg.h> | |
| #include <wtf/ASCIICType.h> | |
| #include <wtf/DataLog.h> | |
| #include <wtf/HexNumber.h> | |
| #include <wtf/MathExtras.h> | |
| #include <wtf/text/CString.h> | |
| #include <wtf/StringExtras.h> | |
| #include <wtf/Vector.h> | |
| #include <wtf/dtoa.h> | |
| #include <wtf/unicode/CharacterNames.h> | |
| #include <wtf/unicode/UTF8.h> | |
| #include <wtf/unicode/Unicode.h> | |
| using namespace std; | |
| namespace WTF { | |
| using namespace Unicode; | |
| using namespace std; | |
| // Construct a string with UTF-16 data. | |
| String::String(const UChar* characters, unsigned length) | |
| : m_impl(characters ? StringImpl::create(characters, length) : 0) | |
| { | |
| } | |
| // Construct a string with UTF-16 data, from a null-terminated source. | |
| String::String(const UChar* str) | |
| { | |
| if (!str) | |
| return; | |
| size_t len = 0; | |
| while (str[len] != UChar(0)) | |
| ++len; | |
| if (len > numeric_limits<unsigned>::max()) | |
| CRASH(); | |
| m_impl = StringImpl::create(str, len); | |
| } | |
| // Construct a string with latin1 data. | |
| String::String(const LChar* characters, unsigned length) | |
| : m_impl(characters ? StringImpl::create(characters, length) : 0) | |
| { | |
| } | |
| String::String(const char* characters, unsigned length) | |
| : m_impl(characters ? StringImpl::create(reinterpret_cast<const LChar*>(characters), length) : 0) | |
| { | |
| } | |
| // Construct a string with latin1 data, from a null-terminated source. | |
| String::String(const LChar* characters) | |
| : m_impl(characters ? StringImpl::create(characters) : 0) | |
| { | |
| } | |
| String::String(const char* characters) | |
| : m_impl(characters ? StringImpl::create(reinterpret_cast<const LChar*>(characters)) : 0) | |
| { | |
| } | |
| String::String(ASCIILiteral characters) | |
| : m_impl(StringImpl::createFromLiteral(characters)) | |
| { | |
| } | |
| void String::append(const String& str) | |
| { | |
| if (str.isEmpty()) | |
| return; | |
| // FIXME: This is extremely inefficient. So much so that we might want to take this | |
| // out of String's API. We can make it better by optimizing the case where exactly | |
| // one String is pointing at this StringImpl, but even then it's going to require a | |
| // call to fastMalloc every single time. | |
| if (str.m_impl) { | |
| if (m_impl) { | |
| if (m_impl->is8Bit() && str.m_impl->is8Bit()) { | |
| LChar* data; | |
| if (str.length() > numeric_limits<unsigned>::max() - m_impl->length()) | |
| CRASH(); | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + str.length(), data); | |
| memcpy(data, m_impl->characters8(), m_impl->length() * sizeof(LChar)); | |
| memcpy(data + m_impl->length(), str.characters8(), str.length() * sizeof(LChar)); | |
| m_impl = newImpl.release(); | |
| return; | |
| } | |
| UChar* data; | |
| if (str.length() > numeric_limits<unsigned>::max() - m_impl->length()) | |
| CRASH(); | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + str.length(), data); | |
| memcpy(data, m_impl->characters(), m_impl->length() * sizeof(UChar)); | |
| memcpy(data + m_impl->length(), str.characters(), str.length() * sizeof(UChar)); | |
| m_impl = newImpl.release(); | |
| } else | |
| m_impl = str.m_impl; | |
| } | |
| } | |
| void String::append(LChar c) | |
| { | |
| // FIXME: This is extremely inefficient. So much so that we might want to take this | |
| // out of String's API. We can make it better by optimizing the case where exactly | |
| // one String is pointing at this StringImpl, but even then it's going to require a | |
| // call to fastMalloc every single time. | |
| if (m_impl) { | |
| UChar* data; | |
| if (m_impl->length() >= numeric_limits<unsigned>::max()) | |
| CRASH(); | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + 1, data); | |
| memcpy(data, m_impl->characters(), m_impl->length() * sizeof(UChar)); | |
| data[m_impl->length()] = c; | |
| m_impl = newImpl.release(); | |
| } else | |
| m_impl = StringImpl::create(&c, 1); | |
| } | |
| void String::append(UChar c) | |
| { | |
| // FIXME: This is extremely inefficient. So much so that we might want to take this | |
| // out of String's API. We can make it better by optimizing the case where exactly | |
| // one String is pointing at this StringImpl, but even then it's going to require a | |
| // call to fastMalloc every single time. | |
| if (m_impl) { | |
| UChar* data; | |
| if (m_impl->length() >= numeric_limits<unsigned>::max()) | |
| CRASH(); | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + 1, data); | |
| memcpy(data, m_impl->characters(), m_impl->length() * sizeof(UChar)); | |
| data[m_impl->length()] = c; | |
| m_impl = newImpl.release(); | |
| } else | |
| m_impl = StringImpl::create(&c, 1); | |
| } | |
| int codePointCompare(const String& a, const String& b) | |
| { | |
| return codePointCompare(a.impl(), b.impl()); | |
| } | |
| void String::insert(const String& str, unsigned pos) | |
| { | |
| if (str.isEmpty()) { | |
| if (str.isNull()) | |
| return; | |
| if (isNull()) | |
| m_impl = str.impl(); | |
| return; | |
| } | |
| insert(str.characters(), str.length(), pos); | |
| } | |
| void String::append(const LChar* charactersToAppend, unsigned lengthToAppend) | |
| { | |
| if (!m_impl) { | |
| if (!charactersToAppend) | |
| return; | |
| m_impl = StringImpl::create(charactersToAppend, lengthToAppend); | |
| return; | |
| } | |
| if (!lengthToAppend) | |
| return; | |
| ASSERT(charactersToAppend); | |
| unsigned strLength = m_impl->length(); | |
| if (m_impl->is8Bit()) { | |
| if (lengthToAppend > numeric_limits<unsigned>::max() - strLength) | |
| CRASH(); | |
| LChar* data; | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data); | |
| StringImpl::copyChars(data, m_impl->characters8(), strLength); | |
| StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend); | |
| m_impl = newImpl.release(); | |
| return; | |
| } | |
| if (lengthToAppend > numeric_limits<unsigned>::max() - strLength) | |
| CRASH(); | |
| UChar* data; | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() + lengthToAppend, data); | |
| StringImpl::copyChars(data, m_impl->characters16(), strLength); | |
| StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend); | |
| m_impl = newImpl.release(); | |
| } | |
| void String::append(const UChar* charactersToAppend, unsigned lengthToAppend) | |
| { | |
| if (!m_impl) { | |
| if (!charactersToAppend) | |
| return; | |
| m_impl = StringImpl::create(charactersToAppend, lengthToAppend); | |
| return; | |
| } | |
| if (!lengthToAppend) | |
| return; | |
| unsigned strLength = m_impl->length(); | |
| ASSERT(charactersToAppend); | |
| if (lengthToAppend > numeric_limits<unsigned>::max() - strLength) | |
| CRASH(); | |
| UChar* data; | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data); | |
| if (m_impl->is8Bit()) | |
| StringImpl::copyChars(data, characters8(), strLength); | |
| else | |
| StringImpl::copyChars(data, characters16(), strLength); | |
| StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend); | |
| m_impl = newImpl.release(); | |
| } | |
| void String::insert(const UChar* charactersToInsert, unsigned lengthToInsert, unsigned position) | |
| { | |
| if (position >= length()) { | |
| append(charactersToInsert, lengthToInsert); | |
| return; | |
| } | |
| ASSERT(m_impl); | |
| if (!lengthToInsert) | |
| return; | |
| ASSERT(charactersToInsert); | |
| UChar* data; | |
| if (lengthToInsert > numeric_limits<unsigned>::max() - length()) | |
| CRASH(); | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() + lengthToInsert, data); | |
| memcpy(data, characters(), position * sizeof(UChar)); | |
| memcpy(data + position, charactersToInsert, lengthToInsert * sizeof(UChar)); | |
| memcpy(data + position + lengthToInsert, characters() + position, (length() - position) * sizeof(UChar)); | |
| m_impl = newImpl.release(); | |
| } | |
| UChar32 String::characterStartingAt(unsigned i) const | |
| { | |
| if (!m_impl || i >= m_impl->length()) | |
| return 0; | |
| return m_impl->characterStartingAt(i); | |
| } | |
| void String::truncate(unsigned position) | |
| { | |
| if (position >= length()) | |
| return; | |
| UChar* data; | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(position, data); | |
| memcpy(data, characters(), position * sizeof(UChar)); | |
| m_impl = newImpl.release(); | |
| } | |
| template <typename CharacterType> | |
| inline void String::removeInternal(const CharacterType* characters, unsigned position, int lengthToRemove) | |
| { | |
| CharacterType* data; | |
| RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() - lengthToRemove, data); | |
| memcpy(data, characters, position * sizeof(CharacterType)); | |
| memcpy(data + position, characters + position + lengthToRemove, | |
| (length() - lengthToRemove - position) * sizeof(CharacterType)); | |
| m_impl = newImpl.release(); | |
| } | |
| void String::remove(unsigned position, int lengthToRemove) | |
| { | |
| if (lengthToRemove <= 0) | |
| return; | |
| if (position >= length()) | |
| return; | |
| if (static_cast<unsigned>(lengthToRemove) > length() - position) | |
| lengthToRemove = length() - position; | |
| if (is8Bit()) { | |
| removeInternal(characters8(), position, lengthToRemove); | |
| return; | |
| } | |
| removeInternal(characters16(), position, lengthToRemove); | |
| } | |
| String String::substring(unsigned pos, unsigned len) const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->substring(pos, len); | |
| } | |
| String String::substringSharingImpl(unsigned offset, unsigned length) const | |
| { | |
| // FIXME: We used to check against a limit of Heap::minExtraCost / sizeof(UChar). | |
| unsigned stringLength = this->length(); | |
| offset = min(offset, stringLength); | |
| length = min(length, stringLength - offset); | |
| if (!offset && length == stringLength) | |
| return *this; | |
| return String(StringImpl::create(m_impl, offset, length)); | |
| } | |
| String String::lower() const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->lower(); | |
| } | |
| String String::upper() const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->upper(); | |
| } | |
| String String::stripWhiteSpace() const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->stripWhiteSpace(); | |
| } | |
| String String::stripWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->stripWhiteSpace(isWhiteSpace); | |
| } | |
| String String::simplifyWhiteSpace() const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->simplifyWhiteSpace(); | |
| } | |
| String String::simplifyWhiteSpace(IsWhiteSpaceFunctionPtr isWhiteSpace) const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->simplifyWhiteSpace(isWhiteSpace); | |
| } | |
| String String::removeCharacters(CharacterMatchFunctionPtr findMatch) const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->removeCharacters(findMatch); | |
| } | |
| String String::foldCase() const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->foldCase(); | |
| } | |
| bool String::percentage(int& result) const | |
| { | |
| if (!m_impl || !m_impl->length()) | |
| return false; | |
| if ((*m_impl)[m_impl->length() - 1] != '%') | |
| return false; | |
| result = charactersToIntStrict(m_impl->characters(), m_impl->length() - 1); | |
| return true; | |
| } | |
| const UChar* String::charactersWithNullTermination() | |
| { | |
| if (!m_impl) | |
| return 0; | |
| if (m_impl->hasTerminatingNullCharacter()) | |
| return m_impl->characters(); | |
| m_impl = StringImpl::createWithTerminatingNullCharacter(*m_impl); | |
| return m_impl->characters(); | |
| } | |
| String String::format(const char *format, ...) | |
| { | |
| #if PLATFORM(QT) | |
| // Use QString::vsprintf to avoid the locale dependent formatting of vsnprintf. | |
| // https://bugs.webkit.org/show_bug.cgi?id=18994 | |
| va_list args; | |
| va_start(args, format); | |
| QString buffer; | |
| buffer.vsprintf(format, args); | |
| va_end(args); | |
| QByteArray ba = buffer.toUtf8(); | |
| return StringImpl::create(reinterpret_cast<const LChar*>(ba.constData()), ba.length()); | |
| #elif OS(WINCE) | |
| va_list args; | |
| va_start(args, format); | |
| Vector<char, 256> buffer; | |
| int bufferSize = 256; | |
| buffer.resize(bufferSize); | |
| for (;;) { | |
| int written = vsnprintf(buffer.data(), bufferSize, format, args); | |
| va_end(args); | |
| if (written == 0) | |
| return String(""); | |
| if (written > 0) | |
| return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), written); | |
| bufferSize <<= 1; | |
| buffer.resize(bufferSize); | |
| va_start(args, format); | |
| } | |
| #else | |
| va_list args; | |
| va_start(args, format); | |
| Vector<char, 256> buffer; | |
| // Do the format once to get the length. | |
| #if COMPILER(MSVC) | |
| int result = _vscprintf(format, args); | |
| #else | |
| char ch; | |
| int result = vsnprintf(&ch, 1, format, args); | |
| // We need to call va_end() and then va_start() again here, as the | |
| // contents of args is undefined after the call to vsnprintf | |
| // according to http://man.cx/snprintf(3) | |
| // | |
| // Not calling va_end/va_start here happens to work on lots of | |
| // systems, but fails e.g. on 64bit Linux. | |
| va_end(args); | |
| va_start(args, format); | |
| #endif | |
| if (result == 0) | |
| return String(""); | |
| if (result < 0) | |
| return String(); | |
| unsigned len = result; | |
| buffer.grow(len + 1); | |
| // Now do the formatting again, guaranteed to fit. | |
| vsnprintf(buffer.data(), buffer.size(), format, args); | |
| va_end(args); | |
| return StringImpl::create(reinterpret_cast<const LChar*>(buffer.data()), len); | |
| #endif | |
| } | |
| String String::number(int number) | |
| { | |
| return numberToStringSigned<String>(number); | |
| } | |
| String String::number(unsigned int number) | |
| { | |
| return numberToStringUnsigned<String>(number); | |
| } | |
| String String::number(long number) | |
| { | |
| return numberToStringSigned<String>(number); | |
| } | |
| String String::number(unsigned long number) | |
| { | |
| return numberToStringUnsigned<String>(number); | |
| } | |
| String String::number(long long number) | |
| { | |
| return numberToStringSigned<String>(number); | |
| } | |
| String String::number(unsigned long long number) | |
| { | |
| return numberToStringUnsigned<String>(number); | |
| } | |
| String String::number(double number, unsigned precision, TrailingZerosTruncatingPolicy trailingZerosTruncatingPolicy) | |
| { | |
| NumberToStringBuffer buffer; | |
| return String(numberToFixedPrecisionString(number, precision, buffer, trailingZerosTruncatingPolicy == TruncateTrailingZeros)); | |
| } | |
| String String::numberToStringECMAScript(double number) | |
| { | |
| NumberToStringBuffer buffer; | |
| return String(numberToString(number, buffer)); | |
| } | |
| String String::numberToStringFixedWidth(double number, unsigned decimalPlaces) | |
| { | |
| NumberToStringBuffer buffer; | |
| return String(numberToFixedWidthString(number, decimalPlaces, buffer)); | |
| } | |
| int String::toIntStrict(bool* ok, int base) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toIntStrict(ok, base); | |
| } | |
| unsigned String::toUIntStrict(bool* ok, int base) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toUIntStrict(ok, base); | |
| } | |
| int64_t String::toInt64Strict(bool* ok, int base) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toInt64Strict(ok, base); | |
| } | |
| uint64_t String::toUInt64Strict(bool* ok, int base) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toUInt64Strict(ok, base); | |
| } | |
| intptr_t String::toIntPtrStrict(bool* ok, int base) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toIntPtrStrict(ok, base); | |
| } | |
| int String::toInt(bool* ok) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toInt(ok); | |
| } | |
| unsigned String::toUInt(bool* ok) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toUInt(ok); | |
| } | |
| int64_t String::toInt64(bool* ok) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toInt64(ok); | |
| } | |
| uint64_t String::toUInt64(bool* ok) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toUInt64(ok); | |
| } | |
| intptr_t String::toIntPtr(bool* ok) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0; | |
| } | |
| return m_impl->toIntPtr(ok); | |
| } | |
| double String::toDouble(bool* ok) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0.0; | |
| } | |
| return m_impl->toDouble(ok); | |
| } | |
| float String::toFloat(bool* ok) const | |
| { | |
| if (!m_impl) { | |
| if (ok) | |
| *ok = false; | |
| return 0.0f; | |
| } | |
| return m_impl->toFloat(ok); | |
| } | |
| String String::isolatedCopy() const | |
| { | |
| if (!m_impl) | |
| return String(); | |
| return m_impl->isolatedCopy(); | |
| } | |
| void String::split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const | |
| { | |
| result.clear(); | |
| unsigned startPos = 0; | |
| size_t endPos; | |
| while ((endPos = find(separator, startPos)) != notFound) { | |
| if (allowEmptyEntries || startPos != endPos) | |
| result.append(substring(startPos, endPos - startPos)); | |
| startPos = endPos + separator.length(); | |
| } | |
| if (allowEmptyEntries || startPos != length()) | |
| result.append(substring(startPos)); | |
| } | |
| void String::split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const | |
| { | |
| result.clear(); | |
| unsigned startPos = 0; | |
| size_t endPos; | |
| while ((endPos = find(separator, startPos)) != notFound) { | |
| if (allowEmptyEntries || startPos != endPos) | |
| result.append(substring(startPos, endPos - startPos)); | |
| startPos = endPos + 1; | |
| } | |
| if (allowEmptyEntries || startPos != length()) | |
| result.append(substring(startPos)); | |
| } | |
| CString String::ascii() const | |
| { | |
| // Printable ASCII characters 32..127 and the null character are | |
| // preserved, characters outside of this range are converted to '?'. | |
| unsigned length = this->length(); | |
| if (!length) { | |
| char* characterBuffer; | |
| return CString::newUninitialized(length, characterBuffer); | |
| } | |
| if (this->is8Bit()) { | |
| const LChar* characters = this->characters8(); | |
| char* characterBuffer; | |
| CString result = CString::newUninitialized(length, characterBuffer); | |
| for (unsigned i = 0; i < length; ++i) { | |
| LChar ch = characters[i]; | |
| characterBuffer[i] = ch && (ch < 0x20 || ch > 0x7f) ? '?' : ch; | |
| } | |
| return result; | |
| } | |
| const UChar* characters = this->characters16(); | |
| char* characterBuffer; | |
| CString result = CString::newUninitialized(length, characterBuffer); | |
| for (unsigned i = 0; i < length; ++i) { | |
| UChar ch = characters[i]; | |
| characterBuffer[i] = ch && (ch < 0x20 || ch > 0x7f) ? '?' : ch; | |
| } | |
| return result; | |
| } | |
| CString String::latin1() const | |
| { | |
| // Basic Latin1 (ISO) encoding - Unicode characters 0..255 are | |
| // preserved, characters outside of this range are converted to '?'. | |
| unsigned length = this->length(); | |
| if (!length) | |
| return CString("", 0); | |
| if (is8Bit()) | |
| return CString(reinterpret_cast<const char*>(this->characters8()), length); | |
| const UChar* characters = this->characters16(); | |
| char* characterBuffer; | |
| CString result = CString::newUninitialized(length, characterBuffer); | |
| for (unsigned i = 0; i < length; ++i) { | |
| UChar ch = characters[i]; | |
| characterBuffer[i] = ch > 0xff ? '?' : ch; | |
| } | |
| return result; | |
| } | |
| // Helper to write a three-byte UTF-8 code point to the buffer, caller must check room is available. | |
| static inline void putUTF8Triple(char*& buffer, UChar ch) | |
| { | |
| ASSERT(ch >= 0x0800); | |
| *buffer++ = static_cast<char>(((ch >> 12) & 0x0F) | 0xE0); | |
| *buffer++ = static_cast<char>(((ch >> 6) & 0x3F) | 0x80); | |
| *buffer++ = static_cast<char>((ch & 0x3F) | 0x80); | |
| } | |
| CString String::utf8(ConversionMode mode) const | |
| { | |
| unsigned length = this->length(); | |
| if (!length) | |
| return CString("", 0); | |
| // Allocate a buffer big enough to hold all the characters | |
| // (an individual UTF-16 UChar can only expand to 3 UTF-8 bytes). | |
| // Optimization ideas, if we find this function is hot: | |
| // * We could speculatively create a CStringBuffer to contain 'length' | |
| // characters, and resize if necessary (i.e. if the buffer contains | |
| // non-ascii characters). (Alternatively, scan the buffer first for | |
| // ascii characters, so we know this will be sufficient). | |
| // * We could allocate a CStringBuffer with an appropriate size to | |
| // have a good chance of being able to write the string into the | |
| // buffer without reallocing (say, 1.5 x length). | |
| if (length > numeric_limits<unsigned>::max() / 3) | |
| return CString(); | |
| Vector<char, 1024> bufferVector(length * 3); | |
| char* buffer = bufferVector.data(); | |
| if (is8Bit()) { | |
| const LChar* characters = this->characters8(); | |
| ConversionResult result = convertLatin1ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size()); | |
| ASSERT_UNUSED(result, result != targetExhausted); // (length * 3) should be sufficient for any conversion | |
| } else { | |
| const UChar* characters = this->characters16(); | |
| if (mode == StrictConversionReplacingUnpairedSurrogatesWithFFFD) { | |
| const UChar* charactersEnd = characters + length; | |
| char* bufferEnd = buffer + bufferVector.size(); | |
| while (characters < charactersEnd) { | |
| // Use strict conversion to detect unpaired surrogates. | |
| ConversionResult result = convertUTF16ToUTF8(&characters, charactersEnd, &buffer, bufferEnd, true); | |
| ASSERT(result != targetExhausted); | |
| // Conversion fails when there is an unpaired surrogate. | |
| // Put replacement character (U+FFFD) instead of the unpaired surrogate. | |
| if (result != conversionOK) { | |
| ASSERT((0xD800 <= *characters && *characters <= 0xDFFF)); | |
| // There should be room left, since one UChar hasn't been converted. | |
| ASSERT((buffer + 3) <= bufferEnd); | |
| putUTF8Triple(buffer, replacementCharacter); | |
| ++characters; | |
| } | |
| } | |
| } else { | |
| bool strict = mode == StrictConversion; | |
| ConversionResult result = convertUTF16ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size(), strict); | |
| ASSERT(result != targetExhausted); // (length * 3) should be sufficient for any conversion | |
| // Only produced from strict conversion. | |
| if (result == sourceIllegal) { | |
| ASSERT(strict); | |
| return CString(); | |
| } | |
| // Check for an unconverted high surrogate. | |
| if (result == sourceExhausted) { | |
| if (strict) | |
| return CString(); | |
| // This should be one unpaired high surrogate. Treat it the same | |
| // was as an unpaired high surrogate would have been handled in | |
| // the middle of a string with non-strict conversion - which is | |
| // to say, simply encode it to UTF-8. | |
| ASSERT((characters + 1) == (this->characters() + length)); | |
| ASSERT((*characters >= 0xD800) && (*characters <= 0xDBFF)); | |
| // There should be room left, since one UChar hasn't been converted. | |
| ASSERT((buffer + 3) <= (buffer + bufferVector.size())); | |
| putUTF8Triple(buffer, *characters); | |
| } | |
| } | |
| } | |
| return CString(bufferVector.data(), buffer - bufferVector.data()); | |
| } | |
| String String::make8BitFrom16BitSource(const UChar* source, size_t length) | |
| { | |
| if (!length) | |
| return String(); | |
| LChar* destination; | |
| String result = String::createUninitialized(length, destination); | |
| copyLCharsFromUCharSource(destination, source, length); | |
| return result; | |
| } | |
| String String::make16BitFrom8BitSource(const LChar* source, size_t length) | |
| { | |
| if (!length) | |
| return String(); | |
| UChar* destination; | |
| String result = String::createUninitialized(length, destination); | |
| StringImpl::copyChars(destination, source, length); | |
| return result; | |
| } | |
| String String::fromUTF8(const LChar* stringStart, size_t length) | |
| { | |
| if (length > numeric_limits<unsigned>::max()) | |
| CRASH(); | |
| if (!stringStart) | |
| return String(); | |
| if (!length) | |
| return emptyString(); | |
| // We'll use a StringImpl as a buffer; if the source string only contains ascii this should be | |
| // the right length, if there are any multi-byte sequences this buffer will be too large. | |
| UChar* buffer; | |
| String stringBuffer(StringImpl::createUninitialized(length, buffer)); | |
| UChar* bufferEnd = buffer + length; | |
| // Try converting into the buffer. | |
| const char* stringCurrent = reinterpret_cast<const char*>(stringStart); | |
| bool isAllASCII; | |
| if (convertUTF8ToUTF16(&stringCurrent, reinterpret_cast<const char *>(stringStart + length), &buffer, bufferEnd, &isAllASCII) != conversionOK) | |
| return String(); | |
| if (isAllASCII) | |
| return String(stringStart, length); | |
| // stringBuffer is full (the input must have been all ascii) so just return it! | |
| if (buffer == bufferEnd) | |
| return stringBuffer; | |
| // stringBuffer served its purpose as a buffer, copy the contents out into a new string. | |
| unsigned utf16Length = buffer - stringBuffer.characters(); | |
| ASSERT(utf16Length < length); | |
| return String(stringBuffer.characters(), utf16Length); | |
| } | |
| String String::fromUTF8(const LChar* string) | |
| { | |
| if (!string) | |
| return String(); | |
| return fromUTF8(string, strlen(reinterpret_cast<const char*>(string))); | |
| } | |
| String String::fromUTF8(const CString& s) | |
| { | |
| return fromUTF8(s.data()); | |
| } | |
| String String::fromUTF8WithLatin1Fallback(const LChar* string, size_t size) | |
| { | |
| String utf8 = fromUTF8(string, size); | |
| if (!utf8) | |
| return String(string, size); | |
| return utf8; | |
| } | |
| // String Operations | |
| static bool isCharacterAllowedInBase(UChar c, int base) | |
| { | |
| if (c > 0x7F) | |
| return false; | |
| if (isASCIIDigit(c)) | |
| return c - '0' < base; | |
| if (isASCIIAlpha(c)) { | |
| if (base > 36) | |
| base = 36; | |
| return (c >= 'a' && c < 'a' + base - 10) | |
| || (c >= 'A' && c < 'A' + base - 10); | |
| } | |
| return false; | |
| } | |
| template <typename IntegralType, typename CharType> | |
| static inline IntegralType toIntegralType(const CharType* data, size_t length, bool* ok, int base) | |
| { | |
| static const IntegralType integralMax = numeric_limits<IntegralType>::max(); | |
| static const bool isSigned = numeric_limits<IntegralType>::is_signed; | |
| const IntegralType maxMultiplier = integralMax / base; | |
| IntegralType value = 0; | |
| bool isOk = false; | |
| bool isNegative = false; | |
| if (!data) | |
| goto bye; | |
| // skip leading whitespace | |
| while (length && isSpaceOrNewline(*data)) { | |
| --length; | |
| ++data; | |
| } | |
| if (isSigned && length && *data == '-') { | |
| --length; | |
| ++data; | |
| isNegative = true; | |
| } else if (length && *data == '+') { | |
| --length; | |
| ++data; | |
| } | |
| if (!length || !isCharacterAllowedInBase(*data, base)) | |
| goto bye; | |
| while (length && isCharacterAllowedInBase(*data, base)) { | |
| --length; | |
| IntegralType digitValue; | |
| CharType c = *data; | |
| if (isASCIIDigit(c)) | |
| digitValue = c - '0'; | |
| else if (c >= 'a') | |
| digitValue = c - 'a' + 10; | |
| else | |
| digitValue = c - 'A' + 10; | |
| if (value > maxMultiplier || (value == maxMultiplier && digitValue > (integralMax % base) + isNegative)) | |
| goto bye; | |
| value = base * value + digitValue; | |
| ++data; | |
| } | |
| #if COMPILER(MSVC) | |
| #pragma warning(push, 0) | |
| #pragma warning(disable:4146) | |
| #endif | |
| if (isNegative) | |
| value = -value; | |
| #if COMPILER(MSVC) | |
| #pragma warning(pop) | |
| #endif | |
| // skip trailing space | |
| while (length && isSpaceOrNewline(*data)) { | |
| --length; | |
| ++data; | |
| } | |
| if (!length) | |
| isOk = true; | |
| bye: | |
| if (ok) | |
| *ok = isOk; | |
| return isOk ? value : 0; | |
| } | |
| template <typename CharType> | |
| static unsigned lengthOfCharactersAsInteger(const CharType* data, size_t length) | |
| { | |
| size_t i = 0; | |
| // Allow leading spaces. | |
| for (; i != length; ++i) { | |
| if (!isSpaceOrNewline(data[i])) | |
| break; | |
| } | |
| // Allow sign. | |
| if (i != length && (data[i] == '+' || data[i] == '-')) | |
| ++i; | |
| // Allow digits. | |
| for (; i != length; ++i) { | |
| if (!isASCIIDigit(data[i])) | |
| break; | |
| } | |
| return i; | |
| } | |
| int charactersToIntStrict(const LChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<int, LChar>(data, length, ok, base); | |
| } | |
| int charactersToIntStrict(const UChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<int, UChar>(data, length, ok, base); | |
| } | |
| unsigned charactersToUIntStrict(const LChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<unsigned, LChar>(data, length, ok, base); | |
| } | |
| unsigned charactersToUIntStrict(const UChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<unsigned, UChar>(data, length, ok, base); | |
| } | |
| int64_t charactersToInt64Strict(const LChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<int64_t, LChar>(data, length, ok, base); | |
| } | |
| int64_t charactersToInt64Strict(const UChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<int64_t, UChar>(data, length, ok, base); | |
| } | |
| uint64_t charactersToUInt64Strict(const LChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<uint64_t, LChar>(data, length, ok, base); | |
| } | |
| uint64_t charactersToUInt64Strict(const UChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<uint64_t, UChar>(data, length, ok, base); | |
| } | |
| intptr_t charactersToIntPtrStrict(const LChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<intptr_t, LChar>(data, length, ok, base); | |
| } | |
| intptr_t charactersToIntPtrStrict(const UChar* data, size_t length, bool* ok, int base) | |
| { | |
| return toIntegralType<intptr_t, UChar>(data, length, ok, base); | |
| } | |
| int charactersToInt(const LChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<int, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10); | |
| } | |
| int charactersToInt(const UChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<int, UChar>(data, lengthOfCharactersAsInteger(data, length), ok, 10); | |
| } | |
| unsigned charactersToUInt(const LChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<unsigned, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10); | |
| } | |
| unsigned charactersToUInt(const UChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<unsigned, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10); | |
| } | |
| int64_t charactersToInt64(const LChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<int64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10); | |
| } | |
| int64_t charactersToInt64(const UChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<int64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10); | |
| } | |
| uint64_t charactersToUInt64(const LChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<uint64_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10); | |
| } | |
| uint64_t charactersToUInt64(const UChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<uint64_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10); | |
| } | |
| intptr_t charactersToIntPtr(const LChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<intptr_t, LChar>(data, lengthOfCharactersAsInteger<LChar>(data, length), ok, 10); | |
| } | |
| intptr_t charactersToIntPtr(const UChar* data, size_t length, bool* ok) | |
| { | |
| return toIntegralType<intptr_t, UChar>(data, lengthOfCharactersAsInteger<UChar>(data, length), ok, 10); | |
| } | |
| enum TrailingJunkPolicy { DisallowTrailingJunk, AllowTrailingJunk }; | |
| template <typename CharType, TrailingJunkPolicy policy> | |
| static inline double toDoubleType(const CharType* data, size_t length, bool* ok, size_t& parsedLength) | |
| { | |
| size_t leadingSpacesLength = 0; | |
| while (leadingSpacesLength < length && isASCIISpace(data[leadingSpacesLength])) | |
| ++leadingSpacesLength; | |
| double number = parseDouble(data + leadingSpacesLength, length - leadingSpacesLength, parsedLength); | |
| if (!parsedLength) { | |
| if (ok) | |
| *ok = false; | |
| return 0.0; | |
| } | |
| parsedLength += leadingSpacesLength; | |
| if (ok) | |
| *ok = policy == AllowTrailingJunk || parsedLength == length; | |
| return number; | |
| } | |
| double charactersToDouble(const LChar* data, size_t length, bool* ok) | |
| { | |
| size_t parsedLength; | |
| return toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength); | |
| } | |
| double charactersToDouble(const UChar* data, size_t length, bool* ok) | |
| { | |
| size_t parsedLength; | |
| return toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength); | |
| } | |
| float charactersToFloat(const LChar* data, size_t length, bool* ok) | |
| { | |
| // FIXME: This will return ok even when the string fits into a double but not a float. | |
| size_t parsedLength; | |
| return static_cast<float>(toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength)); | |
| } | |
| float charactersToFloat(const UChar* data, size_t length, bool* ok) | |
| { | |
| // FIXME: This will return ok even when the string fits into a double but not a float. | |
| size_t parsedLength; | |
| return static_cast<float>(toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength)); | |
| } | |
| float charactersToFloat(const LChar* data, size_t length, size_t& parsedLength) | |
| { | |
| // FIXME: This will return ok even when the string fits into a double but not a float. | |
| return static_cast<float>(toDoubleType<LChar, AllowTrailingJunk>(data, length, 0, parsedLength)); | |
| } | |
| float charactersToFloat(const UChar* data, size_t length, size_t& parsedLength) | |
| { | |
| // FIXME: This will return ok even when the string fits into a double but not a float. | |
| return static_cast<float>(toDoubleType<UChar, AllowTrailingJunk>(data, length, 0, parsedLength)); | |
| } | |
| const String& emptyString() | |
| { | |
| DEFINE_STATIC_LOCAL(String, emptyString, (StringImpl::empty())); | |
| return emptyString; | |
| } | |
| } // namespace WTF | |
| #ifndef NDEBUG | |
| // For use in the debugger | |
| String* string(const char*); | |
| Vector<char> asciiDebug(StringImpl* impl); | |
| Vector<char> asciiDebug(String& string); | |
| void String::show() const | |
| { | |
| dataLogF("%s\n", asciiDebug(impl()).data()); | |
| } | |
| String* string(const char* s) | |
| { | |
| // leaks memory! | |
| return new String(s); | |
| } | |
| Vector<char> asciiDebug(StringImpl* impl) | |
| { | |
| if (!impl) | |
| return asciiDebug(String("[null]").impl()); | |
| Vector<char> buffer; | |
| for (unsigned i = 0; i < impl->length(); ++i) { | |
| UChar ch = (*impl)[i]; | |
| if (isASCIIPrintable(ch)) { | |
| if (ch == '\\') | |
| buffer.append(ch); | |
| buffer.append(ch); | |
| } else { | |
| buffer.append('\\'); | |
| buffer.append('u'); | |
| appendUnsignedAsHexFixedSize(ch, buffer, 4); | |
| } | |
| } | |
| buffer.append('\0'); | |
| return buffer; | |
| } | |
| Vector<char> asciiDebug(String& string) | |
| { | |
| return asciiDebug(string.impl()); | |
| } | |
| #endif |