/*

 *  This file is part of the KDE libraries

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

 *  Copyright (C) 2001 Peter Kelly (pmk@post.com)

 *  Copyright (C) 2003 Apple Computer, 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 "value.h"

#include "error_object.h"

#include "nodes.h"

#include "operations.h"

#include <stdio.h>

#include <string.h>

#include <wtf/MathExtras.h>

namespace KJS {

static const double D16 = 65536.0;

static const double D32 = 4294967296.0;

EXPORT

void *JSCell::operator new(size_t size)

{

    return Collector::allocate(size);

}

EXPORT

bool JSCell::getUInt32(unsigned&) const

{

    return false;

}

// ECMA 9.4

double JSValue::toInteger(ExecState *exec) const

{

    uint32_t i;

    if (getUInt32(i))

        return i;

    return roundValue(exec, const_cast<JSValue*>(this));

}

EXPORT

int32_t JSValue::toInt32(ExecState* exec) const

{

    bool ok;

    return toInt32(exec, ok);

}

EXPORT

int32_t JSValue::toInt32(ExecState* exec, bool& ok) const

{

    ok = true;

    uint32_t i;

    if (getUInt32(i))

        return i;

    double d = roundValue(exec, const_cast<JSValue*>(this));

    if (isNaN(d) || isInf(d)) {

        ok = false;

        return 0;

    }

    double d32 = fmod(d, D32);

    if (d32 >= D32 / 2)

        d32 -= D32;

    else if (d32 < -D32 / 2)

        d32 += D32;

    return static_cast<int32_t>(d32);

}

EXPORT

uint32_t JSValue::toUInt32(ExecState* exec) const

{

    bool ok;

    return toUInt32(exec, ok);

}

EXPORT

uint32_t JSValue::toUInt32(ExecState* exec, bool& ok) const

{

    ok = true;

    uint32_t i;

    if (getUInt32(i))

        return i;

    double d = roundValue(exec, const_cast<JSValue*>(this));

    if (isNaN(d) || isInf(d)) {

        ok = false;

        return 0;

    }

    double d32 = fmod(d, D32);

    if (d32 < 0)

        d32 += D32;

    return static_cast<uint32_t>(d32);

}

uint16_t JSValue::toUInt16(ExecState *exec) const

{

    uint32_t i;

    if (getUInt32(i))

        return static_cast<uint16_t>(i);

    double d = roundValue(exec, const_cast<JSValue*>(this));

    if (isNaN(d) || isInf(d))

        return 0;

    double d16 = fmod(d, D16);

    if (d16 < 0)

        d16 += D16;

    return static_cast<uint16_t>(d16);

}

EXPORT

float JSValue::toFloat(ExecState* exec) const

{

    return static_cast<float>(toNumber(exec));

}

bool JSCell::getNumber(double &numericValue) const

{

    if (!isNumber())

        return false;

    numericValue = static_cast<const NumberImp *>(this)->value();

    return true;

}

EXPORT

double JSCell::getNumber() const

{

    return isNumber() ? static_cast<const NumberImp *>(this)->value() : NaN;

}

EXPORT

bool JSCell::getString(UString &stringValue) const

{

    if (!isString())

        return false;

    stringValue = static_cast<const StringImp *>(this)->value();

    return true;

}

UString JSCell::getString() const

{

    return isString() ? static_cast<const StringImp *>(this)->value() : UString();

}

EXPORT

JSObject *JSCell::getObject()

{

    return isObject() ? static_cast<JSObject *>(this) : 0;

}

const JSObject *JSCell::getObject() const

{

    return isObject() ? static_cast<const JSObject *>(this) : 0;

}

EXPORT

JSCell* jsString(const char* s)

{

    return new StringImp(s ? s : "");

}

EXPORT

JSCell* jsString(const UString& s)

{

    return s.isNull() ? new StringImp("") : new StringImp(s);

}

EXPORT

JSCell* jsOwnedString(const UString& s)

{

    return s.isNull() ? new StringImp("", StringImp::HasOtherOwner) : new StringImp(s, StringImp::HasOtherOwner);

}

// This method includes a PIC branch to set up the NumberImp's vtable, so we quarantine

// it in a separate function to keep the normal case speedy.

EXPORT

JSValue *jsNumberCell(double d)

{

    return new NumberImp(d);

}

} // namespace KJS