****************************************************************************/
#include "qhashedstring_p.h"
-#include <private/qcalculatehash_p.h>
inline quint32 stringHash(const QChar* data, int length)
{
- quint32 rv = calculateHash((quint16*)data, length);
- Q_ASSERT(rv == v8::String::ComputeHash((uint16_t*)data, length));
- return rv;
+ return QV4::String::createHashValue(data, length);
}
inline quint32 stringHash(const char *data, int length)
{
- quint32 rv = calculateHash((quint8*)data, length);
- Q_ASSERT(rv == v8::String::ComputeHash((char *)data, length));
- return rv;
+ QString s = QString::fromLatin1(data, length);
+ return QV4::String::createHashValue(s.constData(), s.length());
}
void QHashedString::computeHash() const
#include <QtCore/qglobal.h>
#include <QtCore/qstring.h>
-#include <private/qv8_p.h>
#include <private/qv4string_p.h>
+#include <private/qv4value_p.h>
#include <private/qflagpointer_p.h>
inline quint32 hash() const;
inline quint32 existingHash() const;
- static inline bool isUpper(const QChar &);
-
static bool compare(const QChar *lhs, const QChar *rhs, int length);
static inline bool compare(const QChar *lhs, const char *rhs, int length);
static inline bool compare(const char *lhs, const char *rhs, int length);
mutable quint32 m_hash;
};
-class Q_AUTOTEST_EXPORT QHashedV8String
+class Q_AUTOTEST_EXPORT QHashedV4String
{
public:
- inline QHashedV8String();
- explicit inline QHashedV8String(v8::Handle<v8::String>);
- inline QHashedV8String(const QHashedV8String &string);
- inline QHashedV8String &operator=(const QHashedV8String &other);
+ inline QHashedV4String();
+ explicit inline QHashedV4String(const QV4::Value &s);
+ inline QHashedV4String(const QHashedV4String &string);
+ inline QHashedV4String &operator=(const QHashedV4String &other);
- inline bool operator==(const QHashedV8String &string);
+ inline bool operator==(const QHashedV4String &string);
inline quint32 hash() const;
inline int length() const;
inline quint32 symbolId() const;
- inline v8::Handle<v8::String> string() const;
+ inline QV4::Value string() const;
inline QString toString() const;
private:
- v8::String::CompleteHashData m_hash;
- v8::Handle<v8::String> m_string;
+ QV4::PersistentValue m_string;
};
class QHashedCStringRef;
inline char *cStrData() const { return (char *)ckey; }
inline uint16_t *utf16Data() const { return (uint16_t *)strData->data(); }
- inline bool equals(v8::Handle<v8::String> string) const {
- v8::Handle<v8::String> data = isQString() ? v8::String::New(utf16Data(), length)
- : v8::String::New(cStrData(), length);
- return string->Equals(data);
+ inline bool equals(const QV4::Value &string) const {
+ QString s = string.toQString();
+ if (isQString()) {
+ QStringDataPtr dd;
+ dd.ptr = strData;
+ return QString(dd) == s;
+ } else {
+ return QLatin1String(cStrData(), length) == s;
+ }
}
- inline bool symbolEquals(const QHashedV8String &string) const {
+ inline bool symbolEquals(const QHashedV4String &string) const {
Q_ASSERT(string.symbolId() != 0);
return length == string.length() && hash == string.hash() &&
(string.symbolId() == symbolId || equals(string.string()));
}
- inline bool equals(const QHashedV8String &string) const {
+ inline bool equals(const QHashedV4String &string) const {
return length == string.length() && hash == string.hash() &&
equals(string.string());
}
template<> struct HashedForm<QString> { typedef QHashedString Type; };
template<> struct HashedForm<QStringRef> { typedef QHashedStringRef Type; };
template<> struct HashedForm<QHashedString> { typedef const QHashedString &Type; };
-template<> struct HashedForm<QHashedV8String> { typedef const QHashedV8String &Type; };
+template<> struct HashedForm<QHashedV4String> { typedef const QHashedV4String &Type; };
template<> struct HashedForm<QHashedStringRef> { typedef const QHashedStringRef &Type; };
template<> struct HashedForm<QLatin1String> { typedef QHashedCStringRef Type; };
template<> struct HashedForm<QHashedCStringRef> { typedef const QHashedCStringRef &Type; };
static HashedForm<QString>::Type hashedString(const QString &s) { return QHashedString(s);}
static HashedForm<QStringRef>::Type hashedString(const QStringRef &s) { return QHashedStringRef(s.constData(), s.size());}
static HashedForm<QHashedString>::Type hashedString(const QHashedString &s) { return s; }
- static HashedForm<QHashedV8String>::Type hashedString(const QHashedV8String &s) { return s; }
+ static HashedForm<QHashedV4String>::Type hashedString(const QHashedV4String &s) { return s; }
static HashedForm<QHashedStringRef>::Type hashedString(const QHashedStringRef &s) { return s; }
static HashedForm<QLatin1String>::Type hashedString(const QLatin1String &s) { return QHashedCStringRef(s.data(), s.size()); }
static const QString &toQString(const QString &s) { return s; }
static const QString &toQString(const QHashedString &s) { return s; }
- static QString toQString(const QHashedV8String &s) { return s.toString(); }
+ static QString toQString(const QHashedV4String &s) { return s.toString(); }
static QString toQString(const QHashedStringRef &s) { return s.toString(); }
static QString toQString(const QLatin1String &s) { return QString(s); }
static QString toQString(const QHashedCStringRef &s) { return s.toUtf16(); }
static inline quint32 hashOf(const QHashedStringRef &s) { return s.hash(); }
- static inline quint32 hashOf(const QHashedV8String &s) { return s.hash(); }
+ static inline quint32 hashOf(const QHashedV4String &s) { return s.hash(); }
template<typename K>
static inline quint32 hashOf(const K &key) { return hashedString(key).hash(); }
template<typename K>
inline Node *findNode(const K &) const;
- inline Node *findSymbolNode(const QHashedV8String &) const;
+ inline Node *findSymbolNode(const QHashedV4String &) const;
inline Node *createNode(const Node &o);
template<typename K>
inline T *value(const K &) const;
- inline T *value(const QHashedV8String &string) const;
+ inline T *value(const QHashedV4String &string) const;
inline T *value(const ConstIterator &) const;
template<typename K>
}
template<class T>
-typename QStringHash<T>::Node *QStringHash<T>::findSymbolNode(const QHashedV8String &string) const
+typename QStringHash<T>::Node *QStringHash<T>::findSymbolNode(const QHashedV4String &string) const
{
Q_ASSERT(string.symbolId() != 0);
}
template<class T>
-T *QStringHash<T>::value(const QHashedV8String &string) const
+T *QStringHash<T>::value(const QHashedV4String &string) const
{
Node *n = string.symbolId()?findSymbolNode(string):findNode(string);
return n?&n->value:0;
return m_hash;
}
-bool QHashedString::isUpper(const QChar &qc)
-{
- ushort c = qc.unicode();
- // Optimize for _, a-z and A-Z.
- return ((c != '_' ) && (!(c >= 'a' && c <= 'z')) &&
- ((c >= 'A' && c <= 'Z') || QChar::category(c) == QChar::Letter_Uppercase));
-}
-
-QHashedV8String::QHashedV8String()
+QHashedV4String::QHashedV4String()
{
}
-QHashedV8String::QHashedV8String(v8::Handle<v8::String> string)
-: m_hash(string->CompleteHash()), m_string(string)
+QHashedV4String::QHashedV4String(const QV4::Value &s)
+ : m_string(s)
{
- Q_ASSERT(!m_string.IsEmpty());
+ Q_ASSERT(!s.toQString().isEmpty());
}
-QHashedV8String::QHashedV8String(const QHashedV8String &string)
-: m_hash(string.m_hash), m_string(string.m_string)
+QHashedV4String::QHashedV4String(const QHashedV4String &string)
+ : m_string(string.m_string)
{
}
-QHashedV8String &QHashedV8String::operator=(const QHashedV8String &other)
+QHashedV4String &QHashedV4String::operator=(const QHashedV4String &other)
{
- m_hash = other.m_hash;
m_string = other.m_string;
return *this;
}
-bool QHashedV8String::operator==(const QHashedV8String &string)
+bool QHashedV4String::operator==(const QHashedV4String &string)
{
- return m_hash.hash == string.m_hash.hash && m_hash.length == string.m_hash.length &&
- m_string.IsEmpty() == m_string.IsEmpty() &&
- (m_string.IsEmpty() || m_string->StrictEquals(string.m_string));
+ return m_string.value().asString()->isEqualTo(string.m_string.value().asString());
}
-quint32 QHashedV8String::hash() const
+quint32 QHashedV4String::hash() const
{
- return m_hash.hash;
+ return m_string.value().asString()->hashValue();
}
-int QHashedV8String::length() const
+int QHashedV4String::length() const
{
- return m_hash.length;
+ return m_string.value().asString()->toQString().length();
}
-quint32 QHashedV8String::symbolId() const
+quint32 QHashedV4String::symbolId() const
{
- return m_hash.symbol_id;
+ return m_string.value().asString()->identifier;
}
-v8::Handle<v8::String> QHashedV8String::string() const
+QV4::Value QHashedV4String::string() const
{
- return m_string;
+ return m_string.value();
}
-QString QHashedV8String::toString() const
+QString QHashedV4String::toString() const
{
- return m_string->v4Value().toQString();
+ return m_string.value().toQString();
}
QHashedStringRef::QHashedStringRef()
bool QHashedStringRef::startsWithUpper() const
{
if (m_length < 1) return false;
- return QHashedString::isUpper(m_data[0]);
+ return m_data[0].isUpper();
}
quint32 QHashedStringRef::hash() const
void reserve(int);
int value(const QString &);
- inline int value(const QHashedV8String &);
+ inline int value(const QHashedV4String &);
QString findId(int value) const;
StringCache stringCache;
};
-int QQmlIntegerCache::value(const QHashedV8String &name)
+int QQmlIntegerCache::value(const QHashedV4String &name)
{
int *result = stringCache.value(name);
return result?*result:-1;
return -1;
}
-int QQmlType::enumValue(const QHashedV8String &name, bool *ok) const
+int QQmlType::enumValue(const QHashedV4String &name, bool *ok) const
{
Q_ASSERT(ok);
*ok = true;
return 0;
}
-QQmlType *QQmlTypeModule::type(const QHashedV8String &name, int minor)
+QQmlType *QQmlTypeModule::type(const QHashedV4String &name, int minor)
{
QReadLocker lock(metaTypeDataLock());
else return 0;
}
-QQmlType *QQmlTypeModuleVersion::type(const QHashedV8String &name) const
+QQmlType *QQmlTypeModuleVersion::type(const QHashedV4String &name) const
{
if (m_module) return m_module->type(name, m_minor);
else return 0;
struct QQmlMetaTypeData;
class QHashedCStringRef;
-class QHashedV8String;
+class QHashedV4String;
class Q_QML_PRIVATE_EXPORT QQmlType
{
public:
int enumValue(const QHashedStringRef &, bool *ok) const;
int enumValue(const QHashedCStringRef &, bool *ok) const;
- int enumValue(const QHashedV8String &, bool *ok) const;
+ int enumValue(const QHashedV4String &, bool *ok) const;
private:
QQmlType *superType() const;
friend class QQmlTypePrivate;
int maximumMinorVersion() const;
QQmlType *type(const QHashedStringRef &, int);
- QQmlType *type(const QHashedV8String &, int);
+ QQmlType *type(const QHashedV4String &, int);
QList<QQmlType*> singletonTypes(int) const;
int minorVersion() const;
QQmlType *type(const QHashedStringRef &) const;
- QQmlType *type(const QHashedV8String &) const;
+ QQmlType *type(const QHashedV4String &) const;
private:
QQmlTypeModule *m_module;
return string;
}
-inline QString qQmlPropertyCacheToString(const QHashedV8String &string)
+inline QString qQmlPropertyCacheToString(const QHashedV4String &string)
{
- return string.string()->v4Value().toQString();
+ return string.toString();
}
template<typename T>
}
QQmlPropertyData *
-QQmlPropertyCache::property(QQmlEngine *engine, QObject *obj, const QHashedV8String &name,
+QQmlPropertyCache::property(QQmlEngine *engine, QObject *obj, const QHashedV4String &name,
QQmlContextData *context, QQmlPropertyData &local)
{
- return qQmlPropertyCacheProperty<QHashedV8String>(engine, obj, name, context, local);
+ return qQmlPropertyCacheProperty<QHashedV4String>(engine, obj, name, context, local);
}
QQmlPropertyData *
inline QQmlEngine *qmlEngine() const;
static QQmlPropertyData *property(QQmlEngine *, QObject *, const QString &,
QQmlContextData *, QQmlPropertyData &);
- static QQmlPropertyData *property(QQmlEngine *, QObject *, const QHashedV8String &,
+ static QQmlPropertyData *property(QQmlEngine *, QObject *, const QHashedV4String &,
QQmlContextData *, QQmlPropertyData &);
static int *methodParameterTypes(QObject *, int index, QVarLengthArray<int, 9> &dummy,
QByteArray *unknownTypeError);
return typeSearch(i->modules, name);
}
-QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedV8String &name)
+QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedV4String &name)
{
Result result = query(m_namedImports, name);
return result;
}
-QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedV8String &name, const void *importNamespace)
+QQmlTypeNameCache::Result QQmlTypeNameCache::query(const QHashedV4String &name, const void *importNamespace)
{
Q_ASSERT(importNamespace);
const Import *i = static_cast<const Import *>(importNamespace);
};
Result query(const QHashedStringRef &);
Result query(const QHashedStringRef &, const void *importNamespace);
- Result query(const QHashedV8String &);
- Result query(const QHashedV8String &, const void *importNamespace);
+ Result query(const QHashedV4String &);
+ Result query(const QHashedV4String &, const void *importNamespace);
private:
friend class QQmlImports;
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/legal
-**
-** This file is part of the QtV8 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 CALCULATEHASH_P_H
-#define CALCULATEHASH_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 <QtCore/qglobal.h>
-#include <QtCore/qstring.h>
-#include "qv4v8_p.h"
-QT_BEGIN_NAMESPACE
-
-inline uint32_t calculateHash(const quint8* chars, int length)
-{
- return v8::String::ComputeHash((char *)chars, length);
-}
-
-inline uint32_t calculateHash(const quint16* chars, int length)
-{
- return v8::String::ComputeHash((uint16_t *)chars, length);
-}
-
-QT_END_NAMESPACE
-
-#endif // CALCULATEHASH_P_H
void createHashValue() const;
static uint createHashValue(const QChar *ch, int length);
+ bool startsWithUpper() const {
+ return _text.length() && _text.at(0).isUpper();
+ }
+
QString _text;
mutable uint stringHash;
mutable uint identifier;
}
-int String::Length() const
-{
- return asV4String()->toQString().length();
-}
-
-uint32_t String::Hash() const
-{
- return asV4String()->hashValue();
-}
-
-
-String::CompleteHashData String::CompleteHash() const
-{
- QV4::String *s = asV4String();
- CompleteHashData data;
- data.hash = s->hashValue();
- data.length = s->toQString().length();
- data.symbol_id = s->identifier;
- return data;
-}
-
-uint32_t String::ComputeHash(uint16_t *string, int length)
-{
- return QV4::String::createHashValue(reinterpret_cast<const QChar *>(string), length);
-}
-
-uint32_t String::ComputeHash(char *string, int length)
-{
- // ### unefficient
- QString s = QString::fromLatin1((char *)string, length);
- return QV4::String::createHashValue(s.constData(), s.length());
-}
-
-bool String::Equals(uint16_t *str, int length)
-{
- return asQString() == QString(reinterpret_cast<QChar*>(str), length);
-}
-
-bool String::Equals(char *str, int length)
-{
- return asQString() == QString::fromLatin1(str, length);
-}
-
-int String::Write(uint16_t *buffer) const
-{
- uint length = asQString().length();
- if (length == 0)
- return 0;
- memcpy(buffer, asQString().constData(), length*sizeof(QChar));
- return length;
-}
-
String::ExternalStringResource *String::GetExternalStringResource() const
{
Q_UNIMPLEMENTED();
return v;
}
-Handle<String> String::NewSymbol(const char *data, int length)
-{
- QString str = QString::fromLatin1(data, length);
- QV4::String *vmString = currentEngine()->newIdentifier(str);
- return New(vmString);
-}
-
Handle<String> String::New(QV4::String *s)
{
return QV4::Value::fromString(s);
*/
class V8EXPORT String : public Value {
public:
- /**
- * Returns the number of characters in this string.
- */
- int Length() const;
-
-
- /**
- * Returns the hash of this string.
- */
- uint32_t Hash() const;
-
- struct CompleteHashData {
- CompleteHashData() : length(0), hash(0), symbol_id(0) {}
- int length;
- uint32_t hash;
- uint32_t symbol_id;
- };
-
- /**
- * Returns the "complete" hash of the string. This is
- * all the information about the string needed to implement
- * a very efficient hash keyed on the string.
- *
- * The members of CompleteHashData are:
- * length: The length of the string. Equivalent to Length()
- * hash: The hash of the string. Equivalent to Hash()
- * symbol_id: If the string is a sequential symbol, the symbol
- * id, otherwise 0. If the symbol ids of two strings are
- * the same (and non-zero) the two strings are identical.
- * If the symbol ids are different the strings may still be
- * identical, but an Equals() check must be performed.
- */
- CompleteHashData CompleteHash() const;
-
- /**
- * Compute a hash value for the passed UTF16 string
- * data.
- */
- static uint32_t ComputeHash(uint16_t *string, int length);
- static uint32_t ComputeHash(char *string, int length);
-
- /**
- * Returns true if this string is equal to the external
- * string data provided.
- */
- bool Equals(uint16_t *string, int length);
- bool Equals(char *string, int length);
- bool Equals(Handle<Value> that) const {
- return v8::Value::Equals(that);
- }
-
- /**
- * Write the contents of the string to an external buffer.
- * If no arguments are given, expects the buffer to be large
- * enough to hold the entire string and NULL terminator. Copies
- * the contents of the string and the NULL terminator into the
- * buffer.
- */
- int Write(uint16_t* buffer) const;
-
- class V8EXPORT ExternalStringResourceBase { // NOLINT
- public:
- virtual ~ExternalStringResourceBase() {}
-
- protected:
- ExternalStringResourceBase() {}
-
- /**
- * Internally V8 will call this Dispose method when the external string
- * resource is no longer needed. The default implementation will use the
- * delete operator. This method can be overridden in subclasses to
- * control how allocated external string resources are disposed.
- */
- virtual void Dispose() { delete this; }
-
- };
/**
* An ExternalStringResource is a wrapper around a two-byte string
* ExternalStringResource to manage the life cycle of the underlying
* buffer. Note that the string data must be immutable.
*/
- class V8EXPORT ExternalStringResource
- : public ExternalStringResourceBase {
+ class V8EXPORT ExternalStringResource {
public:
/**
* Override the destructor to manage the life cycle of the underlying
*/
virtual size_t length() const = 0;
+ virtual void Dispose() { delete this; }
+
protected:
ExternalStringResource() {}
};
/** Allocates a new string from 16-bit character codes.*/
static Handle<String> New(const uint16_t* data, int length = -1);
- /** Creates a symbol. Returns one if it exists already.*/
- static Handle<String> NewSymbol(const char* data, int length = -1);
-
static Handle<String> New(QV4::String *s);
/**
$$PWD/qv4unwindhelper_p-arm.h \
$$PWD/qv4serialize_p.h \
$$PWD/qv4v8_p.h \
- $$PWD/qcalculatehash_p.h \
$$PWD/qv4util_p.h \
$$PWD/qv4executableallocator_p.h \
$$PWD/qv4sequenceobject_p.h
QObject *scopeObject = resource->getScopeObject();
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
- if (context->imports && QV8Engine::startsWithUpper(property->v4Value().asString())) {
+ if (context->imports && property->v4Value().asString()->startsWithUpper()) {
// Search for attached properties, enums and imported scripts
QQmlTypeNameCache::Result r = context->imports->query(propertystring);
QV8Engine *engine = resource->engine;
QObject *scopeObject = resource->getScopeObject();
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
QV8QObjectWrapper *qobjectWrapper = engine->qobjectWrapper();
QV4::Value getOwnPropertyNames(const QV4::Value &o);
void freezeObject(const QV4::Value &value);
- static inline bool startsWithUpper(QV4::String *);
-
QVariant toVariant(const QV4::Value &value, int typeHint);
QV4::Value fromVariant(const QVariant &);
return m_bindingFlagKey;
}
-// XXX Can this be made more optimal? It is called prior to resolving each and every
-// unqualified name in QV8ContextWrapper.
-bool QV8Engine::startsWithUpper(QV4::String *string)
-{
- uint16_t c = string->toQString().at(0).unicode();
- return (c >= 'A' && c <= 'Z') ||
- (c > 127 && QChar::category(c) == QChar::Letter_Uppercase);
-}
-
QV8Engine::Deletable *QV8Engine::extensionData(int index) const
{
if (index < m_extensionData.count())
m_destroySymbol = QV4::Value::fromString(v4->newIdentifier("destroy"));
m_hiddenObject = QV4::Value::fromObject(v4->newObject());
- m_toStringString = QHashedV8String(m_toStringSymbol.value());
- m_destroyString = QHashedV8String(m_destroySymbol.value());
+ m_toStringString = QHashedV4String(m_toStringSymbol.value());
+ m_destroyString = QHashedV4String(m_destroySymbol.value());
toStringHash = m_toStringString.hash();
destroyHash = m_destroyString.hash();
v8::Handle<v8::Value> QV8QObjectWrapper::GetProperty(QV8Engine *engine, QObject *object,
v8::Handle<v8::Value> *objectHandle,
- const QHashedV8String &property,
+ const QHashedV4String &property,
QQmlContextData *context,
QV8QObjectWrapper::RevisionMode revisionMode)
{
}
}
-bool QV8QObjectWrapper::SetProperty(QV8Engine *engine, QObject *object, const QHashedV8String &property, QQmlContextData *context,
+bool QV8QObjectWrapper::SetProperty(QV8Engine *engine, QObject *object, const QHashedV4String &property, QQmlContextData *context,
v8::Handle<v8::Value> value, QV8QObjectWrapper::RevisionMode revisionMode)
{
if (engine->qobjectWrapper()->m_toStringString == property ||
if (!result->isWritable() && !result->isQList()) {
QString error = QLatin1String("Cannot assign to read-only property \"") +
- property.string()->v4Value().toQString() + QLatin1Char('\"');
+ property.toString() + QLatin1Char('\"');
v8::ThrowException(v8::Exception::Error(engine->toString(error)));
return true;
}
QObject *object = resource->object;
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
QV8Engine *v8engine = resource->engine;
QQmlContextData *context = v8engine->callingContext();
if (!result.IsEmpty())
return result;
- if (QV8Engine::startsWithUpper(property->v4Value().asString())) {
+ if (property->v4Value().asString()->startsWithUpper()) {
// Check for attached properties
if (context && context->imports) {
QQmlTypeNameCache::Result r = context->imports->query(propertystring);
QObject *object = resource->object;
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
QV8Engine *v8engine = resource->engine;
QQmlContextData *context = v8engine->callingContext();
QObject *object = resource->object;
QQmlContextData *context = engine->callingContext();
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
QQmlPropertyData local;
QQmlPropertyData *result = 0;
static QObject *toQObject(QV8ObjectResource *);
enum RevisionMode { IgnoreRevision, CheckRevision };
- inline v8::Handle<v8::Value> getProperty(QObject *, const QHashedV8String &, QQmlContextData *, RevisionMode);
- inline bool setProperty(QObject *, const QHashedV8String &, QQmlContextData *, v8::Handle<v8::Value>, RevisionMode);
+ inline v8::Handle<v8::Value> getProperty(QObject *, const QHashedV4String &, QQmlContextData *, RevisionMode);
+ inline bool setProperty(QObject *, const QHashedV4String &, QQmlContextData *, v8::Handle<v8::Value>, RevisionMode);
void registerWeakQObjectReference(QV8QObjectResource *resource)
{
v8::Handle<v8::Object> newQObject(QObject *, QQmlData *, QV8Engine *);
bool deleteWeakQObject(QV8QObjectResource *resource, bool calledFromEngineDtor = false);
static v8::Handle<v8::Value> GetProperty(QV8Engine *, QObject *, v8::Handle<v8::Value> *,
- const QHashedV8String &, QQmlContextData *, QV8QObjectWrapper::RevisionMode);
- static bool SetProperty(QV8Engine *, QObject *, const QHashedV8String &, QQmlContextData *,
+ const QHashedV4String &, QQmlContextData *, QV8QObjectWrapper::RevisionMode);
+ static bool SetProperty(QV8Engine *, QObject *, const QHashedV4String &, QQmlContextData *,
v8::Handle<v8::Value>, QV8QObjectWrapper::RevisionMode);
static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
const v8::AccessorInfo &info);
QV4::PersistentValue m_signalHandlerConstructor;
QV4::PersistentValue m_toStringSymbol;
QV4::PersistentValue m_destroySymbol;
- QHashedV8String m_toStringString;
- QHashedV8String m_destroyString;
+ QHashedV4String m_toStringString;
+ QHashedV4String m_destroyString;
QV4::PersistentValue m_hiddenObject;
QHash<QObject *, QV8QObjectConnectionList *> m_connections;
typedef QHash<QObject *, QV8QObjectInstance *> TaintedHash;
QIntrusiveList<QV8QObjectResource, &QV8QObjectResource::weakResource> m_javaScriptOwnedWeakQObjects;
};
-v8::Handle<v8::Value> QV8QObjectWrapper::getProperty(QObject *object, const QHashedV8String &string,
+v8::Handle<v8::Value> QV8QObjectWrapper::getProperty(QObject *object, const QHashedV4String &string,
QQmlContextData *context, RevisionMode mode)
{
QQmlData *dd = QQmlData::get(object, false);
}
}
-bool QV8QObjectWrapper::setProperty(QObject *object, const QHashedV8String &string,
+bool QV8QObjectWrapper::setProperty(QObject *object, const QHashedV4String &string,
QQmlContextData *context, v8::Handle<v8::Value> value, RevisionMode mode)
{
QQmlData *dd = QQmlData::get(object, false);
QObject *object = resource->object;
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
if (resource->type) {
QQmlType *type = resource->type;
QObject *qobjectSingleton = siinfo->qobjectApi(e);
if (qobjectSingleton) {
// check for enum value
- if (QV8Engine::startsWithUpper(property->v4Value().asString())) {
+ if (property->v4Value().asString()->startsWithUpper()) {
if (resource->mode == IncludeEnums) {
QString name = property->v4Value().toQString();
} else {
- if (QV8Engine::startsWithUpper(property->v4Value().asString())) {
+ if (property->v4Value().asString()->startsWithUpper()) {
bool ok = false;
int value = type->enumValue(propertystring, &ok);
if (ok)
QV8Engine *v8engine = resource->engine;
QQmlContextData *context = v8engine->callingContext();
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
QQmlType *type = resource->type;
if (type && !type->isSingleton() && resource->object) {
m_constructor = ft->GetFunction()->v4Value();
m_toStringSymbol = QV4::Value::fromString(QV8Engine::getV4(engine)->newIdentifier(QStringLiteral("toString")));
- m_toStringString = QHashedV8String(m_toStringSymbol.value());
+ m_toStringString = QHashedV4String(m_toStringSymbol.value());
toStringHash = m_toStringString.hash();
}
QV8ValueTypeResource *r = v8_resource_cast<QV8ValueTypeResource>(info.This());
if (!r) return v8::Handle<v8::Value>();
- QHashedV8String propertystring(property);
+ QHashedV4String propertystring(property->v4Value());
{
// Comparing the hash first actually makes a measurable difference here, at least on x86
QV4::PersistentValue m_constructor;
QV4::PersistentValue m_toString;
QV4::PersistentValue m_toStringSymbol;
- QHashedV8String m_toStringString;
+ QHashedV4String m_toStringString;
};
QT_END_NAMESPACE
const ListLayout::Role &ListLayout::getRoleOrCreate(v8::Handle<v8::String> key, Role::DataType type)
{
- QHashedV8String hashedKey(key);
+ QHashedV4String hashedKey(key->v4Value());
QStringHash<Role *>::Node *node = roleHash.findNode(hashedKey);
if (node) {
const Role &r = *node->value;
return r;
}
- QString qkey;
- qkey.resize(key->Length());
- key->Write(reinterpret_cast<uint16_t*>(qkey.data()));
+ QString qkey = key->asQString();
return createRole(qkey, type);
}
const ListLayout::Role *ListLayout::getExistingRole(v8::Handle<v8::String> key)
{
Role *r = 0;
- QHashedV8String hashedKey(key);
+ QHashedV4String hashedKey(key->v4Value());
QStringHash<Role *>::Node *node = roleHash.findNode(hashedKey);
if (node)
r = node->value;
if (propertyValue->IsString()) {
const ListLayout::Role &r = m_layout->getRoleOrCreate(propertyName, ListLayout::Role::String);
v8::Handle<v8::String> jsString = propertyValue->ToString();
- QString qstr;
- qstr.resize(jsString->Length());
- jsString->Write(reinterpret_cast<uint16_t*>(qstr.data()));
+ QString qstr = jsString->asQString();
roleIndex = e->setStringProperty(r, qstr);
} else if (propertyValue->IsNumber()) {
const ListLayout::Role &r = m_layout->getRoleOrCreate(propertyName, ListLayout::Role::Number);
const ListLayout::Role &r = m_layout->getRoleOrCreate(propertyName, ListLayout::Role::String);
if (r.type == ListLayout::Role::String) {
v8::Handle<v8::String> jsString = propertyValue->ToString();
- QString qstr;
- qstr.resize(jsString->Length());
- jsString->Write(reinterpret_cast<uint16_t*>(qstr.data()));
+ QString qstr = jsString->asQString();
e->setStringPropertyFast(r, qstr);
}
} else if (propertyValue->IsNumber()) {
// Add the value now
if (d->IsString()) {
v8::Handle<v8::String> jsString = d->ToString();
- QString qstr;
- qstr.resize(jsString->Length());
- jsString->Write(reinterpret_cast<uint16_t*>(qstr.data()));
+ QString qstr = jsString->asQString();
roleIndex = setStringProperty(role, qstr);
} else if (d->IsNumber()) {
roleIndex = setDoubleProperty(role, d->NumberValue());
projects / platform / upstream / qtdeclarative.git / commitdiff