Revision control
++ // 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 "qv4runtime_p.h"
++
++ #include <private/qqmlengine_p.h>
++ #include <private/qqmljavascriptexpression_p.h>
++ #include <private/qqmljsast_p.h>
++ #include <private/qqmltypewrapper_p.h>
++ #include <private/qqmlvaluetypewrapper_p.h>
++ #include <private/qv4argumentsobject_p.h>
++ #include <private/qv4engine_p.h>
++ #include <private/qv4function_p.h>
++ #include <private/qv4generatorobject_p.h>
++ #include <private/qv4global_p.h>
++ #include <private/qv4globalobject_p.h>
++ #include <private/qv4jscall_p.h>
++ #include <private/qv4lookup_p.h>
++ #include <private/qv4math_p.h>
++ #include <private/qv4object_p.h>
++ #include <private/qv4qmlcontext_p.h>
++ #include <private/qv4qobjectwrapper_p.h>
++ #include <private/qv4regexp_p.h>
++ #include <private/qv4regexpobject_p.h>
++ #include <private/qv4scopedvalue_p.h>
++ #include <private/qv4stackframe_p.h>
++ #include <private/qv4symbol_p.h>
++
++ #include <wtf/MathExtras.h>
++
++ #include <QtCore/private/qlocale_tools_p.h>
++ #include <QtCore/qdebug.h>
++
++ #ifdef QV4_COUNT_RUNTIME_FUNCTIONS
++ # include <QtCore/qbuffer.h>
++ #endif // QV4_COUNT_RUNTIME_FUNCTIONS
++
++ #include <cassert>
++ #include <cstdio>
++ #include <stdlib.h>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_STATIC_LOGGING_CATEGORY(lcCoercingTypeAssertion, "qt.qml.coercingTypeAssertion");
++
++ namespace QV4 {
++
++ #ifdef QV4_COUNT_RUNTIME_FUNCTIONS
++ struct RuntimeCounters::Data {
++ enum Type {
++ None = 0,
++ Undefined = 1,
++ Null = 2,
++ Boolean = 3,
++ Integer = 4,
++ Managed = 5,
++ Double = 7
++ };
++
++ static const char *pretty(Type t) {
++ switch (t) {
++ case None: return "";
++ case Undefined: return "Undefined";
++ case Null: return "Null";
++ case Boolean: return "Boolean";
++ case Integer: return "Integer";
++ case Managed: return "Managed";
++ case Double: return "Double";
++ default: return "Unknown";
++ }
++ }
++
++ static unsigned mangle(unsigned tag) {
++ switch (tag) {
++ case Value::Undefined_Type: return Undefined;
++ case Value::Null_Type: return Null;
++ case Value::Boolean_Type: return Boolean;
++ case Value::Integer_Type: return Integer;
++ case Value::Managed_Type: return Managed;
++ default: return Double;
++ }
++ }
++
++ static unsigned mangle(unsigned tag1, unsigned tag2) {
++ return (mangle(tag1) << 3) | mangle(tag2);
++ }
++
++ static void unmangle(unsigned signature, Type &tag1, Type &tag2) {
++ tag1 = Type((signature >> 3) & 7);
++ tag2 = Type(signature & 7);
++ }
++
++ typedef QList<quint64> Counters;
++ QHash<const char *, Counters> counters;
++
++ inline void count(const char *func) {
++ QList<quint64> &cnt = counters[func];
++ if (cnt.isEmpty())
++ cnt.resize(64);
++ cnt[0] += 1;
++ }
++
++ inline void count(const char *func, unsigned tag) {
++ QList<quint64> &cnt = counters[func];
++ if (cnt.isEmpty())
++ cnt.resize(64);
++ cnt[mangle(tag)] += 1;
++ }
++
++ inline void count(const char *func, unsigned tag1, unsigned tag2) {
++ QList<quint64> &cnt = counters[func];
++ if (cnt.isEmpty())
++ cnt.resize(64);
++ cnt[mangle(tag1, tag2)] += 1;
++ }
++
++ struct Line {
++ const char *func;
++ Type tag1, tag2;
++ quint64 count;
++
++ static bool less(const Line &line1, const Line &line2) {
++ return line1.count > line2.count;
++ }
++ };
++
++ void dump() const {
++ QBuffer buf;
++ buf.open(QIODevice::WriteOnly);
++ QTextStream outs(&buf);
++ QList<Line> lines;
++ for (auto it = counters.cbegin(), end = counters.cend(); it != end; ++it) {
++ const Counters &fCount = it.value();
++ for (int i = 0, ei = fCount.size(); i != ei; ++i) {
++ quint64 count = fCount[i];
++ if (!count)
++ continue;
++ Line line;
++ line.func = it.key();
++ unmangle(i, line.tag1, line.tag2);
++ line.count = count;
++ lines.append(line);
++ }
++ }
++ std::sort(lines.begin(), lines.end(), Line::less);
++ outs << lines.size() << " counters:" << endl;
++ for (const Line &line : std::as_const(lines))
++ outs << qSetFieldWidth(10) << line.count << qSetFieldWidth(0)
++ << " | " << line.func
++ << " | " << pretty(line.tag1)
++ << " | " << pretty(line.tag2)
++ << endl;
++ qDebug("%s", buf.data().constData());
++ }
++ };
++
++ RuntimeCounters *RuntimeCounters::instance = 0;
++ static RuntimeCounters runtimeCountersInstance;
++ RuntimeCounters::RuntimeCounters()
++ : d(new Data)
++ {
++ if (!instance)
++ instance = this;
++ }
++
++ RuntimeCounters::~RuntimeCounters()
++ {
++ d->dump();
++ delete d;
++ }
++
++ void RuntimeCounters::count(const char *func)
++ {
++ d->count(func);
++ }
++
++ void RuntimeCounters::count(const char *func, uint tag)
++ {
++ d->count(func, tag);
++ }
++
++ void RuntimeCounters::count(const char *func, uint tag1, uint tag2)
++ {
++ d->count(func, tag1, tag2);
++ }
++
++ #endif // QV4_COUNT_RUNTIME_FUNCTIONS
++
++ static QV4::Lookup *runtimeLookup(Function *f, uint i)
++ {
++ return f->executableCompilationUnit()->runtimeLookups + i;
++ }
++
++ void RuntimeHelpers::numberToString(QString *result, double num, int radix)
++ {
++ Q_ASSERT(result);
++
++ if (std::isnan(num)) {
++ *result = QStringLiteral("NaN");
++ return;
++ } else if (qt_is_inf(num)) {
++ *result = num < 0 ? QStringLiteral("-Infinity") : QStringLiteral("Infinity");
++ return;
++ }
++
++ if (radix == 10) {
++ // We cannot use our usual locale->toString(...) here, because EcmaScript has special rules
++ // about the longest permissible number, depending on if it's <0 or >0.
++ const int ecma_shortest_low = -6;
++ const int ecma_shortest_high = 21;
++
++ const QLatin1Char zero('0');
++ const QLatin1Char dot('.');
++
++ int decpt = 0;
++ int sign = 0;
++ *result = qdtoa(num, &decpt, &sign);
++
++ if (decpt <= ecma_shortest_low || decpt > ecma_shortest_high) {
++ if (result->size() > 1)
++ result->insert(1, dot);
++ result->append(QLatin1Char('e'));
++ if (decpt > 0)
++ result->append(QLatin1Char('+'));
++ result->append(QString::number(decpt - 1));
++ } else if (decpt <= 0) {
++ result->prepend(QLatin1String("0.") + QString(-decpt, zero));
++ } else if (decpt < result->size()) {
++ result->insert(decpt, dot);
++ } else {
++ result->append(QString(decpt - result->size(), zero));
++ }
++
++ if (sign && num)
++ result->prepend(QLatin1Char('-'));
++
++ return;
++ }
++
++ result->clear();
++ bool negative = false;
++
++ if (num < 0) {
++ negative = true;
++ num = -num;
++ }
++
++ double frac = num - ::floor(num);
++ num = Value::toInteger(num);
++
++ do {
++ char c = (char)::fmod(num, radix);
++ c = (c < 10) ? (c + '0') : (c - 10 + 'a');
++ result->prepend(QLatin1Char(c));
++ num = ::floor(num / radix);
++ } while (num != 0);
++
++ if (frac != 0) {
++ result->append(QLatin1Char('.'));
++ double magnitude = 1;
++ double next = frac;
++ do {
++ next *= radix;
++ const int floored = ::floor(next);
++ char c = char(floored);
++ c = (c < 10) ? (c + '0') : (c - 10 + 'a');
++ result->append(QLatin1Char(c));
++ magnitude /= radix;
++ frac -= double(floored) * magnitude;
++ next -= double(floored);
++
++ // The next digit still makes a difference
++ // if a value of "radix" for it would change frac.
++ // Otherwise we've reached the limit of numerical precision.
++ } while (frac > 0 && frac - magnitude != frac);
++ }
++
++ if (negative)
++ result->prepend(QLatin1Char('-'));
++ }
++
++ ReturnedValue Runtime::Closure::call(ExecutionEngine *engine, int functionId)
++ {
++ QV4::Function *clos = engine->currentStackFrame->v4Function->executableCompilationUnit()
++ ->runtimeFunctions[functionId];
++ Q_ASSERT(clos);
++ ExecutionContext *current = engine->currentContext();
++ Scope s(engine);
++ QV4::ScopedObject closure(s);
++
++ if (clos->isGenerator())
++ closure = GeneratorFunction::create(current, clos)->asReturnedValue();
++ else
++ closure = FunctionObject::createScriptFunction(current, clos)->asReturnedValue();
++ // ### TODO: only keep reference to scripts if actually needed; see QTBUG-130795
++ Scoped<QV4::QmlContext> callingQmlContext(s, s.engine->qmlContext());
++ if (callingQmlContext) {
++ // ### TODO: It would be more efficient to use custom Function prototypes instead of setting a property
++ // ==> QTBUG-130798
++ Scoped<QV4::QQmlContextWrapper> qmlContextWrapper(s, callingQmlContext->d()->qml());
++ const QV4::QQmlContextWrapper *resource = qmlContextWrapper;
++ QQmlRefPointer<QQmlContextData> context = resource->getContext();
++ /* we can use fromReturnedValue here, as isNullOrUndefined doesn't allocate.
++ fetching importedScripts twvice is less overhead than unconditionally creating a scope,
++ as script imports are rather rare*/
++ if (!QV4::Value::fromReturnedValue(context->importedScripts()).isNullOrUndefined()) {
++ QV4::ScopedString name(s, engine->newString(QLatin1StringView("$importedScripts")));
++ QV4::ScopedObject scripts(s, context->importedScripts());
++ closure->insertMember(name, scripts, Attr_Invalid);
++ }
++ }
++ return closure.asReturnedValue();
++ }
++
++ Bool Runtime::DeleteProperty_NoThrow::call(ExecutionEngine *engine, const Value &base, const Value &index)
++ {
++ Scope scope(engine);
++ ScopedObject o(scope, base.toObject(engine));
++ if (scope.hasException())
++ return Encode::undefined();
++ Q_ASSERT(o);
++
++ ScopedPropertyKey key(scope, index.toPropertyKey(engine));
++ if (engine->hasException)
++ return false;
++ return o->deleteProperty(key);
++ }
++
++ ReturnedValue Runtime::DeleteProperty::call(ExecutionEngine *engine, QV4::Function *function, const QV4::Value &base, const QV4::Value &index)
++ {
++ if (!Runtime::DeleteProperty_NoThrow::call(engine, base, index)) {
++ if (function->isStrict())
++ engine->throwTypeError();
++ return Encode(false);
++ } else {
++ return Encode(true);
++ }
++ }
++
++ Bool Runtime::DeleteName_NoThrow::call(ExecutionEngine *engine, int nameIndex)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ return engine->currentContext()->deleteProperty(name);
++ }
++
++ ReturnedValue Runtime::DeleteName::call(ExecutionEngine *engine, Function *function, int name)
++ {
++ if (!Runtime::DeleteName_NoThrow::call(engine, name)) {
++ if (function->isStrict())
++ engine->throwTypeError();
++ return Encode(false);
++ } else {
++ return Encode(true);
++ }
++ }
++
++ static QV4::ReturnedValue doInstanceof(ExecutionEngine *engine, const Value &lval, const Value &rval)
++ {
++ // 11.8.6, 5: rval must be an Object
++ const Object *rhs = rval.as<Object>();
++ if (!rhs)
++ return engine->throwTypeError();
++
++ const FunctionObject *f = rhs->as<FunctionObject>();
++ // shortcut hasInstance evaluation. In this case we know that we are calling the regular hasInstance()
++ // method of the FunctionPrototype
++ if (f && f->d()->prototype() == engine->functionPrototype()->d() && !f->hasHasInstanceProperty())
++ return Object::checkedInstanceOf(engine, f, lval);
++
++ Scope scope(engine);
++ ScopedValue hasInstance(scope, rhs->get(engine->symbol_hasInstance()));
++ if (hasInstance->isUndefined())
++ return Encode(rhs->instanceOf(lval));
++
++ FunctionObject *fHasInstance = hasInstance->as<FunctionObject>();
++ if (!fHasInstance)
++ return engine->throwTypeError();
++
++ return Encode(fHasInstance->call(&rval, &lval, 1));
++ }
++
++ QV4::ReturnedValue Runtime::Instanceof::call(ExecutionEngine *engine, const Value &lval, const Value &rval)
++ {
++ Scope scope(engine);
++ ScopedValue result(scope, doInstanceof(engine, lval, rval));
++ return scope.hasException() ? Encode::undefined() : Encode(result->toBoolean());
++ }
++
++ QV4::ReturnedValue Runtime::As::call(ExecutionEngine *engine, const Value &lval, const Value &rval)
++ {
++ Scope scope(engine);
++ ScopedValue result(scope, doInstanceof(engine, lval, rval));
++
++ if (scope.hasException()) {
++ // "foo instanceof valueType" must not throw an exception.
++ // So this can only be an object type.
++ engine->catchException();
++ return Encode::null();
++ }
++
++ if (result->toBoolean())
++ return lval.asReturnedValue();
++ else if (result->isBoolean())
++ return Encode::null();
++
++ if (engine->callingQmlContext()->valueTypesAreAssertable())
++ return Encode::undefined();
++
++ // Try to convert the value type
++ Scoped<QQmlTypeWrapper> typeWrapper(scope, rval);
++ if (!typeWrapper)
++ return Encode::undefined();
++
++ const auto *stackFrame = engine->currentStackFrame;
++ if (lval.as<QQmlValueTypeWrapper>()) {
++ qCWarning(lcCoercingTypeAssertion).nospace().noquote()
++ << stackFrame->source() << ':' << stackFrame->lineNumber() << ':'
++ << " Coercing between incompatible value types mistakenly yields null rather than"
++ << " undefined. Add 'pragma ValueTypeBehavior: Assertable' to prevent this.";
++ return Encode::null();
++ }
++
++ if (lval.as<QV4::QObjectWrapper>()) {
++ qCWarning(lcCoercingTypeAssertion).nospace().noquote()
++ << stackFrame->source() << ':' << stackFrame->lineNumber() << ':'
++ << " Coercing from instances of object types to value types mistakenly yields null"
++ << " rather than undefined. Add 'pragma ValueTypeBehavior: Assertable' to prevent"
++ << " this.";
++ return Encode::null();
++ }
++
++ result = coerce(engine, lval, typeWrapper->d()->type(), false);
++ if (result->isUndefined())
++ return Encode::undefined();
++
++ qCWarning(lcCoercingTypeAssertion).nospace().noquote()
++ << stackFrame->source() << ':' << stackFrame->lineNumber() << ':'
++ << " Coercing a value to " << typeWrapper->toQStringNoThrow()
++ << " using a type assertion. This behavior is deprecated."
++ << " Add 'pragma ValueTypeBehavior: Assertable' to prevent it.";
++ return result->asReturnedValue();
++ }
++
++ QV4::ReturnedValue Runtime::In::call(ExecutionEngine *engine, const Value &left, const Value &right)
++ {
++ Object *ro = right.objectValue();
++ if (!ro)
++ return engine->throwTypeError();
++ Scope scope(engine);
++ ScopedPropertyKey s(scope, left.toPropertyKey(engine));
++ if (scope.hasException())
++ return Encode::undefined();
++ bool r = ro->hasProperty(s);
++ return Encode(r);
++ }
++
++ double RuntimeHelpers::stringToNumber(const QString &string)
++ {
++ // The actual maximum valid length is certainly shorter, but due to the sheer number of
++ // different number formatting variants, we rather err on the side of caution here.
++ // For example, you can have up to 772 valid decimal digits left of the dot, as stated in the
++ // libdoubleconversion sources. The same maximum value would be represented by roughly 3.5 times
++ // as many binary digits.
++ const int excessiveLength = 16 * 1024;
++ if (string.size() > excessiveLength)
++ return qQNaN();
++
++ const QStringView s = QStringView(string).trimmed();
++ if (s.startsWith(QLatin1Char('0'))) {
++ int base = -1;
++ if (s.startsWith(QLatin1String("0x")) || s.startsWith(QLatin1String("0X")))
++ base = 16;
++ else if (s.startsWith(QLatin1String("0o")) || s.startsWith(QLatin1String("0O")))
++ base = 8;
++ else if (s.startsWith(QLatin1String("0b")) || s.startsWith(QLatin1String("0B")))
++ base = 2;
++ if (base > 0) {
++ bool ok = true;
++ qlonglong num;
++ num = s.mid(2).toLongLong(&ok, base);
++ if (!ok)
++ return qQNaN();
++ return num;
++ }
++ }
++ bool ok = false;
++ QByteArray ba = s.toLatin1();
++ const char *begin = ba.constData();
++ const char *end = nullptr;
++ double d = qstrtod(begin, &end, &ok);
++ if (end - begin != ba.size()) {
++ if (ba == "Infinity" || ba == "+Infinity")
++ d = Q_INFINITY;
++ else if (ba == "-Infinity")
++ d = -Q_INFINITY;
++ else
++ d = std::numeric_limits<double>::quiet_NaN();
++ }
++ return d;
++ }
++
++ Heap::String *RuntimeHelpers::stringFromNumber(ExecutionEngine *engine, double number)
++ {
++ QString qstr;
++ RuntimeHelpers::numberToString(&qstr, number, 10);
++ return engine->newString(qstr);
++ }
++
++ ReturnedValue RuntimeHelpers::objectDefaultValue(const Object *object, int typeHint)
++ {
++ ExecutionEngine *engine = object->internalClass()->engine;
++ if (engine->hasException)
++ return Encode::undefined();
++
++ String *hint;
++ switch (typeHint) {
++ case STRING_HINT:
++ hint = engine->id_string();
++ break;
++ case NUMBER_HINT:
++ hint = engine->id_number();
++ break;
++ default:
++ hint = engine->id_default();
++ break;
++ }
++
++ Scope scope(engine);
++ Value v = Value::fromReturnedValue(object->get(engine->symbol_toPrimitive()));
++ if (engine->hasException || (!v.isNullOrUndefined() && !v.isFunctionObject())) {
++ engine->throwTypeError(QStringLiteral("Value for symbol toPrimitive is not a function"));
++ return Encode::undefined();
++ }
++
++ ScopedFunctionObject toPrimitive(scope, v);
++ if (toPrimitive) {
++ ScopedValue result(scope, toPrimitive->call(object, hint, 1));
++ if (engine->hasException)
++ return Encode::undefined();
++ if (!result->isPrimitive())
++ return engine->throwTypeError();
++ return result->asReturnedValue();
++ }
++
++ if (hint == engine->id_default())
++ hint = engine->id_number();
++ return ordinaryToPrimitive(engine, object, hint);
++ }
++
++
++ ReturnedValue RuntimeHelpers::ordinaryToPrimitive(ExecutionEngine *engine, const Object *object, String *typeHint)
++ {
++ Q_ASSERT(!engine->hasException);
++
++ String *meth1 = engine->id_toString();
++ String *meth2 = engine->id_valueOf();
++
++ if (typeHint->propertyKey() == engine->id_number()->propertyKey()) {
++ qSwap(meth1, meth2);
++ } else {
++ Q_ASSERT(typeHint->propertyKey() == engine->id_string()->propertyKey());
++ }
++
++ Scope scope(engine);
++ ScopedValue result(scope);
++
++ ScopedValue conv(scope, object->get(meth1));
++ if (FunctionObject *o = conv->as<FunctionObject>()) {
++ result = o->call(object, nullptr, 0);
++ if (engine->hasException)
++ return Encode::undefined();
++ if (result->isPrimitive())
++ return result->asReturnedValue();
++ }
++
++ if (engine->hasException)
++ return Encode::undefined();
++
++ conv = object->get(meth2);
++ if (FunctionObject *o = conv->as<FunctionObject>()) {
++ result = o->call(object, nullptr, 0);
++ if (engine->hasException)
++ return Encode::undefined();
++ if (result->isPrimitive())
++ return result->asReturnedValue();
++ }
++
++ return engine->throwTypeError();
++ }
++
++
++ Heap::Object *RuntimeHelpers::convertToObject(ExecutionEngine *engine, const Value &value)
++ {
++ Q_ASSERT(!value.isObject());
++ switch (value.type()) {
++ case Value::Undefined_Type:
++ engine->throwTypeError(QLatin1String("Value is undefined and could not be converted to an object"));
++ return nullptr;
++ case Value::Null_Type:
++ engine->throwTypeError(QLatin1String("Value is null and could not be converted to an object"));
++ return nullptr;
++ case Value::Boolean_Type:
++ return engine->newBooleanObject(value.booleanValue());
++ case Value::Managed_Type:
++ Q_ASSERT(value.isStringOrSymbol());
++ if (!value.isString())
++ return engine->newSymbolObject(value.symbolValue());
++ return engine->newStringObject(value.stringValue());
++ case Value::Integer_Type:
++ default: // double
++ return engine->newNumberObject(value.asDouble());
++ }
++ }
++
++ Heap::String *RuntimeHelpers::convertToString(ExecutionEngine *engine, Value value, TypeHint hint)
++ {
++ redo:
++ switch (value.type()) {
++ case Value::Empty_Type:
++ Q_ASSERT(!"empty Value encountered");
++ Q_UNREACHABLE();
++ case Value::Undefined_Type:
++ return engine->id_undefined()->d();
++ case Value::Null_Type:
++ return engine->id_null()->d();
++ case Value::Boolean_Type:
++ if (value.booleanValue())
++ return engine->id_true()->d();
++ else
++ return engine->id_false()->d();
++ case Value::Managed_Type: {
++ if (value.isString())
++ return static_cast<const String &>(value).d();
++ if (value.isSymbol()) {
++ engine->throwTypeError(QLatin1String("Cannot convert a symbol to a string."));
++ return nullptr;
++ }
++ value = Value::fromReturnedValue(RuntimeHelpers::toPrimitive(value, hint));
++ Q_ASSERT(value.isPrimitive());
++ if (value.isString())
++ return static_cast<const String &>(value).d();
++ goto redo;
++ }
++ case Value::Integer_Type:
++ return engine->newString(QString::number(value.int_32()));
++ default: // double
++ return RuntimeHelpers::stringFromNumber(engine, value.doubleValue());
++ } // switch
++ }
++
++ // This is slightly different from the method above, as
++ // the + operator requires a slightly different conversion
++ static Heap::String *convert_to_string_add(ExecutionEngine *engine, Value value)
++ {
++ return RuntimeHelpers::convertToString(engine, value, PREFERREDTYPE_HINT);
++ }
++
++ QV4::ReturnedValue RuntimeHelpers::addHelper(ExecutionEngine *engine, const Value &left, const Value &right)
++ {
++ Scope scope(engine);
++
++ ScopedValue pleft(scope, RuntimeHelpers::toPrimitive(left, PREFERREDTYPE_HINT));
++ ScopedValue pright(scope, RuntimeHelpers::toPrimitive(right, PREFERREDTYPE_HINT));
++ String *sleft = pleft->stringValue();
++ String *sright = pright->stringValue();
++ if (sleft || sright) {
++ if (!sleft) {
++ pleft = convert_to_string_add(engine, pleft);
++ sleft = static_cast<String *>(pleft.ptr);
++ }
++ if (!sright) {
++ pright = convert_to_string_add(engine, pright);
++ sright = static_cast<String *>(pright.ptr);
++ }
++ if (engine->hasException)
++ return Encode::undefined();
++ if (!sleft->d()->length())
++ return sright->asReturnedValue();
++ if (!sright->d()->length())
++ return sleft->asReturnedValue();
++ MemoryManager *mm = engine->memoryManager;
++ return (mm->alloc<ComplexString>(sleft->d(), sright->d()))->asReturnedValue();
++ }
++ double x = RuntimeHelpers::toNumber(pleft);
++ double y = RuntimeHelpers::toNumber(pright);
++ return Encode(x + y);
++ }
++
++ ReturnedValue Runtime::GetTemplateObject::call(Function *function, int index)
++ {
++ return function->executableCompilationUnit()->templateObjectAt(index)->asReturnedValue();
++ }
++
++ void Runtime::StoreProperty::call(ExecutionEngine *engine, const Value &object, int nameIndex, const Value &value)
++ {
++ Scope scope(engine);
++ QV4::Function *v4Function = engine->currentStackFrame->v4Function;
++ ScopedString name(scope, v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ ScopedObject o(scope, object);
++ if (!o) {
++ if (v4Function->isStrict()) {
++ engine->throwTypeError();
++ return;
++ }
++ o = object.toObject(engine);
++ }
++ if ((!o || !o->put(name, value)) && v4Function->isStrict())
++ engine->throwTypeError();
++ }
++
++ static Q_NEVER_INLINE ReturnedValue getElementIntFallback(ExecutionEngine *engine, const Value &object, uint idx)
++ {
++ Q_ASSERT(idx < UINT_MAX);
++ Scope scope(engine);
++
++ ScopedObject o(scope, object);
++ if (!o) {
++ if (const String *str = object.as<String>()) {
++ if (idx >= (uint)str->toQString().size()) {
++ return Encode::undefined();
++ }
++ const QString s = str->toQString().mid(idx, 1);
++ return scope.engine->newString(s)->asReturnedValue();
++ }
++
++ if (object.isNullOrUndefined()) {
++ QString message = QStringLiteral("Cannot read property '%1' of %2").arg(idx).arg(object.toQStringNoThrow());
++ return engine->throwTypeError(message);
++ }
++
++ o = RuntimeHelpers::convertToObject(scope.engine, object);
++ Q_ASSERT(!!o); // can't fail as null/undefined is covered above
++ }
++
++ if (o->arrayData() && !o->arrayData()->attrs) {
++ ScopedValue v(scope, o->arrayData()->get(idx));
++ if (!v->isEmpty())
++ return v->asReturnedValue();
++ }
++
++ return o->get(idx);
++ }
++
++ static Q_NEVER_INLINE ReturnedValue getElementFallback(ExecutionEngine *engine, const Value &object, const Value &index)
++ {
++ Q_ASSERT(!index.isPositiveInt());
++
++ Scope scope(engine);
++
++ ScopedObject o(scope, object);
++ if (!o) {
++ if (object.isNullOrUndefined()) {
++ const QString message =
++ QStringLiteral("Cannot read property '%1' of %2")
++ .arg(index.toQStringNoThrow(), object.toQStringNoThrow());
++ return engine->throwTypeError(message);
++ }
++
++ o = RuntimeHelpers::convertToObject(scope.engine, object);
++ Q_ASSERT(!!o); // can't fail as null/undefined is covered above
++ }
++
++ ScopedPropertyKey name(scope, index.toPropertyKey(engine));
++ if (scope.hasException())
++ return Encode::undefined();
++ return o->get(name);
++ }
++
++ ReturnedValue Runtime::LoadElement::call(ExecutionEngine *engine, const Value &object, const Value &index)
++ {
++ if (index.isPositiveInt()) {
++ uint idx = static_cast<uint>(index.int_32());
++ if (Heap::Base *b = object.heapObject()) {
++ if (b->internalClass->vtable->isObject) {
++ Heap::Object *o = static_cast<Heap::Object *>(b);
++ if (o->arrayData && o->arrayData->type == Heap::ArrayData::Simple) {
++ Heap::SimpleArrayData *s = o->arrayData.cast<Heap::SimpleArrayData>();
++ if (idx < s->values.size)
++ if (!s->data(idx).isEmpty())
++ return s->data(idx).asReturnedValue();
++ }
++ }
++ }
++ return getElementIntFallback(engine, object, idx);
++ }
++
++ return getElementFallback(engine, object, index);
++ }
++
++ static Q_NEVER_INLINE bool setElementFallback(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value)
++ {
++ Scope scope(engine);
++ ScopedObject o(scope, object);
++ if (!o) {
++ if (engine->currentStackFrame->v4Function->isStrict()) {
++ engine->throwTypeError();
++ return false;
++ }
++
++ o = object.toObject(engine);
++ }
++ if (engine->hasException)
++ return false;
++
++ if (index.isPositiveInt()) {
++ uint idx = static_cast<uint>(index.int_32());
++ if (o->d()->arrayData && o->d()->arrayData->type == Heap::ArrayData::Simple) {
++ Heap::SimpleArrayData *s = o->d()->arrayData.cast<Heap::SimpleArrayData>();
++ if (idx < s->values.size) {
++ s->setData(engine, idx, value);
++ return true;
++ }
++ }
++ return o->put(idx, value);
++ }
++
++ ScopedPropertyKey name(scope, index.toPropertyKey(engine));
++ if (engine->hasException)
++ return false;
++ return o->put(name, value);
++ }
++
++ void Runtime::StoreElement::call(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value)
++ {
++ if (index.isPositiveInt()) {
++ uint idx = static_cast<uint>(index.int_32());
++ if (Heap::Base *b = object.heapObject()) {
++ if (b->internalClass->vtable->isObject) {
++ Heap::Object *o = static_cast<Heap::Object *>(b);
++ if (o->arrayData && o->arrayData->type == Heap::ArrayData::Simple) {
++ Heap::SimpleArrayData *s = o->arrayData.cast<Heap::SimpleArrayData>();
++ if (idx < s->values.size) {
++ s->setData(engine, idx, value);
++ return;
++ }
++ }
++ }
++ }
++ }
++
++ if (!setElementFallback(engine, object, index, value) && engine->currentStackFrame->v4Function->isStrict())
++ engine->throwTypeError();
++ }
++
++ ReturnedValue Runtime::GetIterator::call(ExecutionEngine *engine, const Value &in, int iterator)
++ {
++ Scope scope(engine);
++ ScopedObject o(scope, (Object *)nullptr);
++ if (!in.isNullOrUndefined())
++ o = in.toObject(engine);
++ if (engine->hasException)
++ return Encode::undefined();
++ if (iterator == static_cast<int>(QQmlJS::AST::ForEachType::Of)) {
++ if (!o)
++ return engine->throwTypeError();
++ ScopedFunctionObject f(scope, o->get(engine->symbol_iterator()));
++ if (!f)
++ return engine->throwTypeError();
++ JSCallData cData(o, nullptr, 0);
++ ScopedObject it(scope, f->call(cData));
++ if (engine->hasException)
++ return Encode::undefined();
++ if (!it)
++ return engine->throwTypeError();
++ return it->asReturnedValue();
++ }
++ return engine->newForInIteratorObject(o)->asReturnedValue();
++ }
++
++ ReturnedValue Runtime::IteratorNext::call(ExecutionEngine *engine, const Value &iterator, Value *value)
++ {
++ // if we throw an exception from here, return true, not undefined. This is to ensure iteratorDone is set to true
++ // and the stack unwinding won't close the iterator
++ Q_ASSERT(iterator.isObject());
++
++ Scope scope(engine);
++ ScopedFunctionObject f(scope, static_cast<const Object &>(iterator).get(engine->id_next()));
++ if (!f) {
++ engine->throwTypeError();
++ return Encode(true);
++ }
++ JSCallData cData(&iterator, nullptr, 0);
++ ScopedObject o(scope, f->call(cData));
++ if (scope.hasException())
++ return Encode(true);
++ if (!o) {
++ engine->throwTypeError();
++ return Encode(true);
++ }
++
++ ScopedValue d(scope, o->get(engine->id_done()));
++ if (scope.hasException())
++ return Encode(true);
++ bool done = d->toBoolean();
++ if (done) {
++ *value = Encode::undefined();
++ return Encode(true);
++ }
++
++ *value = o->get(engine->id_value());
++ if (scope.hasException())
++ return Encode(true);
++ return Encode(false);
++ }
++
++ ReturnedValue Runtime::IteratorNextForYieldStar::call(ExecutionEngine *engine, const Value &received, const Value &iterator, Value *object)
++ {
++ // the return value encodes how to continue the yield* iteration.
++ // true implies iteration is done, false for iteration to continue
++ // a return value of undefines is a special marker, that the iterator has been invoked with return()
++
++ Scope scope(engine);
++ Q_ASSERT(iterator.isObject());
++
++ const Value *arg = &received;
++ bool returnCalled = false;
++ FunctionObject *f = nullptr;
++ if (engine->hasException) {
++ if (engine->exceptionValue->isEmpty()) {
++ // generator called with return()
++ *engine->exceptionValue = Encode::undefined();
++ engine->hasException = false;
++
++ ScopedValue ret(scope, static_cast<const Object &>(iterator).get(engine->id_return()));
++ if (engine->hasException)
++ return Encode(true);
++ if (ret->isUndefined()) {
++ // propagate return()
++ return Encode::undefined();
++ }
++ returnCalled = true;
++ f = ret->as<FunctionObject>();
++ } else {
++ // generator called with throw
++ ScopedValue exceptionValue(scope, *engine->exceptionValue);
++ *engine->exceptionValue = Encode::undefined();
++ engine->hasException = false;
++
++ ScopedValue t(scope, static_cast<const Object &>(iterator).get(engine->id_throw()));
++ if (engine->hasException)
++ return Encode(true);
++ if (t->isUndefined()) {
++ // no throw method on the iterator
++ IteratorClose::call(engine, iterator);
++ if (!engine->hasException)
++ engine->throwTypeError();
++ return Encode(true);
++ }
++ f = t->as<FunctionObject>();
++ arg = exceptionValue;
++ }
++ } else {
++ // generator called with next()
++ ScopedFunctionObject next(scope, static_cast<const Object &>(iterator).get(engine->id_next()));
++ f = next->as<FunctionObject>();
++ }
++
++ if (!f) {
++ engine->throwTypeError();
++ return Encode(true);
++ }
++
++ ScopedObject o(scope, f->call(&iterator, arg, 1));
++ if (scope.hasException())
++ return Encode(true);
++ if (!o) {
++ engine->throwTypeError();
++ return Encode(true);
++ }
++
++ ScopedValue d(scope, o->get(engine->id_done()));
++ if (scope.hasException())
++ return Encode(true);
++ bool done = d->toBoolean();
++ if (done) {
++ *object = o->get(engine->id_value());
++ return (returnCalled && !engine->hasException) ? Encode::undefined() : Encode(true);
++ }
++ *object = o;
++ return Encode(false);
++ }
++
++ ReturnedValue Runtime::IteratorClose::call(ExecutionEngine *engine, const Value &iterator)
++ {
++ Q_ASSERT(iterator.isObject());
++
++ Scope scope(engine);
++ ScopedValue e(scope);
++ bool hadException = engine->hasException;
++ if (hadException) {
++ e = *engine->exceptionValue;
++ engine->hasException = false;
++ }
++
++ auto originalCompletion = [=]() {
++ if (hadException) {
++ *engine->exceptionValue = e;
++ engine->hasException = hadException;
++ }
++ return Encode::undefined();
++ };
++
++ ScopedValue ret(scope, static_cast<const Object &>(iterator).get(engine->id_return()));
++ ScopedObject o(scope);
++ if (!ret->isUndefined()) {
++ FunctionObject *f = ret->as<FunctionObject>();
++ o = f->call(&iterator, nullptr, 0);
++ if (engine->hasException && !hadException)
++ return Encode::undefined();
++ }
++ if (hadException || ret->isUndefined())
++ return originalCompletion();
++
++ if (!o)
++ return engine->throwTypeError();
++
++ return originalCompletion();
++ }
++
++ ReturnedValue Runtime::DestructureRestElement::call(ExecutionEngine *engine, const Value &iterator)
++ {
++ Q_ASSERT(iterator.isObject());
++
++ Scope scope(engine);
++ ScopedArrayObject array(scope, engine->newArrayObject());
++ array->arrayCreate();
++ uint index = 0;
++ while (1) {
++ ScopedValue n(scope);
++ ScopedValue done(scope, IteratorNext::call(engine, iterator, n));
++ if (engine->hasException)
++ return Encode::undefined();
++ Q_ASSERT(done->isBoolean());
++ if (done->booleanValue())
++ break;
++ array->arraySet(index, n);
++ ++index;
++ }
++ return array->asReturnedValue();
++ }
++
++ void Runtime::StoreNameSloppy::call(ExecutionEngine *engine, int nameIndex, const Value &value)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ ExecutionContext::Error e = engine->currentContext()->setProperty(name, value);
++
++ if (e == ExecutionContext::RangeError)
++ engine->globalObject->put(name, value);
++ }
++
++ void Runtime::StoreNameStrict::call(ExecutionEngine *engine, int nameIndex, const Value &value)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ ExecutionContext::Error e = engine->currentContext()->setProperty(name, value);
++ if (e == ExecutionContext::TypeError)
++ engine->throwTypeError();
++ else if (e == ExecutionContext::RangeError)
++ engine->throwReferenceError(name);
++ }
++
++ ReturnedValue Runtime::LoadProperty::call(ExecutionEngine *engine, const Value &object, int nameIndex)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++
++ ScopedObject o(scope, object);
++ if (o)
++ return o->get(name);
++
++ if (object.isNullOrUndefined()) {
++ const QString message = QStringLiteral("Cannot read property '%1' of %2")
++ .arg(name->toQString(), object.toQStringNoThrow());
++ return engine->throwTypeError(message);
++ }
++
++ o = RuntimeHelpers::convertToObject(scope.engine, object);
++ if (!o) // type error
++ return Encode::undefined();
++ return o->get(name);
++ }
++
++ ReturnedValue Runtime::LoadName::call(ExecutionEngine *engine, int nameIndex)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ return engine->currentContext()->getProperty(name);
++ }
++
++ static Object *getSuperBase(Scope &scope)
++ {
++ Scoped<JavaScriptFunctionObject> f(scope);
++ ScopedObject homeObject(scope);
++ if (scope.engine->currentStackFrame->isJSTypesFrame()) {
++ JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(
++ scope.engine->currentStackFrame);
++
++ if (frame->jsFrame->thisObject.isEmpty()) {
++ scope.engine->throwReferenceError(
++ QStringLiteral("Missing call to super()."), QString(), 0, 0);
++ return nullptr;
++ }
++
++ f = Value::fromStaticValue(frame->jsFrame->function);
++ homeObject = f->getHomeObject();
++ } else {
++ Q_ASSERT(scope.engine->currentStackFrame->isMetaTypesFrame());
++ MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(
++ scope.engine->currentStackFrame);
++ if (frame->thisObject() == nullptr) {
++ scope.engine->throwReferenceError(
++ QStringLiteral("Missing call to super()."), QString(), 0, 0);
++ return nullptr;
++ }
++ }
++
++ if (!homeObject) {
++ ScopedContext ctx(scope, scope.engine->currentContext());
++ Q_ASSERT(ctx);
++ while (ctx) {
++ if (CallContext *c = ctx->asCallContext()) {
++ f = c->d()->function;
++ QV4::Function *fn = f->function();
++ if (fn && !fn->isArrowFunction() && fn->kind != Function::Eval)
++ break;
++ }
++ ctx = ctx->d()->outer;
++ }
++ if (f)
++ homeObject = f->getHomeObject();
++ }
++ if (!homeObject) {
++ scope.engine->throwTypeError();
++ return nullptr;
++ }
++ Q_ASSERT(homeObject);
++ ScopedObject proto(scope, homeObject->getPrototypeOf());
++ if (!proto) {
++ scope.engine->throwTypeError();
++ return nullptr;
++ }
++ return proto;
++ }
++
++ ReturnedValue Runtime::LoadSuperProperty::call(ExecutionEngine *engine, const Value &property)
++ {
++ Scope scope(engine);
++ Object *base = getSuperBase(scope);
++ if (!base)
++ return Encode::undefined();
++ ScopedPropertyKey key(scope, property.toPropertyKey(engine));
++ if (engine->hasException)
++ return Encode::undefined();
++
++ if (scope.engine->currentStackFrame->isJSTypesFrame()) {
++ JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(
++ scope.engine->currentStackFrame);
++ return base->get(key, &(frame->jsFrame->thisObject.asValue<Value>()));
++ } else {
++ Q_ASSERT(scope.engine->currentStackFrame->isMetaTypesFrame());
++ MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(
++ scope.engine->currentStackFrame);
++ Scoped<QObjectWrapper> wrapper(scope, QObjectWrapper::wrap(engine, frame->thisObject()));
++ return base->get(key, wrapper);
++ }
++ }
++
++ void Runtime::StoreSuperProperty::call(ExecutionEngine *engine, const Value &property, const Value &value)
++ {
++ Scope scope(engine);
++ Object *base = getSuperBase(scope);
++ if (!base)
++ return;
++ ScopedPropertyKey key(scope, property.toPropertyKey(engine));
++ if (engine->hasException)
++ return;
++
++ bool result;
++ if (scope.engine->currentStackFrame->isJSTypesFrame()) {
++ JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(
++ scope.engine->currentStackFrame);
++ result = base->put(key, value, &(frame->jsFrame->thisObject.asValue<Value>()));
++ } else {
++ Q_ASSERT(scope.engine->currentStackFrame->isMetaTypesFrame());
++ MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(
++ scope.engine->currentStackFrame);
++ Scoped<QObjectWrapper> wrapper(scope, QObjectWrapper::wrap(engine, frame->thisObject()));
++ result = base->put(key, value, wrapper);
++ }
++
++ if (!result && engine->currentStackFrame->v4Function->isStrict())
++ engine->throwTypeError();
++ }
++
++ ReturnedValue Runtime::LoadGlobalLookup::call(ExecutionEngine *engine, Function *f, int index)
++ {
++ Lookup *l = runtimeLookup(f, index);
++ return l->globalGetter(engine);
++ }
++
++ ReturnedValue Runtime::LoadQmlContextPropertyLookup::call(ExecutionEngine *engine, uint index)
++ {
++ Lookup *l = runtimeLookup(engine->currentStackFrame->v4Function, index);
++ return l->contextGetter(engine, nullptr);
++ }
++
++ ReturnedValue Runtime::GetLookup::call(ExecutionEngine *engine, Function *f, const Value &base, int index)
++ {
++ Lookup *l = runtimeLookup(f, index);
++
++ if (base.isNullOrUndefined()) {
++ const QString message = QStringLiteral("Cannot read property '%1' of %2")
++ .arg(f->compilationUnit->runtimeStrings[l->nameIndex]->toQString(),
++ base.toQStringNoThrow());
++ return engine->throwTypeError(message);
++ }
++
++ return l->getter(engine, base);
++ }
++
++ void Runtime::SetLookupSloppy::call(Function *f, const Value &base, int index, const Value &value)
++ {
++ ExecutionEngine *engine = f->internalClass->engine;
++ QV4::Lookup *l = runtimeLookup(f, index);
++ l->setter(engine, const_cast<Value &>(base), value);
++ }
++
++ void Runtime::SetLookupStrict::call(Function *f, const Value &base, int index, const Value &value)
++ {
++ ExecutionEngine *engine = f->internalClass->engine;
++ QV4::Lookup *l = runtimeLookup(f, index);
++ if (!l->setter(engine, const_cast<Value &>(base), value))
++ engine->throwTypeError();
++ }
++
++ ReturnedValue Runtime::LoadSuperConstructor::call(ExecutionEngine *engine, const Value &t)
++ {
++ if (engine->currentStackFrame->isJSTypesFrame()) {
++ JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame);
++ if (frame->thisObject() != Value::emptyValue().asReturnedValue()) {
++ // ### TODO: fix line number
++ return engine->throwReferenceError(
++ QStringLiteral("super() already called."), QString(), 0, 0);
++ }
++ } else {
++ Q_ASSERT(engine->currentStackFrame->isMetaTypesFrame());
++ MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(engine->currentStackFrame);
++ if (frame->thisObject() != nullptr) {
++ // ### TODO: fix line number
++ return engine->throwReferenceError(
++ QStringLiteral("super() already called."), QString(), 0, 0);
++ }
++ }
++
++ const FunctionObject *f = t.as<FunctionObject>();
++ if (!f)
++ return engine->throwTypeError();
++ Heap::Object *c = static_cast<const Object &>(t).getPrototypeOf();
++ if (!c->vtable()->callAsConstructor)
++ return engine->throwTypeError();
++ return c->asReturnedValue();
++ }
++
++ uint RuntimeHelpers::equalHelper(const Value &x, const Value &y)
++ {
++ Q_ASSERT(x.type() != y.type() || (x.isManaged() && (x.isString() != y.isString())));
++
++ if (x.isNumber() && y.isNumber())
++ return x.asDouble() == y.asDouble();
++ if (x.isNull() && y.isUndefined()) {
++ return true;
++ } else if (x.isUndefined() && y.isNull()) {
++ return true;
++ } else if (x.isNumber() && y.isString()) {
++ double dy = RuntimeHelpers::toNumber(y);
++ return x.asDouble() == dy;
++ } else if (x.isString() && y.isNumber()) {
++ double dx = RuntimeHelpers::toNumber(x);
++ return dx == y.asDouble();
++ } else if (x.isBoolean()) {
++ return Runtime::CompareEqual::call(Value::fromDouble((double) x.booleanValue()), y);
++ } else if (y.isBoolean()) {
++ return Runtime::CompareEqual::call(x, Value::fromDouble((double) y.booleanValue()));
++ } else {
++ Object *xo = x.objectValue();
++ Object *yo = y.objectValue();
++ if (yo && (x.isNumber() || x.isString())) {
++ Scope scope(yo->engine());
++ ScopedValue py(scope, RuntimeHelpers::objectDefaultValue(yo, PREFERREDTYPE_HINT));
++ return Runtime::CompareEqual::call(x, py);
++ } else if (xo && (y.isNumber() || y.isString())) {
++ Scope scope(xo->engine());
++ ScopedValue px(scope, RuntimeHelpers::objectDefaultValue(xo, PREFERREDTYPE_HINT));
++ return Runtime::CompareEqual::call(px, y);
++ }
++ }
++
++ return false;
++ }
++
++ Bool RuntimeHelpers::strictEqual(const Value &x, const Value &y)
++ {
++ TRACE2(x, y);
++
++ if (x.rawValue() == y.rawValue())
++ // NaN != NaN
++ return !x.isNaN();
++
++ if (x.isNumber())
++ return y.isNumber() && x.asDouble() == y.asDouble();
++ if (x.isManaged()) {
++ return y.isManaged() && x.cast<Managed>()->isEqualTo(y.cast<Managed>());
++ }
++ return false;
++ }
++
++ QV4::Bool Runtime::CompareGreaterThan::call(const Value &l, const Value &r)
++ {
++ TRACE2(l, r);
++ if (l.isInteger() && r.isInteger())
++ return l.integerValue() > r.integerValue();
++ if (l.isNumber() && r.isNumber())
++ return l.asDouble() > r.asDouble();
++ String *sl = l.stringValue();
++ String *sr = r.stringValue();
++ if (sl && sr) {
++ return sr->lessThan(sl);
++ }
++
++ Object *ro = r.objectValue();
++ Object *lo = l.objectValue();
++ if (ro || lo) {
++ QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
++ QV4::Scope scope(e);
++ QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
++ QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
++ return Runtime::CompareGreaterThan::call(pl, pr);
++ }
++
++ double dl = RuntimeHelpers::toNumber(l);
++ double dr = RuntimeHelpers::toNumber(r);
++ return dl > dr;
++ }
++
++ QV4::Bool Runtime::CompareLessThan::call(const Value &l, const Value &r)
++ {
++ TRACE2(l, r);
++ if (l.isInteger() && r.isInteger())
++ return l.integerValue() < r.integerValue();
++ if (l.isNumber() && r.isNumber())
++ return l.asDouble() < r.asDouble();
++ String *sl = l.stringValue();
++ String *sr = r.stringValue();
++ if (sl && sr) {
++ return sl->lessThan(sr);
++ }
++
++ Object *ro = r.objectValue();
++ Object *lo = l.objectValue();
++ if (ro || lo) {
++ QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
++ QV4::Scope scope(e);
++ QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
++ QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
++ return Runtime::CompareLessThan::call(pl, pr);
++ }
++
++ double dl = RuntimeHelpers::toNumber(l);
++ double dr = RuntimeHelpers::toNumber(r);
++ return dl < dr;
++ }
++
++ QV4::Bool Runtime::CompareGreaterEqual::call(const Value &l, const Value &r)
++ {
++ TRACE2(l, r);
++ if (l.isInteger() && r.isInteger())
++ return l.integerValue() >= r.integerValue();
++ if (l.isNumber() && r.isNumber())
++ return l.asDouble() >= r.asDouble();
++ String *sl = l.stringValue();
++ String *sr = r.stringValue();
++ if (sl && sr) {
++ return !sl->lessThan(sr);
++ }
++
++ Object *ro = r.objectValue();
++ Object *lo = l.objectValue();
++ if (ro || lo) {
++ QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
++ QV4::Scope scope(e);
++ QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
++ QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
++ return Runtime::CompareGreaterEqual::call(pl, pr);
++ }
++
++ double dl = RuntimeHelpers::toNumber(l);
++ double dr = RuntimeHelpers::toNumber(r);
++ return dl >= dr;
++ }
++
++ QV4::Bool Runtime::CompareLessEqual::call(const Value &l, const Value &r)
++ {
++ TRACE2(l, r);
++ if (l.isInteger() && r.isInteger())
++ return l.integerValue() <= r.integerValue();
++ if (l.isNumber() && r.isNumber())
++ return l.asDouble() <= r.asDouble();
++ String *sl = l.stringValue();
++ String *sr = r.stringValue();
++ if (sl && sr) {
++ return !sr->lessThan(sl);
++ }
++
++ Object *ro = r.objectValue();
++ Object *lo = l.objectValue();
++ if (ro || lo) {
++ QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
++ QV4::Scope scope(e);
++ QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(lo, QV4::NUMBER_HINT) : l.asReturnedValue());
++ QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(ro, QV4::NUMBER_HINT) : r.asReturnedValue());
++ return Runtime::CompareLessEqual::call(pl, pr);
++ }
++
++ double dl = RuntimeHelpers::toNumber(l);
++ double dr = RuntimeHelpers::toNumber(r);
++ return dl <= dr;
++ }
++
++ Bool Runtime::CompareInstanceof::call(ExecutionEngine *engine, const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ Scope scope(engine);
++ ScopedValue v(scope, Instanceof::call(engine, left, right));
++ return v->booleanValue();
++ }
++
++ uint Runtime::CompareIn::call(ExecutionEngine *engine, const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ Scope scope(engine);
++ ScopedValue v(scope, In::call(engine, left, right));
++ return v->booleanValue();
++ }
++
++ static ReturnedValue throwPropertyIsNotAFunctionTypeError(ExecutionEngine *engine, Value *thisObject, const QString &propertyName)
++ {
++ QString objectAsString = QStringLiteral("[null]");
++ if (!thisObject->isUndefined())
++ objectAsString = thisObject->toQStringNoThrow();
++ QString msg = QStringLiteral("Property '%1' of object %2 is not a function")
++ .arg(propertyName, objectAsString);
++ return engine->throwTypeError(msg);
++ }
++
++ ReturnedValue Runtime::CallGlobalLookup::call(ExecutionEngine *engine, uint index, Value argv[], int argc)
++ {
++ Scope scope(engine);
++ Lookup *l = runtimeLookup(engine->currentStackFrame->v4Function, index);
++ Value function = Value::fromReturnedValue(l->globalGetter(engine));
++ Value thisObject = Value::undefinedValue();
++ if (!function.isFunctionObject()) {
++ return throwPropertyIsNotAFunctionTypeError(engine, &thisObject,
++ engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[l->nameIndex]->toQString());
++ }
++
++ return checkedResult(engine, static_cast<FunctionObject &>(function).call(
++ &thisObject, argv, argc));
++ }
++
++ ReturnedValue Runtime::CallQmlContextPropertyLookup::call(ExecutionEngine *engine, uint index,
++ Value *argv, int argc)
++ {
++ Scope scope(engine);
++ ScopedValue thisObject(scope);
++ Lookup *l = runtimeLookup(engine->currentStackFrame->v4Function, index);
++ Value function = Value::fromReturnedValue(l->contextGetter(engine, thisObject));
++ if (!function.isFunctionObject()) {
++ return throwPropertyIsNotAFunctionTypeError(engine, thisObject,
++ engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[l->nameIndex]->toQString());
++ }
++
++ return checkedResult(engine, static_cast<FunctionObject &>(function).call(
++ thisObject, argv, argc));
++ }
++
++ ReturnedValue Runtime::CallPossiblyDirectEval::call(ExecutionEngine *engine, Value *argv, int argc)
++ {
++ Scope scope(engine);
++ ScopedValue thisObject(scope);
++
++ ScopedFunctionObject function(
++ scope, engine->currentContext()->getPropertyAndBase(engine->id_eval(), thisObject));
++ if (engine->hasException)
++ return Encode::undefined();
++
++ if (!function)
++ return throwPropertyIsNotAFunctionTypeError(engine, thisObject, QLatin1String("eval"));
++
++ if (function->d() == engine->evalFunction()->d())
++ return static_cast<EvalFunction *>(function.getPointer())->evalCall(thisObject, argv, argc, true);
++
++ return checkedResult(engine, function->call(thisObject, argv, argc));
++ }
++
++ ReturnedValue Runtime::CallName::call(ExecutionEngine *engine, int nameIndex, Value *argv, int argc)
++ {
++ Scope scope(engine);
++ ScopedValue thisObject(scope);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++
++ ScopedFunctionObject f(scope, engine->currentContext()->getPropertyAndBase(name, thisObject));
++ if (engine->hasException)
++ return Encode::undefined();
++
++ if (!f) {
++ return throwPropertyIsNotAFunctionTypeError(
++ engine, thisObject, engine->currentStackFrame->v4Function->compilationUnit
++ ->runtimeStrings[nameIndex]->toQString());
++ }
++
++ return checkedResult(engine, f->call(thisObject, argv, argc));
++ }
++
++ ReturnedValue Runtime::CallProperty::call(ExecutionEngine *engine, const Value &baseRef, int nameIndex, Value *argv, int argc)
++ {
++ const Value *base = &baseRef;
++ Scope scope(engine);
++ ScopedString name(
++ scope,
++ engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ ScopedObject lookupObject(scope, base);
++
++ if (!lookupObject) {
++ Q_ASSERT(!base->isEmpty());
++ if (base->isNullOrUndefined()) {
++ QString message = QStringLiteral("Cannot call method '%1' of %2")
++ .arg(name->toQString(), base->toQStringNoThrow());
++ return engine->throwTypeError(message);
++ }
++
++ if (base->isManaged()) {
++ const Managed *m = static_cast<const Managed *>(base);
++ lookupObject = m->internalClass()->prototype;
++ Q_ASSERT(m->internalClass()->prototype);
++ } else {
++ lookupObject = RuntimeHelpers::convertToObject(engine, *base);
++ if (engine->hasException) // type error
++ return Encode::undefined();
++ if (!engine->currentStackFrame->v4Function->isStrict())
++ base = lookupObject;
++ }
++ }
++
++ ScopedFunctionObject f(scope, static_cast<Object *>(lookupObject)->get(name));
++
++ if (!f) {
++ QString error = QStringLiteral("Property '%1' of object %2 is not a function")
++ .arg(name->toQString(),
++ base->toQStringNoThrow());
++ return engine->throwTypeError(error);
++ }
++
++ return checkedResult(engine, f->call(base, argv, argc));
++ }
++
++ ReturnedValue Runtime::CallPropertyLookup::call(ExecutionEngine *engine, const Value &base, uint index, Value *argv, int argc)
++ {
++ Lookup *l = runtimeLookup(engine->currentStackFrame->v4Function, index);
++
++ if (base.isNullOrUndefined()) {
++ const QString message = QStringLiteral("Cannot call method '%1' of %2")
++ .arg(engine->currentStackFrame->v4Function->compilationUnit
++ ->runtimeStrings[l->nameIndex]->toQString(),
++ base.toQStringNoThrow());
++ return engine->throwTypeError(message);
++ }
++
++ // ok to have the value on the stack here
++ Value f = Value::fromReturnedValue(l->getter(engine, base));
++
++ if (Q_LIKELY(f.isFunctionObject()))
++ return checkedResult(engine, static_cast<FunctionObject &>(f).call(&base, argv, argc));
++
++ if (QmlSignalHandler *handler = f.as<QmlSignalHandler>())
++ return checkedResult(engine, handler->call(&base, argv, argc));
++
++ const QString message = QStringLiteral("Property '%1' of object %2 is not a function")
++ .arg(engine->currentStackFrame->v4Function->compilationUnit
++ ->runtimeStrings[l->nameIndex]
++ ->toQString(),
++ base.toQStringNoThrow());
++ return engine->throwTypeError(message);
++ }
++
++ ReturnedValue Runtime::CallValue::call(ExecutionEngine *engine, const Value &func, Value *argv, int argc)
++ {
++ if (!func.isFunctionObject())
++ return engine->throwTypeError(QStringLiteral("%1 is not a function").arg(func.toQStringNoThrow()));
++ Value undef = Value::undefinedValue();
++ return checkedResult(engine, static_cast<const FunctionObject &>(func).call(
++ &undef, argv, argc));
++ }
++
++ ReturnedValue Runtime::CallWithReceiver::call(ExecutionEngine *engine, const Value &func,
++ const Value &thisObject, Value argv[], int argc)
++ {
++ if (!func.isFunctionObject())
++ return engine->throwTypeError(QStringLiteral("%1 is not a function").arg(func.toQStringNoThrow()));
++ return checkedResult(engine, static_cast<const FunctionObject &>(func).call(
++ &thisObject, argv, argc));
++ }
++
++ struct CallArgs {
++ Value *argv;
++ int argc;
++ };
++
++ static CallArgs createSpreadArguments(Scope &scope, Value *argv, int argc)
++ {
++ ScopedValue it(scope);
++ ScopedValue done(scope);
++
++ int argCount = 0;
++
++ Value *v = scope.constructUndefined(1);
++ Value *arguments = v;
++ for (int i = 0; i < argc; ++i) {
++ if (!argv[i].isEmpty()) {
++ *v = argv[i];
++ ++argCount;
++ v = scope.constructUndefined(1);
++ continue;
++ }
++ // spread element
++ ++i;
++ it = Runtime::GetIterator::call(scope.engine, argv[i], /* ForInIterator */ 1);
++ if (scope.hasException())
++ return { nullptr, 0 };
++ while (1) {
++ done = Runtime::IteratorNext::call(scope.engine, it, v);
++ if (scope.hasException())
++ return { nullptr, 0 };
++ Q_ASSERT(done->isBoolean());
++ if (done->booleanValue())
++ break;
++ ++argCount;
++ constexpr auto safetyMargin = 100; // leave some space on the stack for actual work with the elements
++ if (qint64(scope.engine->jsStackLimit - scope.engine->jsStackTop) < safetyMargin) {
++ scope.engine->throwRangeError(QLatin1String("Too many elements in array to use it with the spread operator"));
++ return { nullptr, 0 };
++ }
++ v = scope.constructUndefined(1);
++ }
++ }
++ return { arguments, argCount };
++ }
++
++ ReturnedValue Runtime::CallWithSpread::call(ExecutionEngine *engine, const Value &function, const Value &thisObject, Value *argv, int argc)
++ {
++ Q_ASSERT(argc >= 1);
++ if (!function.isFunctionObject())
++ return engine->throwTypeError();
++
++ Scope scope(engine);
++ CallArgs arguments = createSpreadArguments(scope, argv, argc);
++ if (engine->hasException)
++ return Encode::undefined();
++
++ return checkedResult(engine, static_cast<const FunctionObject &>(function).call(
++ &thisObject, arguments.argv, arguments.argc));
++ }
++
++ ReturnedValue Runtime::Construct::call(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
++ {
++ if (!function.isFunctionObject())
++ return engine->throwTypeError();
++
++ return static_cast<const FunctionObject &>(function).callAsConstructor(argv, argc, &newTarget);
++ }
++
++ ReturnedValue Runtime::ConstructWithSpread::call(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
++ {
++ if (!function.isFunctionObject())
++ return engine->throwTypeError();
++
++ Scope scope(engine);
++ CallArgs arguments = createSpreadArguments(scope, argv, argc);
++ if (engine->hasException)
++ return Encode::undefined();
++
++ return static_cast<const FunctionObject &>(function).callAsConstructor(arguments.argv, arguments.argc, &newTarget);
++ }
++
++ ReturnedValue Runtime::TailCall::call(JSTypesStackFrame *frame, ExecutionEngine *engine)
++ {
++ // IMPORTANT! The JIT assumes that this method has the same amount (or less) arguments than
++ // the jitted function, so it can safely do a tail call.
++
++ Value *tos = engine->jsStackTop;
++ const Value &function = tos[StackOffsets::tailCall_function];
++ const Value &thisObject = tos[StackOffsets::tailCall_thisObject];
++ Value *argv = reinterpret_cast<Value *>(frame->jsFrame) + tos[StackOffsets::tailCall_argv].int_32();
++ int argc = tos[StackOffsets::tailCall_argc].int_32();
++ Q_ASSERT(argc >= 0);
++
++ const JavaScriptFunctionObject *jsfo = function.as<JavaScriptFunctionObject>();
++ if (!jsfo) {
++ if (const FunctionObject *fo = function.as<FunctionObject>())
++ return checkedResult(engine, fo->call(&thisObject, argv, argc));
++ return engine->throwTypeError();
++ }
++
++ if (!frame->callerCanHandleTailCall() || !jsfo->canBeTailCalled() || engine->debugger()
++ || unsigned(argc) > jsfo->formalParameterCount()) {
++ // Cannot tailcall, do a normal call:
++ return checkedResult(engine, jsfo->call(&thisObject, argv, argc));
++ }
++
++ memmove(frame->jsFrame->args, argv, argc * sizeof(Value));
++ frame->init(jsfo->function(), frame->jsFrame->argValues<Value>(), argc,
++ frame->callerCanHandleTailCall());
++ frame->setupJSFrame(frame->framePointer(), *jsfo, jsfo->scope(), thisObject,
++ Primitive::undefinedValue());
++ engine->jsStackTop = frame->framePointer() + frame->requiredJSStackFrameSize();
++ frame->setPendingTailCall(true);
++ return Encode::undefined();
++ }
++
++ void Runtime::ThrowException::call(ExecutionEngine *engine, const Value &value)
++ {
++ if (!value.isEmpty())
++ engine->throwError(value);
++ }
++
++ ReturnedValue Runtime::TypeofValue::call(ExecutionEngine *engine, const Value &value)
++ {
++ Scope scope(engine);
++ ScopedString res(scope);
++ switch (value.type()) {
++ case Value::Undefined_Type:
++ res = engine->id_undefined();
++ break;
++ case Value::Null_Type:
++ res = engine->id_object();
++ break;
++ case Value::Boolean_Type:
++ res = engine->id_boolean();
++ break;
++ case Value::Managed_Type:
++ if (value.isString())
++ res = engine->id_string();
++ else if (value.isSymbol())
++ res = engine->id_symbol();
++ else if (value.objectValue()->as<FunctionObject>())
++ res = engine->id_function();
++ else
++ res = engine->id_object(); // ### implementation-defined
++ break;
++ default:
++ res = engine->id_number();
++ break;
++ }
++ return res.asReturnedValue();
++ }
++
++ QV4::ReturnedValue Runtime::TypeofName::call(ExecutionEngine *engine, int nameIndex)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ ScopedValue prop(scope, engine->currentContext()->getProperty(name));
++ // typeof doesn't throw. clear any possible exception
++ scope.engine->hasException = false;
++ return TypeofValue::call(engine, prop);
++ }
++
++ void Runtime::PushCallContext::call(JSTypesStackFrame *frame)
++ {
++ frame->jsFrame->context = ExecutionContext::newCallContext(frame)->asReturnedValue();
++ }
++
++ ReturnedValue Runtime::PushWithContext::call(ExecutionEngine *engine, const Value &acc)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ CallData *jsFrame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame;
++ Value &newAcc = jsFrame->accumulator.asValue<Value>();
++ newAcc = Value::fromHeapObject(acc.toObject(engine));
++ if (!engine->hasException) {
++ Q_ASSERT(newAcc.isObject());
++ const Object &obj = static_cast<const Object &>(newAcc);
++ Value &context = jsFrame->context.asValue<Value>();
++ auto ec = static_cast<const ExecutionContext *>(&context);
++ context = ec->newWithContext(obj.d())->asReturnedValue();
++ }
++ return newAcc.asReturnedValue();
++ }
++
++ void Runtime::PushCatchContext::call(ExecutionEngine *engine, int blockIndex, int exceptionVarNameIndex)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ auto name = engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[exceptionVarNameIndex];
++ static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context
++ = ExecutionContext::newCatchContext(engine->currentStackFrame, blockIndex, name)->asReturnedValue();
++ }
++
++ void Runtime::PushBlockContext::call(ExecutionEngine *engine, int index)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context
++ = ExecutionContext::newBlockContext(engine->currentStackFrame, index)->asReturnedValue();
++ }
++
++ void Runtime::CloneBlockContext::call(ExecutionEngine *engine)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ auto frame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame);
++ auto context = static_cast<Heap::CallContext *>(
++ Value::fromStaticValue(frame->jsFrame->context).m());
++ frame->jsFrame->context =
++ ExecutionContext::cloneBlockContext(engine, context)->asReturnedValue();
++ }
++
++ void Runtime::PushScriptContext::call(ExecutionEngine *engine, int index)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ Q_ASSERT(engine->currentContext()->d()->type == Heap::ExecutionContext::Type_GlobalContext ||
++ engine->currentContext()->d()->type == Heap::ExecutionContext::Type_QmlContext);
++ ReturnedValue c = ExecutionContext::newBlockContext(engine->currentStackFrame, index)->asReturnedValue();
++ engine->setScriptContext(c);
++ static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context = c;
++ }
++
++ void Runtime::PopScriptContext::call(ExecutionEngine *engine)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ ReturnedValue root = engine->rootContext()->asReturnedValue();
++ engine->setScriptContext(root);
++ static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context = root;
++ }
++
++ void Runtime::ThrowReferenceError::call(ExecutionEngine *engine, int nameIndex)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ engine->throwReferenceError(name);
++ }
++
++ void Runtime::ThrowOnNullOrUndefined::call(ExecutionEngine *engine, const Value &v)
++ {
++ if (v.isNullOrUndefined())
++ engine->throwTypeError();
++ }
++
++ void Runtime::MarkCustom::call(const Value &toBeMarked)
++ {
++ auto *h = toBeMarked.heapObject();
++ if (!h)
++ return;
++ Q_ASSERT(h->internalClass);
++ auto engine = h->internalClass->engine;
++ Q_ASSERT(engine);
++ // runtime function is only meant to be called while gc is ongoing
++ Q_ASSERT(engine->isGCOngoing);
++ QV4::WriteBarrier::markCustom(engine, [&](QV4::MarkStack *ms) {
++ h->mark(ms);
++ });
++ }
++
++ ReturnedValue Runtime::ConvertThisToObject::call(ExecutionEngine *engine, const Value &t)
++ {
++ if (!t.isObject()) {
++ if (t.isNullOrUndefined()) {
++ return engine->globalObject->asReturnedValue();
++ } else {
++ return t.toObject(engine)->asReturnedValue();
++ }
++ }
++ return t.asReturnedValue();
++ }
++
++ void Runtime::DeclareVar::call(ExecutionEngine *engine, Bool deletable, int nameIndex)
++ {
++ Scope scope(engine);
++ ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
++ engine->currentContext()->createMutableBinding(name, deletable);
++ }
++
++ ReturnedValue Runtime::ArrayLiteral::call(ExecutionEngine *engine, Value *values, uint length)
++ {
++ return engine->newArrayObject(values, length)->asReturnedValue();
++ }
++
++ ReturnedValue Runtime::ObjectLiteral::call(ExecutionEngine *engine, int classId, QV4::Value args[], int argc)
++ {
++ Scope scope(engine);
++ Scoped<InternalClass> klass(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeClasses[classId]);
++ ScopedObject o(scope, engine->newObject(klass->d()));
++
++ Q_ASSERT(uint(argc) >= klass->d()->size);
++
++ for (uint i = 0; i < klass->d()->size; ++i)
++ o->setProperty(i, *args++);
++
++ Q_ASSERT((argc - klass->d()->size) % 3 == 0);
++ int additionalArgs = (argc - int(klass->d()->size))/3;
++
++ if (!additionalArgs)
++ return o->asReturnedValue();
++
++ ScopedPropertyKey name(scope);
++ ScopedProperty pd(scope);
++ ScopedFunctionObject fn(scope);
++ ScopedString fnName(scope);
++ ScopedValue value(scope);
++ for (int i = 0; i < additionalArgs; ++i) {
++ Q_ASSERT(args->isInteger());
++ ObjectLiteralArgument arg = ObjectLiteralArgument(args->integerValue());
++ name = args[1].toPropertyKey(engine);
++ value = args[2];
++ if (engine->hasException)
++ return Encode::undefined();
++ if (arg != ObjectLiteralArgument::Value) {
++ Q_ASSERT(args[2].isInteger());
++ int functionId = args[2].integerValue();
++ QV4::Function *clos = engine->currentStackFrame->v4Function->executableCompilationUnit()
++ ->runtimeFunctions[functionId];
++ Q_ASSERT(clos);
++
++ PropertyKey::FunctionNamePrefix prefix = PropertyKey::None;
++ if (arg == ObjectLiteralArgument::Getter)
++ prefix = PropertyKey::Getter;
++ else if (arg == ObjectLiteralArgument::Setter)
++ prefix = PropertyKey::Setter;
++ else
++ arg = ObjectLiteralArgument::Value;
++ fnName = name->asFunctionName(engine, prefix);
++
++ ExecutionContext *current = engine->currentContext();
++ if (clos->isGenerator())
++ value = MemberGeneratorFunction::create(current, clos, o, fnName)->asReturnedValue();
++ else
++ value = FunctionObject::createMemberFunction(current, clos, o, fnName)->asReturnedValue();
++ } else if (args[2].isFunctionObject()) {
++ fn = static_cast<const FunctionObject &>(args[2]);
++
++ fnName = name->asFunctionName(engine, PropertyKey::None);
++ fn->setName(fnName);
++ }
++ Q_ASSERT(arg != ObjectLiteralArgument::Method);
++ Q_ASSERT(arg == ObjectLiteralArgument::Value || value->isFunctionObject());
++ if (arg == ObjectLiteralArgument::Value || arg == ObjectLiteralArgument::Getter) {
++ pd->value = value;
++ pd->set = Value::emptyValue();
++ } else {
++ pd->value = Value::emptyValue();
++ pd->set = value;
++ }
++ bool ok = o->defineOwnProperty(name, pd, (arg == ObjectLiteralArgument::Value ? Attr_Data : Attr_Accessor));
++ if (!ok)
++ return engine->throwTypeError();
++
++ args += 3;
++ }
++ return o.asReturnedValue();
++ }
++
++ ReturnedValue Runtime::CreateClass::call(ExecutionEngine *engine, int classIndex,
++ const Value &superClass, Value computedNames[])
++ {
++ const QV4::ExecutableCompilationUnit *unit
++ = engine->currentStackFrame->v4Function->executableCompilationUnit();
++ const QV4::CompiledData::Class *cls = unit->unitData()->classAt(classIndex);
++
++ Scope scope(engine);
++ ScopedObject protoParent(scope, engine->objectPrototype());
++ ScopedObject constructorParent(scope, engine->functionPrototype());
++ if (!superClass.isEmpty()) {
++ if (superClass.isNull()) {
++ protoParent = Encode::null();
++ } else {
++ const FunctionObject *superFunction = superClass.as<FunctionObject>();
++ // ### check that the heritage object is a constructor
++ if (!superFunction || !superFunction->isConstructor())
++ return engine->throwTypeError(QStringLiteral("The superclass is not a function object."));
++ const FunctionObject *s = static_cast<const FunctionObject *>(&superClass);
++ ScopedValue result(scope, s->get(scope.engine->id_prototype()));
++ if (!result->isObject() && !result->isNull())
++ return engine->throwTypeError(QStringLiteral("The value of the superclass's prototype property is not an object."));
++ protoParent = *result;
++ constructorParent = superClass;
++ }
++ }
++
++ ScopedObject proto(scope, engine->newObject());
++ proto->setPrototypeUnchecked(protoParent);
++ ExecutionContext *current = engine->currentContext();
++
++ ScopedFunctionObject constructor(scope);
++ QV4::Function *f = cls->constructorFunction != UINT_MAX ? unit->runtimeFunctions[cls->constructorFunction] : nullptr;
++ constructor = FunctionObject::createConstructorFunction(current, f, proto, !superClass.isEmpty())->asReturnedValue();
++ constructor->setPrototypeUnchecked(constructorParent);
++ Value argCount = Value::fromInt32(f ? f->nFormals : 0);
++ constructor->defineReadonlyConfigurableProperty(scope.engine->id_length(), argCount);
++ constructor->defineReadonlyConfigurableProperty(engine->id_prototype(), proto);
++ proto->defineDefaultProperty(engine->id_constructor(), constructor);
++
++ ScopedString name(scope);
++ if (cls->nameIndex != UINT_MAX) {
++ name = unit->runtimeStrings[cls->nameIndex];
++ constructor->defineReadonlyConfigurableProperty(engine->id_name(), name);
++ }
++
++ ScopedObject receiver(scope, *constructor);
++ ScopedPropertyKey propertyName(scope);
++ ScopedFunctionObject function(scope);
++ ScopedProperty property(scope);
++ const CompiledData::Method *methods = cls->methodTable();
++ for (uint i = 0; i < cls->nStaticMethods + cls->nMethods; ++i) {
++ if (i == cls->nStaticMethods)
++ receiver = proto;
++ if (methods[i].name == UINT_MAX) {
++ propertyName = computedNames->toPropertyKey(engine);
++ if (propertyName == scope.engine->id_prototype()->propertyKey() && receiver->d() == constructor->d())
++ return engine->throwTypeError(QStringLiteral("Cannot declare a static method named 'prototype'."));
++ if (engine->hasException)
++ return Encode::undefined();
++ ++computedNames;
++ } else {
++ name = unit->runtimeStrings[methods[i].name];
++ propertyName = name->toPropertyKey();
++ }
++ QV4::Function *f = unit->runtimeFunctions[methods[i].function];
++ Q_ASSERT(f);
++ PropertyKey::FunctionNamePrefix prefix = PropertyKey::None;
++ if (methods[i].type == CompiledData::Method::Getter)
++ prefix = PropertyKey::Getter;
++ else if (methods[i].type == CompiledData::Method::Setter)
++ prefix = PropertyKey::Setter;
++
++ name = propertyName->asFunctionName(engine, prefix);
++
++ if (f->isGenerator())
++ function = MemberGeneratorFunction::create(current, f, receiver, name);
++ else
++ function = FunctionObject::createMemberFunction(current, f, receiver, name);
++ Q_ASSERT(function);
++ PropertyAttributes attributes;
++ switch (methods[i].type) {
++ case CompiledData::Method::Getter:
++ property->setGetter(function);
++ property->set = Value::emptyValue();
++ attributes = Attr_Accessor|Attr_NotEnumerable;
++ break;
++ case CompiledData::Method::Setter:
++ property->value = Value::emptyValue();
++ property->setSetter(function);
++ attributes = Attr_Accessor|Attr_NotEnumerable;
++ break;
++ default: // Regular
++ property->value = function;
++ property->set = Value::emptyValue();
++ attributes = Attr_Data|Attr_NotEnumerable;
++ break;
++ }
++ receiver->defineOwnProperty(propertyName, property, attributes);
++ }
++
++ return constructor->asReturnedValue();
++ }
++
++ QV4::ReturnedValue Runtime::CreateMappedArgumentsObject::call(ExecutionEngine *engine)
++ {
++ Q_ASSERT(engine->currentContext()->d()->type == Heap::ExecutionContext::Type_CallContext);
++ Heap::InternalClass *ic = engine->internalClasses(EngineBase::Class_ArgumentsObject);
++ return engine->memoryManager->allocObject<ArgumentsObject>(ic, engine->currentStackFrame)->asReturnedValue();
++ }
++
++ QV4::ReturnedValue Runtime::CreateUnmappedArgumentsObject::call(ExecutionEngine *engine)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ Heap::InternalClass *ic = engine->internalClasses(EngineBase::Class_StrictArgumentsObject);
++ return engine->memoryManager->allocObject<StrictArgumentsObject>(
++ ic, static_cast<JSTypesStackFrame *>(engine->currentStackFrame))->asReturnedValue();
++ }
++
++ QV4::ReturnedValue Runtime::CreateRestParameter::call(ExecutionEngine *engine, int argIndex)
++ {
++ Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
++ JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame);
++ const Value *values = frame->argv() + argIndex;
++ int nValues = frame->argc() - argIndex;
++ if (nValues <= 0)
++ return engine->newArrayObject(0)->asReturnedValue();
++ return engine->newArrayObject(values, nValues)->asReturnedValue();
++ }
++
++ ReturnedValue Runtime::RegexpLiteral::call(ExecutionEngine *engine, int id)
++ {
++ const auto val
++ = engine->currentStackFrame->v4Function->compilationUnit->runtimeRegularExpressions[id];
++ Heap::RegExpObject *ro = engine->newRegExpObject(Value::fromStaticValue(val).as<RegExp>());
++ return ro->asReturnedValue();
++ }
++
++ ReturnedValue Runtime::ToObject::call(ExecutionEngine *engine, const Value &obj)
++ {
++ if (obj.isObject())
++ return obj.asReturnedValue();
++
++ return obj.toObject(engine)->asReturnedValue();
++ }
++
++ Bool Runtime::ToBoolean::call(const Value &obj)
++ {
++ return obj.toBoolean();
++ }
++
++ ReturnedValue Runtime::ToNumber::call(ExecutionEngine *, const Value &v)
++ {
++ return Encode(v.toNumber());
++ }
++
++ ReturnedValue Runtime::UMinus::call(const Value &value)
++ {
++ TRACE1(value);
++
++ // +0 != -0, so we need to convert to double when negating 0
++ if (value.isInteger() && value.integerValue() &&
++ value.integerValue() != std::numeric_limits<int>::min())
++ return Encode(-value.integerValue());
++ else {
++ double n = RuntimeHelpers::toNumber(value);
++ return Encode(-n);
++ }
++ }
++
++ // binary operators
++
++ ReturnedValue Runtime::Add::call(ExecutionEngine *engine, const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ if (Q_LIKELY(left.integerCompatible() && right.integerCompatible()))
++ return add_int32(left.integerValue(), right.integerValue());
++ if (left.isNumber() && right.isNumber())
++ return Value::fromDouble(left.asDouble() + right.asDouble()).asReturnedValue();
++
++ return RuntimeHelpers::addHelper(engine, left, right);
++ }
++
++ ReturnedValue Runtime::Sub::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ if (Q_LIKELY(left.integerCompatible() && right.integerCompatible()))
++ return sub_int32(left.integerValue(), right.integerValue());
++
++ double lval = left.isNumber() ? left.asDouble() : left.toNumberImpl();
++ double rval = right.isNumber() ? right.asDouble() : right.toNumberImpl();
++
++ return Value::fromDouble(lval - rval).asReturnedValue();
++ }
++
++ ReturnedValue Runtime::Mul::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ if (Q_LIKELY(left.integerCompatible() && right.integerCompatible()))
++ return mul_int32(left.integerValue(), right.integerValue());
++
++ double lval = left.isNumber() ? left.asDouble() : left.toNumberImpl();
++ double rval = right.isNumber() ? right.asDouble() : right.toNumberImpl();
++
++ return Value::fromDouble(lval * rval).asReturnedValue();
++ }
++
++ ReturnedValue Runtime::Div::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ if (Value::integerCompatible(left, right)) {
++ int lval = left.integerValue();
++ int rval = right.integerValue();
++ if (rval != 0 // division by zero should result in a NaN
++ && !(lval == std::numeric_limits<int>::min() && rval == -1) // doesn't fit in int
++ && (lval % rval == 0) // fractions can't be stored in an int
++ && !(lval == 0 && rval < 0)) // 0 / -something results in -0.0
++ return Encode(int(lval / rval));
++ else
++ return Encode(double(lval) / rval);
++ }
++
++ double lval = left.toNumber();
++ double rval = right.toNumber();
++ return Value::fromDouble(lval / rval).asReturnedValue();
++ }
++
++ ReturnedValue Runtime::Mod::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ if (Value::integerCompatible(left, right) && left.integerValue() >= 0 && right.integerValue() > 0) {
++ // special cases are handled by fmod, among them:
++ // - arithmic execeptions for ints in c++, eg: INT_MIN % -1
++ // - undefined behavior in c++, e.g.: anything % 0
++ // - uncommon cases which would complicate the condition, e.g.: negative integers
++ // (this makes sure that -1 % 1 == -0 by passing it to fmod)
++ return Encode(left.integerValue() % right.integerValue());
++ }
++
++ double lval = RuntimeHelpers::toNumber(left);
++ double rval = RuntimeHelpers::toNumber(right);
++ #ifdef fmod
++ # undef fmod
++ #endif
++ return Value::fromDouble(std::fmod(lval, rval)).asReturnedValue();
++ }
++
++ ReturnedValue Runtime::Exp::call(const Value &base, const Value &exp)
++ {
++ double b = base.toNumber();
++ double e = exp.toNumber();
++ return Encode(QQmlPrivate::jsExponentiate(b, e));
++ }
++
++ ReturnedValue Runtime::BitAnd::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ int lval = left.toInt32();
++ int rval = right.toInt32();
++ return Encode((int)(lval & rval));
++ }
++
++ ReturnedValue Runtime::BitOr::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ int lval = left.toInt32();
++ int rval = right.toInt32();
++ return Encode((int)(lval | rval));
++ }
++
++ ReturnedValue Runtime::BitXor::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ int lval = left.toInt32();
++ int rval = right.toInt32();
++ return Encode((int)(lval ^ rval));
++ }
++
++ ReturnedValue Runtime::Shl::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ int lval = left.toInt32();
++ int rval = right.toInt32() & 0x1f;
++ return Encode((int)(lval << rval));
++ }
++
++ ReturnedValue Runtime::Shr::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ int lval = left.toInt32();
++ unsigned rval = right.toUInt32() & 0x1f;
++ return Encode((int)(lval >> rval));
++ }
++
++ ReturnedValue Runtime::UShr::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ unsigned lval = left.toUInt32();
++ unsigned rval = right.toUInt32() & 0x1f;
++ uint res = lval >> rval;
++
++ return Encode(res);
++ }
++
++ ReturnedValue Runtime::GreaterThan::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = CompareGreaterThan::call(left, right);
++ return Encode(r);
++ }
++
++ ReturnedValue Runtime::LessThan::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = CompareLessThan::call(left, right);
++ return Encode(r);
++ }
++
++ ReturnedValue Runtime::GreaterEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = CompareGreaterEqual::call(left, right);
++ return Encode(r);
++ }
++
++ ReturnedValue Runtime::LessEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = CompareLessEqual::call(left, right);
++ return Encode(r);
++ }
++
++ struct LazyScope
++ {
++ ExecutionEngine *engine = nullptr;
++ Value *stackMark = nullptr;
++ ~LazyScope() {
++ if (engine)
++ engine->jsStackTop = stackMark;
++ }
++ template <typename T>
++ void set(Value **scopedValue, T value, ExecutionEngine *e) {
++ if (!engine) {
++ engine = e;
++ stackMark = engine->jsStackTop;
++ }
++ if (!*scopedValue)
++ *scopedValue = e->jsAlloca(1);
++ **scopedValue = value;
++ }
++ };
++
++ Bool Runtime::CompareEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ Value lhs = left;
++ Value rhs = right;
++
++ LazyScope scope;
++ Value *lhsGuard = nullptr;
++ Value *rhsGuard = nullptr;
++
++ redo:
++ if (lhs.asReturnedValue() == rhs.asReturnedValue())
++ return !lhs.isNaN();
++
++ quint32 lt = lhs.quickType();
++ quint32 rt = rhs.quickType();
++
++ // LHS: Check if managed
++ if ((lt & (Value::ManagedMask >> Value::Tag_Shift)) == 0) {
++ if (lhs.isUndefined())
++ return rhs.isNullOrUndefined();
++
++ // RHS: Check if managed
++ if ((rt & (Value::ManagedMask >> Value::Tag_Shift)) == 0) {
++ if (rhs.isUndefined())
++ return false;
++
++ Heap::Base *l = lhs.m();
++ Heap::Base *r = rhs.m();
++ Q_ASSERT(l);
++ Q_ASSERT(r);
++ if (l->internalClass->vtable->isStringOrSymbol == r->internalClass->vtable->isStringOrSymbol)
++ return static_cast<QV4::Managed &>(lhs).isEqualTo(&static_cast<QV4::Managed &>(rhs));
++ if (l->internalClass->vtable->isStringOrSymbol) {
++ scope.set(&rhsGuard, RuntimeHelpers::objectDefaultValue(&static_cast<QV4::Object &>(rhs), PREFERREDTYPE_HINT), r->internalClass->engine);
++ rhs = rhsGuard->asReturnedValue();
++ goto redo;
++ } else {
++ Q_ASSERT(r->internalClass->vtable->isStringOrSymbol);
++ scope.set(&lhsGuard, RuntimeHelpers::objectDefaultValue(&static_cast<QV4::Object &>(lhs), PREFERREDTYPE_HINT), l->internalClass->engine);
++ lhs = lhsGuard->asReturnedValue();
++ goto redo;
++ }
++ return false;
++ }
++
++ lhs_managed_and_rhs_not:
++ switch (rt) {
++ case QV4::Value::QT_Empty:
++ Q_UNREACHABLE();
++ case QV4::Value::QT_Null:
++ return false;
++ case QV4::Value::QT_Bool:
++ case QV4::Value::QT_Int:
++ rhs = Value::fromDouble(rhs.int_32());
++ Q_FALLTHROUGH();
++ default: // double
++ if (lhs.m()->internalClass->vtable->isStringOrSymbol) {
++ return lhs.m()->internalClass->vtable->isString ? (RuntimeHelpers::toNumber(lhs) == rhs.doubleValue()) : false;
++ } else {
++ scope.set(&lhsGuard, RuntimeHelpers::objectDefaultValue(&static_cast<QV4::Object &>(lhs), PREFERREDTYPE_HINT), lhs.m()->internalClass->engine);
++ lhs = lhsGuard->asReturnedValue();
++ }
++ }
++ goto redo;
++ } else if ((rt & (Value::ManagedMask >> Value::Tag_Shift)) == 0) {
++ if (rhs.isUndefined())
++ return lhs.isNull(); // Can't be undefined
++ qSwap(lhs, rhs);
++ qSwap(lt, rt);
++ goto lhs_managed_and_rhs_not;
++ }
++
++ switch (lt) {
++ case QV4::Value::QT_Empty:
++ Q_UNREACHABLE();
++ case QV4::Value::QT_Null:
++ return rhs.isNull();
++ case QV4::Value::QT_Bool:
++ case QV4::Value::QT_Int:
++ switch (rt) {
++ case QV4::Value::QT_Empty:
++ Q_UNREACHABLE();
++ case QV4::Value::QT_Null:
++ return false;
++ case QV4::Value::QT_Bool:
++ case QV4::Value::QT_Int:
++ return lhs.int_32() == rhs.int_32();
++ default: // double
++ return lhs.int_32() == rhs.doubleValue();
++ }
++ default: // double
++ switch (rt) {
++ case QV4::Value::QT_Empty:
++ Q_UNREACHABLE();
++ case QV4::Value::QT_Null:
++ return false;
++ case QV4::Value::QT_Bool:
++ case QV4::Value::QT_Int:
++ return lhs.doubleValue() == rhs.int_32();
++ default: // double
++ return lhs.doubleValue() == rhs.doubleValue();
++ }
++ }
++ }
++
++ ReturnedValue Runtime::Equal::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = CompareEqual::call(left, right);
++ return Encode(r);
++ }
++
++ ReturnedValue Runtime::NotEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = !CompareEqual::call(left, right);
++ return Encode(r);
++ }
++
++ ReturnedValue Runtime::StrictEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = RuntimeHelpers::strictEqual(left, right);
++ return Encode(r);
++ }
++
++ ReturnedValue Runtime::StrictNotEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ bool r = ! RuntimeHelpers::strictEqual(left, right);
++ return Encode(r);
++ }
++
++ Bool Runtime::CompareNotEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ return !Runtime::CompareEqual::call(left, right);
++ }
++
++ Bool Runtime::CompareStrictEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ return RuntimeHelpers::strictEqual(left, right);
++ }
++
++ Bool Runtime::CompareStrictNotEqual::call(const Value &left, const Value &right)
++ {
++ TRACE2(left, right);
++
++ return ! RuntimeHelpers::strictEqual(left, right);
++ }
++
++ template<typename Operation>
++ static inline const void *symbol()
++ {
++ return reinterpret_cast<void *>(&Operation::call);
++ }
++
++ QHash<const void *, const char *> Runtime::symbolTable()
++ {
++ static const QHash<const void *, const char *> symbols({
++ #ifndef V4_BOOTSTRAP
++ {symbol<CallGlobalLookup>(), "CallGlobalLookup" },
++ {symbol<CallQmlContextPropertyLookup>(), "CallQmlContextPropertyLookup" },
++ {symbol<CallName>(), "CallName" },
++ {symbol<CallProperty>(), "CallProperty" },
++ {symbol<CallPropertyLookup>(), "CallPropertyLookup" },
++ {symbol<CallValue>(), "CallValue" },
++ {symbol<CallWithReceiver>(), "CallWithReceiver" },
++ {symbol<CallPossiblyDirectEval>(), "CallPossiblyDirectEval" },
++ {symbol<CallWithSpread>(), "CallWithSpread" },
++ {symbol<TailCall>(), "TailCall" },
++
++ {symbol<Construct>(), "Construct" },
++ {symbol<ConstructWithSpread>(), "ConstructWithSpread" },
++
++ {symbol<StoreNameStrict>(), "StoreNameStrict" },
++ {symbol<StoreNameSloppy>(), "StoreNameSloppy" },
++ {symbol<StoreProperty>(), "StoreProperty" },
++ {symbol<StoreElement>(), "StoreElement" },
++ {symbol<LoadProperty>(), "LoadProperty" },
++ {symbol<LoadName>(), "LoadName" },
++ {symbol<LoadElement>(), "LoadElement" },
++ {symbol<LoadSuperProperty>(), "LoadSuperProperty" },
++ {symbol<StoreSuperProperty>(), "StoreSuperProperty" },
++ {symbol<LoadSuperConstructor>(), "LoadSuperConstructor" },
++ {symbol<LoadGlobalLookup>(), "LoadGlobalLookup" },
++ {symbol<LoadQmlContextPropertyLookup>(), "LoadQmlContextPropertyLookup" },
++ {symbol<GetLookup>(), "GetLookup" },
++ {symbol<SetLookupStrict>(), "SetLookupStrict" },
++ {symbol<SetLookupSloppy>(), "SetLookupSloppy" },
++
++ {symbol<TypeofValue>(), "TypeofValue" },
++ {symbol<TypeofName>(), "TypeofName" },
++
++ {symbol<DeleteProperty_NoThrow>(), "DeleteProperty_NoThrow" },
++ {symbol<DeleteProperty>(), "DeleteProperty" },
++ {symbol<DeleteName_NoThrow>(), "DeleteName_NoThrow" },
++ {symbol<DeleteName>(), "DeleteName" },
++
++ {symbol<ThrowException>(), "ThrowException" },
++ {symbol<PushCallContext>(), "PushCallContext" },
++ {symbol<PushWithContext>(), "PushWithContext" },
++ {symbol<PushCatchContext>(), "PushCatchContext" },
++ {symbol<PushBlockContext>(), "PushBlockContext" },
++ {symbol<CloneBlockContext>(), "CloneBlockContext" },
++ {symbol<PushScriptContext>(), "PushScriptContext" },
++ {symbol<PopScriptContext>(), "PopScriptContext" },
++ {symbol<ThrowReferenceError>(), "ThrowReferenceError" },
++ {symbol<ThrowOnNullOrUndefined>(), "ThrowOnNullOrUndefined" },
++
++ {symbol<Closure>(), "Closure" },
++
++ {symbol<MarkCustom>(), "MarkCustom"},
++
++ {symbol<ConvertThisToObject>(), "ConvertThisToObject" },
++ {symbol<DeclareVar>(), "DeclareVar" },
++ {symbol<CreateMappedArgumentsObject>(), "CreateMappedArgumentsObject" },
++ {symbol<CreateUnmappedArgumentsObject>(), "CreateUnmappedArgumentsObject" },
++ {symbol<CreateRestParameter>(), "CreateRestParameter" },
++
++ {symbol<ArrayLiteral>(), "ArrayLiteral" },
++ {symbol<ObjectLiteral>(), "ObjectLiteral" },
++ {symbol<CreateClass>(), "CreateClass" },
++
++ {symbol<GetIterator>(), "GetIterator" },
++ {symbol<IteratorNext>(), "IteratorNext" },
++ {symbol<IteratorNextForYieldStar>(), "IteratorNextForYieldStar" },
++ {symbol<IteratorClose>(), "IteratorClose" },
++ {symbol<DestructureRestElement>(), "DestructureRestElement" },
++
++ {symbol<ToObject>(), "ToObject" },
++ {symbol<ToBoolean>(), "ToBoolean" },
++ {symbol<ToNumber>(), "ToNumber" },
++
++ {symbol<UMinus>(), "UMinus" },
++
++ {symbol<Instanceof>(), "Instanceof" },
++ {symbol<As>(), "As" },
++ {symbol<In>(), "In" },
++ {symbol<Add>(), "Add" },
++ {symbol<Sub>(), "Sub" },
++ {symbol<Mul>(), "Mul" },
++ {symbol<Div>(), "Div" },
++ {symbol<Mod>(), "Mod" },
++ {symbol<Exp>(), "Exp" },
++ {symbol<BitAnd>(), "BitAnd" },
++ {symbol<BitOr>(), "BitOr" },
++ {symbol<BitXor>(), "BitXor" },
++ {symbol<Shl>(), "Shl" },
++ {symbol<Shr>(), "Shr" },
++ {symbol<UShr>(), "UShr" },
++ {symbol<GreaterThan>(), "GreaterThan" },
++ {symbol<LessThan>(), "LessThan" },
++ {symbol<GreaterEqual>(), "GreaterEqual" },
++ {symbol<LessEqual>(), "LessEqual" },
++ {symbol<Equal>(), "Equal" },
++ {symbol<NotEqual>(), "NotEqual" },
++ {symbol<StrictEqual>(), "StrictEqual" },
++ {symbol<StrictNotEqual>(), "StrictNotEqual" },
++
++ {symbol<CompareGreaterThan>(), "CompareGreaterThan" },
++ {symbol<CompareLessThan>(), "CompareLessThan" },
++ {symbol<CompareGreaterEqual>(), "CompareGreaterEqual" },
++ {symbol<CompareLessEqual>(), "CompareLessEqual" },
++ {symbol<CompareEqual>(), "CompareEqual" },
++ {symbol<CompareNotEqual>(), "CompareNotEqual" },
++ {symbol<CompareStrictEqual>(), "CompareStrictEqual" },
++ {symbol<CompareStrictNotEqual>(), "CompareStrictNotEqual" },
++
++ {symbol<CompareInstanceof>(), "CompareInstanceOf" },
++ {symbol<CompareIn>(), "CompareIn" },
++
++ {symbol<RegexpLiteral>(), "RegexpLiteral" },
++ {symbol<GetTemplateObject>(), "GetTemplateObject" }
++ #endif
++ });
++
++ return symbols;
++ }
++
++ } // namespace QV4
++
++ QT_END_NAMESPACE