/*

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

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "DeprecatedString.h"

#include "CString.h"

#include "FloatConversion.h"

#include "Logging.h"

#include "PlatformString.h"

#include "RegularExpression.h"

#include "TextEncoding.h"

#include <kjs/dtoa.h>

#include <kjs/identifier.h>

#include <stdarg.h>

#include <stdio.h>

#include <wtf/Platform.h>

#include <wtf/StringExtras.h>

#if PLATFORM(WIN_OS)

#include <windows.h>

#endif

#if PLATFORM(QT)

#include <QString>

#endif

#if PLATFORM(SYMBIAN)

#include <limits.h>

#endif

using namespace std;

using namespace KJS;

namespace WebCore {

COMPILE_ASSERT(sizeof(DeprecatedChar) == 2, deprecated_char_is_2_bytes)

#define CHECK_FOR_HANDLE_LEAKS 0

#if PLATFORM(SYMBIAN)

#undef CHECK_FOR_HANDLE_LEAKS

// symbian:fixme need page aligned allocations as Symbian platform does not have support for valloc

#define CHECK_FOR_HANDLE_LEAKS 1

#endif

#define ALLOC_QCHAR_GOOD_SIZE(X) (X)

#define ALLOC_CHAR_GOOD_SIZE(X) (X)

#define ALLOC_CHAR(N) (char*)fastMalloc(N)

#define REALLOC_CHAR(P, N) (char *)fastRealloc(P, N)

#define DELETE_CHAR(P) fastFree(P)

#define WEBCORE_ALLOCATE_CHARACTERS(N) (DeprecatedChar*)fastMalloc(sizeof(DeprecatedChar)*(N))

#define WEBCORE_REALLOCATE_CHARACTERS(P, N) (DeprecatedChar *)fastRealloc(P, sizeof(DeprecatedChar)*(N))

#define DELETE_QCHAR(P) fastFree(P)

#ifndef CHECK_FOR_HANDLE_LEAKS

struct HandleNode;

struct HandlePageNode;

static HandleNode *allocateNode(HandlePageNode *pageNode);

static HandlePageNode *allocatePageNode();

static HandlePageNode *usedNodeAllocationPages = 0;

static HandlePageNode *freeNodeAllocationPages = 0;

static inline void initializeHandleNodes()

{

    if (freeNodeAllocationPages == 0)

        freeNodeAllocationPages = allocatePageNode();

}

#endif

static inline DeprecatedStringData **allocateHandle()

{

#ifdef CHECK_FOR_HANDLE_LEAKS

    return static_cast<DeprecatedStringData **>(fastMalloc(sizeof(DeprecatedStringData *)));

#else

    initializeHandleNodes();

    return reinterpret_cast<DeprecatedStringData **>(allocateNode(freeNodeAllocationPages));

#endif

}

static void freeHandle(DeprecatedStringData **);

#define IS_ASCII_QCHAR(c) ((c).unicode() > 0 && (c).unicode() <= 0xff)

static const int caseDelta = ('a' - 'A');

const char * const DeprecatedString::null = 0;

DeprecatedStringData *DeprecatedString::shared_null = 0;

DeprecatedStringData **DeprecatedString::shared_null_handle = 0;

// -------------------------------------------------------------------------

// Utility functions

// -------------------------------------------------------------------------

static inline int ucstrcmp( const DeprecatedString &as, const DeprecatedString &bs )

{

    const DeprecatedChar *a = as.unicode();

    const DeprecatedChar *b = bs.unicode();

    if ( a == b )

        return 0;

    if ( a == 0 )

        return 1;

    if ( b == 0 )

        return -1;

    int l = min(as.length(), bs.length());

    while ( l-- && *a == *b )

        a++,b++;

    if ( l == -1 )

        return ( as.length() - bs.length() );

    return a->unicode() - b->unicode();

}

static bool equal(const DeprecatedChar *a, const char *b, int l)

{

    ASSERT(l >= 0);

    while (l--) {

        if (*a != *b)

            return false;

        a++; b++;

    }

    return true;

}

// Not a "true" case insensitive compare; only insensitive for plain ASCII.

static bool equalCaseInsensitive(const char *a, const char *b, int l)

{

    ASSERT(l >= 0);

    while (l--) {

        if (tolower(*a) != tolower(*b))

            return false;

        a++; b++;

    }

    return true;

}

static bool equalCaseInsensitive(const DeprecatedChar *a, const char *b, int l)

{

    ASSERT(l >= 0);

    while (l--) {

        if (tolower(a->unicode()) != tolower(*b))

            return false;

        a++; b++;

    }

    return true;

}

static bool equalCaseInsensitive(const DeprecatedChar *a, const DeprecatedChar *b, int l)

{

    ASSERT(l >= 0);

    while (l--) {

        if (tolower(a->unicode()) != tolower(b->unicode()))

            return false;

        a++; b++;

    }

    return true;

}

static inline bool equalCaseInsensitive(char c1, char c2)

{

    return tolower(c1) == tolower(c2);

}

static inline bool equalCaseInsensitive(DeprecatedChar c1, char c2)

{

    return tolower(c1.unicode()) == tolower(static_cast<unsigned char>(c2));

}

static bool isCharacterAllowedInBase(DeprecatedChar c, int base)

{

    int uc = c.unicode();

    if (uc > 0x7F)

        return false;

    if (isdigit(uc))

        return uc - '0' < base;

    if (isalpha(uc)) {

        if (base > 36)

            base = 36;

        return (uc >= 'a' && uc < 'a' + base - 10)

            || (uc >= 'A' && uc < 'A' + base - 10);

    }

    return false;

}

// -------------------------------------------------------------------------

// DeprecatedStringData

// -------------------------------------------------------------------------

// FIXME, make constructor explicity take a 'copy' flag.

// This can be used to hand off ownership of allocated data when detaching and

// deleting QStrings.

DeprecatedStringData::DeprecatedStringData() :

        refCount(1), _length(0), _unicode(0), _ascii(0), _maxUnicode(WEBCORE_DS_INTERNAL_BUFFER_UCHARS), _isUnicodeValid(0), _isHeapAllocated(0), _maxAscii(WEBCORE_DS_INTERNAL_BUFFER_CHARS), _isAsciiValid(1) 

{ 

    _ascii = _internalBuffer;

    _internalBuffer[0] = 0;

}

void DeprecatedStringData::initialize()

{

    refCount = 1;

    _length = 0;

    _unicode = 0;

    _ascii = _internalBuffer;

    _maxUnicode = WEBCORE_DS_INTERNAL_BUFFER_UCHARS;

    _isUnicodeValid = 0;

    _maxAscii = WEBCORE_DS_INTERNAL_BUFFER_CHARS;

    _isAsciiValid = 1;

    _internalBuffer[0] = 0;

    _isHeapAllocated = 0;

}

// Don't copy data.

DeprecatedStringData::DeprecatedStringData(DeprecatedChar *u, unsigned l, unsigned m) :

        refCount(1), _length(l), _unicode(u), _ascii(0), _maxUnicode(m), _isUnicodeValid(1), _isHeapAllocated(0), _maxAscii(WEBCORE_DS_INTERNAL_BUFFER_CHARS), _isAsciiValid(0)

{

    ASSERT(m >= l);

}

// Don't copy data.

void DeprecatedStringData::initialize(DeprecatedChar *u, unsigned l, unsigned m)

{

    ASSERT(m >= l);

    refCount = 1;

    _length = l;

    _unicode = u;

    _ascii = 0;

    _maxUnicode = m;

    _isUnicodeValid = 1;

    _maxAscii = 0;

    _isAsciiValid = 0;

    _isHeapAllocated = 0;

}

// Copy data

DeprecatedStringData::DeprecatedStringData(const DeprecatedChar *u, unsigned l)

{

    initialize (u, l);

}

// Copy data

void DeprecatedStringData::initialize(const DeprecatedChar *u, unsigned l)

{

    refCount = 1;

    _length = l;

    _ascii = 0;

    _isUnicodeValid = 1;

    _maxAscii = 0;

    _isAsciiValid = 0;

    _isHeapAllocated = 0;

    if (l > WEBCORE_DS_INTERNAL_BUFFER_UCHARS) {

        _maxUnicode = ALLOC_QCHAR_GOOD_SIZE(l);

        _unicode = WEBCORE_ALLOCATE_CHARACTERS(_maxUnicode);

        memcpy(_unicode, u, l*sizeof(DeprecatedChar));

    } else {

        _maxUnicode = WEBCORE_DS_INTERNAL_BUFFER_UCHARS;

        _unicode = (DeprecatedChar *)_internalBuffer;

        if (l)

            memcpy(_internalBuffer, u, l*sizeof(DeprecatedChar));

    }

}

// Copy data

DeprecatedStringData::DeprecatedStringData(const char *a, unsigned l)

{

    initialize(a, l);

}

// Copy data

void DeprecatedStringData::initialize(const char *a, unsigned l)

{

    refCount = 1;

    _length = l;

    _unicode = 0;

    _isUnicodeValid = 0;

    _maxUnicode = 0;

    _isAsciiValid = 1;

    _isHeapAllocated = 0;

    if (l > WEBCORE_DS_INTERNAL_BUFFER_CHARS) {

        _maxAscii = ALLOC_CHAR_GOOD_SIZE(l+1);

        _ascii = ALLOC_CHAR(_maxAscii);

        if (a)

            memcpy(_ascii, a, l);

        _ascii[l] = 0;

    } else {

        _maxAscii = WEBCORE_DS_INTERNAL_BUFFER_CHARS;

        _ascii = _internalBuffer;

        if (a)

            memcpy(_internalBuffer, a, l);

        _internalBuffer[l] = 0;

    }

}

DeprecatedStringData* DeprecatedStringData::createAndAdopt(DeprecatedStringData &o)

{

    DeprecatedStringData* data = new DeprecatedStringData();

    data->adopt(o);

    return data;

}

void DeprecatedStringData::adopt(DeprecatedStringData& o)

{

    ASSERT(refCount == 1);

    _length = o._length;

    _unicode = o._unicode;

    _ascii = o._ascii;

    _maxUnicode = o._maxUnicode;

    _isUnicodeValid = o._isUnicodeValid;

    _isHeapAllocated = 0;

    _maxAscii = o._maxAscii;

    _isAsciiValid = o._isAsciiValid;

    // Handle the case where either the Unicode or 8-bit pointer was

    // pointing to the internal buffer. We need to point at the

    // internal buffer in the new object, and copy the characters.

    if (_unicode == reinterpret_cast<DeprecatedChar *>(o._internalBuffer)) {

        if (_isUnicodeValid) {

            ASSERT(!_isAsciiValid || _ascii != o._internalBuffer);

            ASSERT(_length <= WEBCORE_DS_INTERNAL_BUFFER_UCHARS);

            memcpy(_internalBuffer, o._internalBuffer, _length * sizeof(DeprecatedChar));

            _unicode = reinterpret_cast<DeprecatedChar *>(_internalBuffer);

        } else {

            _unicode = 0;

        }

    }

    if (_ascii == o._internalBuffer) {

        if (_isAsciiValid) {

            ASSERT(_length <= WEBCORE_DS_INTERNAL_BUFFER_CHARS);

            memcpy(_internalBuffer, o._internalBuffer, _length);

            _internalBuffer[_length] = 0;

            _ascii = _internalBuffer;

        } else {

            _ascii = 0;

        }

    }

    // Clean up the other DeprecatedStringData just enough so that it can be destroyed

    // cleanly. It's not in a good enough state to use, but that's OK. It just

    // needs to be in a state where ~DeprecatedStringData won't do anything harmful,

    // and setting these to 0 will do that (preventing any double-free problems).

    o._unicode = 0;

    o._ascii = 0;

}

DeprecatedStringData *DeprecatedString::makeSharedNull()

{

    if (!shared_null) {

        shared_null = new DeprecatedStringData;

        shared_null->ref();

        shared_null->_maxAscii = 0;

        shared_null->_maxUnicode = 0;

        shared_null->_unicode = (DeprecatedChar *)&shared_null->_internalBuffer[0]; 

        shared_null->_isUnicodeValid = 1;   

    }

    return shared_null;

}

DeprecatedStringData **DeprecatedString::makeSharedNullHandle()

{

    if (!shared_null_handle) {

        shared_null_handle = allocateHandle();

        *shared_null_handle = makeSharedNull();

    }

    return shared_null_handle;

}

DeprecatedStringData::~DeprecatedStringData()

{

    ASSERT(refCount == 0);

    if (_unicode && !isUnicodeInternal())

        DELETE_QCHAR(_unicode);

    if (_ascii && !isAsciiInternal())

        DELETE_CHAR(_ascii);

}

void DeprecatedStringData::increaseAsciiSize(unsigned size)

{

    ASSERT(this != DeprecatedString::shared_null);

    unsigned newSize = (unsigned)ALLOC_CHAR_GOOD_SIZE((size * 3 + 1) / 2);

    if (!_isAsciiValid)

        makeAscii();

    ASSERT(_isAsciiValid);

    if (isAsciiInternal()) {

        char *newAscii = ALLOC_CHAR(newSize);

        if (_length)

            memcpy(newAscii, _ascii, _length);

        _ascii = newAscii;

    } else {

        _ascii = REALLOC_CHAR(_ascii, newSize);

    }

    _maxAscii = newSize;

    _isAsciiValid = 1;

    _isUnicodeValid = 0;

}

void DeprecatedStringData::increaseUnicodeSize(unsigned size)

{

    ASSERT(size > _length);

    ASSERT(this != DeprecatedString::shared_null);

    unsigned newSize = (unsigned)ALLOC_QCHAR_GOOD_SIZE((size * 3 + 1) / 2);

    if (!_isUnicodeValid)

        makeUnicode();

    ASSERT(_isUnicodeValid);

    if (isUnicodeInternal()) {

        DeprecatedChar *newUni = WEBCORE_ALLOCATE_CHARACTERS(newSize);

        if (_length)

            memcpy(newUni, _unicode, _length*sizeof(DeprecatedChar));

        _unicode = newUni;

    } else {

        _unicode = WEBCORE_REALLOCATE_CHARACTERS(_unicode, newSize);

    }

    _maxUnicode = newSize;

    _isUnicodeValid = 1;

    _isAsciiValid = 0;

}

char *DeprecatedStringData::makeAscii()

{

    ASSERT(this != DeprecatedString::shared_null);

    if (_isUnicodeValid){

        DeprecatedChar copyBuf[WEBCORE_DS_INTERNAL_BUFFER_CHARS];

        DeprecatedChar *str;

        if (_ascii && !isAsciiInternal())

            DELETE_QCHAR(_ascii);

        if (_length < WEBCORE_DS_INTERNAL_BUFFER_CHARS){

            if (isUnicodeInternal()) {

                unsigned i = _length;

                DeprecatedChar *tp = &copyBuf[0], *fp = _unicode;

                while (i--)

                    *tp++ = *fp++;

                str = &copyBuf[0];

                _isUnicodeValid = 0;

            }

            else

                str = _unicode;

            _ascii = _internalBuffer;

            _maxAscii = WEBCORE_DS_INTERNAL_BUFFER_CHARS;

        }

        else {

            unsigned newSize = ALLOC_CHAR_GOOD_SIZE(_length+1);

            _ascii = ALLOC_CHAR(newSize);

            _maxAscii = newSize;

            str = _unicode;

        }

        unsigned i = _length;

        char* cp = _ascii;

        while (i--)

            // FIXME: this converts non-Latin1 characters to '\0', which may be not what we want in some cases.

            // In particular, toDouble() may fail to report errors, believing that the string ends earlier

            // than it actually does.

            *cp++ = (*str++).latin1();

        *cp = 0;

        _isAsciiValid = 1;

    }

    else if (!_isAsciiValid)

        FATAL("ASCII character cache not valid");

    return _ascii;

}

DeprecatedChar *DeprecatedStringData::makeUnicode()

{

    ASSERT(this != DeprecatedString::shared_null);

    if (_isAsciiValid){

        char copyBuf[WEBCORE_DS_INTERNAL_BUFFER_CHARS];

        char *str;

        if (_unicode && !isUnicodeInternal())

            DELETE_QCHAR(_unicode);

        if (_length <= WEBCORE_DS_INTERNAL_BUFFER_UCHARS){

            if (isAsciiInternal()) {

                unsigned i = _length;

                char *tp = &copyBuf[0], *fp = _ascii;

                while (i--)

                    *tp++ = *fp++;