/**

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

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 *           (C) 2001 Dirk Mueller ( mueller@kde.org )

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

 * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)

 *

 * 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 "StringImpl.h"

#include "AtomicString.h"

#include "CString.h"

#include "CharacterNames.h"

#include "DeprecatedString.h"

#include "FloatConversion.h"

#include "Length.h"

#include "StringHash.h"

#include "TextBreakIterator.h"

#include "TextEncoding.h"

#include <kjs/dtoa.h>

#include <kjs/identifier.h>

#include <wtf/Assertions.h>

#include <wtf/unicode/Unicode.h>

using namespace WTF;

using namespace Unicode;

using KJS::Identifier;

using KJS::UString;

namespace WebCore {

static inline bool isSpace(UChar c)

{

    // Use isspace() for basic Latin-1.

    // This will include newlines, which aren't included in unicode DirWS.

    return c <= 0x7F ? isspace(c) : direction(c) == WhiteSpaceNeutral;

}    

static inline UChar* newUCharVector(unsigned n)

{

    return static_cast<UChar*>(fastMalloc(sizeof(UChar) * n));

}

static inline void deleteUCharVector(UChar* p)

{

    fastFree(p);

}

StringImpl* StringImpl::empty()

{

    static WithOneRef w;

    static StringImpl e(w);

    return &e;

}

StringImpl::StringImpl(const DeprecatedString& str)

{

    init(reinterpret_cast<const UChar*>(str.unicode()), str.length());

}

StringImpl::StringImpl(const UChar* str, unsigned len)

{

    init(str, len);

}

StringImpl::StringImpl(const char* str)

{

    init(str, strlen(str));

}

StringImpl::StringImpl(const char* str, unsigned len)

{

    init(str, len);

}

void StringImpl::init(const char* str, unsigned len)

{

    m_hash = 0;

    m_inTable = false;

    m_hasTerminatingNullCharacter = false;

    m_length = len;

    if (!m_length || !str) {

        m_data = 0;

        return;

    }

    m_data = newUCharVector(m_length);

    int i = m_length;

    UChar* ptr = m_data;

    while (i--) {

        unsigned char c = *str++;

        *ptr++ = c;

    }

}

void StringImpl::init(const UChar* str, unsigned len)

{

    m_hash = 0;

    m_inTable = false;

    m_hasTerminatingNullCharacter = false;

    m_length = len;

    if (!m_length || !str) {

        m_data = 0;

        return;

    }

    m_data = newUCharVector(len);

    memcpy(m_data, str, len * sizeof(UChar));

}

StringImpl::~StringImpl()

{

    if (m_inTable)

        AtomicString::remove(this);

    deleteUCharVector(m_data);

}

const UChar* StringImpl::charactersWithNullTermination()

{

    if (m_hasTerminatingNullCharacter)

        return m_data;

    m_data = static_cast<UChar*>(fastRealloc(m_data, (m_length + 1) * sizeof(UChar)));

    m_data[m_length] = 0;

    m_hasTerminatingNullCharacter = true;

    return m_data;

}

void StringImpl::append(const UChar* str, unsigned length)

{

    ASSERT(!m_inTable);

    if (str && length != 0) {

        int newlen = m_length + length;

        UChar* c = newUCharVector(newlen);

        memcpy(c, m_data, m_length * sizeof(UChar));

        memcpy(c + m_length, str, length * sizeof(UChar));

        deleteUCharVector(m_data);

        m_data = c;

        m_length = newlen;

        m_hasTerminatingNullCharacter = false;

    }

}

void StringImpl::append(const StringImpl* str)

{

    if (str)

        append(str->m_data, str->m_length);

}

void StringImpl::append(char c)

{

    append(UChar(c));

}

void StringImpl::append(UChar c)

{

    ASSERT(!m_inTable);

    UChar* nc = newUCharVector(m_length + 1);

    memcpy(nc, m_data, m_length * sizeof(UChar));

    nc[m_length] = c;

    deleteUCharVector(m_data);

    m_data = nc;

    m_length++;

    m_hasTerminatingNullCharacter = false;

}

void StringImpl::insert(const UChar* str, unsigned length, unsigned pos)

{

    ASSERT(!m_inTable);

    if (pos >= m_length) {

        append(str, length);

        return;

    }

    if (str && length != 0) {

        size_t newlen = m_length + length;

        UChar* c = newUCharVector(newlen);

        memcpy(c, m_data, pos * sizeof(UChar));

        memcpy(c + pos, str, length * sizeof(UChar));

        memcpy(c + pos + length, m_data + pos, (m_length - pos) * sizeof(UChar));

        deleteUCharVector(m_data);

        m_data = c;

        m_length = newlen;

        m_hasTerminatingNullCharacter = false;

    }

}

void StringImpl::insert(const StringImpl* str, unsigned pos)

{

    if (str)

        insert(str->m_data, str->m_length, pos);

}

void StringImpl::truncate(int len)

{

    ASSERT(!m_inTable);

    if (len >= (int)m_length)

        return;

    int nl = len < 1 ? 1 : len;

    UChar* c = newUCharVector(nl);

    memcpy(c, m_data, nl * sizeof(UChar));

    deleteUCharVector(m_data);

    m_data = c;

    m_length = len;

    m_hasTerminatingNullCharacter = false;

}

void StringImpl::remove(unsigned pos, int len)

{

    ASSERT(!m_inTable);

    if (len <= 0)

        return;

    if (pos >= m_length)

        return;

    if ((unsigned)len > m_length - pos)

        len = m_length - pos;

    unsigned newLen = m_length-len;

    UChar* c = newUCharVector(newLen);

    memcpy(c, m_data, pos * sizeof(UChar));

    memcpy(c + pos, m_data + pos + len, (m_length - len - pos) * sizeof(UChar));

    deleteUCharVector(m_data);

    m_data = c;

    m_length = newLen;

    m_hasTerminatingNullCharacter = false;

}

bool StringImpl::containsOnlyWhitespace() const

{

    return containsOnlyWhitespace(0, m_length);

}

bool StringImpl::containsOnlyWhitespace(unsigned from, unsigned len) const

{

    if (!m_data)

        return true;

    // FIXME: Both the definition of what whitespace is, and the definition of what

    // the "len" parameter means are different here from what's done in RenderText.

    // FIXME: No range checking here.

    for (unsigned i = from; i < len; i++)

        if (m_data[i] > 0x7F || !isspace(m_data[i]))

            return false;

    return true;

}

StringImpl* StringImpl::substring(unsigned pos, unsigned len)

{

    if (pos >= m_length) return

        new StringImpl;

    if (len > m_length - pos)

        len = m_length - pos;

    return new StringImpl(m_data + pos, len);

}

static Length parseLength(const UChar* m_data, unsigned int m_length)

{

    if (m_length == 0)

        return Length(1, Relative);

    unsigned i = 0;

    while (i < m_length && isSpace(m_data[i]))

        ++i;

    if (i < m_length && (m_data[i] == '+' || m_data[i] == '-'))

        ++i;

    while (i < m_length && Unicode::isDigit(m_data[i]))

        ++i;

    bool ok;

    int r = DeprecatedConstString(reinterpret_cast<const DeprecatedChar*>(m_data), i).string().toInt(&ok);

    /* Skip over any remaining digits, we are not that accurate (5.5% => 5%) */

    while (i < m_length && (Unicode::isDigit(m_data[i]) || m_data[i] == '.'))

        ++i;

    /* IE Quirk: Skip any whitespace (20 % => 20%) */

    while (i < m_length && DeprecatedChar(m_data[i]).isSpace())

        ++i;

    if (ok) {

        if (i < m_length) {

            UChar next = m_data[i];

            if (next == '%')

                return Length(static_cast<double>(r), Percent);

            if (next == '*')

                return Length(r, Relative);

        }

        return Length(r, Fixed);

    } else {

        if (i < m_length) {

            UChar next = m_data[i];

            if (next == '*')

                return Length(1, Relative);

            if (next == '%')

                return Length(1, Relative);

        }

    }

    return Length(0, Relative);

}

Length StringImpl::toLength() const

{

    return parseLength(m_data, m_length);

}

Length* StringImpl::toCoordsArray(int& len) const

{

    UChar* spacified = newUCharVector(m_length);

    for (unsigned i = 0; i < m_length; i++) {

        UChar cc = m_data[i];

        if (cc > '9' || (cc < '0' && cc != '-' && cc != '*' && cc != '.'))

            spacified[i] = ' ';

        else

            spacified[i] = cc;

    }

    DeprecatedString str(reinterpret_cast<const DeprecatedChar*>(spacified), m_length);

    deleteUCharVector(spacified);

    str = str.simplifyWhiteSpace();

    len = str.contains(' ') + 1;

    Length* r = new Length[len];

    int i = 0;

    int pos = 0;

    int pos2;

    while((pos2 = str.find(' ', pos)) != -1) {

        r[i++] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, pos2 - pos);

        pos = pos2+1;

    }

    r[i] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, str.length() - pos);

    return r;

}

Length* StringImpl::toLengthArray(int& len) const

{

    DeprecatedString str(reinterpret_cast<const DeprecatedChar*>(m_data), m_length);

    str = str.simplifyWhiteSpace();

    if (!str.length()) {

        len = 1;

        return 0;

    }

    len = str.contains(',') + 1;

    Length* r = new Length[len];

    int i = 0;

    int pos = 0;

    int pos2;

    while ((pos2 = str.find(',', pos)) != -1) {

        r[i++] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, pos2 - pos);

        pos = pos2+1;

    }

    /* IE Quirk: If the last comma is the last char skip it and reduce len by one */

    if (str.length()-pos > 0)

        r[i] = parseLength(reinterpret_cast<const UChar*>(str.unicode()) + pos, str.length() - pos);

    else

        len--;

    return r;

}

bool StringImpl::isLower() const

{

    // Do a faster loop for the case where all the characters are ASCII.

    bool allLower = true;

    UChar ored = 0;

    for (unsigned i = 0; i < m_length; i++) {

        UChar c = m_data[i];

        // The islower function is only guaranteed to work correctly and 

        // in a locale-independent fashion for ASCII characters. We mask

        // to guarantee we don't pass any non-ASCII values in.

        allLower = allLower && islower(c & 0x7F);

        ored |= c;

    }

    if (!(ored & ~0x7F))

        return allLower;

    // Do a slower check for cases that include non-ASCII characters.

    allLower = true;

    unsigned i = 0;

    while (i < m_length) {

        UChar32 character;

        U16_NEXT(m_data, i, m_length, character)

        allLower = allLower && Unicode::isLower(character);

    }

    return allLower;

}

StringImpl* StringImpl::lower() const

{

    StringImpl* c = new StringImpl;

    if (!m_length)

        return c;

    UChar* data = newUCharVector(m_length);

    int length = m_length;

    c->m_data = data;

    c->m_length = length;

    // Do a faster loop for the case where all the characters are ASCII.

    UChar ored = 0;

    for (int i = 0; i < length; i++) {

        UChar c = m_data[i];

        ored |= c;

        // The tolower function is only guaranteed to work correctly and 

        // in a locale-independent fashion for ASCII characters. We mask

        // to guarantee we don't pass any non-ASCII values in.

        data[i] = tolower(c & 0x7F);

    }

    if (!(ored & ~0x7F))

        return c;

    // Do a slower implementation for cases that include non-ASCII characters.

    bool error;

    int32_t realLength = Unicode::toLower(data, length, m_data, m_length, &error);

    if (!error && realLength == length)

        return c;

    if (realLength > length) {

        deleteUCharVector(data);

        data = newUCharVector(realLength);

    }

    length = realLength;

    c->m_data = data;

    c->m_length = length;

    Unicode::toLower(data, length, m_data, m_length, &error);

    if (error) {

        c->ref();

        c->deref();

        return copy();

    }

    return c;

}

StringImpl* StringImpl::upper() const

{

    StringImpl* c = new StringImpl;

    if (!m_length)

        return c;

    bool error;

    int32_t length = Unicode::toUpper(0, 0, m_data, m_length, &error);

    c->m_data = newUCharVector(length);

    c->m_length = length;

    Unicode::toUpper(c->m_data, length, m_data, m_length, &error);

    if (error) {

        c->ref();

        c->deref();

        return copy();

    }

    return c;

}

StringImpl* StringImpl::secure(UChar aChar) const

{

    int length = m_length;

    UChar* data = newUCharVector(length);

    for (int i = 0; i < length; ++i)

        data[i] = aChar;

    StringImpl* c = new StringImpl;

    c->m_data = data;

    c->m_length = length;

    return c;

}

#if PLATFORM(SYMBIAN)

{

    StringImpl* temp = secure(aChar);

    if (m_data && temp) {

        }

    return temp; 

}

#endif

StringImpl* StringImpl::foldCase() const

{

    StringImpl* c = new StringImpl;

    if (!m_length)

        return c;

    bool error;

    int32_t length = Unicode::foldCase(0, 0, m_data, m_length, &error);

    c->m_data = newUCharVector(length);

    c->m_length = length;

    Unicode::foldCase(c->m_data, length, m_data, m_length, &error);

    if (error) {

        c->ref();

        c->deref();

        return copy();

    }

    return c;

}

StringImpl* StringImpl::stripWhiteSpace() const

{

    StringImpl* c = new StringImpl;

    if (!m_length)

        return c;