X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/fb8617cde5834786bd4e4afd579883e4acf5666e..a253471d7f8e4d91bf6ebabab00155c3b387d3d0:/runtime/UString.cpp diff --git a/runtime/UString.cpp b/runtime/UString.cpp index 54eac6a..5b1e9a0 100644 --- a/runtime/UString.cpp +++ b/runtime/UString.cpp @@ -25,24 +25,21 @@ #include "UString.h" #include "JSGlobalObjectFunctions.h" -#include "Collector.h" -#include "dtoa.h" +#include "Heap.h" #include "Identifier.h" #include "Operations.h" #include #include #include -#include #include #include -#include #include #include #include #include #include +#include #include -#include #if HAVE(STRINGS_H) #include @@ -53,188 +50,56 @@ using namespace WTF::Unicode; using namespace std; namespace JSC { - -extern const double NaN; -extern const double Inf; - -CString::CString(const char* c) - : m_length(strlen(c)) - , m_data(new char[m_length + 1]) -{ - memcpy(m_data, c, m_length + 1); -} - -CString::CString(const char* c, size_t length) - : m_length(length) - , m_data(new char[length + 1]) -{ - memcpy(m_data, c, m_length); - m_data[m_length] = 0; -} - -CString::CString(const CString& b) -{ - m_length = b.m_length; - if (b.m_data) { - m_data = new char[m_length + 1]; - memcpy(m_data, b.m_data, m_length + 1); - } else - m_data = 0; -} -CString::~CString() -{ - delete [] m_data; -} +COMPILE_ASSERT(sizeof(UString) == sizeof(void*), UString_should_stay_small); -CString CString::adopt(char* c, size_t length) +// Construct a string with UTF-16 data. +UString::UString(const UChar* characters, unsigned length) + : m_impl(characters ? StringImpl::create(characters, length) : 0) { - CString s; - s.m_data = c; - s.m_length = length; - return s; } -CString& CString::append(const CString& t) +// Construct a string with UTF-16 data, from a null-terminated source. +UString::UString(const UChar* characters) { - char* n; - n = new char[m_length + t.m_length + 1]; - if (m_length) - memcpy(n, m_data, m_length); - if (t.m_length) - memcpy(n + m_length, t.m_data, t.m_length); - m_length += t.m_length; - n[m_length] = 0; - - delete [] m_data; - m_data = n; - - return *this; -} + if (!characters) + return; -CString& CString::operator=(const char* c) -{ - if (m_data) - delete [] m_data; - m_length = strlen(c); - m_data = new char[m_length + 1]; - memcpy(m_data, c, m_length + 1); + int length = 0; + while (characters[length] != UChar(0)) + ++length; - return *this; + m_impl = StringImpl::create(characters, length); } -CString& CString::operator=(const CString& str) +// Construct a string with latin1 data. +UString::UString(const LChar* characters, unsigned length) + : m_impl(characters ? StringImpl::create(characters, length) : 0) { - if (this == &str) - return *this; - - if (m_data) - delete [] m_data; - m_length = str.m_length; - if (str.m_data) { - m_data = new char[m_length + 1]; - memcpy(m_data, str.m_data, m_length + 1); - } else - m_data = 0; - - return *this; } -bool operator==(const CString& c1, const CString& c2) +UString::UString(const char* characters, unsigned length) + : m_impl(characters ? StringImpl::create(reinterpret_cast(characters), length) : 0) { - size_t len = c1.size(); - return len == c2.size() && (len == 0 || memcmp(c1.c_str(), c2.c_str(), len) == 0); } -// These static strings are immutable, except for rc, whose initial value is chosen to -// reduce the possibility of it becoming zero due to ref/deref not being thread-safe. -static UChar sharedEmptyChar; -UStringImpl* UStringImpl::s_null; -UStringImpl* UStringImpl::s_empty; -UString* UString::nullUString; - -void initializeUString() +// Construct a string with latin1 data, from a null-terminated source. +UString::UString(const LChar* characters) + : m_impl(characters ? StringImpl::create(characters) : 0) { - UStringImpl::s_null = new UStringImpl(0, 0, UStringImpl::ConstructStaticString); - UStringImpl::s_empty = new UStringImpl(&sharedEmptyChar, 0, UStringImpl::ConstructStaticString); - UString::nullUString = new UString; } -static PassRefPtr createRep(const char* c) +UString::UString(const char* characters) + : m_impl(characters ? StringImpl::create(reinterpret_cast(characters)) : 0) { - if (!c) - return &UString::Rep::null(); - - if (!c[0]) - return &UString::Rep::empty(); - - size_t length = strlen(c); - UChar* d; - PassRefPtr result = UStringImpl::tryCreateUninitialized(length, d); - if (!result) - return &UString::Rep::null(); - - for (size_t i = 0; i < length; i++) - d[i] = static_cast(c[i]); // use unsigned char to zero-extend instead of sign-extend - return result; } -static inline PassRefPtr createRep(const char* c, int length) +UString UString::number(int i) { - if (!c) - return &UString::Rep::null(); - - if (!length) - return &UString::Rep::empty(); + LChar buf[1 + sizeof(i) * 3]; + LChar* end = buf + WTF_ARRAY_LENGTH(buf); + LChar* p = end; - UChar* d; - PassRefPtr result = UStringImpl::tryCreateUninitialized(length, d); - if (!result) - return &UString::Rep::null(); - - for (int i = 0; i < length; i++) - d[i] = static_cast(c[i]); // use unsigned char to zero-extend instead of sign-extend - return result; -} - -UString::UString(const char* c) - : m_rep(createRep(c)) -{ -} - -UString::UString(const char* c, int length) - : m_rep(createRep(c, length)) -{ -} - -UString::UString(const UChar* c, int length) -{ - if (length == 0) - m_rep = &Rep::empty(); - else - m_rep = Rep::create(c, length); -} - -UString UString::createFromUTF8(const char* string) -{ - if (!string) - return null(); - - size_t length = strlen(string); - Vector buffer(length); - UChar* p = buffer.data(); - if (conversionOK != convertUTF8ToUTF16(&string, string + length, &p, p + length)) - return null(); - - return UString(buffer.data(), p - buffer.data()); -} - -UString UString::from(int i) -{ - UChar buf[1 + sizeof(i) * 3]; - UChar* end = buf + sizeof(buf) / sizeof(UChar); - UChar* p = end; - if (i == 0) *--p = '0'; else if (i == INT_MIN) { @@ -255,25 +120,23 @@ UString UString::from(int i) *--p = '-'; } - return UString(p, static_cast(end - p)); + return UString(p, static_cast(end - p)); } -UString UString::from(long long i) +UString UString::number(long long i) { - UChar buf[1 + sizeof(i) * 3]; - UChar* end = buf + sizeof(buf) / sizeof(UChar); - UChar* p = end; + LChar buf[1 + sizeof(i) * 3]; + LChar* end = buf + WTF_ARRAY_LENGTH(buf); + LChar* p = end; if (i == 0) *--p = '0'; else if (i == std::numeric_limits::min()) { char minBuf[1 + sizeof(i) * 3]; #if OS(WINDOWS) - snprintf(minBuf, sizeof(minBuf) - 1, "%I64d", std::numeric_limits::min()); -#elif PLATFORM(IPHONE) - snprintf(minBuf, sizeof(minBuf), "%lld", std::numeric_limits::min()); + snprintf(minBuf, sizeof(minBuf), "%I64d", std::numeric_limits::min()); #else - snprintf(minBuf, sizeof(minBuf) - 1, "%lld", std::numeric_limits::min()); + snprintf(minBuf, sizeof(minBuf), "%lld", std::numeric_limits::min()); #endif return UString(minBuf); } else { @@ -290,15 +153,15 @@ UString UString::from(long long i) *--p = '-'; } - return UString(p, static_cast(end - p)); + return UString(p, static_cast(end - p)); } -UString UString::from(unsigned int u) +UString UString::number(unsigned u) { - UChar buf[sizeof(u) * 3]; - UChar* end = buf + sizeof(buf) / sizeof(UChar); - UChar* p = end; - + LChar buf[sizeof(u) * 3]; + LChar* end = buf + WTF_ARRAY_LENGTH(buf); + LChar* p = end; + if (u == 0) *--p = '0'; else { @@ -307,15 +170,15 @@ UString UString::from(unsigned int u) u /= 10; } } - - return UString(p, static_cast(end - p)); + + return UString(p, static_cast(end - p)); } -UString UString::from(long l) +UString UString::number(long l) { - UChar buf[1 + sizeof(l) * 3]; - UChar* end = buf + sizeof(buf) / sizeof(UChar); - UChar* p = end; + LChar buf[1 + sizeof(l) * 3]; + LChar* end = buf + WTF_ARRAY_LENGTH(buf); + LChar* p = end; if (l == 0) *--p = '0'; @@ -337,482 +200,135 @@ UString UString::from(long l) *--p = '-'; } - return UString(p, static_cast(end - p)); -} - -UString UString::from(double d) -{ - DtoaBuffer buffer; - unsigned length; - doubleToStringInJavaScriptFormat(d, buffer, &length); - return UString(buffer, length); -} - -UString UString::spliceSubstringsWithSeparators(const Range* substringRanges, int rangeCount, const UString* separators, int separatorCount) const -{ - m_rep->checkConsistency(); - - if (rangeCount == 1 && separatorCount == 0) { - int thisSize = size(); - int position = substringRanges[0].position; - int length = substringRanges[0].length; - if (position <= 0 && length >= thisSize) - return *this; - return UString::Rep::create(m_rep, max(0, position), min(thisSize, length)); - } - - int totalLength = 0; - for (int i = 0; i < rangeCount; i++) - totalLength += substringRanges[i].length; - for (int i = 0; i < separatorCount; i++) - totalLength += separators[i].size(); - - if (totalLength == 0) - return ""; - - UChar* buffer; - PassRefPtr rep = Rep::tryCreateUninitialized(totalLength, buffer); - if (!rep) - return null(); - - int maxCount = max(rangeCount, separatorCount); - int bufferPos = 0; - for (int i = 0; i < maxCount; i++) { - if (i < rangeCount) { - UStringImpl::copyChars(buffer + bufferPos, data() + substringRanges[i].position, substringRanges[i].length); - bufferPos += substringRanges[i].length; - } - if (i < separatorCount) { - UStringImpl::copyChars(buffer + bufferPos, separators[i].data(), separators[i].size()); - bufferPos += separators[i].size(); - } - } - - return rep; + return UString(p, end - p); } -UString UString::replaceRange(int rangeStart, int rangeLength, const UString& replacement) const +UString UString::number(double d) { - m_rep->checkConsistency(); - - int replacementLength = replacement.size(); - int totalLength = size() - rangeLength + replacementLength; - if (totalLength == 0) - return ""; - - UChar* buffer; - PassRefPtr rep = Rep::tryCreateUninitialized(totalLength, buffer); - if (!rep) - return null(); - - UStringImpl::copyChars(buffer, data(), rangeStart); - UStringImpl::copyChars(buffer + rangeStart, replacement.data(), replacementLength); - int rangeEnd = rangeStart + rangeLength; - UStringImpl::copyChars(buffer + rangeStart + replacementLength, data() + rangeEnd, size() - rangeEnd); - - return rep; + NumberToStringBuffer buffer; + return UString(numberToString(d, buffer)); } -bool UString::getCString(CStringBuffer& buffer) const +UString UString::substringSharingImpl(unsigned offset, unsigned length) const { - int length = size(); - int neededSize = length + 1; - buffer.resize(neededSize); - char* buf = buffer.data(); - - UChar ored = 0; - const UChar* p = data(); - char* q = buf; - const UChar* limit = p + length; - while (p != limit) { - UChar c = p[0]; - ored |= c; - *q = static_cast(c); - ++p; - ++q; - } - *q = '\0'; - - return !(ored & 0xFF00); -} + // FIXME: We used to check against a limit of Heap::minExtraCost / sizeof(UChar). -char* UString::ascii() const -{ - static char* asciiBuffer = 0; - - int length = size(); - int neededSize = length + 1; - delete[] asciiBuffer; - asciiBuffer = new char[neededSize]; - - const UChar* p = data(); - char* q = asciiBuffer; - const UChar* limit = p + length; - while (p != limit) { - *q = static_cast(p[0]); - ++p; - ++q; - } - *q = '\0'; + unsigned stringLength = this->length(); + offset = min(offset, stringLength); + length = min(length, stringLength - offset); - return asciiBuffer; -} - -UString& UString::operator=(const char* c) -{ - if (!c) { - m_rep = &Rep::null(); - return *this; - } - - if (!c[0]) { - m_rep = &Rep::empty(); + if (!offset && length == stringLength) return *this; - } - - int l = static_cast(strlen(c)); - UChar* d = 0; - m_rep = Rep::tryCreateUninitialized(l, d); - if (m_rep) { - for (int i = 0; i < l; i++) - d[i] = static_cast(c[i]); // use unsigned char to zero-extend instead of sign-extend - } else - makeNull(); - - return *this; + return UString(StringImpl::create(m_impl, offset, length)); } -bool UString::is8Bit() const +bool operator==(const UString& s1, const char *s2) { - const UChar* u = data(); - const UChar* limit = u + size(); - while (u < limit) { - if (u[0] > 0xFF) - return false; - ++u; - } + if (s1.isEmpty()) + return !s2; - return true; + return equal(s1.impl(), s2); } -UChar UString::operator[](int pos) const +// This method assumes that all simple checks have been performed by +// the inlined operator==() in the header file. +bool equalSlowCase(const UString& s1, const UString& s2) { - if (pos >= size()) - return '\0'; - return data()[pos]; -} + StringImpl* rep1 = s1.impl(); + StringImpl* rep2 = s2.impl(); + unsigned size1 = rep1->length(); -double UString::toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const -{ - if (size() == 1) { - UChar c = data()[0]; - if (isASCIIDigit(c)) - return c - '0'; - if (isASCIISpace(c) && tolerateEmptyString) - return 0; - return NaN; - } - - // FIXME: If tolerateTrailingJunk is true, then we want to tolerate non-8-bit junk - // after the number, so this is too strict a check. - CStringBuffer s; - if (!getCString(s)) - return NaN; - const char* c = s.data(); - - // skip leading white space - while (isASCIISpace(*c)) - c++; - - // empty string ? - if (*c == '\0') - return tolerateEmptyString ? 0.0 : NaN; - - double d; - - // hex number ? - if (*c == '0' && (*(c + 1) == 'x' || *(c + 1) == 'X')) { - const char* firstDigitPosition = c + 2; - c++; - d = 0.0; - while (*(++c)) { - if (*c >= '0' && *c <= '9') - d = d * 16.0 + *c - '0'; - else if ((*c >= 'A' && *c <= 'F') || (*c >= 'a' && *c <= 'f')) - d = d * 16.0 + (*c & 0xdf) - 'A' + 10.0; - else - break; - } - - if (d >= mantissaOverflowLowerBound) - d = parseIntOverflow(firstDigitPosition, c - firstDigitPosition, 16); - } else { - // regular number ? - char* end; - d = WTF::strtod(c, &end); - if ((d != 0.0 || end != c) && d != Inf && d != -Inf) { - c = end; - } else { - double sign = 1.0; - - if (*c == '+') - c++; - else if (*c == '-') { - sign = -1.0; - c++; + // At this point we know + // (a) that the strings are the same length and + // (b) that they are greater than zero length. + bool s1Is8Bit = rep1->is8Bit(); + bool s2Is8Bit = rep2->is8Bit(); + + if (s1Is8Bit) { + const LChar* d1 = rep1->characters8(); + if (s2Is8Bit) { + const LChar* d2 = rep2->characters8(); + + if (d1 == d2) // Check to see if the data pointers are the same. + return true; + + // Do quick checks for sizes 1 and 2. + switch (size1) { + case 1: + return d1[0] == d2[0]; + case 2: + return (d1[0] == d2[0]) & (d1[1] == d2[1]); + default: + return (!memcmp(d1, d2, size1 * sizeof(LChar))); } - - // We used strtod() to do the conversion. However, strtod() handles - // infinite values slightly differently than JavaScript in that it - // converts the string "inf" with any capitalization to infinity, - // whereas the ECMA spec requires that it be converted to NaN. - - if (c[0] == 'I' && c[1] == 'n' && c[2] == 'f' && c[3] == 'i' && c[4] == 'n' && c[5] == 'i' && c[6] == 't' && c[7] == 'y') { - d = sign * Inf; - c += 8; - } else if ((d == Inf || d == -Inf) && *c != 'I' && *c != 'i') - c = end; - else - return NaN; } - } - - // allow trailing white space - while (isASCIISpace(*c)) - c++; - // don't allow anything after - unless tolerant=true - if (!tolerateTrailingJunk && *c != '\0') - d = NaN; - - return d; -} - -double UString::toDouble(bool tolerateTrailingJunk) const -{ - return toDouble(tolerateTrailingJunk, true); -} - -double UString::toDouble() const -{ - return toDouble(false, true); -} - -uint32_t UString::toUInt32(bool* ok) const -{ - double d = toDouble(); - bool b = true; - - if (d != static_cast(d)) { - b = false; - d = 0; - } - - if (ok) - *ok = b; - - return static_cast(d); -} - -uint32_t UString::toUInt32(bool* ok, bool tolerateEmptyString) const -{ - double d = toDouble(false, tolerateEmptyString); - bool b = true; - - if (d != static_cast(d)) { - b = false; - d = 0; - } - - if (ok) - *ok = b; - - return static_cast(d); -} - -uint32_t UString::toStrictUInt32(bool* ok) const -{ - if (ok) - *ok = false; - - // Empty string is not OK. - int len = m_rep->size(); - if (len == 0) - return 0; - const UChar* p = m_rep->data(); - unsigned short c = p[0]; - - // If the first digit is 0, only 0 itself is OK. - if (c == '0') { - if (len == 1 && ok) - *ok = true; - return 0; - } - - // Convert to UInt32, checking for overflow. - uint32_t i = 0; - while (1) { - // Process character, turning it into a digit. - if (c < '0' || c > '9') - return 0; - const unsigned d = c - '0'; - - // Multiply by 10, checking for overflow out of 32 bits. - if (i > 0xFFFFFFFFU / 10) - return 0; - i *= 10; - - // Add in the digit, checking for overflow out of 32 bits. - const unsigned max = 0xFFFFFFFFU - d; - if (i > max) - return 0; - i += d; - - // Handle end of string. - if (--len == 0) { - if (ok) - *ok = true; - return i; + + const UChar* d2 = rep2->characters16(); + + for (unsigned i = 0; i < size1; i++) { + if (d1[i] != d2[i]) + return false; } - - // Get next character. - c = *(++p); + return true; } -} - -int UString::find(const UString& f, int pos) const -{ - int fsz = f.size(); - - if (pos < 0) - pos = 0; - - if (fsz == 1) { - UChar ch = f[0]; - const UChar* end = data() + size(); - for (const UChar* c = data() + pos; c < end; c++) { - if (*c == ch) - return static_cast(c - data()); + + if (s2Is8Bit) { + const UChar* d1 = rep1->characters16(); + const LChar* d2 = rep2->characters8(); + + for (unsigned i = 0; i < size1; i++) { + if (d1[i] != d2[i]) + return false; } - return -1; - } - - int sz = size(); - if (sz < fsz) - return -1; - if (fsz == 0) - return pos; - const UChar* end = data() + sz - fsz; - int fsizeminusone = (fsz - 1) * sizeof(UChar); - const UChar* fdata = f.data(); - unsigned short fchar = fdata[0]; - ++fdata; - for (const UChar* c = data() + pos; c <= end; c++) { - if (c[0] == fchar && !memcmp(c + 1, fdata, fsizeminusone)) - return static_cast(c - data()); - } - - return -1; -} - -int UString::find(UChar ch, int pos) const -{ - if (pos < 0) - pos = 0; - const UChar* end = data() + size(); - for (const UChar* c = data() + pos; c < end; c++) { - if (*c == ch) - return static_cast(c - data()); + return true; + } - return -1; -} - -int UString::rfind(const UString& f, int pos) const -{ - int sz = size(); - int fsz = f.size(); - if (sz < fsz) - return -1; - if (pos < 0) - pos = 0; - if (pos > sz - fsz) - pos = sz - fsz; - if (fsz == 0) - return pos; - int fsizeminusone = (fsz - 1) * sizeof(UChar); - const UChar* fdata = f.data(); - for (const UChar* c = data() + pos; c >= data(); c--) { - if (*c == *fdata && !memcmp(c + 1, fdata + 1, fsizeminusone)) - return static_cast(c - data()); - } - - return -1; -} - -int UString::rfind(UChar ch, int pos) const -{ - if (isEmpty()) - return -1; - if (pos + 1 >= size()) - pos = size() - 1; - for (const UChar* c = data() + pos; c >= data(); c--) { - if (*c == ch) - return static_cast(c - data()); + const UChar* d1 = rep1->characters16(); + const UChar* d2 = rep2->characters16(); + + if (d1 == d2) // Check to see if the data pointers are the same. + return true; + + // Do quick checks for sizes 1 and 2. + switch (size1) { + case 1: + return d1[0] == d2[0]; + case 2: + return (d1[0] == d2[0]) & (d1[1] == d2[1]); + default: + return (!memcmp(d1, d2, size1 * sizeof(UChar))); } - - return -1; } -UString UString::substr(int pos, int len) const +bool operator<(const UString& s1, const UString& s2) { - int s = size(); - - if (pos < 0) - pos = 0; - else if (pos >= s) - pos = s; - if (len < 0) - len = s; - if (pos + len >= s) - len = s - pos; - - if (pos == 0 && len == s) - return *this; - - return UString(Rep::create(m_rep, pos, len)); -} + const unsigned l1 = s1.length(); + const unsigned l2 = s2.length(); + const unsigned lmin = l1 < l2 ? l1 : l2; + if (s1.is8Bit() && s2.is8Bit()) { + const LChar* c1 = s1.characters8(); + const LChar* c2 = s2.characters8(); + unsigned length = 0; + while (length < lmin && *c1 == *c2) { + c1++; + c2++; + length++; + } + if (length < lmin) + return (c1[0] < c2[0]); -bool operator==(const UString& s1, const char *s2) -{ - if (s2 == 0) - return s1.isEmpty(); - - const UChar* u = s1.data(); - const UChar* uend = u + s1.size(); - while (u != uend && *s2) { - if (u[0] != (unsigned char)*s2) - return false; - s2++; - u++; + return (l1 < l2); } - - return u == uend && *s2 == 0; -} - -bool operator<(const UString& s1, const UString& s2) -{ - const int l1 = s1.size(); - const int l2 = s2.size(); - const int lmin = l1 < l2 ? l1 : l2; - const UChar* c1 = s1.data(); - const UChar* c2 = s2.data(); - int l = 0; - while (l < lmin && *c1 == *c2) { + const UChar* c1 = s1.characters(); + const UChar* c2 = s2.characters(); + unsigned length = 0; + while (length < lmin && *c1 == *c2) { c1++; c2++; - l++; + length++; } - if (l < lmin) + if (length < lmin) return (c1[0] < c2[0]); return (l1 < l2); @@ -820,12 +336,12 @@ bool operator<(const UString& s1, const UString& s2) bool operator>(const UString& s1, const UString& s2) { - const int l1 = s1.size(); - const int l2 = s2.size(); - const int lmin = l1 < l2 ? l1 : l2; - const UChar* c1 = s1.data(); - const UChar* c2 = s2.data(); - int l = 0; + const unsigned l1 = s1.length(); + const unsigned l2 = s2.length(); + const unsigned lmin = l1 < l2 ? l1 : l2; + const UChar* c1 = s1.characters(); + const UChar* c2 = s2.characters(); + unsigned l = 0; while (l < lmin && *c1 == *c2) { c1++; c2++; @@ -837,69 +353,123 @@ bool operator>(const UString& s1, const UString& s2) return (l1 > l2); } -int compare(const UString& s1, const UString& s2) +CString UString::ascii() const { - const int l1 = s1.size(); - const int l2 = s2.size(); - const int lmin = l1 < l2 ? l1 : l2; - const UChar* c1 = s1.data(); - const UChar* c2 = s2.data(); - int l = 0; - while (l < lmin && *c1 == *c2) { - c1++; - c2++; - l++; - } + // Basic Latin1 (ISO) encoding - Unicode characters 0..255 are + // preserved, characters outside of this range are converted to '?'. - if (l < lmin) - return (c1[0] > c2[0]) ? 1 : -1; + unsigned length = this->length(); - if (l1 == l2) - return 0; + 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; + } - return (l1 > l2) ? 1 : -1; -} + const UChar* characters = this->characters16(); -bool equal(const UString::Rep* r, const UString::Rep* b) -{ - int length = r->size(); - if (length != b->size()) - return false; - const UChar* d = r->data(); - const UChar* s = b->data(); - for (int i = 0; i != length; ++i) { - if (d[i] != s[i]) - return false; + 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 true; + + return result; } -CString UString::UTF8String(bool strict) const +CString UString::latin1() const { - // Allocate a buffer big enough to hold all the characters. - const int length = size(); - Vector buffer(length * 3); - - // Convert to runs of 8-bit characters. - char* p = buffer.data(); - const UChar* d = reinterpret_cast(&data()[0]); - ConversionResult result = convertUTF16ToUTF8(&d, d + length, &p, p + buffer.size(), strict); - if (result != conversionOK) - return CString(); + // Basic Latin1 (ISO) encoding - Unicode characters 0..255 are + // preserved, characters outside of this range are converted to '?'. + + unsigned length = this->length(); + const UChar* characters = this->characters(); + + 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 CString(buffer.data(), p - buffer.data()); + return result; } -// For use in error handling code paths -- having this not be inlined helps avoid PIC branches to fetch the global on Mac OS X. -NEVER_INLINE void UString::makeNull() +// 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) { - m_rep = &Rep::null(); + ASSERT(ch >= 0x0800); + *buffer++ = static_cast(((ch >> 12) & 0x0F) | 0xE0); + *buffer++ = static_cast(((ch >> 6) & 0x3F) | 0x80); + *buffer++ = static_cast((ch & 0x3F) | 0x80); } -// For use in error handling code paths -- having this not be inlined helps avoid PIC branches to fetch the global on Mac OS X. -NEVER_INLINE UString::Rep* UString::nullRep() +CString UString::utf8(bool strict) const { - return &Rep::null(); + 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::max() / 3) + return CString(); + + Vector 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(); + + 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) + 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()); } } // namespace JSC