From e37a9eb4a47eb3e5cb9f4dedccec6b69e8509625 Mon Sep 17 00:00:00 2001 From: Lars Knoll Date: Fri, 24 Jan 2014 15:07:34 +0100 Subject: Rename some files Rename qv4value_def_p.h -> qv4value_p.h and qv4value_p.h to qv4value_inl_p.h. It makes more sense to have the class definition in the file that is named after the class and move the inline methods into a _inl file. Doing this now, as I expect we'll be needing a few more _inl files soon. Change-Id: Ib59e9380e9e976254c6b4369574157f39b1b5f51 Reviewed-by: Simon Hausmann --- src/qml/jsruntime/qv4value_inl_p.h | 397 +++++++++++++++++++++++++++++++++++++ 1 file changed, 397 insertions(+) create mode 100644 src/qml/jsruntime/qv4value_inl_p.h (limited to 'src/qml/jsruntime/qv4value_inl_p.h') diff --git a/src/qml/jsruntime/qv4value_inl_p.h b/src/qml/jsruntime/qv4value_inl_p.h new file mode 100644 index 0000000000..2618ef3faa --- /dev/null +++ b/src/qml/jsruntime/qv4value_inl_p.h @@ -0,0 +1,397 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** 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 Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#ifndef QV4VALUE_INL_H +#define QV4VALUE_INL_H + +#include // this HAS to come + +#include +#include +#include "qv4global_p.h" +#include "qv4string_p.h" +#include +#include "qv4managed_p.h" +#include "qv4engine_p.h" +#include + +//#include + +#include "qv4value_p.h" + +QT_BEGIN_NAMESPACE + +namespace QV4 { + +inline bool Value::isString() const +{ + if (!isManaged()) + return false; + return managed() && managed()->internalClass->vtable->isString; +} +inline bool Value::isObject() const +{ + if (!isManaged()) + return false; + return managed() && managed()->internalClass->vtable->isObject; +} + +inline bool Value::isPrimitive() const +{ + return !isObject(); +} + +inline ExecutionEngine *Value::engine() const +{ + Managed *m = asManaged(); + return m ? m->engine() : 0; +} + +inline void Value::mark(ExecutionEngine *e) const +{ + if (!val) + return; + Managed *m = asManaged(); + if (m) + m->mark(e); +} + +inline Primitive Primitive::nullValue() +{ + Primitive v; +#if QT_POINTER_SIZE == 8 + v.val = quint64(_Null_Type) << Tag_Shift; +#else + v.tag = _Null_Type; + v.int_32 = 0; +#endif + return v; +} + +inline Primitive Primitive::fromBoolean(bool b) +{ + Primitive v; + v.tag = _Boolean_Type; + v.int_32 = (bool)b; + return v; +} + +inline Primitive Primitive::fromDouble(double d) +{ + Primitive v; + v.setDouble(d); + return v; +} + +inline Primitive Primitive::fromInt32(int i) +{ + Primitive v; + v.tag = _Integer_Type; + v.int_32 = i; + return v; +} + +inline Primitive Primitive::fromUInt32(uint i) +{ + Primitive v; + if (i < INT_MAX) { + v.tag = _Integer_Type; + v.int_32 = (int)i; + } else { + v.setDouble(i); + } + return v; +} + +inline double Value::toNumber() const +{ + if (integerCompatible()) + return int_32; + if (isDouble()) + return doubleValue(); + return toNumberImpl(); +} + +inline int Value::toInt32() const +{ + if (integerCompatible()) + return int_32; + double d; + if (isDouble()) + d = doubleValue(); + else + d = toNumberImpl(); + + const double D32 = 4294967296.0; + const double D31 = D32 / 2.0; + + if ((d >= -D31 && d < D31)) + return static_cast(d); + + return Primitive::toInt32(d); +} + +inline unsigned int Value::toUInt32() const +{ + return (unsigned int)toInt32(); +} + + +inline bool Value::toBoolean() const +{ + switch (type()) { + case Value::Undefined_Type: + case Value::Null_Type: + return false; + case Value::Boolean_Type: + case Value::Integer_Type: + return (bool)int_32; + case Value::Managed_Type: + if (isString()) + return stringValue()->toQString().length() > 0; + return true; + default: // double + return doubleValue() && !std::isnan(doubleValue()); + } +} + +inline uint Value::asArrayIndex() const +{ +#if QT_POINTER_SIZE == 8 + if (!isNumber()) + return UINT_MAX; + if (isInteger()) + return int_32 >= 0 ? (uint)int_32 : UINT_MAX; +#else + if (isInteger() && int_32 >= 0) + return (uint)int_32; + if (!isDouble()) + return UINT_MAX; +#endif + double d = doubleValue(); + uint idx = (uint)d; + if (idx != d) + return UINT_MAX; + return idx; +} + +inline uint Value::asArrayLength(bool *ok) const +{ + *ok = true; + if (integerCompatible() && int_32 >= 0) + return (uint)int_32; + if (isDouble()) { + double d = doubleValue(); + uint idx = (uint)d; + if (idx != d) { + *ok = false; + return UINT_MAX; + } + return idx; + } + if (isString()) + return stringValue()->toUInt(ok); + + uint idx = toUInt32(); + double d = toNumber(); + if (d != idx) { + *ok = false; + return UINT_MAX; + } + return idx; +} + +inline Object *Value::asObject() const +{ + return isObject() ? objectValue() : 0; +} + +inline FunctionObject *Value::asFunctionObject() const +{ + return isObject() ? managed()->asFunctionObject() : 0; +} + +inline NumberObject *Value::asNumberObject() const +{ + return isObject() ? managed()->asNumberObject() : 0; +} + +inline StringObject *Value::asStringObject() const +{ + return isObject() ? managed()->asStringObject() : 0; +} + +inline DateObject *Value::asDateObject() const +{ + return isObject() ? managed()->asDateObject() : 0; +} + +inline ArrayObject *Value::asArrayObject() const +{ + return isObject() ? managed()->asArrayObject() : 0; +} + +inline ErrorObject *Value::asErrorObject() const +{ + return isObject() ? managed()->asErrorObject() : 0; +} + +template +inline T *Value::as() const { Managed *m = isObject() ? managed() : 0; return m ? m->as() : 0; } + +struct Q_QML_PRIVATE_EXPORT PersistentValuePrivate +{ + PersistentValuePrivate(ReturnedValue v, ExecutionEngine *engine = 0, bool weak = false); + virtual ~PersistentValuePrivate(); + SafeValue value; + uint refcount; + bool weak; + QV4::ExecutionEngine *engine; + PersistentValuePrivate **prev; + PersistentValuePrivate *next; + + void init(); + void removeFromList(); + void ref() { ++refcount; } + void deref(); + PersistentValuePrivate *detach(const ReturnedValue value, bool weak = false); + + bool checkEngine(QV4::ExecutionEngine *otherEngine) { + if (!engine) { + Q_ASSERT(!value.isObject()); + engine = otherEngine; + } + return (engine == otherEngine); + } +}; + +class Q_QML_EXPORT PersistentValue +{ +public: + PersistentValue() : d(0) {} + PersistentValue(const PersistentValue &other); + PersistentValue &operator=(const PersistentValue &other); + + PersistentValue(const ValueRef val); + PersistentValue(ReturnedValue val); + template + PersistentValue(Returned *obj); + template + PersistentValue(const Referenced obj); + PersistentValue &operator=(const ValueRef other); + PersistentValue &operator =(ReturnedValue other); + template + PersistentValue &operator=(Returned *obj); + template + PersistentValue &operator=(const Referenced obj); + ~PersistentValue(); + + ReturnedValue value() const { + return (d ? d->value.asReturnedValue() : Primitive::undefinedValue().asReturnedValue()); + } + + ExecutionEngine *engine() { + if (!d) + return 0; + if (d->engine) + return d->engine; + Managed *m = d->value.asManaged(); + return m ? m->engine() : 0; + } + + bool isUndefined() const { return !d || d->value.isUndefined(); } + bool isNullOrUndefined() const { return !d || d->value.isNullOrUndefined(); } + void clear() { + *this = PersistentValue(); + } + +private: + friend struct ValueRef; + PersistentValuePrivate *d; +}; + +class Q_QML_EXPORT WeakValue +{ +public: + WeakValue() : d(0) {} + WeakValue(const ValueRef val); + WeakValue(const WeakValue &other); + WeakValue(ReturnedValue val); + template + WeakValue(Returned *obj); + WeakValue &operator=(const WeakValue &other); + WeakValue &operator=(const ValueRef other); + WeakValue &operator =(const ReturnedValue &other); + template + WeakValue &operator=(Returned *obj); + + ~WeakValue(); + + ReturnedValue value() const { + return (d ? d->value.asReturnedValue() : Primitive::undefinedValue().asReturnedValue()); + } + + ExecutionEngine *engine() { + if (!d) + return 0; + if (d->engine) + return d->engine; + Managed *m = d->value.asManaged(); + return m ? m->engine() : 0; + } + + bool isUndefined() const { return !d || d->value.isUndefined(); } + bool isNullOrUndefined() const { return !d || d->value.isNullOrUndefined(); } + void clear() { + *this = WeakValue(); + } + + void markOnce(ExecutionEngine *e); + +private: + friend struct ValueRef; + PersistentValuePrivate *d; +}; + +} // namespace QV4 + +QT_END_NAMESPACE + +#endif -- cgit v1.2.3