#include "config.h"
#include "UString.h"
#include "JSGlobalObjectFunctions.h"
#include "Heap.h"
#include "Identifier.h"
#include "Operations.h"
#include <ctype.h>
#include <limits.h>
#include <limits>
#include <stdio.h>
#include <stdlib.h>
#include <wtf/ASCIICType.h>
#include <wtf/Assertions.h>
#include <wtf/MathExtras.h>
#include <wtf/StringExtras.h>
#include <wtf/Vector.h>
#include <wtf/dtoa.h>
#include <wtf/unicode/UTF8.h>
#if HAVE(STRINGS_H)
#include <strings.h>
#endif
using namespace WTF;
using namespace WTF::Unicode;
using namespace std;
namespace JSC {
COMPILE_ASSERT(sizeof(UString) == sizeof(void*), UString_should_stay_small);
UString::UString(const UChar* characters, unsigned length)
: m_impl(characters ? StringImpl::create(characters, length) : 0)
{
}
UString::UString(const UChar* characters)
{
if (!characters)
return;
int length = 0;
while (characters[length] != UChar(0))
++length;
m_impl = StringImpl::create(characters, length);
}
UString::UString(const LChar* characters, unsigned length)
: m_impl(characters ? StringImpl::create(characters, length) : 0)
{
}
UString::UString(const char* characters, unsigned length)
: m_impl(characters ? StringImpl::create(reinterpret_cast<const LChar*>(characters), length) : 0)
{
}
UString::UString(const LChar* characters)
: m_impl(characters ? StringImpl::create(characters) : 0)
{
}
UString::UString(const char* characters)
: m_impl(characters ? StringImpl::create(reinterpret_cast<const LChar*>(characters)) : 0)
{
}
UString UString::number(int i)
{
LChar buf[1 + sizeof(i) * 3];
LChar* end = buf + WTF_ARRAY_LENGTH(buf);
LChar* p = end;
if (i == 0)
*--p = '0';
else if (i == INT_MIN) {
char minBuf[1 + sizeof(i) * 3];
snprintf(minBuf, sizeof(minBuf), "%d", INT_MIN);
return UString(minBuf);
} else {
bool negative = false;
if (i < 0) {
negative = true;
i = -i;
}
while (i) {
*--p = static_cast<unsigned short>((i % 10) + '0');
i /= 10;
}
if (negative)
*--p = '-';
}
return UString(p, static_cast<unsigned>(end - p));
}
UString UString::number(long long i)
{
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<long long>::min()) {
char minBuf[1 + sizeof(i) * 3];
#if OS(WINDOWS)
snprintf(minBuf, sizeof(minBuf), "%I64d", std::numeric_limits<long long>::min());
#else
snprintf(minBuf, sizeof(minBuf), "%lld", std::numeric_limits<long long>::min());
#endif
return UString(minBuf);
} else {
bool negative = false;
if (i < 0) {
negative = true;
i = -i;
}
while (i) {
*--p = static_cast<unsigned short>((i % 10) + '0');
i /= 10;
}
if (negative)
*--p = '-';
}
return UString(p, static_cast<unsigned>(end - p));
}
UString UString::number(unsigned u)
{
LChar buf[sizeof(u) * 3];
LChar* end = buf + WTF_ARRAY_LENGTH(buf);
LChar* p = end;
if (u == 0)
*--p = '0';
else {
while (u) {
*--p = static_cast<unsigned short>((u % 10) + '0');
u /= 10;
}
}
return UString(p, static_cast<unsigned>(end - p));
}
UString UString::number(long l)
{
LChar buf[1 + sizeof(l) * 3];
LChar* end = buf + WTF_ARRAY_LENGTH(buf);
LChar* p = end;
if (l == 0)
*--p = '0';
else if (l == LONG_MIN) {
char minBuf[1 + sizeof(l) * 3];
snprintf(minBuf, sizeof(minBuf), "%ld", LONG_MIN);
return UString(minBuf);
} else {
bool negative = false;
if (l < 0) {
negative = true;
l = -l;
}
while (l) {
*--p = static_cast<unsigned short>((l % 10) + '0');
l /= 10;
}
if (negative)
*--p = '-';
}
return UString(p, end - p);
}
UString UString::number(double d)
{
NumberToStringBuffer buffer;
return UString(numberToString(d, buffer));
}
UString UString::substringSharingImpl(unsigned offset, unsigned length) const
{
unsigned stringLength = this->length();
offset = min(offset, stringLength);
length = min(length, stringLength - offset);
if (!offset && length == stringLength)
return *this;
return UString(StringImpl::create(m_impl, offset, length));
}
bool operator==(const UString& s1, const char *s2)
{
if (s1.isEmpty())
return !s2;
return equal(s1.impl(), s2);
}
bool equalSlowCase(const UString& s1, const UString& s2)
{
StringImpl* rep1 = s1.impl();
StringImpl* rep2 = s2.impl();
unsigned size1 = rep1->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) return true;
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)));
}
}
const UChar* d2 = rep2->characters16();
for (unsigned i = 0; i < size1; i++) {
if (d1[i] != d2[i])
return false;
}
return true;
}
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 true;
}
const UChar* d1 = rep1->characters16();
const UChar* d2 = rep2->characters16();
if (d1 == d2) return true;
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)));
}
}
bool operator<(const UString& s1, const UString& s2)
{
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]);
return (l1 < l2);
}
const UChar* c1 = s1.characters();
const UChar* c2 = s2.characters();
unsigned length = 0;
while (length < lmin && *c1 == *c2) {
c1++;
c2++;
length++;
}
if (length < lmin)
return (c1[0] < c2[0]);
return (l1 < l2);
}
bool operator>(const UString& s1, const UString& s2)
{
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++;
l++;
}
if (l < lmin)
return (c1[0] > c2[0]);
return (l1 > l2);
}
CString UString::ascii() const
{
unsigned length = this->length();
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 UString::latin1() const
{
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 result;
}
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 UString::utf8(bool strict) const
{
unsigned length = this->length();
if (!length)
return CString("", 0);
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); } else {
const UChar* characters = this->characters16();
ConversionResult result = convertUTF16ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size(), strict);
ASSERT(result != targetExhausted);
if (result == sourceIllegal)
return CString();
if (result == sourceExhausted) {
if (strict)
return CString();
ASSERT((characters + 1) == (this->characters() + length));
ASSERT((*characters >= 0xD800) && (*characters <= 0xDBFF));
ASSERT((buffer + 3) <= (buffer + bufferVector.size()));
putUTF8Triple(buffer, *characters);
}
}
return CString(bufferVector.data(), buffer - bufferVector.data());
}
}