/*

 * (C) 1999 Lars Knoll (knoll@kde.org)

 * Copyright (C) 2004, 2005, 2006, 2007, 2008 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 <limits>

#include <stdarg.h>

#include <wtf/ASCIICType.h>

#include <wtf/text/CString.h>

#include <wtf/StringExtras.h>

#include <wtf/Vector.h>

#include <wtf/dtoa.h>

#include <wtf/unicode/UTF8.h>

#include <wtf/unicode/Unicode.h>

using namespace WTF;

using namespace WTF::Unicode;

namespace WebCore {

String::String(const UChar* str)

{

    if (!str)

        return;

    int len = 0;

    while (str[len] != UChar(0))

        len++;

    m_impl = StringImpl::create(str, len);

}

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

            UChar* data;

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

        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;

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

}

String operator+(const String& a, const String& b)

{

    if (a.isEmpty())

        return b;

    if (b.isEmpty())

        return a;

    String c = a;

    c += b;

    return c;

}

String operator+(const String& s, const char* cs)

{

    return s + String(cs);

}

String operator+(const char* cs, const String& s)

{

    return String(cs) + s;

}

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 UChar* charactersToAppend, unsigned lengthToAppend)

{

    if (!m_impl) {

        if (!charactersToAppend)

            return;

        m_impl = StringImpl::create(charactersToAppend, lengthToAppend);

        return;

    }

    if (!lengthToAppend)

        return;

    ASSERT(charactersToAppend);

    UChar* data;

    RefPtr<StringImpl> newImpl =

        StringImpl::createUninitialized(length() + lengthToAppend, data);

    memcpy(data, characters(), length() * sizeof(UChar));

    memcpy(data + length(), charactersToAppend, lengthToAppend * sizeof(UChar));

    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;

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

}

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;

    UChar* data;

    RefPtr<StringImpl> newImpl =

        StringImpl::createUninitialized(length() - lengthToRemove, data);

    memcpy(data, characters(), position * sizeof(UChar));

    memcpy(data + position, characters() + position + lengthToRemove,

        (length() - lengthToRemove - position) * sizeof(UChar));

    m_impl = newImpl.release();

}

String String::substring(unsigned pos, unsigned len) const

{

    if (!m_impl) 

        return String();

    return m_impl->substring(pos, len);

}

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::simplifyWhiteSpace() const

{

    if (!m_impl)

        return String();

    return m_impl->simplifyWhiteSpace();

}

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

    return buffer;

#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(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(buffer.data(), len);

#endif

}

String String::number(short n)

{

    return String::format("%hd", n);

}

String String::number(unsigned short n)

{

    return String::format("%hu", n);

}

String String::number(int n)

{

    return String::format("%d", n);

}

String String::number(unsigned n)

{

    return String::format("%u", n);

}

String String::number(long n)

{

    return String::format("%ld", n);

}

String String::number(unsigned long n)

{

    return String::format("%lu", n);

}

String String::number(long long n)

{

#if OS(WINDOWS) && !PLATFORM(QT)

    return String::format("%I64i", n);

#else

    return String::format("%lli", n);

#endif

}

String String::number(unsigned long long n)

{

#if OS(WINDOWS) && !PLATFORM(QT)

    return String::format("%I64u", n);

#else

    return String::format("%llu", n);

#endif

}

String String::number(double n)

{

    return String::format("%.6lg", n);

}

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;