/*

 *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)

 *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

 *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)

 *  Copyright (C) 2009 Google Inc. All rights reserved.

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Library General Public

 *  License as published by the Free Software Foundation; either

 *  version 2 of the License, or (at your option) any later version.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Library General Public License for more details.

 *

 *  You should have received a copy of the GNU Library General Public License

 *  along with this library; see the file COPYING.LIB.  If not, write to

 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 *  Boston, MA 02110-1301, USA.

 *

 */

#include "config.h"

#include "UString.h"

#include "JSGlobalObjectFunctions.h"

#include "Collector.h"

#include "dtoa.h"

#include "Identifier.h"

#include "Operations.h"

#include <ctype.h>

#include <limits.h>

#include <limits>

#include <math.h>

#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/unicode/UTF8.h>

#include <wtf/StringExtras.h>

#if HAVE(STRINGS_H)

#include <strings.h>

#endif

using namespace WTF;

using namespace WTF::Unicode;

using namespace std;

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;

}

CString CString::adopt(char* c, size_t length)

{

    CString s;

    s.m_data = c;

    s.m_length = length;

    return s;

}

CString& CString::append(const CString& t)

{

    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;

}

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);

    return *this;

}

CString& CString::operator=(const CString& str)

{

    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)

{

    size_t len = c1.size();

    return len == c2.size() && (len == 0 || memcmp(c1.c_str(), c2.c_str(), len) == 0);

}

void initializeUString()

{

}

UString::UString(const char* c)

{

}

{

}

{

}

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) {

        char minBuf[1 + sizeof(i) * 3];

        sprintf(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 = '-';

    }

}

UString UString::from(long long 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 == std::numeric_limits<long long>::min()) {

        char minBuf[1 + sizeof(i) * 3];

        snprintf(minBuf, sizeof(minBuf) - 1, "%I64d", std::numeric_limits<long long>::min());

#else

        snprintf(minBuf, sizeof(minBuf) - 1, "%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 = '-';

    }

}

{

    UChar buf[sizeof(u) * 3];

    UChar* end = buf + sizeof(buf) / sizeof(UChar);

    UChar* p = end;

    if (u == 0)

        *--p = '0';

    else {

        while (u) {

            *--p = static_cast<unsigned short>((u % 10) + '0');

            u /= 10;

        }

    }

}

UString UString::from(long l)

{

    UChar buf[1 + sizeof(l) * 3];

    UChar* end = buf + sizeof(buf) / sizeof(UChar);

    UChar* p = end;

    if (l == 0)

        *--p = '0';

    else if (l == LONG_MIN) {

        char minBuf[1 + sizeof(l) * 3];

        sprintf(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 = '-';

    }

}

UString UString::from(double d)

{

}

bool UString::getCString(CStringBuffer& buffer) const

{

    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<char>(c);

        ++p;

        ++q;

    }

    *q = '\0';

    return !(ored & 0xFF00);

}

char* UString::ascii() const

{

    const UChar* p = data();

    const UChar* limit = p + length;

    while (p != limit) {

        *q = static_cast<char>(p[0]);

        ++p;

        ++q;

    }

    *q = '\0';

}

bool UString::is8Bit() const

{

    const UChar* u = data();

    const UChar* limit = u + size();

    while (u < limit) {

        if (u[0] > 0xFF)

            return false;

        ++u;

    }

    return true;

}

{

    if (pos >= size())

        return '\0';

    return data()[pos];

}

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++;

            }

            // 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<uint32_t>(d)) {

        b = false;

        d = 0;

    }

    if (ok)

        *ok = b;

    return static_cast<uint32_t>(d);

}

uint32_t UString::toUInt32(bool* ok, bool tolerateEmptyString) const

{

    double d = toDouble(false, tolerateEmptyString);

    bool b = true;

    if (d != static_cast<uint32_t>(d)) {

        b = false;

        d = 0;

    }

    if (ok)

        *ok = b;

    return static_cast<uint32_t>(d);

}

uint32_t UString::toStrictUInt32(bool* ok) const

{

    if (ok)

        *ok = false;

    // Empty string is not OK.

    if (len == 0)

        return 0;

    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;