/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtQml module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QV4VALUE_P_H
#define QV4VALUE_P_H

//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//

#include <limits.h>
#include <cmath>

#include <QtCore/QString>
#include "qv4global_p.h"
#include <private/qv4heap_p.h>
#include <private/qv4internalclass_p.h>

#include <private/qnumeric_p.h>

QT_BEGIN_NAMESPACE

namespace QV4 {

namespace Heap {
    struct Base;
}

struct Q_QML_PRIVATE_EXPORT Value
{
    /*
        We use 8 bytes for a value and a different variant of NaN boxing. A Double
        NaN (actually -qNaN) is indicated by a number that has the top 13 bits set, and for a
        signalling NaN it is the top 14 bits. The other values are usually set to 0 by the
        processor, and are thus free for us to store other data. We keep pointers in there for
        managed objects, and encode the other types using the free space given to use by the unused
        bits for NaN values. This also works for pointers on 64 bit systems, as they all currently
        only have 48 bits of addressable memory. (Note: we do leave the lower 49 bits available for
        pointers.)

        We xor Doubles with (0xffff8000 << 32). That has the effect that no doubles will
        get encoded with bits 63-49 all set to 0. We then use bit 48 to distinguish between
        managed/undefined (0), or Null/Int/Bool/Empty (1). So, storing a 49 bit pointer will leave
        the top 15 bits 0, which is exactly the 'natural' representation of pointers. If bit 49 is
        set, bit 48 indicates Empty (0) or integer-convertible (1). Then the 3 bit below that are
        used to encode Null/Int/Bool.

        Undefined is encoded as a managed pointer with value 0. This is the same as a nullptr.

        Specific bit-sequences:
        0 = always 0
        1 = always 1
        x = stored value
        a,b,c,d = specific bit values, see notes

        32109876 54321098 76543210 98765432 10987654 32109876 54321098 76543210 |
        66665555 55555544 44444444 33333333 33222222 22221111 11111100 00000000 | JS Value
        ------------------------------------------------------------------------+--------------
        00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 | Undefined
        00000000 0000000x xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx | Managed (heap pointer)
        a0000000 0000bc00 00000000 00000000 00000000 00000000 00000000 00000000 | NaN/Inf
        dddddddd ddddddxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx | double
        00000000 00000010 00000000 00000000 00000000 00000000 00000000 00000000 | empty (non-sparse array hole)
        00000000 00000010 10000000 00000000 00000000 00000000 00000000 00000000 | Null
        00000000 00000011 00000000 00000000 00000000 00000000 00000000 0000000x | Bool
        00000000 00000011 10000000 00000000 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx | Int

        Notes:
        - a: xor-ed signbit, always 1 for NaN
        - bc, xor-ed values: 11 = inf, 10 = sNaN, 01 = qNaN, 00 = boxed value
        - d: xor-ed bits, where at least one bit is set, so: (val >> (64-14)) > 0
        - Undefined maps to C++ nullptr, so the "default" initialization is the same for both C++
          and JS
        - Managed has the left 15 bits set to 0, so: (val >> (64-15)) == 0
        - empty, Null, Bool, and Int have the left 14 bits set to 0, and bit 49 set to 1,
          so: (val >> (64-15)) == 1
        - Null, Bool, and Int have bit 48 set, indicating integer-convertible
        - xoring _val with NaNEncodeMask will convert to a double in "natural" representation, where
          any non double results in a NaN
        - on 32bit we can use the fact that addresses are 32bits wide, so the tag part (bits 32 to
          63) are zero. No need to shift.
    */

    quint64 _val;

    QML_NEARLY_ALWAYS_INLINE Q_DECL_RELAXED_CONSTEXPR quint64 &rawValueRef() { return _val; }
    QML_NEARLY_ALWAYS_INLINE Q_DECL_RELAXED_CONSTEXPR quint64 rawValue() const { return _val; }
    QML_NEARLY_ALWAYS_INLINE Q_DECL_RELAXED_CONSTEXPR void setRawValue(quint64 raw) { _val = raw; }

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
    static inline int valueOffset() { return 0; }
    static inline int tagOffset() { return 4; }
#else // !Q_LITTLE_ENDIAN
    static inline int valueOffset() { return 4; }
    static inline int tagOffset() { return 0; }
#endif
    static inline constexpr quint64 tagValue(quint32 tag, quint32 value) { return quint64(tag) << 32 | value; }
    QML_NEARLY_ALWAYS_INLINE Q_DECL_RELAXED_CONSTEXPR void setTagValue(quint32 tag, quint32 value) { _val = quint64(tag) << 32 | value; }
    QML_NEARLY_ALWAYS_INLINE constexpr quint32 value() const { return _val & quint64(~quint32(0)); }
    QML_NEARLY_ALWAYS_INLINE constexpr quint32 tag() const { return _val >> 32; }
    QML_NEARLY_ALWAYS_INLINE Q_DECL_RELAXED_CONSTEXPR void setTag(quint32 tag) { setTagValue(tag, value()); }

#if QT_POINTER_SIZE == 8
    QML_NEARLY_ALWAYS_INLINE Heap::Base *m() const
    {
        Heap::Base *b;
        memcpy(&b, &_val, 8);
        return b;
    }
    QML_NEARLY_ALWAYS_INLINE void setM(Heap::Base *b)
    {
        memcpy(&_val, &b, 8);
    }
#elif QT_POINTER_SIZE == 4
    QML_NEARLY_ALWAYS_INLINE Heap::Base *m() const
    {
        Q_STATIC_ASSERT(sizeof(Heap::Base*) == sizeof(quint32));
        Heap::Base *b;
        quint32 v = value();
        memcpy(&b, &v, 4);
        return b;
    }
    QML_NEARLY_ALWAYS_INLINE void setM(Heap::Base *b)
    {
        quint32 v;
        memcpy(&v, &b, 4);
        setTagValue(Managed_Type_Internal, v);
    }
#else
#  error "unsupported pointer size"
#endif

    QML_NEARLY_ALWAYS_INLINE constexpr int int_32() const
    {
        return int(value());
    }
    QML_NEARLY_ALWAYS_INLINE Q_DECL_RELAXED_CONSTEXPR void setInt_32(int i)
    {
        setTagValue(quint32(ValueTypeInternal::Integer), quint32(i));
    }
    QML_NEARLY_ALWAYS_INLINE uint uint_32() const { return value(); }

    QML_NEARLY_ALWAYS_INLINE Q_DECL_RELAXED_CONSTEXPR void setEmpty()
    {
        setTagValue(quint32(ValueTypeInternal::Empty), 0);
    }

    // ### Fix for 32 bit (easiest solution is to set highest bit to 1 for mananged/undefined/integercompatible
    // and use negative numbers here
    enum QuickType {
        QT_ManagedOrUndefined = 0,
        QT_ManagedOrUndefined1 = 1,
        QT_ManagedOrUndefined2 = 2,
        QT_ManagedOrUndefined3 = 3,
        QT_Empty = 4,
        QT_Null = 5,
        QT_Bool = 6,
        QT_Int = 7
        // all other values are doubles
    };

    enum Type {
        Undefined_Type = 0,
        Managed_Type = 1,
        Empty_Type = 4,
        Null_Type = 5,
        Boolean_Type = 6,
        Integer_Type = 7,
        Double_Type = 8
    };

    inline Type type() const {
        int t = quickType();
        if (t < QT_Empty)
            return _val ? Managed_Type : Undefined_Type;
        if (t > QT_Int)
            return Double_Type;
        return static_cast<Type>(t);
    }

    // Shared between 32-bit and 64-bit encoding
    enum {
        Tag_Shift = 32
    };

    // Used only by 64-bit encoding
    static const quint64 NaNEncodeMask = 0xfffc000000000000ull;
    enum {
        IsDouble_Shift = 64-14,
        IsManagedOrUndefined_Shift = 64-15,
        IsIntegerConvertible_Shift = 64-15,
        IsIntegerOrBool_Shift = 64-16,
        QuickType_Shift = 64 - 17,
        IsPositiveIntShift = 31
    };

    static const quint64 Immediate_Mask_64 = 0x00020000u; // bit 49

    enum class ValueTypeInternal_64 {
        Empty            = Immediate_Mask_64 | 0,
        Null             = Immediate_Mask_64 | 0x08000u,
        Boolean          = Immediate_Mask_64 | 0x10000u,
        Integer          = Immediate_Mask_64 | 0x18000u
    };

    // Used only by 32-bit encoding
    enum Masks {
        SilentNaNBit           =                  0x00040000,
        NotDouble_Mask         =                  0x7ffa0000,
    };
    static const quint64 Immediate_Mask_32 = NotDouble_Mask | 0x00020000u | SilentNaNBit;

    enum class ValueTypeInternal_32 {
        Empty            = Immediate_Mask_32 | 0,
        Null             = Immediate_Mask_32 | 0x08000u,
        Boolean          = Immediate_Mask_32 | 0x10000u,
        Integer          = Immediate_Mask_32 | 0x18000u
    };

    enum {
        Managed_Type_Internal = 0
    };

    using ValueTypeInternal = ValueTypeInternal_64;

    enum {
        NaN_Mask = 0x7ff80000,
    };

    inline quint64 quickType() const { return (_val >> QuickType_Shift); }

    // used internally in property
    inline bool isEmpty() const { return tag() == quint32(ValueTypeInternal::Empty); }
    inline bool isNull() const { return tag() == quint32(ValueTypeInternal::Null); }
    inline bool isBoolean() const { return tag() == quint32(ValueTypeInternal::Boolean); }
    inline bool isInteger() const { return tag() == quint32(ValueTypeInternal::Integer); }
    inline bool isNullOrUndefined() const { return isNull() || isUndefined(); }
    inline bool isNumber() const { return quickType() >= QT_Int; }

    inline bool isUndefined() const { return _val == 0; }
    inline bool isDouble() const { return (_val >> IsDouble_Shift); }
    inline bool isManaged() const
    {
#if QT_POINTER_SIZE == 4
        return value() && tag() == Managed_Type_Internal;
#else
        return _val && ((_val >> IsManagedOrUndefined_Shift) == 0);
#endif
    }
    inline bool isManagedOrUndefined() const
    {
#if QT_POINTER_SIZE == 4
        return tag() == Managed_Type_Internal;
#else
        return ((_val >> IsManagedOrUndefined_Shift) == 0);
#endif
    }

    inline bool isIntOrBool() const {
        return (_val >> IsIntegerOrBool_Shift) == 3;
    }

    inline bool integerCompatible() const {
        Q_ASSERT(!isEmpty());
        return (_val >> IsIntegerConvertible_Shift) == 1;
    }
    static inline bool integerCompatible(Value a, Value b) {
        return a.integerCompatible() && b.integerCompatible();
    }
    static inline bool bothDouble(Value a, Value b) {
        return a.isDouble() && b.isDouble();
    }
    inline bool isNaN() const { return (tag() & 0x7ffc0000  ) == 0x00040000; }

    inline bool isPositiveInt() const {
#if QT_POINTER_SIZE == 4
        return isInteger() && int_32() >= 0;
#else
        return (_val >> IsPositiveIntShift) == (quint64(ValueTypeInternal::Integer) << 1);
#endif
    }

    QML_NEARLY_ALWAYS_INLINE double doubleValue() const {
        Q_ASSERT(isDouble());
        double d;
        Value v = *this;
        v._val ^= NaNEncodeMask;
        memcpy(&d, &v._val, 8);
        return d;
    }
    QML_NEARLY_ALWAYS_INLINE void setDouble(double d) {
        if (qt_is_nan(d))
            d = qt_qnan();
        memcpy(&_val, &d, 8);
        _val ^= NaNEncodeMask;
        Q_ASSERT(isDouble());
    }
    inline bool isString() const;
    inline bool isStringOrSymbol() const;
    inline bool isSymbol() const;
    inline bool isObject() const;
    inline bool isFunctionObject() const;
    inline bool isInt32() {
        if (tag() == quint32(ValueTypeInternal::Integer))
            return true;
        if (isDouble()) {
            double d = doubleValue();
            if (isInt32(d)) {
                setInt_32(int(d));
                return true;
            }
        }
        return false;
    }
    QML_NEARLY_ALWAYS_INLINE static bool isInt32(double d) {
        int i = int(d);
        return (i == d && !(d == 0 && std::signbit(d)));
    }
    double asDouble() const {
        if (tag() == quint32(ValueTypeInternal::Integer))
            return int_32();
        return doubleValue();
    }

    bool booleanValue() const {
        return int_32();
    }
    int integerValue() const {
        return int_32();
    }

    QML_NEARLY_ALWAYS_INLINE String *stringValue() const {
        if (!isString())
            return nullptr;
        return reinterpret_cast<String *>(const_cast<Value *>(this));
    }
    QML_NEARLY_ALWAYS_INLINE StringOrSymbol *stringOrSymbolValue() const {
        if (!isStringOrSymbol())
            return nullptr;
        return reinterpret_cast<StringOrSymbol *>(const_cast<Value *>(this));
    }
    QML_NEARLY_ALWAYS_INLINE Symbol *symbolValue() const {
        if (!isSymbol())
            return nullptr;
        return reinterpret_cast<Symbol *>(const_cast<Value *>(this));
    }
    QML_NEARLY_ALWAYS_INLINE Object *objectValue() const {
        if (!isObject())
            return nullptr;
        return reinterpret_cast<Object*>(const_cast<Value *>(this));
    }
    QML_NEARLY_ALWAYS_INLINE Managed *managed() const {
        if (!isManaged())
            return nullptr;
        return reinterpret_cast<Managed*>(const_cast<Value *>(this));
    }
    QML_NEARLY_ALWAYS_INLINE Heap::Base *heapObject() const {
        return isManagedOrUndefined() ? m() : nullptr;
    }

    static inline Value fromHeapObject(Heap::Base *m)
    {
        Value v;
        v.setM(m);
        return v;
    }

    int toUInt16() const;
    inline int toInt32() const;
    inline unsigned int toUInt32() const;
    qint64 toLength() const;
    inline qint64 toIndex() const;

    bool toBoolean() const {
        if (integerCompatible())
            return static_cast<bool>(int_32());

        return toBooleanImpl(*this);
    }
    static bool toBooleanImpl(Value val);
    double toInteger() const;
    inline ReturnedValue convertedToNumber() const;
    inline double toNumber() const;
    static double toNumberImpl(Value v);
    double toNumberImpl() const { return toNumberImpl(*this); }
    QString toQStringNoThrow() const;
    QString toQString() const;
    Heap::String *toString(ExecutionEngine *e) const {
        if (isString())
            return reinterpret_cast<Heap::String *>(m());
        return toString(e, *this);
    }
    QV4::PropertyKey toPropertyKey(ExecutionEngine *e) const;

    static Heap::String *toString(ExecutionEngine *e, Value val);
    Heap::Object *toObject(ExecutionEngine *e) const {
        if (isObject())
            return reinterpret_cast<Heap::Object *>(m());
        return toObject(e, *this);
    }
    static Heap::Object *toObject(ExecutionEngine *e, Value val);

    inline bool isPrimitive() const;
    inline bool tryIntegerConversion() {
        bool b = integerCompatible();
        if (b)
            setTagValue(quint32(ValueTypeInternal::Integer), value());
        return b;
    }

    template <typename T>
    const T *as() const {
        if (!isManaged())
            return nullptr;

        Q_ASSERT(m()->internalClass->vtable);
#if !defined(QT_NO_QOBJECT_CHECK)
        static_cast<const T *>(this)->qt_check_for_QMANAGED_macro(static_cast<const T *>(this));
#endif
        const VTable *vt = m()->internalClass->vtable;
        while (vt) {
            if (vt == T::staticVTable())
                return static_cast<const T *>(this);
            vt = vt->parent;
        }
        return nullptr;
    }
    template <typename T>
    T *as() {
        if (isManaged())
            return const_cast<T *>(const_cast<const Value *>(this)->as<T>());
        else
            return nullptr;
    }

    template<typename T> inline T *cast() {
        return static_cast<T *>(managed());
    }
    template<typename T> inline const T *cast() const {
        return static_cast<const T *>(managed());
    }

#ifndef V4_BOOTSTRAP
    uint asArrayLength(bool *ok) const;
#endif

    ReturnedValue *data_ptr() { return &_val; }
    constexpr ReturnedValue asReturnedValue() const { return _val; }
    static Value fromReturnedValue(ReturnedValue val) { Value v; v._val = val; return v; }

    // As per ES specs
    bool sameValue(Value other) const;
    bool sameValueZero(Value other) const;

    inline void mark(MarkStack *markStack);

    inline static constexpr Value emptyValue() { return { tagValue(quint32(ValueTypeInternal::Empty), 0) }; }
    static inline constexpr Value fromBoolean(bool b) { return { tagValue(quint32(ValueTypeInternal::Boolean), b) }; }
    static inline constexpr Value fromInt32(int i) { return { tagValue(quint32(ValueTypeInternal::Integer), quint32(i)) }; }
    inline static constexpr Value undefinedValue() { return { 0 }; }
    static inline constexpr Value nullValue() { return { tagValue(quint32(ValueTypeInternal::Null), 0) }; }
    static inline Value fromDouble(double d);
    static inline Value fromUInt32(uint i);

    static double toInteger(double d);
    static int toInt32(double d);
    static unsigned int toUInt32(double d);

    Value &operator =(const ScopedValue &v);
    Value &operator=(ReturnedValue v) { _val = v; return *this; }
    Value &operator=(Managed *m) {
        if (!m) {
            setM(nullptr);
        } else {
            _val = reinterpret_cast<Value *>(m)->_val;
        }
        return *this;
    }
    Value &operator=(Heap::Base *o) {
        setM(o);
        return *this;
    }

    template<typename T>
    Value &operator=(const Scoped<T> &t);
};
Q_STATIC_ASSERT(std::is_trivial< Value >::value);

inline void Value::mark(MarkStack *markStack)
{
    Heap::Base *o = heapObject();
    if (o)
        o->mark(markStack);
}

inline bool Value::isString() const
{
    Heap::Base *b = heapObject();
    return b && b->internalClass->vtable->isString;
}

bool Value::isStringOrSymbol() const
{
    Heap::Base *b = heapObject();
    return b && b->internalClass->vtable->isStringOrSymbol;
}

bool Value::isSymbol() const
{
    Heap::Base *b = heapObject();
    return b && b->internalClass->vtable->isStringOrSymbol && !b->internalClass->vtable->isString;
}

inline bool Value::isObject() const

{
    Heap::Base *b = heapObject();
    return b && b->internalClass->vtable->isObject;
}

inline bool Value::isFunctionObject() const
{
    Heap::Base *b = heapObject();
    return b && b->internalClass->vtable->isFunctionObject;
}

inline bool Value::isPrimitive() const
{
    return !isObject();
}

inline double Value::toNumber() const
{
    if (isInteger())
        return int_32();
    if (isDouble())
        return doubleValue();
    return toNumberImpl();
}

inline ReturnedValue Value::convertedToNumber() const
{
    if (isInteger() || isDouble())
        return asReturnedValue();
    Value v;
    v.setDouble(toNumberImpl());
    return v.asReturnedValue();
}

inline
ReturnedValue Heap::Base::asReturnedValue() const
{
    return Value::fromHeapObject(const_cast<Heap::Base *>(this)).asReturnedValue();
}

inline Value Value::fromDouble(double d)
{
    Value v;
    v.setDouble(d);
    return v;
}

inline Value Value::fromUInt32(uint i)
{
    Value v;
    if (i < INT_MAX) {
        v.setTagValue(quint32(ValueTypeInternal::Integer), i);
    } else {
        v.setDouble(i);
    }
    return v;
}

struct Double {
    quint64 d;

    Double(double dbl) {
        memcpy(&d, &dbl, sizeof(double));
    }

    int sign() const {
        return (d >> 63) ? -1 : 1;
    }

    bool isDenormal() const {
        return static_cast<int>((d << 1) >> 53) == 0;
    }

    int exponent() const {
        return static_cast<int>((d << 1) >> 53) - 1023;
    }

    quint64 significant() const {
        quint64 m = (d << 12) >> 12;
        if (!isDenormal())
            m |= (static_cast<quint64>(1) << 52);
        return m;
    }

    static int toInt32(double d) {
        int i = static_cast<int>(d);
        if (i == d)
                return i;
        return Double(d).toInt32();
    }

    int toInt32() {
        int e = exponent() - 52;
        if (e < 0) {
            if (e <= -53)
                return 0;
            return sign() * static_cast<int>(significant() >> -e);
        } else {
            if (e > 31)
                return 0;
            return sign() * (static_cast<int>(significant()) << e);
        }
    }
};

inline double Value::toInteger(double d)
{
    if (std::isnan(d))
        return +0;
    else if (!d || std::isinf(d))
        return d;
    return d >= 0 ? std::floor(d) : std::ceil(d);
}

inline int Value::toInt32(double value)
{
    return Double::toInt32(value);
}

inline unsigned int Value::toUInt32(double d)
{
    return static_cast<uint>(toInt32(d));
}

// For source compat with older code in other modules
using Primitive = Value;

struct Encode {
    static constexpr ReturnedValue undefined() {
        return Value::undefinedValue().asReturnedValue();
    }
    static constexpr ReturnedValue null() {
        return Value::nullValue().asReturnedValue();
    }

    explicit constexpr Encode(bool b)
        : val(Value::fromBoolean(b).asReturnedValue())
    {
    }
    explicit Encode(double d) {
        val = Value::fromDouble(d).asReturnedValue();
    }
    explicit constexpr Encode(int i)
        : val(Value::fromInt32(i).asReturnedValue())
    {
    }
    explicit Encode(uint i) {
        val = Value::fromUInt32(i).asReturnedValue();
    }
    explicit constexpr Encode(ReturnedValue v)
        : val(v)
    {
    }
    constexpr Encode(Value v)
        : val(v.asReturnedValue())
    {
    }

    explicit Encode(Heap::Base *o) {
        val = Value::fromHeapObject(o).asReturnedValue();
    }

    explicit Encode(Value *o) {
        Q_ASSERT(o);
        val = o->asReturnedValue();
    }

    static ReturnedValue smallestNumber(double d) {
        if (Value::isInt32(d))
            return Encode(static_cast<int>(d));
        else
            return Encode(d);
    }

    constexpr operator ReturnedValue() const {
        return val;
    }
    quint64 val;
private:
    explicit Encode(void *);
};

template<typename T>
ReturnedValue value_convert(ExecutionEngine *e, const Value &v);

inline int Value::toInt32() const
{
    if (Q_LIKELY(integerCompatible()))
        return int_32();

    if (Q_LIKELY(isDouble()))
        return Double::toInt32(doubleValue());

    return Double::toInt32(toNumberImpl());
}

inline unsigned int Value::toUInt32() const
{
    return static_cast<unsigned int>(toInt32());
}

inline qint64 Value::toLength() const
{
    if (Q_LIKELY(integerCompatible()))
        return int_32() < 0 ? 0 : int_32();
    double i = Value::toInteger(isDouble() ? doubleValue() : toNumberImpl());
    if (i <= 0)
        return 0;
    if (i > (static_cast<qint64>(1) << 53) - 1)
        return (static_cast<qint64>(1) << 53) - 1;
    return static_cast<qint64>(i);
}

inline qint64 Value::toIndex() const
{
    qint64 idx;
    if (Q_LIKELY(integerCompatible())) {
        idx = int_32();
    } else {
        idx = static_cast<qint64>(Value::toInteger(isDouble() ? doubleValue() : toNumberImpl()));
    }
    if (idx > (static_cast<qint64>(1) << 53) - 1)
        idx = -1;
    return idx;
}

inline double Value::toInteger() const
{
    if (integerCompatible())
        return int_32();

    return Value::toInteger(isDouble() ? doubleValue() : toNumberImpl());
}


template <size_t o>
struct HeapValue : Value {
    static Q_CONSTEXPR size_t offset = o;
    Heap::Base *base() {
        Heap::Base *base = reinterpret_cast<Heap::Base *>(this) - (offset/sizeof(Heap::Base));
        Q_ASSERT(base->inUse());
        return base;
    }

    void set(EngineBase *e, const Value &newVal) {
        WriteBarrier::write(e, base(), data_ptr(), newVal.asReturnedValue());
    }
    void set(EngineBase *e, Heap::Base *b) {
        WriteBarrier::write(e, base(), data_ptr(), b->asReturnedValue());
    }
};

template <size_t o>
struct ValueArray {
    static Q_CONSTEXPR size_t offset = o;
    uint size;
    uint alloc;
    Value values[1];

    Heap::Base *base() {
        Heap::Base *base = reinterpret_cast<Heap::Base *>(this) - (offset/sizeof(Heap::Base));
        Q_ASSERT(base->inUse());
        return base;
    }

    void set(EngineBase *e, uint index, Value v) {
        WriteBarrier::write(e, base(), values[index].data_ptr(), v.asReturnedValue());
    }
    void set(EngineBase *e, uint index, Heap::Base *b) {
        WriteBarrier::write(e, base(), values[index].data_ptr(), Value::fromHeapObject(b).asReturnedValue());
    }
    inline const Value &operator[] (uint index) const {
        Q_ASSERT(index < alloc);
        return values[index];
    }
    inline const Value *data() const {
        return values;
    }

    void insertData(EngineBase *e, uint index, Value v) {
        for (uint i = size - 1; i > index; --i) {
            values[i] = values[i - 1];
        }
        set(e, index, v);
    }
    void removeData(EngineBase *e, uint index, int n = 1) {
        Q_UNUSED(e);
        for (uint i = index; i < size - n; ++i) {
            values[i] = values[i + n];
        }
    }

    void mark(MarkStack *markStack) {
        Value *v = values;
        const Value *end = v + alloc;
        if (alloc > 32*1024) {
            // drain from time to time to avoid overflows in the js stack
            Heap::Base **currentBase = markStack->top;
            while (v < end) {
                v->mark(markStack);
                ++v;
                if (markStack->top >= currentBase + 32*1024) {
                    Heap::Base **oldBase = markStack->base;
                    markStack->base = currentBase;
                    markStack->drain();
                    markStack->base = oldBase;
                }
            }
        } else {
            while (v < end) {
                v->mark(markStack);
                ++v;
            }
        }
    }
};

// It's really important that the offset of values in this structure is
// constant across all architecture,  otherwise JIT cross-compiled code will
// have wrong offsets between host and target.
Q_STATIC_ASSERT(offsetof(ValueArray<0>, values) == 8);

class OptionalReturnedValue {
    ReturnedValue value;
public:

    OptionalReturnedValue() : value(Value::emptyValue().asReturnedValue()) {}
    explicit OptionalReturnedValue(ReturnedValue v)
        : value(v)
    {
        Q_ASSERT(!Value::fromReturnedValue(v).isEmpty());
    }

    ReturnedValue operator->() const { return value; }
    ReturnedValue operator*() const { return value; }
    explicit operator bool() const { return !Value::fromReturnedValue(value).isEmpty(); }
};

}

QT_END_NAMESPACE

#endif // QV4VALUE_DEF_P_H