Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
#ifndef QV4STRING_H
#define QV4STRING_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/qstring.h>
#include "qv4managed_p.h"
#include <QtCore/private/qnumeric_p.h>
#include "qv4enginebase_p.h"
#include <private/qv4stringtoarrayindex_p.h>
QT_BEGIN_NAMESPACE
namespace QV4 {
struct ExecutionEngine;
struct PropertyKey;
namespace Heap {
struct Q_QML_EXPORT StringOrSymbol : Base
{
enum StringType {
StringType_Symbol,
StringType_Regular,
StringType_ArrayIndex,
StringType_Unknown,
StringType_AddedString,
StringType_SubString,
StringType_Complex = StringType_AddedString
};
void init() {
Base::init();
new (&textStorage) QStringPrivate;
}
void init(QStringPrivate text)
{
Base::init();
new (&textStorage) QStringPrivate(std::move(text));
}
mutable struct { alignas(QStringPrivate) unsigned char data[sizeof(QStringPrivate)]; } textStorage;
mutable PropertyKey identifier;
mutable uint subtype;
mutable uint stringHash;
static void markObjects(Heap::Base *that, MarkStack *markStack);
void destroy();
QStringPrivate &text() const { return *reinterpret_cast<QStringPrivate *>(&textStorage); }
inline QString toQString() const {
QStringPrivate dd = text();
return QString(std::move(dd));
}
void createHashValue() const;
inline unsigned hashValue() const {
if (subtype >= StringType_Unknown)
createHashValue();
Q_ASSERT(subtype < StringType_Complex);
return stringHash;
}
};
struct Q_QML_EXPORT String : StringOrSymbol {
static void markObjects(Heap::Base *that, MarkStack *markStack);
const VTable *vtable() const {
return internalClass->vtable;
}
void init(const QString &text);
void simplifyString() const;
int length() const;
std::size_t retainedTextSize() const {
return subtype >= StringType_Complex ? 0 : (std::size_t(text().size) * sizeof(QChar));
}
inline QString toQString() const {
if (subtype >= StringType_Complex)
simplifyString();
return StringOrSymbol::toQString();
}
inline bool isEqualTo(const String *other) const {
if (this == other)
return true;
if (hashValue() != other->hashValue())
return false;
Q_ASSERT(subtype < StringType_Complex);
if (identifier.isValid() && identifier == other->identifier)
return true;
if (subtype == Heap::String::StringType_ArrayIndex && other->subtype == Heap::String::StringType_ArrayIndex)
return true;
return toQString() == other->toQString();
}
bool startsWithUpper() const;
private:
static void append(const String *data, QChar *ch);
};
static_assert(std::is_trivially_copyable_v<String>);
static_assert(std::is_trivially_default_constructible_v<String>);
struct ComplexString : String {
void init(String *l, String *n);
void init(String *ref, int from, int len);
mutable String *left;
mutable String *right;
union {
mutable int largestSubLength;
int from;
};
int len;
};
static_assert(std::is_trivially_copyable_v<ComplexString>);
static_assert(std::is_trivially_default_constructible_v<ComplexString>);
inline
int String::length() const {
// TODO: ensure that our strings never actually grow larger than INT_MAX
return subtype < StringType_AddedString ? int(text().size) : static_cast<const ComplexString *>(this)->len;
}
}
struct Q_QML_EXPORT StringOrSymbol : public Managed {
V4_MANAGED(StringOrSymbol, Managed)
Q_MANAGED_TYPE(StringOrSymbol);
V4_NEEDS_DESTROY
enum {
IsStringOrSymbol = true
};
private:
inline void createPropertyKey() const;
public:
PropertyKey propertyKey() const { Q_ASSERT(d()->identifier.isValid()); return d()->identifier; }
PropertyKey toPropertyKey() const;
inline QString toQString() const {
return d()->toQString();
}
};
struct Q_QML_EXPORT String : public StringOrSymbol {
V4_MANAGED(String, StringOrSymbol)
Q_MANAGED_TYPE(String)
V4_INTERNALCLASS(String)
enum {
IsString = true
};
uchar subtype() const { return d()->subtype; }
void setSubtype(uchar subtype) const { d()->subtype = subtype; }
bool equals(String *other) const {
return d()->isEqualTo(other->d());
}
inline bool isEqualTo(const String *other) const {
return d()->isEqualTo(other->d());
}
inline bool lessThan(const String *other) {
return toQString() < other->toQString();
}
inline QString toQString() const {
return d()->toQString();
}
inline unsigned hashValue() const {
return d()->hashValue();
}
uint toUInt(bool *ok) const;
// slow path
Q_NEVER_INLINE void createPropertyKeyImpl() const;
static uint createHashValue(const QChar *ch, int length, uint *subtype)
{
const QChar *end = ch + length;
return calculateHashValue(ch, end, subtype);
}
static uint createHashValueDisallowingArrayIndex(const QChar *ch, int length, uint *subtype)
{
const QChar *end = ch + length;
return calculateHashValue<String::DisallowArrayIndex>(ch, end, subtype);
}
static uint createHashValue(const char *ch, int length, uint *subtype)
{
const char *end = ch + length;
return calculateHashValue(ch, end, subtype);
}
bool startsWithUpper() const { return d()->startsWithUpper(); }
protected:
static bool virtualIsEqualTo(Managed *that, Managed *o);
static qint64 virtualGetLength(const Managed *m);
public:
enum IndicesBehavior {Default, DisallowArrayIndex};
template <IndicesBehavior Behavior = Default, typename T>
static inline uint calculateHashValue(const T *ch, const T* end, uint *subtype)
{
// array indices get their number as hash value
uint h = UINT_MAX;
if constexpr (Behavior != DisallowArrayIndex) {
h = stringToArrayIndex(ch, end);
if (h != UINT_MAX) {
if (subtype)
*subtype = Heap::StringOrSymbol::StringType_ArrayIndex;
return h;
}
}
while (ch < end) {
h = 31 * h + charToUInt(ch);
++ch;
}
if (subtype)
*subtype = (ch != end && charToUInt(ch) == '@') ? Heap::StringOrSymbol::StringType_Symbol : Heap::StringOrSymbol::StringType_Regular;
return h;
}
};
struct ComplexString : String {
typedef QV4::Heap::ComplexString Data;
QV4::Heap::ComplexString *d() const { return static_cast<QV4::Heap::ComplexString *>(m()); }
};
inline
void StringOrSymbol::createPropertyKey() const {
Q_ASSERT(!d()->identifier.isValid());
Q_ASSERT(isString());
static_cast<const String *>(this)->createPropertyKeyImpl();
}
inline PropertyKey StringOrSymbol::toPropertyKey() const {
if (!d()->identifier.isValid())
createPropertyKey();
return d()->identifier;
}
template<>
inline const StringOrSymbol *Value::as() const {
return isManaged() && m()->internalClass->vtable->isStringOrSymbol ? static_cast<const String *>(this) : nullptr;
}
template<>
inline const String *Value::as() const {
return isManaged() && m()->internalClass->vtable->isString ? static_cast<const String *>(this) : nullptr;
}
template<>
inline ReturnedValue value_convert<String>(ExecutionEngine *e, const Value &v)
{
return v.toString(e)->asReturnedValue();
}
}
QT_END_NAMESPACE
#endif