qv4string.cpp

Go to the documentation of this file.

// 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
 
#include "qv4string_p.h"
#include "qv4value_p.h"
#include "qv4identifiertable_p.h"
#include "qv4runtime_p.h"
#include <QtQml/private/qv4mm_p.h>
#include <QtCore/QHash>
#include <QtCore/private/qnumeric_p.h>
 
using namespace QV4;
 
void Heap::StringOrSymbol::markObjects(Heap::Base *that, MarkStack *markStack)
{
    StringOrSymbol *s = static_cast<StringOrSymbol *>(that);
    Heap::StringOrSymbol *id = s->identifier.asStringOrSymbol();
    if (id)
        id->mark(markStack);
}
 
void Heap::String::markObjects(Heap::Base *that, MarkStack *markStack)
{
    StringOrSymbol::markObjects(that, markStack);
    String *s = static_cast<String *>(that);
    if (s->subtype < StringType_Complex)
        return;
 
    ComplexString *cs = static_cast<ComplexString *>(s);
    if (cs->subtype == StringType_AddedString) {
        cs->left->mark(markStack);
        cs->right->mark(markStack);
    } else {
        Q_ASSERT(cs->subtype == StringType_SubString);
        cs->left->mark(markStack);
    }
}
 
DEFINE_MANAGED_VTABLE(StringOrSymbol);
DEFINE_MANAGED_VTABLE(String);
 
 
bool String::virtualIsEqualTo(Managed *t, Managed *o)
{
    if (t == o)
        return true;
 
    if (!o->vtable()->isString)
        return false;
 
    return static_cast<String *>(t)->isEqualTo(static_cast<String *>(o));
}
 
 
void Heap::String::init(const QString &t)
{
    QString mutableText(t);
    StringOrSymbol::init(mutableText.data_ptr());
    subtype = String::StringType_Unknown;
}
 
void Heap::ComplexString::init(String *l, String *r)
{
    StringOrSymbol::init();
    subtype = String::StringType_AddedString;
 
    left = l;
    right = r;
    len = left->length() + right->length();
    if (left->subtype >= StringType_Complex)
        largestSubLength = static_cast<ComplexString *>(left)->largestSubLength;
    else
        largestSubLength = left->length();
    if (right->subtype >= StringType_Complex)
        largestSubLength = qMax(largestSubLength, static_cast<ComplexString *>(right)->largestSubLength);
    else
        largestSubLength = qMax(largestSubLength, right->length());
 
    // make sure we don't get excessive depth in our strings
    if (len > 256 && len >= 2*largestSubLength)
        simplifyString();
}
 
void Heap::ComplexString::init(Heap::String *ref, int from, int len)
{
    Q_ASSERT(ref->length() >= from + len);
    StringOrSymbol::init();
 
    subtype = String::StringType_SubString;
 
    left = ref;
    this->from = from;
    this->len = len;
}
 
void Heap::StringOrSymbol::destroy()
{
    if (subtype < Heap::String::StringType_AddedString) {
        internalClass->engine->memoryManager->changeUnmanagedHeapSizeUsage(
                    qptrdiff(-text()->size) * qptrdiff(sizeof(QChar)));
    }
    text().~QStringPrivate();
    Base::destroy();
}
 
uint String::toUInt(bool *ok) const
{
    *ok = true;
 
    if (subtype() >= Heap::String::StringType_Unknown)
        d()->createHashValue();
    if (subtype() == Heap::String::StringType_ArrayIndex)
        return d()->stringHash;
 
    // required for UINT_MAX or numbers starting with a leading 0
    double d = RuntimeHelpers::stringToNumber(toQString());
    uint l = (uint)d;
    if (d == l)
        return l;
    *ok = false;
    return UINT_MAX;
}
 
void String::createPropertyKeyImpl() const
{
    if (d()->subtype >= Heap::String::StringType_AddedString)
        d()->simplifyString();
    Q_ASSERT(d()->subtype < Heap::String::StringType_AddedString);
    engine()->identifierTable->asPropertyKey(this);
}
 
void Heap::String::simplifyString() const
{
    Q_ASSERT(subtype >= StringType_AddedString);
 
    int l = length();
    QString result(l, Qt::Uninitialized);
    QChar *ch = const_cast<QChar *>(result.constData());
    append(this, ch);
    text() = result.data_ptr();
    const ComplexString *cs = static_cast<const ComplexString *>(this);
    identifier = PropertyKey::invalid();
    cs->left = cs->right = nullptr;
 
    internalClass->engine->memoryManager->changeUnmanagedHeapSizeUsage(
                qptrdiff(text().size) * qptrdiff(sizeof(QChar)));
    subtype = StringType_Unknown;
}
 
bool Heap::String::startsWithUpper() const
{
    if (subtype == StringType_AddedString)
        return static_cast<const Heap::ComplexString *>(this)->left->startsWithUpper();
 
    const Heap::String *str = this;
    int offset = 0;
    if (subtype == StringType_SubString) {
        const ComplexString *cs = static_cast<const Heap::ComplexString *>(this);
        if (!cs->len)
            return false;
        // simplification here is not ideal, but hopefully not a common case.
        if (cs->left->subtype >= Heap::String::StringType_Complex)
            cs->left->simplifyString();
        str = cs->left;
        offset = cs->from;
    }
    Q_ASSERT(str->subtype < Heap::String::StringType_Complex);
    return str->text().size > offset && QChar::isUpper(str->text().data()[offset]);
}
 
void Heap::String::append(const String *data, QChar *ch)
{
    // in-order visitation with explicit stack
    // where leaf nodes are "real" strings that get appended to ch
 
    enum StatusTag : bool { NotVisited, Visited };
    using Pointer = QTaggedPointer<const String, StatusTag>;
 
    std::vector<Pointer> worklist;
    worklist.reserve(32);
    worklist.push_back(Pointer(data));
 
    while (!worklist.empty()) {
        Pointer item = worklist.back();
        if (item.tag() == Visited) {
            Q_ASSERT(item->subtype == StringType_AddedString);
            const ComplexString *cs = static_cast<const ComplexString *>(item.data());
            worklist.pop_back();
            worklist.push_back(Pointer(cs->right));
            continue;
        }
 
        if (item->subtype == StringType_AddedString) {
            // we need to keep the node in the worklist, as we still need to handle "right"
            worklist.back().setTag(Visited);
            const ComplexString *cs = static_cast<const ComplexString *>(item.data());
            worklist.push_back(Pointer(cs->left));
        } else if (item->subtype == StringType_SubString) {
            worklist.pop_back();
            const ComplexString *cs = static_cast<const ComplexString *>(item.data());
            memcpy(ch, cs->left->toQString().constData() + cs->from, cs->len*sizeof(QChar));
            ch += cs->len;
        } else {
            worklist.pop_back();
            memcpy(static_cast<void *>(ch), item->text().data(), item->text().size * sizeof(QChar));
            ch += item->text().size;
        }
    }
}
 
void Heap::StringOrSymbol::createHashValue() const
{
    if (subtype >= StringType_AddedString) {
        Q_ASSERT(internalClass->vtable->isString);
        static_cast<const Heap::String *>(this)->simplifyString();
    }
    Q_ASSERT(subtype < StringType_AddedString);
    const QChar *ch = reinterpret_cast<const QChar *>(text().data());
    const QChar *end = ch + text().size;
    stringHash = QV4::String::calculateHashValue(ch, end, &subtype);
}
 
qint64 String::virtualGetLength(const Managed *m)
{
    return static_cast<const String *>(m)->d()->length();
}