1// Copyright (C) 2021 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3#include <qv4engine_p.h>
4
5#include <private/qv4compileddata_p.h>
6#include <private/qv4codegen_p.h>
7#include <private/qqmljsdiagnosticmessage_p.h>
8
9#include <QtCore/QTextStream>
10#include <QDateTime>
11#include <QDir>
12#include <QFileInfo>
13#include <QLoggingCategory>
14#if QT_CONFIG(regularexpression)
15#include <QRegularExpression>
16#endif
17#include <QtCore/QTimeZone>
18#include <QtCore/qiterable.h>
19
20#include <qv4qmlcontext_p.h>
21#include <qv4value_p.h>
22#include <qv4object_p.h>
23#include <qv4objectproto_p.h>
24#include <qv4objectiterator_p.h>
25#include <qv4setiterator_p.h>
26#include <qv4mapiterator_p.h>
27#include <qv4arrayiterator_p.h>
28#include <qv4arrayobject_p.h>
29#include <qv4booleanobject_p.h>
30#include <qv4globalobject_p.h>
31#include <qv4errorobject_p.h>
32#include <qv4functionobject_p.h>
33#include "qv4function_p.h"
34#include <qv4mathobject_p.h>
35#include <qv4numberobject_p.h>
36#include <qv4regexpobject_p.h>
37#include <qv4regexp_p.h>
38#include "qv4symbol_p.h"
39#include "qv4setobject_p.h"
40#include "qv4mapobject_p.h"
41#include <qv4variantobject_p.h>
42#include <qv4runtime_p.h>
43#include <private/qv4mm_p.h>
44#include <qv4argumentsobject_p.h>
45#include <qv4dateobject_p.h>
46#include <qv4jsonobject_p.h>
47#include <qv4stringobject_p.h>
48#include <qv4identifiertable_p.h>
49#include "qv4debugging_p.h"
50#include "qv4profiling_p.h"
51#include "qv4executableallocator_p.h"
52#include "qv4iterator_p.h"
53#include "qv4stringiterator_p.h"
54#include "qv4generatorobject_p.h"
55#include "qv4reflect_p.h"
56#include "qv4proxy_p.h"
57#include "qv4stackframe_p.h"
58#include "qv4stacklimits_p.h"
59#include "qv4atomics_p.h"
60#include "qv4urlobject_p.h"
61#include "qv4variantobject_p.h"
62#include "qv4sequenceobject_p.h"
63#include "qv4qobjectwrapper_p.h"
64#include "qv4qmetaobjectwrapper_p.h"
65#include "qv4memberdata_p.h"
66#include "qv4arraybuffer_p.h"
67#include "qv4dataview_p.h"
68#include "qv4promiseobject_p.h"
69#include "qv4typedarray_p.h"
70#include <private/qjsvalue_p.h>
71#include <private/qqmltypewrapper_p.h>
72#include <private/qqmlvaluetypewrapper_p.h>
73#include <private/qqmlvaluetype_p.h>
74#include <private/qqmllistwrapper_p.h>
75#include <private/qqmllist_p.h>
76#include <private/qqmltypeloader_p.h>
77#include <private/qqmlbuiltinfunctions_p.h>
78#if QT_CONFIG(qml_locale)
79#include <private/qqmllocale_p.h>
80#endif
81#if QT_CONFIG(qml_xml_http_request)
82#include <private/qv4domerrors_p.h>
83#include <private/qqmlxmlhttprequest_p.h>
84#endif
85#include <private/qv4sqlerrors_p.h>
86#include <qqmlfile.h>
87#include <qmetatype.h>
88#include <qsequentialiterable.h>
89
90#include <private/qqmlengine_p.h>
91
92#ifdef V4_USE_VALGRIND
93#include <valgrind/memcheck.h>
94#endif
95
96QT_BEGIN_NAMESPACE
97
98DEFINE_BOOL_CONFIG_OPTION(disableDiskCache, QML_DISABLE_DISK_CACHE);
99DEFINE_BOOL_CONFIG_OPTION(forceDiskCache, QML_FORCE_DISK_CACHE);
100
101using namespace QV4;
102
103// While engineSerial is odd the statics haven't been initialized. The engine that receives ID 1
104// initializes the statics and sets engineSerial to 2 afterwards.
105// Each engine does engineSerial.fetchAndAddOrdered(2) on creation. Therefore engineSerial stays
106// odd while the statics are being initialized, and stays even afterwards.
107// Any further engines created while the statics are being initialized busy-wait until engineSerial
108// is even.
109Q_CONSTINIT static QBasicAtomicInt engineSerial = Q_BASIC_ATOMIC_INITIALIZER(1);
110Q_CONSTINIT static QBasicAtomicInt hasPreview = Q_BASIC_ATOMIC_INITIALIZER(0);
111int ExecutionEngine::s_maxCallDepth = -1;
112int ExecutionEngine::s_jitCallCountThreshold = 3;
113int ExecutionEngine::s_maxJSStackSize = 4 * 1024 * 1024;
114int ExecutionEngine::s_maxGCStackSize = 2 * 1024 * 1024;
115
116ReturnedValue throwTypeError(const FunctionObject *b, const QV4::Value *, const QV4::Value *, int)
117{
118 return b->engine()->throwTypeError();
119}
120
121
122template <typename ReturnType>
123ReturnType convertJSValueToVariantType(const QJSValue &value)
124{
125 const QVariant variant = value.toVariant();
126 return variant.metaType() == QMetaType::fromType<QJSValue>()
127 ? ReturnType()
128 : variant.value<ReturnType>();
129}
130
131struct JSArrayIterator {
132 QJSValue const* data;
133 quint32 index;
134};
135
136namespace {
137void createNewIteratorIfNonExisting(void **iterator) {
138 if (*iterator == nullptr)
139 *iterator = new JSArrayIterator;
140}
141}
142
143static QtMetaContainerPrivate::QMetaSequenceInterface emptySequenceInterface()
144{
145 // set up some functions so that non-array QSequentialIterables do not crash
146 // but instead appear as an empty sequence
147
148 using namespace QtMetaContainerPrivate;
149 QMetaSequenceInterface iface;
150 iface.sizeFn = [](const void *) { return qsizetype(0); };
151 iface.valueAtIndexFn = [](const void *, qsizetype, void *) {};
152 iface.createIteratorFn = [](void *, QMetaSequenceInterface::Position) -> void * {
153 return nullptr;
154 };
155 iface.advanceIteratorFn = [](void *, qsizetype) {};
156 iface.compareIteratorFn = [](const void *, const void *) {
157 return true; /*all iterators are nullptr*/
158 };
159 iface.destroyIteratorFn = [](const void *) {};
160 iface.copyIteratorFn = [](void *, const void *) {};
161 iface.diffIteratorFn = [](const void *, const void *) { return qsizetype(0); };
162 return iface;
163}
164
165static QtMetaContainerPrivate::QMetaSequenceInterface sequenceInterface()
166{
167 using namespace QtMetaContainerPrivate;
168 QMetaSequenceInterface iface;
169 iface.valueMetaType = QtPrivate::qMetaTypeInterfaceForType<QVariant>();
170 iface.iteratorCapabilities = RandomAccessCapability | BiDirectionalCapability | ForwardCapability;
171 iface.addRemoveCapabilities = CanAddAtEnd;
172 iface.sizeFn = [](const void *p) -> qsizetype {
173 return static_cast<QJSValue const *>(p)->property(name: QString::fromLatin1(ba: "length")).toInt();
174 };
175
176 /* Lifetime management notes:
177 * valueAtIndexFn and valueAtIteratorFn return a pointer to a JSValue allocated via
178 * QMetaType::create Because we set QVariantConstructionFlags::ShouldDeleteVariantData,
179 * QSequentialIterable::at and QSequentialIterable::operator*() will free that memory
180 */
181
182 iface.valueAtIndexFn = [](const void *iterable, qsizetype index, void *dataPtr) -> void {
183 auto *data = static_cast<QVariant *>(dataPtr);
184 *data = static_cast<QJSValue const *>(iterable)->property(arrayIndex: quint32(index)).toVariant();
185 };
186 iface.createIteratorFn = [](void *iterable, QMetaSequenceInterface::Position pos) {
187 void *iterator = nullptr;
188 createNewIteratorIfNonExisting(iterator: &iterator);
189 auto jsArrayIterator = static_cast<JSArrayIterator *>(iterator);
190 jsArrayIterator->index = 0;
191 jsArrayIterator->data = reinterpret_cast<QJSValue const*>(iterable);
192 if (pos == QMetaSequenceInterface::AtEnd) {
193 auto length = static_cast<QJSValue const *>(iterable)->property(
194 name: QString::fromLatin1(ba: "length")).toInt();
195 jsArrayIterator->index = quint32(length);
196 }
197 return iterator;
198 };
199 iface.createConstIteratorFn = [](const void *iterable, QMetaSequenceInterface::Position pos) {
200 void *iterator = nullptr;
201 createNewIteratorIfNonExisting(iterator: &iterator);
202 auto jsArrayIterator = static_cast<JSArrayIterator *>(iterator);
203 jsArrayIterator->index = 0;
204 jsArrayIterator->data = reinterpret_cast<QJSValue const*>(iterable);
205 if (pos == QMetaSequenceInterface::AtEnd) {
206 auto length = static_cast<QJSValue const *>(iterable)->property(
207 name: QString::fromLatin1(ba: "length")).toInt();
208 jsArrayIterator->index = quint32(length);
209 }
210 return iterator;
211 };
212 iface.advanceIteratorFn = [](void *iterator, qsizetype advanceBy) {
213 static_cast<JSArrayIterator *>(iterator)->index += quint32(advanceBy);
214 };
215 iface.advanceConstIteratorFn = [](void *iterator, qsizetype advanceBy) {
216 static_cast<JSArrayIterator *>(iterator)->index += quint32(advanceBy);
217 };
218 iface.valueAtIteratorFn = [](const void *iterator, void *dataPtr) -> void {
219 const auto *arrayIterator = static_cast<const JSArrayIterator *>(iterator);
220 const QJSValue *jsArray = arrayIterator->data;
221 auto *data = static_cast<QVariant *>(dataPtr);
222 *data = jsArray->property(arrayIndex: arrayIterator->index).toVariant();
223 };
224 iface.valueAtConstIteratorFn = [](const void *iterator, void *dataPtr) -> void {
225 const auto *arrayIterator = static_cast<const JSArrayIterator *>(iterator);
226 const QJSValue *jsArray = arrayIterator->data;
227 auto *data = static_cast<QVariant *>(dataPtr);
228 *data = jsArray->property(arrayIndex: arrayIterator->index).toVariant();
229 };
230 iface.destroyIteratorFn = [](const void *iterator) {
231 delete static_cast<const JSArrayIterator *>(iterator);
232 };
233 iface.destroyConstIteratorFn = [](const void *iterator) {
234 delete static_cast<const JSArrayIterator *>(iterator);
235 };
236 iface.compareIteratorFn = [](const void *p, const void *other) {
237 auto this_ = static_cast<const JSArrayIterator *>(p);
238 auto that_ = static_cast<const JSArrayIterator *>(other);
239 return this_->index == that_->index && this_->data == that_->data;
240 };
241 iface.compareConstIteratorFn = [](const void *p, const void *other) {
242 auto this_ = static_cast<const JSArrayIterator *>(p);
243 auto that_ = static_cast<const JSArrayIterator *>(other);
244 return this_->index == that_->index && this_->data == that_->data;
245 };
246 iface.copyIteratorFn = [](void *iterator, const void *otherIterator) {
247 auto *otherIter = (static_cast<JSArrayIterator const *>(otherIterator));
248 static_cast<JSArrayIterator *>(iterator)->index = otherIter->index;
249 static_cast<JSArrayIterator *>(iterator)->data = otherIter->data;
250 };
251 iface.copyConstIteratorFn = [](void *iterator, const void *otherIterator) {
252 auto *otherIter = (static_cast<JSArrayIterator const *>(otherIterator));
253 static_cast<JSArrayIterator *>(iterator)->index = otherIter->index;
254 static_cast<JSArrayIterator *>(iterator)->data = otherIter->data;
255 };
256 iface.diffIteratorFn = [](const void *iterator, const void *otherIterator) -> qsizetype {
257 const auto *self = static_cast<const JSArrayIterator *>(iterator);
258 const auto *other = static_cast<const JSArrayIterator *>(otherIterator);
259 return self->index - other->index;
260 };
261 iface.diffConstIteratorFn = [](const void *iterator, const void *otherIterator) -> qsizetype {
262 const auto *self = static_cast<const JSArrayIterator *>(iterator);
263 const auto *other = static_cast<const JSArrayIterator *>(otherIterator);
264 return self->index - other->index;
265 };
266 iface.addValueFn = [](void *iterable, const void *data, QMetaSequenceInterface::Position) {
267 auto *jsvalue = static_cast<QJSValue *>(iterable);
268 QV4::Scope scope(QJSValuePrivate::engine(jsval: jsvalue));
269 QV4::ScopedArrayObject a(scope, QJSValuePrivate::asManagedType<QV4::ArrayObject>(jsval: jsvalue));
270 QV4::ScopedValue v(scope, scope.engine->fromVariant(*static_cast<const QVariant *>(data)));
271 if (!a)
272 return;
273 int len = a->getLength();
274 a->setIndexed(idx: len, v, shouldThrow: QV4::Object::DoNotThrow);
275 };
276 return iface;
277}
278
279static QSequentialIterable jsvalueToSequence (const QJSValue& value) {
280 using namespace QtMetaTypePrivate;
281 using namespace QtMetaContainerPrivate;
282
283
284 if (!value.isArray()) {
285 static QMetaSequenceInterface emptySequence = emptySequenceInterface();
286 return QSequentialIterable(QMetaSequence(&emptySequence), nullptr);
287 }
288
289 static QMetaSequenceInterface sequence = sequenceInterface();
290 return QSequentialIterable(QMetaSequence(&sequence), &value);
291}
292
293void ExecutionEngine::initializeStaticMembers()
294{
295 bool ok = false;
296
297 const int envMaxJSStackSize = qEnvironmentVariableIntValue(varName: "QV4_JS_MAX_STACK_SIZE", ok: &ok);
298 if (ok && envMaxJSStackSize > 0)
299 s_maxJSStackSize = envMaxJSStackSize;
300
301 const int envMaxGCStackSize = qEnvironmentVariableIntValue(varName: "QV4_GC_MAX_STACK_SIZE", ok: &ok);
302 if (ok && envMaxGCStackSize > 0)
303 s_maxGCStackSize = envMaxGCStackSize;
304
305 if (qEnvironmentVariableIsSet(varName: "QV4_CRASH_ON_STACKOVERFLOW")) {
306 s_maxCallDepth = std::numeric_limits<qint32>::max();
307 } else {
308 ok = false;
309 s_maxCallDepth = qEnvironmentVariableIntValue(varName: "QV4_MAX_CALL_DEPTH", ok: &ok);
310 if (!ok || s_maxCallDepth <= 0)
311 s_maxCallDepth = -1;
312 }
313
314 ok = false;
315 s_jitCallCountThreshold = qEnvironmentVariableIntValue(varName: "QV4_JIT_CALL_THRESHOLD", ok: &ok);
316 if (!ok)
317 s_jitCallCountThreshold = 3;
318 if (qEnvironmentVariableIsSet(varName: "QV4_FORCE_INTERPRETER"))
319 s_jitCallCountThreshold = std::numeric_limits<int>::max();
320
321 qMetaTypeId<QJSValue>();
322 qMetaTypeId<QList<int> >();
323
324 if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QVariantMap>())
325 QMetaType::registerConverter<QJSValue, QVariantMap>(function: convertJSValueToVariantType<QVariantMap>);
326 if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QVariantList>())
327 QMetaType::registerConverter<QJSValue, QVariantList>(function: convertJSValueToVariantType<QVariantList>);
328 if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QStringList>())
329 QMetaType::registerConverter<QJSValue, QStringList>(function: convertJSValueToVariantType<QStringList>);
330 if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QSequentialIterable>())
331 QMetaType::registerConverter<QJSValue, QSequentialIterable>(function: jsvalueToSequence);
332}
333
334ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine)
335 : executableAllocator(new QV4::ExecutableAllocator)
336 , regExpAllocator(new QV4::ExecutableAllocator)
337 , bumperPointerAllocator(new WTF::BumpPointerAllocator)
338 , jsStack(new WTF::PageAllocation)
339 , gcStack(new WTF::PageAllocation)
340 , globalCode(nullptr)
341 , publicEngine(jsEngine)
342 , m_engineId(engineSerial.fetchAndAddOrdered(valueToAdd: 2))
343 , regExpCache(nullptr)
344 , m_multiplyWrappedQObjects(nullptr)
345#if QT_CONFIG(qml_jit)
346 , m_canAllocateExecutableMemory(OSAllocator::canAllocateExecutableMemory())
347#endif
348#if QT_CONFIG(qml_xml_http_request)
349 , m_xmlHttpRequestData(nullptr)
350#endif
351 , m_qmlEngine(nullptr)
352{
353 if (m_engineId == 1) {
354 initializeStaticMembers();
355 engineSerial.storeRelease(newValue: 2); // make it even
356 } else if (Q_UNLIKELY(m_engineId & 1)) {
357 // This should be rare. You usually don't create lots of engines at the same time.
358 while (engineSerial.loadAcquire() & 1) {
359 QThread::yieldCurrentThread();
360 }
361 }
362
363 if (s_maxCallDepth < 0) {
364 const StackProperties stack = stackProperties();
365 cppStackBase = stack.base;
366 cppStackLimit = stack.softLimit;
367 } else {
368 callDepth = 0;
369 }
370
371 // We allocate guard pages around our stacks.
372 const size_t guardPages = 2 * WTF::pageSize();
373
374 memoryManager = new QV4::MemoryManager(this);
375 // we don't want to run the gc while the initial setup is not done; not even in aggressive mode
376 GCCriticalSection gcCriticalSection(this);
377 // reserve space for the JS stack
378 // we allow it to grow to a bit more than m_maxJSStackSize, as we can overshoot due to ScopedValues
379 // allocated outside of JIT'ed methods.
380 *jsStack = WTF::PageAllocation::allocate(
381 size: s_maxJSStackSize + 256*1024 + guardPages, usage: WTF::OSAllocator::JSVMStackPages,
382 /* writable */ true, /* executable */ false, /* includesGuardPages */ true);
383 jsStackBase = (Value *)jsStack->base();
384#ifdef V4_USE_VALGRIND
385 VALGRIND_MAKE_MEM_UNDEFINED(jsStackBase, m_maxJSStackSize + 256*1024);
386#endif
387
388 jsStackTop = jsStackBase;
389
390 *gcStack = WTF::PageAllocation::allocate(
391 size: s_maxGCStackSize + guardPages, usage: WTF::OSAllocator::JSVMStackPages,
392 /* writable */ true, /* executable */ false, /* includesGuardPages */ true);
393
394 exceptionValue = jsAlloca(nValues: 1);
395 *exceptionValue = Encode::undefined();
396 globalObject = static_cast<Object *>(jsAlloca(nValues: 1));
397 jsObjects = jsAlloca(nValues: NJSObjects);
398 typedArrayPrototype = static_cast<Object *>(jsAlloca(nValues: NTypedArrayTypes));
399 typedArrayCtors = static_cast<FunctionObject *>(jsAlloca(nValues: NTypedArrayTypes));
400 jsStrings = jsAlloca(nValues: NJSStrings);
401 jsSymbols = jsAlloca(nValues: NJSSymbols);
402
403 // set up stack limits
404 jsStackLimit = jsStackBase + s_maxJSStackSize/sizeof(Value);
405
406 identifierTable = new IdentifierTable(this);
407
408 memset(s: classes, c: 0, n: sizeof(classes));
409 classes[Class_Empty] = memoryManager->allocIC<InternalClass>();
410 classes[Class_Empty]->init(engine: this);
411
412 classes[Class_MemberData] = classes[Class_Empty]->changeVTable(vt: QV4::MemberData::staticVTable());
413 classes[Class_SimpleArrayData] = classes[Class_Empty]->changeVTable(vt: QV4::SimpleArrayData::staticVTable());
414 classes[Class_SparseArrayData] = classes[Class_Empty]->changeVTable(vt: QV4::SparseArrayData::staticVTable());
415 classes[Class_ExecutionContext] = classes[Class_Empty]->changeVTable(vt: QV4::ExecutionContext::staticVTable());
416 classes[Class_CallContext] = classes[Class_Empty]->changeVTable(vt: QV4::CallContext::staticVTable());
417 classes[Class_QmlContext] = classes[Class_Empty]->changeVTable(vt: QV4::QmlContext::staticVTable());
418
419 Scope scope(this);
420 Scoped<InternalClass> ic(scope);
421 ic = classes[Class_Empty]->changeVTable(vt: QV4::Object::staticVTable());
422 jsObjects[ObjectProto] = memoryManager->allocObject<ObjectPrototype>(ic: ic->d());
423 classes[Class_Object] = ic->changePrototype(proto: objectPrototype()->d());
424 classes[Class_QmlContextWrapper] = classes[Class_Object]->changeVTable(vt: QV4::QQmlContextWrapper::staticVTable());
425
426 ic = newInternalClass(vtable: QV4::StringObject::staticVTable(), prototype: objectPrototype());
427 jsObjects[StringProto] = memoryManager->allocObject<StringPrototype>(ic: ic->d(), /*init =*/ args: false);
428 classes[Class_String] = classes[Class_Empty]->changeVTable(vt: QV4::String::staticVTable())->changePrototype(proto: stringPrototype()->d());
429 Q_ASSERT(stringPrototype()->d() && classes[Class_String]->prototype);
430
431 jsObjects[SymbolProto] = memoryManager->allocate<SymbolPrototype>();
432 classes[Class_Symbol] = classes[EngineBase::Class_Empty]->changeVTable(vt: QV4::Symbol::staticVTable())->changePrototype(proto: symbolPrototype()->d());
433
434 jsStrings[String_Empty] = newIdentifier(text: QString());
435 jsStrings[String_undefined] = newIdentifier(QStringLiteral("undefined"));
436 jsStrings[String_null] = newIdentifier(QStringLiteral("null"));
437 jsStrings[String_true] = newIdentifier(QStringLiteral("true"));
438 jsStrings[String_false] = newIdentifier(QStringLiteral("false"));
439 jsStrings[String_boolean] = newIdentifier(QStringLiteral("boolean"));
440 jsStrings[String_number] = newIdentifier(QStringLiteral("number"));
441 jsStrings[String_string] = newIdentifier(QStringLiteral("string"));
442 jsStrings[String_default] = newIdentifier(QStringLiteral("default"));
443 jsStrings[String_symbol] = newIdentifier(QStringLiteral("symbol"));
444 jsStrings[String_object] = newIdentifier(QStringLiteral("object"));
445 jsStrings[String_function] = newIdentifier(QStringLiteral("function"));
446 jsStrings[String_length] = newIdentifier(QStringLiteral("length"));
447 jsStrings[String_prototype] = newIdentifier(QStringLiteral("prototype"));
448 jsStrings[String_constructor] = newIdentifier(QStringLiteral("constructor"));
449 jsStrings[String_arguments] = newIdentifier(QStringLiteral("arguments"));
450 jsStrings[String_caller] = newIdentifier(QStringLiteral("caller"));
451 jsStrings[String_callee] = newIdentifier(QStringLiteral("callee"));
452 jsStrings[String_this] = newIdentifier(QStringLiteral("this"));
453 jsStrings[String___proto__] = newIdentifier(QStringLiteral("__proto__"));
454 jsStrings[String_enumerable] = newIdentifier(QStringLiteral("enumerable"));
455 jsStrings[String_configurable] = newIdentifier(QStringLiteral("configurable"));
456 jsStrings[String_writable] = newIdentifier(QStringLiteral("writable"));
457 jsStrings[String_value] = newIdentifier(QStringLiteral("value"));
458 jsStrings[String_get] = newIdentifier(QStringLiteral("get"));
459 jsStrings[String_set] = newIdentifier(QStringLiteral("set"));
460 jsStrings[String_eval] = newIdentifier(QStringLiteral("eval"));
461 jsStrings[String_uintMax] = newIdentifier(QStringLiteral("4294967295"));
462 jsStrings[String_name] = newIdentifier(QStringLiteral("name"));
463 jsStrings[String_index] = newIdentifier(QStringLiteral("index"));
464 jsStrings[String_input] = newIdentifier(QStringLiteral("input"));
465 jsStrings[String_toString] = newIdentifier(QStringLiteral("toString"));
466 jsStrings[String_toLocaleString] = newIdentifier(QStringLiteral("toLocaleString"));
467 jsStrings[String_destroy] = newIdentifier(QStringLiteral("destroy"));
468 jsStrings[String_valueOf] = newIdentifier(QStringLiteral("valueOf"));
469 jsStrings[String_byteLength] = newIdentifier(QStringLiteral("byteLength"));
470 jsStrings[String_byteOffset] = newIdentifier(QStringLiteral("byteOffset"));
471 jsStrings[String_buffer] = newIdentifier(QStringLiteral("buffer"));
472 jsStrings[String_lastIndex] = newIdentifier(QStringLiteral("lastIndex"));
473 jsStrings[String_next] = newIdentifier(QStringLiteral("next"));
474 jsStrings[String_done] = newIdentifier(QStringLiteral("done"));
475 jsStrings[String_return] = newIdentifier(QStringLiteral("return"));
476 jsStrings[String_throw] = newIdentifier(QStringLiteral("throw"));
477 jsStrings[String_global] = newIdentifier(QStringLiteral("global"));
478 jsStrings[String_ignoreCase] = newIdentifier(QStringLiteral("ignoreCase"));
479 jsStrings[String_multiline] = newIdentifier(QStringLiteral("multiline"));
480 jsStrings[String_unicode] = newIdentifier(QStringLiteral("unicode"));
481 jsStrings[String_sticky] = newIdentifier(QStringLiteral("sticky"));
482 jsStrings[String_source] = newIdentifier(QStringLiteral("source"));
483 jsStrings[String_flags] = newIdentifier(QStringLiteral("flags"));
484
485 jsSymbols[Symbol_hasInstance] = Symbol::create(e: this, QStringLiteral("@Symbol.hasInstance"));
486 jsSymbols[Symbol_isConcatSpreadable] = Symbol::create(e: this, QStringLiteral("@Symbol.isConcatSpreadable"));
487 jsSymbols[Symbol_iterator] = Symbol::create(e: this, QStringLiteral("@Symbol.iterator"));
488 jsSymbols[Symbol_match] = Symbol::create(e: this, QStringLiteral("@Symbol.match"));
489 jsSymbols[Symbol_replace] = Symbol::create(e: this, QStringLiteral("@Symbol.replace"));
490 jsSymbols[Symbol_search] = Symbol::create(e: this, QStringLiteral("@Symbol.search"));
491 jsSymbols[Symbol_species] = Symbol::create(e: this, QStringLiteral("@Symbol.species"));
492 jsSymbols[Symbol_split] = Symbol::create(e: this, QStringLiteral("@Symbol.split"));
493 jsSymbols[Symbol_toPrimitive] = Symbol::create(e: this, QStringLiteral("@Symbol.toPrimitive"));
494 jsSymbols[Symbol_toStringTag] = Symbol::create(e: this, QStringLiteral("@Symbol.toStringTag"));
495 jsSymbols[Symbol_unscopables] = Symbol::create(e: this, QStringLiteral("@Symbol.unscopables"));
496 jsSymbols[Symbol_revokableProxy] = Symbol::create(e: this, QStringLiteral("@Proxy.revokableProxy"));
497
498 ic = newInternalClass(vtable: ArrayPrototype::staticVTable(), prototype: objectPrototype());
499 Q_ASSERT(ic->d()->prototype);
500 ic = ic->addMember(identifier: id_length()->propertyKey(), data: Attr_NotConfigurable|Attr_NotEnumerable);
501 Q_ASSERT(ic->d()->prototype);
502 jsObjects[ArrayProto] = memoryManager->allocObject<ArrayPrototype>(ic: ic->d());
503 classes[Class_ArrayObject] = ic->changePrototype(proto: arrayPrototype()->d());
504 jsObjects[PropertyListProto] = memoryManager->allocate<PropertyListPrototype>();
505
506 Scoped<InternalClass> argsClass(scope);
507 argsClass = newInternalClass(vtable: ArgumentsObject::staticVTable(), prototype: objectPrototype());
508 argsClass = argsClass->addMember(identifier: id_length()->propertyKey(), data: Attr_NotEnumerable);
509 argsClass = argsClass->addMember(identifier: symbol_iterator()->propertyKey(), data: Attr_Data|Attr_NotEnumerable);
510 classes[Class_ArgumentsObject] = argsClass->addMember(identifier: id_callee()->propertyKey(), data: Attr_Data|Attr_NotEnumerable);
511 argsClass = newInternalClass(vtable: StrictArgumentsObject::staticVTable(), prototype: objectPrototype());
512 argsClass = argsClass->addMember(identifier: id_length()->propertyKey(), data: Attr_NotEnumerable);
513 argsClass = argsClass->addMember(identifier: symbol_iterator()->propertyKey(), data: Attr_Data|Attr_NotEnumerable);
514 classes[Class_StrictArgumentsObject] = argsClass->addMember(identifier: id_callee()->propertyKey(), data: Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
515
516 *static_cast<Value *>(globalObject) = newObject();
517 Q_ASSERT(globalObject->d()->vtable());
518 initRootContext();
519
520 ic = newInternalClass(vtable: QV4::StringObject::staticVTable(), prototype: objectPrototype());
521 ic = ic->addMember(identifier: id_length()->propertyKey(), data: Attr_ReadOnly);
522 classes[Class_StringObject] = ic->changePrototype(proto: stringPrototype()->d());
523 Q_ASSERT(classes[Class_StringObject]->verifyIndex(id_length()->propertyKey(), Heap::StringObject::LengthPropertyIndex));
524
525 classes[Class_SymbolObject] = newInternalClass(vtable: QV4::SymbolObject::staticVTable(), prototype: symbolPrototype());
526
527 jsObjects[NumberProto] = memoryManager->allocate<NumberPrototype>();
528 jsObjects[BooleanProto] = memoryManager->allocate<BooleanPrototype>();
529 jsObjects[DateProto] = memoryManager->allocate<DatePrototype>();
530
531#if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
532 InternalClassEntry *index = nullptr;
533#else
534 InternalClassEntry _index;
535 auto *index = &_index;
536#endif
537 ic = newInternalClass(vtable: QV4::FunctionPrototype::staticVTable(), prototype: objectPrototype());
538 auto addProtoHasInstance = [&] {
539 // Add an invalid prototype slot, so that all function objects have the same layout
540 // This helps speed up instanceof operations and other things where we need to query
541 // prototype property (as we always know it's location)
542 ic = ic->addMember(identifier: id_prototype()->propertyKey(), data: Attr_Invalid, entry: index);
543 Q_ASSERT(index->index == Heap::FunctionObject::Index_Prototype);
544 // add an invalid @hasInstance slot, so that we can quickly track whether the
545 // hasInstance method has been reimplemented. This is required for a fast
546 // instanceof implementation
547 ic = ic->addMember(identifier: symbol_hasInstance()->propertyKey(), data: Attr_Invalid, entry: index);
548 Q_ASSERT(index->index == Heap::FunctionObject::Index_HasInstance);
549 };
550 addProtoHasInstance();
551 jsObjects[FunctionProto] = memoryManager->allocObject<FunctionPrototype>(ic: ic->d());
552 ic = newInternalClass(vtable: FunctionObject::staticVTable(), prototype: functionPrototype());
553 addProtoHasInstance();
554 classes[Class_FunctionObject] = ic->d();
555 ic = ic->addMember(identifier: id_name()->propertyKey(), data: Attr_ReadOnly, entry: index);
556 Q_ASSERT(index->index == Heap::ArrowFunction::Index_Name);
557 ic = ic->addMember(identifier: id_length()->propertyKey(), data: Attr_ReadOnly_ButConfigurable, entry: index);
558 Q_ASSERT(index->index == Heap::ArrowFunction::Index_Length);
559 classes[Class_ArrowFunction] = ic->changeVTable(vt: ArrowFunction::staticVTable());
560 ic = ic->changeVTable(vt: MemberFunction::staticVTable());
561 classes[Class_MemberFunction] = ic->d();
562 ic = ic->changeVTable(vt: GeneratorFunction::staticVTable());
563 classes[Class_GeneratorFunction] = ic->d();
564 ic = ic->changeVTable(vt: MemberGeneratorFunction::staticVTable());
565 classes[Class_MemberGeneratorFunction] = ic->d();
566
567 ic = ic->changeMember(identifier: id_prototype()->propertyKey(), data: Attr_NotConfigurable|Attr_NotEnumerable);
568 ic = ic->changeVTable(vt: ScriptFunction::staticVTable());
569 classes[Class_ScriptFunction] = ic->d();
570 ic = ic->changeVTable(vt: ConstructorFunction::staticVTable());
571 classes[Class_ConstructorFunction] = ic->d();
572
573 classes[Class_ObjectProto] = classes[Class_Object]->addMember(identifier: id_constructor()->propertyKey(), data: Attr_NotEnumerable, entry: index);
574 Q_ASSERT(index->index == Heap::FunctionObject::Index_ProtoConstructor);
575
576 jsObjects[GeneratorProto] = memoryManager->allocObject<GeneratorPrototype>(ic: classes[Class_Object]);
577 classes[Class_GeneratorObject] = newInternalClass(vtable: QV4::GeneratorObject::staticVTable(), prototype: generatorPrototype());
578
579 ScopedString str(scope);
580 classes[Class_RegExp] = classes[Class_Empty]->changeVTable(vt: QV4::RegExp::staticVTable());
581 ic = newInternalClass(vtable: QV4::RegExpObject::staticVTable(), prototype: objectPrototype());
582 ic = ic->addMember(identifier: id_lastIndex()->propertyKey(), data: Attr_NotEnumerable|Attr_NotConfigurable, entry: index);
583 Q_ASSERT(index->index == RegExpObject::Index_LastIndex);
584 jsObjects[RegExpProto] = memoryManager->allocObject<RegExpPrototype>(ic: classes[Class_Object]);
585 classes[Class_RegExpObject] = ic->changePrototype(proto: regExpPrototype()->d());
586
587 ic = classes[Class_ArrayObject]->addMember(identifier: id_index()->propertyKey(), data: Attr_Data, entry: index);
588 Q_ASSERT(index->index == RegExpObject::Index_ArrayIndex);
589 classes[Class_RegExpExecArray] = ic->addMember(identifier: id_input()->propertyKey(), data: Attr_Data, entry: index);
590 Q_ASSERT(index->index == RegExpObject::Index_ArrayInput);
591
592 ic = newInternalClass(vtable: ErrorObject::staticVTable(), prototype: nullptr);
593 ic = ic->addMember(identifier: (str = newIdentifier(QStringLiteral("stack")))->propertyKey(), data: Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable, entry: index);
594 Q_ASSERT(index->index == ErrorObject::Index_Stack);
595 Q_ASSERT(index->setterIndex == ErrorObject::Index_StackSetter);
596 ic = ic->addMember(identifier: (str = newIdentifier(QStringLiteral("fileName")))->propertyKey(), data: Attr_Data|Attr_NotEnumerable, entry: index);
597 Q_ASSERT(index->index == ErrorObject::Index_FileName);
598 ic = ic->addMember(identifier: (str = newIdentifier(QStringLiteral("lineNumber")))->propertyKey(), data: Attr_Data|Attr_NotEnumerable, entry: index);
599 classes[Class_ErrorObject] = ic->d();
600 Q_ASSERT(index->index == ErrorObject::Index_LineNumber);
601 classes[Class_ErrorObjectWithMessage] = ic->addMember(identifier: (str = newIdentifier(QStringLiteral("message")))->propertyKey(), data: Attr_Data|Attr_NotEnumerable, entry: index);
602 Q_ASSERT(index->index == ErrorObject::Index_Message);
603 ic = newInternalClass(vtable: Object::staticVTable(), prototype: objectPrototype());
604 ic = ic->addMember(identifier: id_constructor()->propertyKey(), data: Attr_Data|Attr_NotEnumerable, entry: index);
605 Q_ASSERT(index->index == ErrorPrototype::Index_Constructor);
606 ic = ic->addMember(identifier: (str = newIdentifier(QStringLiteral("message")))->propertyKey(), data: Attr_Data|Attr_NotEnumerable, entry: index);
607 Q_ASSERT(index->index == ErrorPrototype::Index_Message);
608 classes[Class_ErrorProto] = ic->addMember(identifier: id_name()->propertyKey(), data: Attr_Data|Attr_NotEnumerable, entry: index);
609 Q_ASSERT(index->index == ErrorPrototype::Index_Name);
610
611 classes[Class_ProxyObject] = classes[Class_Empty]->changeVTable(vt: ProxyObject::staticVTable());
612 classes[Class_ProxyFunctionObject] = classes[Class_Empty]->changeVTable(vt: ProxyFunctionObject::staticVTable());
613
614 jsObjects[GetStack_Function] = FunctionObject::createBuiltinFunction(engine: this, nameOrSymbol: str = newIdentifier(QStringLiteral("stack")), code: ErrorObject::method_get_stack, argumentCount: 0);
615
616 jsObjects[ErrorProto] = memoryManager->allocObject<ErrorPrototype>(ic: classes[Class_ErrorProto]);
617 ic = classes[Class_ErrorProto]->changePrototype(proto: errorPrototype()->d());
618 jsObjects[EvalErrorProto] = memoryManager->allocObject<EvalErrorPrototype>(ic: ic->d());
619 jsObjects[RangeErrorProto] = memoryManager->allocObject<RangeErrorPrototype>(ic: ic->d());
620 jsObjects[ReferenceErrorProto] = memoryManager->allocObject<ReferenceErrorPrototype>(ic: ic->d());
621 jsObjects[SyntaxErrorProto] = memoryManager->allocObject<SyntaxErrorPrototype>(ic: ic->d());
622 jsObjects[TypeErrorProto] = memoryManager->allocObject<TypeErrorPrototype>(ic: ic->d());
623 jsObjects[URIErrorProto] = memoryManager->allocObject<URIErrorPrototype>(ic: ic->d());
624
625 jsObjects[VariantProto] = memoryManager->allocate<VariantPrototype>();
626 Q_ASSERT(variantPrototype()->getPrototypeOf() == objectPrototype()->d());
627
628 ic = newInternalClass(vtable: SequencePrototype::staticVTable(), prototype: SequencePrototype::defaultPrototype(e: this));
629 jsObjects[SequenceProto] = ScopedValue(scope, memoryManager->allocObject<SequencePrototype>(ic: ic->d()));
630
631 jsObjects[Object_Ctor] = memoryManager->allocate<ObjectCtor>(args: this);
632 jsObjects[String_Ctor] = memoryManager->allocate<StringCtor>(args: this);
633 jsObjects[Symbol_Ctor] = memoryManager->allocate<SymbolCtor>(args: this);
634 jsObjects[Number_Ctor] = memoryManager->allocate<NumberCtor>(args: this);
635 jsObjects[Boolean_Ctor] = memoryManager->allocate<BooleanCtor>(args: this);
636 jsObjects[Array_Ctor] = memoryManager->allocate<ArrayCtor>(args: this);
637 jsObjects[Function_Ctor] = memoryManager->allocate<FunctionCtor>(args: this);
638 jsObjects[GeneratorFunction_Ctor] = memoryManager->allocate<GeneratorFunctionCtor>(args: this);
639 jsObjects[Date_Ctor] = memoryManager->allocate<DateCtor>(args: this);
640 jsObjects[RegExp_Ctor] = memoryManager->allocate<RegExpCtor>(args: this);
641 jsObjects[Error_Ctor] = memoryManager->allocate<ErrorCtor>(args: this);
642 jsObjects[EvalError_Ctor] = memoryManager->allocate<EvalErrorCtor>(args: this);
643 jsObjects[RangeError_Ctor] = memoryManager->allocate<RangeErrorCtor>(args: this);
644 jsObjects[ReferenceError_Ctor] = memoryManager->allocate<ReferenceErrorCtor>(args: this);
645 jsObjects[SyntaxError_Ctor] = memoryManager->allocate<SyntaxErrorCtor>(args: this);
646 jsObjects[TypeError_Ctor] = memoryManager->allocate<TypeErrorCtor>(args: this);
647 jsObjects[URIError_Ctor] = memoryManager->allocate<URIErrorCtor>(args: this);
648 jsObjects[IteratorProto] = memoryManager->allocate<IteratorPrototype>();
649
650 ic = newInternalClass(vtable: ForInIteratorPrototype::staticVTable(), prototype: iteratorPrototype());
651 jsObjects[ForInIteratorProto] = memoryManager->allocObject<ForInIteratorPrototype>(ic);
652 ic = newInternalClass(vtable: SetIteratorPrototype::staticVTable(), prototype: iteratorPrototype());
653 jsObjects[MapIteratorProto] = memoryManager->allocObject<MapIteratorPrototype>(ic);
654 ic = newInternalClass(vtable: SetIteratorPrototype::staticVTable(), prototype: iteratorPrototype());
655 jsObjects[SetIteratorProto] = memoryManager->allocObject<SetIteratorPrototype>(ic);
656 ic = newInternalClass(vtable: ArrayIteratorPrototype::staticVTable(), prototype: iteratorPrototype());
657 jsObjects[ArrayIteratorProto] = memoryManager->allocObject<ArrayIteratorPrototype>(ic);
658 ic = newInternalClass(vtable: StringIteratorPrototype::staticVTable(), prototype: iteratorPrototype());
659 jsObjects[StringIteratorProto] = memoryManager->allocObject<StringIteratorPrototype>(ic);
660
661 //
662 // url
663 //
664
665 jsObjects[Url_Ctor] = memoryManager->allocate<UrlCtor>(args: this);
666 jsObjects[UrlProto] = memoryManager->allocate<UrlPrototype>();
667 jsObjects[UrlSearchParams_Ctor] = memoryManager->allocate<UrlSearchParamsCtor>(args: this);
668 jsObjects[UrlSearchParamsProto] = memoryManager->allocate<UrlSearchParamsPrototype>();
669
670 str = newString(QStringLiteral("get [Symbol.species]"));
671 jsObjects[GetSymbolSpecies] = FunctionObject::createBuiltinFunction(engine: this, nameOrSymbol: str, code: ArrayPrototype::method_get_species, argumentCount: 0);
672
673 static_cast<ObjectPrototype *>(objectPrototype())->init(engine: this, ctor: objectCtor());
674 static_cast<StringPrototype *>(stringPrototype())->init(engine: this, ctor: stringCtor());
675 static_cast<SymbolPrototype *>(symbolPrototype())->init(engine: this, ctor: symbolCtor());
676 static_cast<NumberPrototype *>(numberPrototype())->init(engine: this, ctor: numberCtor());
677 static_cast<BooleanPrototype *>(booleanPrototype())->init(engine: this, ctor: booleanCtor());
678 static_cast<ArrayPrototype *>(arrayPrototype())->init(engine: this, ctor: arrayCtor());
679 static_cast<PropertyListPrototype *>(propertyListPrototype())->init();
680 static_cast<DatePrototype *>(datePrototype())->init(engine: this, ctor: dateCtor());
681 static_cast<FunctionPrototype *>(functionPrototype())->init(engine: this, ctor: functionCtor());
682 static_cast<GeneratorPrototype *>(generatorPrototype())->init(engine: this, ctor: generatorFunctionCtor());
683 static_cast<RegExpPrototype *>(regExpPrototype())->init(engine: this, ctor: regExpCtor());
684 static_cast<ErrorPrototype *>(errorPrototype())->init(engine: this, ctor: errorCtor());
685 static_cast<EvalErrorPrototype *>(evalErrorPrototype())->init(engine: this, ctor: evalErrorCtor());
686 static_cast<RangeErrorPrototype *>(rangeErrorPrototype())->init(engine: this, ctor: rangeErrorCtor());
687 static_cast<ReferenceErrorPrototype *>(referenceErrorPrototype())->init(engine: this, ctor: referenceErrorCtor());
688 static_cast<SyntaxErrorPrototype *>(syntaxErrorPrototype())->init(engine: this, ctor: syntaxErrorCtor());
689 static_cast<TypeErrorPrototype *>(typeErrorPrototype())->init(engine: this, ctor: typeErrorCtor());
690 static_cast<URIErrorPrototype *>(uRIErrorPrototype())->init(engine: this, ctor: uRIErrorCtor());
691 static_cast<UrlPrototype *>(urlPrototype())->init(engine: this, ctor: urlCtor());
692 static_cast<UrlSearchParamsPrototype *>(urlSearchParamsPrototype())->init(engine: this, ctor: urlSearchParamsCtor());
693
694 static_cast<IteratorPrototype *>(iteratorPrototype())->init(engine: this);
695 static_cast<ForInIteratorPrototype *>(forInIteratorPrototype())->init(engine: this);
696 static_cast<MapIteratorPrototype *>(mapIteratorPrototype())->init(engine: this);
697 static_cast<SetIteratorPrototype *>(setIteratorPrototype())->init(engine: this);
698 static_cast<ArrayIteratorPrototype *>(arrayIteratorPrototype())->init(engine: this);
699 static_cast<StringIteratorPrototype *>(stringIteratorPrototype())->init(engine: this);
700
701 static_cast<VariantPrototype *>(variantPrototype())->init();
702
703 sequencePrototype()->cast<SequencePrototype>()->init();
704
705 jsObjects[WeakMap_Ctor] = memoryManager->allocate<WeakMapCtor>(args: this);
706 jsObjects[WeakMapProto] = memoryManager->allocate<WeakMapPrototype>();
707 static_cast<WeakMapPrototype *>(weakMapPrototype())->init(engine: this, ctor: weakMapCtor());
708
709 jsObjects[Map_Ctor] = memoryManager->allocate<MapCtor>(args: this);
710 jsObjects[MapProto] = memoryManager->allocate<MapPrototype>();
711 static_cast<MapPrototype *>(mapPrototype())->init(engine: this, ctor: mapCtor());
712
713 jsObjects[WeakSet_Ctor] = memoryManager->allocate<WeakSetCtor>(args: this);
714 jsObjects[WeakSetProto] = memoryManager->allocate<WeakSetPrototype>();
715 static_cast<WeakSetPrototype *>(weakSetPrototype())->init(engine: this, ctor: weakSetCtor());
716
717 jsObjects[Set_Ctor] = memoryManager->allocate<SetCtor>(args: this);
718 jsObjects[SetProto] = memoryManager->allocate<SetPrototype>();
719 static_cast<SetPrototype *>(setPrototype())->init(engine: this, ctor: setCtor());
720
721 //
722 // promises
723 //
724
725 jsObjects[Promise_Ctor] = memoryManager->allocate<PromiseCtor>(args: this);
726 jsObjects[PromiseProto] = memoryManager->allocate<PromisePrototype>();
727 static_cast<PromisePrototype *>(promisePrototype())->init(engine: this, ctor: promiseCtor());
728
729 // typed arrays
730
731 jsObjects[SharedArrayBuffer_Ctor] = memoryManager->allocate<SharedArrayBufferCtor>(args: this);
732 jsObjects[SharedArrayBufferProto] = memoryManager->allocate<SharedArrayBufferPrototype>();
733 static_cast<SharedArrayBufferPrototype *>(sharedArrayBufferPrototype())->init(engine: this, ctor: sharedArrayBufferCtor());
734
735 jsObjects[ArrayBuffer_Ctor] = memoryManager->allocate<ArrayBufferCtor>(args: this);
736 jsObjects[ArrayBufferProto] = memoryManager->allocate<ArrayBufferPrototype>();
737 static_cast<ArrayBufferPrototype *>(arrayBufferPrototype())->init(engine: this, ctor: arrayBufferCtor());
738
739 jsObjects[DataView_Ctor] = memoryManager->allocate<DataViewCtor>(args: this);
740 jsObjects[DataViewProto] = memoryManager->allocate<DataViewPrototype>();
741 static_cast<DataViewPrototype *>(dataViewPrototype())->init(engine: this, ctor: dataViewCtor());
742 jsObjects[ValueTypeProto] = (Heap::Base *) nullptr;
743 jsObjects[SignalHandlerProto] = (Heap::Base *) nullptr;
744 jsObjects[TypeWrapperProto] = (Heap::Base *) nullptr;
745
746 jsObjects[IntrinsicTypedArray_Ctor] = memoryManager->allocate<IntrinsicTypedArrayCtor>(args: this);
747 jsObjects[IntrinsicTypedArrayProto] = memoryManager->allocate<IntrinsicTypedArrayPrototype>();
748 static_cast<IntrinsicTypedArrayPrototype *>(intrinsicTypedArrayPrototype())
749 ->init(engine: this, ctor: static_cast<IntrinsicTypedArrayCtor *>(intrinsicTypedArrayCtor()));
750
751 for (int i = 0; i < NTypedArrayTypes; ++i) {
752 static_cast<Value &>(typedArrayCtors[i]) = memoryManager->allocate<TypedArrayCtor>(args: this, args: Heap::TypedArray::Type(i));
753 static_cast<Value &>(typedArrayPrototype[i]) = memoryManager->allocate<TypedArrayPrototype>(args: Heap::TypedArray::Type(i));
754 typedArrayPrototype[i].as<TypedArrayPrototype>()->init(engine: this, ctor: static_cast<TypedArrayCtor *>(typedArrayCtors[i].as<Object>()));
755 }
756
757 //
758 // set up the global object
759 //
760 rootContext()->d()->activation.set(e: scope.engine, newVal: globalObject->d());
761 Q_ASSERT(globalObject->d()->vtable());
762
763 globalObject->defineDefaultProperty(QStringLiteral("Object"), value: *objectCtor());
764 globalObject->defineDefaultProperty(QStringLiteral("String"), value: *stringCtor());
765 globalObject->defineDefaultProperty(QStringLiteral("Symbol"), value: *symbolCtor());
766 FunctionObject *numberObject = numberCtor();
767 globalObject->defineDefaultProperty(QStringLiteral("Number"), value: *numberObject);
768 globalObject->defineDefaultProperty(QStringLiteral("Boolean"), value: *booleanCtor());
769 globalObject->defineDefaultProperty(QStringLiteral("Array"), value: *arrayCtor());
770 globalObject->defineDefaultProperty(QStringLiteral("Function"), value: *functionCtor());
771 globalObject->defineDefaultProperty(QStringLiteral("Date"), value: *dateCtor());
772 globalObject->defineDefaultProperty(QStringLiteral("RegExp"), value: *regExpCtor());
773 globalObject->defineDefaultProperty(QStringLiteral("Error"), value: *errorCtor());
774 globalObject->defineDefaultProperty(QStringLiteral("EvalError"), value: *evalErrorCtor());
775 globalObject->defineDefaultProperty(QStringLiteral("RangeError"), value: *rangeErrorCtor());
776 globalObject->defineDefaultProperty(QStringLiteral("ReferenceError"), value: *referenceErrorCtor());
777 globalObject->defineDefaultProperty(QStringLiteral("SyntaxError"), value: *syntaxErrorCtor());
778 globalObject->defineDefaultProperty(QStringLiteral("TypeError"), value: *typeErrorCtor());
779 globalObject->defineDefaultProperty(QStringLiteral("URIError"), value: *uRIErrorCtor());
780 globalObject->defineDefaultProperty(QStringLiteral("Promise"), value: *promiseCtor());
781 globalObject->defineDefaultProperty(QStringLiteral("URL"), value: *urlCtor());
782 globalObject->defineDefaultProperty(QStringLiteral("URLSearchParams"), value: *urlSearchParamsCtor());
783
784 globalObject->defineDefaultProperty(QStringLiteral("SharedArrayBuffer"), value: *sharedArrayBufferCtor());
785 globalObject->defineDefaultProperty(QStringLiteral("ArrayBuffer"), value: *arrayBufferCtor());
786 globalObject->defineDefaultProperty(QStringLiteral("DataView"), value: *dataViewCtor());
787 globalObject->defineDefaultProperty(QStringLiteral("WeakSet"), value: *weakSetCtor());
788 globalObject->defineDefaultProperty(QStringLiteral("Set"), value: *setCtor());
789 globalObject->defineDefaultProperty(QStringLiteral("WeakMap"), value: *weakMapCtor());
790 globalObject->defineDefaultProperty(QStringLiteral("Map"), value: *mapCtor());
791
792 for (int i = 0; i < NTypedArrayTypes; ++i)
793 globalObject->defineDefaultProperty(name: (str = typedArrayCtors[i].as<FunctionObject>()->name()), value: typedArrayCtors[i]);
794 ScopedObject o(scope);
795 globalObject->defineDefaultProperty(QStringLiteral("Atomics"), value: (o = memoryManager->allocate<Atomics>()));
796 globalObject->defineDefaultProperty(QStringLiteral("Math"), value: (o = memoryManager->allocate<MathObject>()));
797 globalObject->defineDefaultProperty(QStringLiteral("JSON"), value: (o = memoryManager->allocate<JsonObject>()));
798 globalObject->defineDefaultProperty(QStringLiteral("Reflect"), value: (o = memoryManager->allocate<Reflect>()));
799 globalObject->defineDefaultProperty(QStringLiteral("Proxy"), value: (o = memoryManager->allocate<Proxy>(args: this)));
800
801 globalObject->defineReadonlyProperty(QStringLiteral("undefined"), value: Value::undefinedValue());
802 globalObject->defineReadonlyProperty(QStringLiteral("NaN"), value: Value::fromDouble(d: std::numeric_limits<double>::quiet_NaN()));
803 globalObject->defineReadonlyProperty(QStringLiteral("Infinity"), value: Value::fromDouble(Q_INFINITY));
804
805
806 jsObjects[Eval_Function] = memoryManager->allocate<EvalFunction>(args: this);
807 globalObject->defineDefaultProperty(QStringLiteral("eval"), value: *evalFunction());
808
809 // ES6: 20.1.2.12 & 20.1.2.13:
810 // parseInt and parseFloat must be the same FunctionObject on the global &
811 // Number object.
812 {
813 QString piString(QStringLiteral("parseInt"));
814 QString pfString(QStringLiteral("parseFloat"));
815 Scope scope(this);
816 ScopedString pi(scope, newIdentifier(text: piString));
817 ScopedString pf(scope, newIdentifier(text: pfString));
818 ScopedFunctionObject parseIntFn(scope, FunctionObject::createBuiltinFunction(engine: this, nameOrSymbol: pi, code: GlobalFunctions::method_parseInt, argumentCount: 2));
819 ScopedFunctionObject parseFloatFn(scope, FunctionObject::createBuiltinFunction(engine: this, nameOrSymbol: pf, code: GlobalFunctions::method_parseFloat, argumentCount: 1));
820 globalObject->defineDefaultProperty(name: piString, value: parseIntFn);
821 globalObject->defineDefaultProperty(name: pfString, value: parseFloatFn);
822 numberObject->defineDefaultProperty(name: piString, value: parseIntFn);
823 numberObject->defineDefaultProperty(name: pfString, value: parseFloatFn);
824 }
825
826 globalObject->defineDefaultProperty(QStringLiteral("isNaN"), code: GlobalFunctions::method_isNaN, argumentCount: 1);
827 globalObject->defineDefaultProperty(QStringLiteral("isFinite"), code: GlobalFunctions::method_isFinite, argumentCount: 1);
828 globalObject->defineDefaultProperty(QStringLiteral("decodeURI"), code: GlobalFunctions::method_decodeURI, argumentCount: 1);
829 globalObject->defineDefaultProperty(QStringLiteral("decodeURIComponent"), code: GlobalFunctions::method_decodeURIComponent, argumentCount: 1);
830 globalObject->defineDefaultProperty(QStringLiteral("encodeURI"), code: GlobalFunctions::method_encodeURI, argumentCount: 1);
831 globalObject->defineDefaultProperty(QStringLiteral("encodeURIComponent"), code: GlobalFunctions::method_encodeURIComponent, argumentCount: 1);
832 globalObject->defineDefaultProperty(QStringLiteral("escape"), code: GlobalFunctions::method_escape, argumentCount: 1);
833 globalObject->defineDefaultProperty(QStringLiteral("unescape"), code: GlobalFunctions::method_unescape, argumentCount: 1);
834
835 ScopedFunctionObject t(
836 scope,
837 memoryManager->allocate<DynamicFunctionObject>(args: this, args: nullptr, args&: ::throwTypeError));
838 t->defineReadonlyProperty(name: id_length(), value: Value::fromInt32(i: 0));
839 t->setInternalClass(t->internalClass()->cryopreserved());
840 jsObjects[ThrowerObject] = t;
841
842 ScopedProperty pd(scope);
843 pd->value = thrower();
844 pd->set = thrower();
845 functionPrototype()->insertMember(s: id_caller(), p: pd, attributes: Attr_Accessor|Attr_ReadOnly_ButConfigurable);
846 functionPrototype()->insertMember(s: id_arguments(), p: pd, attributes: Attr_Accessor|Attr_ReadOnly_ButConfigurable);
847
848 QV4::QObjectWrapper::initializeBindings(engine: this);
849
850 m_delayedCallQueue.init(this);
851 isInitialized = true;
852}
853
854ExecutionEngine::~ExecutionEngine()
855{
856 for (auto val : nativeModules) {
857 PersistentValueStorage::free(v: val);
858 }
859 nativeModules.clear();
860 qDeleteAll(c: m_extensionData);
861 delete m_multiplyWrappedQObjects;
862 m_multiplyWrappedQObjects = nullptr;
863 delete identifierTable;
864 delete memoryManager;
865
866 for (const auto &cu : std::as_const(t&: m_compilationUnits)) {
867 Q_ASSERT(cu->engine == this);
868 cu->clear();
869 cu->engine = nullptr;
870 }
871 m_compilationUnits.clear();
872
873 delete bumperPointerAllocator;
874 delete regExpCache;
875 delete regExpAllocator;
876 delete executableAllocator;
877 jsStack->deallocate();
878 delete jsStack;
879 gcStack->deallocate();
880 delete gcStack;
881
882#if QT_CONFIG(qml_xml_http_request)
883 qt_rem_qmlxmlhttprequest(engine: this, m_xmlHttpRequestData);
884 m_xmlHttpRequestData = nullptr;
885#endif
886}
887
888#if QT_CONFIG(qml_debug)
889void ExecutionEngine::setDebugger(Debugging::Debugger *debugger)
890{
891 Q_ASSERT(!m_debugger);
892 m_debugger.reset(other: debugger);
893}
894
895void ExecutionEngine::setProfiler(Profiling::Profiler *profiler)
896{
897 Q_ASSERT(!m_profiler);
898 m_profiler.reset(other: profiler);
899}
900
901void ExecutionEngine::setPreviewing(bool enabled)
902{
903 hasPreview.storeRelease(newValue: enabled);
904}
905
906#endif // QT_CONFIG(qml_debug)
907
908void ExecutionEngine::initRootContext()
909{
910 Scope scope(this);
911 Scoped<ExecutionContext> r(scope, memoryManager->allocManaged<ExecutionContext>());
912 r->d_unchecked()->init(t: Heap::ExecutionContext::Type_GlobalContext);
913 r->d()->activation.set(e: this, newVal: globalObject->d());
914 jsObjects[RootContext] = r;
915 jsObjects[ScriptContext] = r;
916 jsObjects[IntegerNull] = Encode((int)0);
917}
918
919Heap::InternalClass *ExecutionEngine::newClass(Heap::InternalClass *other)
920{
921 Heap::InternalClass *ic = memoryManager->allocIC<InternalClass>();
922 ic->init(other);
923 return ic;
924}
925
926Heap::InternalClass *ExecutionEngine::newInternalClass(const VTable *vtable, Object *prototype)
927{
928 Scope scope(this);
929 Scoped<InternalClass> ic(scope, internalClasses(icType: Class_Empty)->changeVTable(vt: vtable));
930 return ic->changePrototype(proto: prototype ? prototype->d() : nullptr);
931}
932
933Heap::Object *ExecutionEngine::newObject()
934{
935 return memoryManager->allocate<Object>();
936}
937
938Heap::Object *ExecutionEngine::newObject(Heap::InternalClass *internalClass)
939{
940 return memoryManager->allocObject<Object>(ic: internalClass);
941}
942
943Heap::String *ExecutionEngine::newString(const QString &s)
944{
945 return memoryManager->allocWithStringData<String>(unmanagedSize: s.size() * sizeof(QChar), arg1: s);
946}
947
948Heap::String *ExecutionEngine::newIdentifier(const QString &text)
949{
950 Scope scope(this);
951 ScopedString s(scope, memoryManager->allocWithStringData<String>(unmanagedSize: text.size() * sizeof(QChar), arg1: text));
952 s->toPropertyKey();
953 return s->d();
954}
955
956Heap::Object *ExecutionEngine::newStringObject(const String *string)
957{
958 return memoryManager->allocate<StringObject>(args&: string);
959}
960
961Heap::Object *ExecutionEngine::newSymbolObject(const Symbol *symbol)
962{
963 return memoryManager->allocObject<SymbolObject>(ic: classes[Class_SymbolObject], args&: symbol);
964}
965
966Heap::Object *ExecutionEngine::newNumberObject(double value)
967{
968 return memoryManager->allocate<NumberObject>(args&: value);
969}
970
971Heap::Object *ExecutionEngine::newBooleanObject(bool b)
972{
973 return memoryManager->allocate<BooleanObject>(args&: b);
974}
975
976Heap::ArrayObject *ExecutionEngine::newArrayObject(int count)
977{
978 Scope scope(this);
979 ScopedArrayObject object(scope, memoryManager->allocate<ArrayObject>());
980
981 if (count) {
982 if (count < 0x1000)
983 object->arrayReserve(n: count);
984 object->setArrayLengthUnchecked(count);
985 }
986 return object->d();
987}
988
989Heap::ArrayObject *ExecutionEngine::newArrayObject(const Value *values, int length)
990{
991 Scope scope(this);
992 ScopedArrayObject a(scope, memoryManager->allocate<ArrayObject>());
993
994 if (length) {
995 size_t size = sizeof(Heap::ArrayData) + (length-1)*sizeof(Value);
996 Heap::SimpleArrayData *d = scope.engine->memoryManager->allocManaged<SimpleArrayData>(size);
997 d->init();
998 d->type = Heap::ArrayData::Simple;
999 d->offset = 0;
1000 d->values.alloc = length;
1001 d->values.size = length;
1002 // this doesn't require a write barrier, things will be ok, when the new array data gets inserted into
1003 // the parent object
1004 memcpy(dest: &d->values.values, src: values, n: length*sizeof(Value));
1005 a->d()->arrayData.set(e: this, newVal: d);
1006 a->setArrayLengthUnchecked(length);
1007 }
1008 return a->d();
1009}
1010
1011Heap::ArrayObject *ExecutionEngine::newArrayObject(const QStringList &list)
1012{
1013 return memoryManager->allocate<ArrayObject>(args: list);
1014}
1015
1016Heap::ArrayObject *ExecutionEngine::newArrayObject(Heap::InternalClass *internalClass)
1017{
1018 return memoryManager->allocObject<ArrayObject>(ic: internalClass);
1019}
1020
1021Heap::ArrayBuffer *ExecutionEngine::newArrayBuffer(const QByteArray &array)
1022{
1023 return memoryManager->allocate<ArrayBuffer>(args: array);
1024}
1025
1026Heap::ArrayBuffer *ExecutionEngine::newArrayBuffer(size_t length)
1027{
1028 return memoryManager->allocate<ArrayBuffer>(args&: length);
1029}
1030
1031Heap::DateObject *ExecutionEngine::newDateObject(double dateTime)
1032{
1033 return memoryManager->allocate<DateObject>(args&: dateTime);
1034}
1035
1036Heap::DateObject *ExecutionEngine::newDateObject(const QDateTime &dateTime)
1037{
1038 return memoryManager->allocate<DateObject>(args: dateTime);
1039}
1040
1041Heap::DateObject *ExecutionEngine::newDateObject(
1042 QDate date, Heap::Object *parent, int index, uint flags)
1043{
1044 return memoryManager->allocate<DateObject>(
1045 args&: date, args&: parent, args&: index, args: Heap::ReferenceObject::Flags(flags));
1046}
1047
1048Heap::DateObject *ExecutionEngine::newDateObject(
1049 QTime time, Heap::Object *parent, int index, uint flags)
1050{
1051 return memoryManager->allocate<DateObject>(
1052 args&: time, args&: parent, args&: index, args: Heap::ReferenceObject::Flags(flags));
1053}
1054
1055Heap::DateObject *ExecutionEngine::newDateObject(
1056 QDateTime dateTime, Heap::Object *parent, int index, uint flags)
1057{
1058 return memoryManager->allocate<DateObject>(
1059 args&: dateTime, args&: parent, args&: index, args: Heap::ReferenceObject::Flags(flags));
1060}
1061
1062Heap::RegExpObject *ExecutionEngine::newRegExpObject(const QString &pattern, int flags)
1063{
1064 Scope scope(this);
1065 Scoped<RegExp> re(scope, RegExp::create(engine: this, pattern, flags: static_cast<CompiledData::RegExp::Flags>(flags)));
1066 return newRegExpObject(re);
1067}
1068
1069Heap::RegExpObject *ExecutionEngine::newRegExpObject(RegExp *re)
1070{
1071 return memoryManager->allocate<RegExpObject>(args&: re);
1072}
1073
1074#if QT_CONFIG(regularexpression)
1075Heap::RegExpObject *ExecutionEngine::newRegExpObject(const QRegularExpression &re)
1076{
1077 return memoryManager->allocate<RegExpObject>(args: re);
1078}
1079#endif
1080
1081Heap::UrlObject *ExecutionEngine::newUrlObject()
1082{
1083 return memoryManager->allocate<UrlObject>();
1084}
1085
1086Heap::UrlObject *ExecutionEngine::newUrlObject(const QUrl &url)
1087{
1088 Scope scope(this);
1089 Scoped<UrlObject> urlObject(scope, newUrlObject());
1090 urlObject->setUrl(url);
1091 return urlObject->d();
1092}
1093
1094Heap::UrlSearchParamsObject *ExecutionEngine::newUrlSearchParamsObject()
1095{
1096 return memoryManager->allocate<UrlSearchParamsObject>();
1097}
1098
1099Heap::Object *ExecutionEngine::newErrorObject(const Value &value)
1100{
1101 return ErrorObject::create<ErrorObject>(e: this, message: value, newTarget: errorCtor());
1102}
1103
1104Heap::Object *ExecutionEngine::newErrorObject(const QString &message)
1105{
1106 return ErrorObject::create<ErrorObject>(e: this, message);
1107}
1108
1109Heap::Object *ExecutionEngine::newSyntaxErrorObject(const QString &message)
1110{
1111 return ErrorObject::create<SyntaxErrorObject>(e: this, message);
1112}
1113
1114Heap::Object *ExecutionEngine::newSyntaxErrorObject(const QString &message, const QString &fileName, int line, int column)
1115{
1116 return ErrorObject::create<SyntaxErrorObject>(e: this, message, filename: fileName, line, column);
1117}
1118
1119
1120Heap::Object *ExecutionEngine::newReferenceErrorObject(const QString &message)
1121{
1122 return ErrorObject::create<ReferenceErrorObject>(e: this, message);
1123}
1124
1125Heap::Object *ExecutionEngine::newReferenceErrorObject(const QString &message, const QString &fileName, int line, int column)
1126{
1127 return ErrorObject::create<ReferenceErrorObject>(e: this, message, filename: fileName, line, column);
1128}
1129
1130
1131Heap::Object *ExecutionEngine::newTypeErrorObject(const QString &message)
1132{
1133 return ErrorObject::create<TypeErrorObject>(e: this, message);
1134}
1135
1136Heap::Object *ExecutionEngine::newRangeErrorObject(const QString &message)
1137{
1138 return ErrorObject::create<RangeErrorObject>(e: this, message);
1139}
1140
1141Heap::Object *ExecutionEngine::newURIErrorObject(const Value &message)
1142{
1143 return ErrorObject::create<URIErrorObject>(e: this, message, newTarget: uRIErrorCtor());
1144}
1145
1146Heap::PromiseObject *ExecutionEngine::newPromiseObject()
1147{
1148 if (!m_reactionHandler) {
1149 m_reactionHandler.reset(other: new Promise::ReactionHandler);
1150 }
1151
1152 Scope scope(this);
1153 Scoped<PromiseObject> object(scope, memoryManager->allocate<PromiseObject>(args: this));
1154 return object->d();
1155}
1156
1157Heap::Object *ExecutionEngine::newPromiseObject(const QV4::FunctionObject *thisObject, const QV4::PromiseCapability *capability)
1158{
1159 if (!m_reactionHandler) {
1160 m_reactionHandler.reset(other: new Promise::ReactionHandler);
1161 }
1162
1163 Scope scope(this);
1164 Scoped<CapabilitiesExecutorWrapper> executor(scope, memoryManager->allocate<CapabilitiesExecutorWrapper>());
1165 executor->d()->capabilities.set(e: this, newVal: capability->d());
1166 executor->insertMember(s: id_length(), v: Primitive::fromInt32(i: 2), attributes: Attr_NotWritable|Attr_NotEnumerable);
1167
1168 ScopedObject object(scope, thisObject->callAsConstructor(argv: executor, argc: 1));
1169 return object->d();
1170}
1171
1172Promise::ReactionHandler *ExecutionEngine::getPromiseReactionHandler()
1173{
1174 Q_ASSERT(m_reactionHandler);
1175 return m_reactionHandler.data();
1176}
1177
1178Heap::Object *ExecutionEngine::newURIErrorObject(const QString &message)
1179{
1180 return ErrorObject::create<URIErrorObject>(e: this, message);
1181}
1182
1183Heap::Object *ExecutionEngine::newEvalErrorObject(const QString &message)
1184{
1185 return ErrorObject::create<EvalErrorObject>(e: this, message);
1186}
1187
1188Heap::Object *ExecutionEngine::newVariantObject(const QMetaType type, const void *data)
1189{
1190 return memoryManager->allocate<VariantObject>(args: type, args&: data);
1191}
1192
1193Heap::Object *ExecutionEngine::newForInIteratorObject(Object *o)
1194{
1195 Scope scope(this);
1196 ScopedObject obj(scope, memoryManager->allocate<ForInIteratorObject>(args&: o));
1197 return obj->d();
1198}
1199
1200Heap::Object *ExecutionEngine::newMapIteratorObject(Object *o)
1201{
1202 return memoryManager->allocate<MapIteratorObject>(args: o->d(), args: this);
1203}
1204
1205Heap::Object *ExecutionEngine::newSetIteratorObject(Object *o)
1206{
1207 return memoryManager->allocate<SetIteratorObject>(args: o->d(), args: this);
1208}
1209
1210Heap::Object *ExecutionEngine::newArrayIteratorObject(Object *o)
1211{
1212 return memoryManager->allocate<ArrayIteratorObject>(args: o->d(), args: this);
1213}
1214
1215Heap::QmlContext *ExecutionEngine::qmlContext() const
1216{
1217 return currentStackFrame
1218 ? static_cast<Heap::QmlContext *>(qmlContext(ctx: currentContext()->d()))
1219 : nullptr;
1220}
1221
1222QObject *ExecutionEngine::qmlScopeObject() const
1223{
1224 Heap::QmlContext *ctx = qmlContext();
1225 if (!ctx)
1226 return nullptr;
1227
1228 return ctx->qml()->scopeObject;
1229}
1230
1231QQmlRefPointer<QQmlContextData> ExecutionEngine::callingQmlContext() const
1232{
1233 Heap::QmlContext *ctx = qmlContext();
1234 if (!ctx)
1235 return nullptr;
1236
1237 return ctx->qml()->context;
1238}
1239
1240StackTrace ExecutionEngine::stackTrace(int frameLimit) const
1241{
1242 StackTrace stack;
1243
1244 CppStackFrame *f = currentStackFrame;
1245 while (f && frameLimit) {
1246 QV4::StackFrame frame;
1247 frame.source = f->source();
1248 frame.function = f->function();
1249 frame.line = f->lineNumber();
1250
1251 stack.append(t: frame);
1252 if (f->isJSTypesFrame()) {
1253 if (static_cast<JSTypesStackFrame *>(f)->isTailCalling()) {
1254 QV4::StackFrame frame;
1255 frame.function = QStringLiteral("[elided tail calls]");
1256 stack.append(t: frame);
1257 }
1258 }
1259 --frameLimit;
1260 f = f->parentFrame();
1261 }
1262
1263 return stack;
1264}
1265
1266/* Helper and "C" linkage exported function to format a GDBMI stacktrace for
1267 * invocation by a debugger.
1268 * Sample GDB invocation: print qt_v4StackTrace((void*)0x7fffffffb290)
1269 * Sample CDB invocation: .call Qt5Qmld!qt_v4StackTrace(0x7fffffffb290) ; gh
1270 * Note: The helper is there to suppress MSVC warning 4190 about anything
1271 * with UDT return types in a "C" linkage function. */
1272
1273static inline char *v4StackTrace(const ExecutionContext *context)
1274{
1275 QString result;
1276 QTextStream str(&result);
1277 str << "stack=[";
1278 if (context && context->engine()) {
1279 const QVector<StackFrame> stackTrace = context->engine()->stackTrace(frameLimit: 20);
1280 for (int i = 0; i < stackTrace.size(); ++i) {
1281 if (i)
1282 str << ',';
1283 const QUrl url(stackTrace.at(i).source);
1284 const QString fileName = url.isLocalFile() ? url.toLocalFile() : url.toString();
1285 str << "frame={level=\"" << i << "\",func=\"" << stackTrace.at(i).function
1286 << "\",file=\"" << fileName << "\",fullname=\"" << fileName
1287 << "\",line=\"" << qAbs(t: stackTrace.at(i).line) << "\",language=\"js\"}";
1288 }
1289 }
1290 str << ']';
1291 return qstrdup(result.toLocal8Bit().constData());
1292}
1293
1294extern "C" Q_QML_EXPORT char *qt_v4StackTrace(void *executionContext)
1295{
1296 return v4StackTrace(context: reinterpret_cast<const ExecutionContext *>(executionContext));
1297}
1298
1299extern "C" Q_QML_EXPORT char *qt_v4StackTraceForEngine(void *executionEngine)
1300{
1301 auto engine = (reinterpret_cast<const ExecutionEngine *>(executionEngine));
1302 return v4StackTrace(context: engine->currentContext());
1303}
1304
1305QUrl ExecutionEngine::resolvedUrl(const QString &file)
1306{
1307 QUrl src(file);
1308 if (!src.isRelative())
1309 return src;
1310
1311 QUrl base;
1312 CppStackFrame *f = currentStackFrame;
1313 while (f) {
1314 if (f->v4Function) {
1315 base = f->v4Function->finalUrl();
1316 break;
1317 }
1318 f = f->parentFrame();
1319 }
1320
1321 if (base.isEmpty() && globalCode)
1322 base = globalCode->finalUrl();
1323
1324 if (base.isEmpty())
1325 return src;
1326
1327 return base.resolved(relative: src);
1328}
1329
1330void ExecutionEngine::markObjects(MarkStack *markStack)
1331{
1332 for (int i = 0; i < NClasses; ++i) {
1333 if (Heap::InternalClass *c = classes[i])
1334 c->mark(markStack);
1335 }
1336
1337 identifierTable->markObjects(markStack);
1338
1339 for (const auto &compilationUnit : std::as_const(t&: m_compilationUnits))
1340 compilationUnit->markObjects(markStack);
1341}
1342
1343ReturnedValue ExecutionEngine::throwError(const Value &value)
1344{
1345 // we can get in here with an exception already set, as the runtime
1346 // doesn't check after every operation that can throw.
1347 // in this case preserve the first exception to give correct error
1348 // information
1349 if (hasException)
1350 return Encode::undefined();
1351
1352 hasException = true;
1353 *exceptionValue = value;
1354 QV4::Scope scope(this);
1355 QV4::Scoped<ErrorObject> error(scope, value);
1356 if (!!error)
1357 exceptionStackTrace = *error->d()->stackTrace;
1358 else
1359 exceptionStackTrace = stackTrace();
1360
1361 if (QV4::Debugging::Debugger *debug = debugger())
1362 debug->aboutToThrow();
1363
1364 return Encode::undefined();
1365}
1366
1367ReturnedValue ExecutionEngine::catchException(StackTrace *trace)
1368{
1369 Q_ASSERT(hasException);
1370 if (trace)
1371 *trace = exceptionStackTrace;
1372 exceptionStackTrace.clear();
1373 hasException = false;
1374 ReturnedValue res = exceptionValue->asReturnedValue();
1375 *exceptionValue = Value::emptyValue();
1376 return res;
1377}
1378
1379ReturnedValue ExecutionEngine::throwError(const QString &message)
1380{
1381 Scope scope(this);
1382 ScopedValue v(scope, newString(s: message));
1383 v = newErrorObject(value: v);
1384 return throwError(value: v);
1385}
1386
1387ReturnedValue ExecutionEngine::throwSyntaxError(const QString &message, const QString &fileName, int line, int column)
1388{
1389 Scope scope(this);
1390 ScopedObject error(scope, newSyntaxErrorObject(message, fileName, line, column));
1391 return throwError(value: error);
1392}
1393
1394ReturnedValue ExecutionEngine::throwSyntaxError(const QString &message)
1395{
1396 Scope scope(this);
1397 ScopedObject error(scope, newSyntaxErrorObject(message));
1398 return throwError(value: error);
1399}
1400
1401
1402ReturnedValue ExecutionEngine::throwTypeError()
1403{
1404 Scope scope(this);
1405 ScopedObject error(scope, newTypeErrorObject(QStringLiteral("Type error")));
1406 return throwError(value: error);
1407}
1408
1409ReturnedValue ExecutionEngine::throwTypeError(const QString &message)
1410{
1411 Scope scope(this);
1412 ScopedObject error(scope, newTypeErrorObject(message));
1413 return throwError(value: error);
1414}
1415
1416ReturnedValue ExecutionEngine::throwReferenceError(const QString &name)
1417{
1418 Scope scope(this);
1419 QString msg = name + QLatin1String(" is not defined");
1420 ScopedObject error(scope, newReferenceErrorObject(message: msg));
1421 return throwError(value: error);
1422}
1423
1424ReturnedValue ExecutionEngine::throwReferenceError(const Value &value)
1425{
1426 Scope scope(this);
1427 ScopedString s(scope, value.toString(e: this));
1428 QString msg = s->toQString() + QLatin1String(" is not defined");
1429 ScopedObject error(scope, newReferenceErrorObject(message: msg));
1430 return throwError(value: error);
1431}
1432
1433ReturnedValue ExecutionEngine::throwReferenceError(const QString &message, const QString &fileName, int line, int column)
1434{
1435 Scope scope(this);
1436 QString msg = message;
1437 ScopedObject error(scope, newReferenceErrorObject(message: msg, fileName, line, column));
1438 return throwError(value: error);
1439}
1440
1441ReturnedValue ExecutionEngine::throwRangeError(const QString &message)
1442{
1443 Scope scope(this);
1444 ScopedObject error(scope, newRangeErrorObject(message));
1445 return throwError(value: error);
1446}
1447
1448ReturnedValue ExecutionEngine::throwRangeError(const Value &value)
1449{
1450 Scope scope(this);
1451 ScopedString s(scope, value.toString(e: this));
1452 QString msg = s->toQString() + QLatin1String(" out of range");
1453 ScopedObject error(scope, newRangeErrorObject(message: msg));
1454 return throwError(value: error);
1455}
1456
1457ReturnedValue ExecutionEngine::throwURIError(const Value &msg)
1458{
1459 Scope scope(this);
1460 ScopedObject error(scope, newURIErrorObject(message: msg));
1461 return throwError(value: error);
1462}
1463
1464ReturnedValue ExecutionEngine::throwUnimplemented(const QString &message)
1465{
1466 Scope scope(this);
1467 ScopedValue v(scope, newString(s: QLatin1String("Unimplemented ") + message));
1468 v = newErrorObject(value: v);
1469 return throwError(value: v);
1470}
1471
1472
1473QQmlError ExecutionEngine::catchExceptionAsQmlError()
1474{
1475 QV4::StackTrace trace;
1476 QV4::Scope scope(this);
1477 QV4::ScopedValue exception(scope, catchException(trace: &trace));
1478 QQmlError error;
1479 if (!trace.isEmpty()) {
1480 QV4::StackFrame frame = trace.constFirst();
1481 error.setUrl(QUrl(frame.source));
1482 error.setLine(qAbs(t: frame.line));
1483 error.setColumn(frame.column);
1484 }
1485 QV4::Scoped<QV4::ErrorObject> errorObj(scope, exception);
1486 error.setDescription(exception->toQStringNoThrow());
1487 return error;
1488}
1489
1490// Variant conversion code
1491
1492typedef QSet<QV4::Heap::Object *> V4ObjectSet;
1493enum class JSToQVariantConversionBehavior {Never, Safish, Aggressive };
1494static QVariant toVariant(
1495 const QV4::Value &value, QMetaType typeHint, JSToQVariantConversionBehavior conversionBehavior,
1496 V4ObjectSet *visitedObjects);
1497static QObject *qtObjectFromJS(const QV4::Value &value);
1498static QVariant objectToVariant(const QV4::Object *o, V4ObjectSet *visitedObjects = nullptr,
1499 JSToQVariantConversionBehavior behavior = JSToQVariantConversionBehavior::Safish);
1500static bool convertToNativeQObject(const QV4::Value &value, QMetaType targetType, void **result);
1501static QV4::ReturnedValue variantMapToJS(QV4::ExecutionEngine *v4, const QVariantMap &vmap);
1502static QV4::ReturnedValue variantToJS(QV4::ExecutionEngine *v4, const QVariant &value)
1503{
1504 return v4->metaTypeToJS(type: value.metaType(), data: value.constData());
1505}
1506
1507static QVariant toVariant(const QV4::Value &value, QMetaType metaType, JSToQVariantConversionBehavior conversionBehavior,
1508 V4ObjectSet *visitedObjects)
1509{
1510 Q_ASSERT (!value.isEmpty());
1511
1512 if (const QV4::VariantObject *v = value.as<QV4::VariantObject>())
1513 return v->d()->data();
1514
1515 if (metaType == QMetaType::fromType<bool>())
1516 return QVariant(value.toBoolean());
1517
1518 if (metaType == QMetaType::fromType<double>())
1519 return QVariant(value.toNumber());
1520
1521 if (metaType == QMetaType::fromType<float>())
1522 return QVariant(float(value.toNumber()));
1523
1524 if (metaType == QMetaType::fromType<QJsonValue>())
1525 return QVariant::fromValue(value: QV4::JsonObject::toJsonValue(value));
1526
1527 if (metaType == QMetaType::fromType<QJSValue>())
1528 return QVariant::fromValue(value: QJSValuePrivate::fromReturnedValue(d: value.asReturnedValue()));
1529
1530 if (const QV4::Object *o = value.as<QV4::Object>()) {
1531 QV4::Scope scope(o->engine());
1532 QV4::ScopedObject object(scope, o);
1533 if (metaType == QMetaType::fromType<QJsonObject>()
1534 && !value.as<ArrayObject>() && !value.as<FunctionObject>()) {
1535 return QVariant::fromValue(value: QV4::JsonObject::toJsonObject(o: object));
1536 } else if (QV4::QObjectWrapper *wrapper = object->as<QV4::QObjectWrapper>()) {
1537 return QVariant::fromValue<QObject *>(value: wrapper->object());
1538 } else if (object->as<QV4::QQmlContextWrapper>()) {
1539 return QVariant();
1540 } else if (QV4::QQmlTypeWrapper *w = object->as<QV4::QQmlTypeWrapper>()) {
1541 return w->toVariant();
1542 } else if (QV4::QQmlValueTypeWrapper *v = object->as<QV4::QQmlValueTypeWrapper>()) {
1543 return v->toVariant();
1544 } else if (QV4::QmlListWrapper *l = object->as<QV4::QmlListWrapper>()) {
1545 return l->toVariant();
1546 } else if (QV4::Sequence *s = object->as<QV4::Sequence>()) {
1547 if (metaType.isValid()
1548 && metaType != QMetaType::fromType<QVariant>()
1549 && metaType != s->d()->listType()) {
1550 // If we can, produce an accurate result.
1551 const QVariant result = QV4::SequencePrototype::toVariant(array: value, targetType: metaType);
1552 if (result.isValid())
1553 return result;
1554 }
1555
1556 // Otherwise produce the "natural" type of the sequence.
1557 return QV4::SequencePrototype::toVariant(object: s);
1558 }
1559 }
1560
1561 if (const QV4::ArrayObject *o = value.as<ArrayObject>()) {
1562 QV4::Scope scope(o->engine());
1563 QV4::ScopedArrayObject a(scope, o);
1564 if (metaType == QMetaType::fromType<QList<QObject *>>()) {
1565 QList<QObject *> list;
1566 uint length = a->getLength();
1567 QV4::Scoped<QV4::QObjectWrapper> qobjectWrapper(scope);
1568 for (uint ii = 0; ii < length; ++ii) {
1569 qobjectWrapper = a->get(idx: ii);
1570 if (!!qobjectWrapper) {
1571 list << qobjectWrapper->object();
1572 } else {
1573 list << 0;
1574 }
1575 }
1576
1577 return QVariant::fromValue<QList<QObject*> >(value: list);
1578 } else if (metaType == QMetaType::fromType<QJsonArray>()) {
1579 return QVariant::fromValue(value: QV4::JsonObject::toJsonArray(o: a));
1580 }
1581
1582 QVariant retn = QV4::SequencePrototype::toVariant(array: value, targetType: metaType);
1583 if (retn.isValid())
1584 return retn;
1585 }
1586
1587 if (value.isUndefined())
1588 return QVariant();
1589 if (value.isNull())
1590 return QVariant::fromValue(value: nullptr);
1591 if (value.isBoolean())
1592 return value.booleanValue();
1593 if (value.isInteger())
1594 return value.integerValue();
1595 if (value.isNumber())
1596 return value.asDouble();
1597 if (String *s = value.stringValue()) {
1598 const QString &str = s->toQString();
1599 // QChars are stored as a strings
1600 if (metaType == QMetaType::fromType<QChar>() && str.size() == 1)
1601 return str.at(i: 0);
1602 return str;
1603 }
1604 if (const QV4::DateObject *d = value.as<DateObject>()) {
1605 // NOTE: since we convert QTime to JS Date,
1606 // round trip will change the variant type (to QDateTime)!
1607
1608 if (metaType == QMetaType::fromType<QDate>())
1609 return DateObject::dateTimeToDate(dateTime: d->toQDateTime());
1610
1611 if (metaType == QMetaType::fromType<QTime>())
1612 return d->toQDateTime().time();
1613
1614 if (metaType == QMetaType::fromType<QString>())
1615 return d->toString();
1616
1617 return d->toQDateTime();
1618 }
1619 if (const QV4::UrlObject *d = value.as<UrlObject>())
1620 return d->toQUrl();
1621 if (const ArrayBuffer *d = value.as<ArrayBuffer>())
1622 return d->asByteArray();
1623 if (const Symbol *symbol = value.as<Symbol>()) {
1624 return conversionBehavior == JSToQVariantConversionBehavior::Never
1625 ? QVariant::fromValue(value: QJSValuePrivate::fromReturnedValue(d: symbol->asReturnedValue()))
1626 : symbol->descriptiveString();
1627 }
1628
1629 const QV4::Object *object = value.as<QV4::Object>();
1630 Q_ASSERT(object);
1631 QV4::Scope scope(object->engine());
1632 QV4::ScopedObject o(scope, object);
1633
1634#if QT_CONFIG(regularexpression)
1635 if (QV4::RegExpObject *re = o->as<QV4::RegExpObject>())
1636 return re->toQRegularExpression();
1637#endif
1638
1639 if (metaType.isValid() && !(metaType.flags() & QMetaType::PointerToQObject)) {
1640 const QVariant result
1641 = QQmlValueTypeProvider::createValueType(value, metaType, scope.engine);
1642 if (result.isValid())
1643 return result;
1644 }
1645
1646 if (conversionBehavior == JSToQVariantConversionBehavior::Never)
1647 return QVariant::fromValue(value: QJSValuePrivate::fromReturnedValue(d: o->asReturnedValue()));
1648
1649 return objectToVariant(o, visitedObjects, behavior: conversionBehavior);
1650}
1651
1652QVariant ExecutionEngine::toVariantLossy(const Value &value)
1653{
1654 return ::toVariant(value, metaType: QMetaType(), conversionBehavior: JSToQVariantConversionBehavior::Aggressive, visitedObjects: nullptr);
1655}
1656
1657QVariant ExecutionEngine::toVariant(
1658 const Value &value, QMetaType typeHint, bool createJSValueForObjectsAndSymbols)
1659{
1660 auto behavior = createJSValueForObjectsAndSymbols ? JSToQVariantConversionBehavior::Never
1661 : JSToQVariantConversionBehavior::Safish;
1662 return ::toVariant(value, metaType: typeHint, conversionBehavior: behavior, visitedObjects: nullptr);
1663}
1664
1665static QVariantMap objectToVariantMap(const QV4::Object *o, V4ObjectSet *visitedObjects,
1666 JSToQVariantConversionBehavior conversionBehvior)
1667{
1668 QVariantMap map;
1669 QV4::Scope scope(o->engine());
1670 QV4::ObjectIterator it(scope, o, QV4::ObjectIterator::EnumerableOnly);
1671 QV4::ScopedValue name(scope);
1672 QV4::ScopedValue val(scope);
1673 while (1) {
1674 name = it.nextPropertyNameAsString(value: val);
1675 if (name->isNull())
1676 break;
1677
1678 QString key = name->toQStringNoThrow();
1679 map.insert(key, value: ::toVariant(
1680 value: val, /*type hint*/ metaType: QMetaType {},
1681 conversionBehavior: conversionBehvior, visitedObjects));
1682 }
1683 return map;
1684}
1685
1686static QVariant objectToVariant(const QV4::Object *o, V4ObjectSet *visitedObjects,
1687 JSToQVariantConversionBehavior conversionBehvior)
1688{
1689 Q_ASSERT(o);
1690
1691 V4ObjectSet recursionGuardSet;
1692 if (!visitedObjects) {
1693 visitedObjects = &recursionGuardSet;
1694 } else if (visitedObjects->contains(value: o->d())) {
1695 // Avoid recursion.
1696 // For compatibility with QVariant{List,Map} conversion, we return an
1697 // empty object (and no error is thrown).
1698 if (o->as<ArrayObject>())
1699 return QVariantList();
1700 return QVariantMap();
1701 }
1702 visitedObjects->insert(value: o->d());
1703
1704 QVariant result;
1705
1706 if (o->as<ArrayObject>()) {
1707 QV4::Scope scope(o->engine());
1708 QV4::ScopedArrayObject a(scope, o->asReturnedValue());
1709 QV4::ScopedValue v(scope);
1710 QVariantList list;
1711
1712 int length = a->getLength();
1713 for (int ii = 0; ii < length; ++ii) {
1714 v = a->get(idx: ii);
1715 list << ::toVariant(value: v, metaType: QMetaType {}, conversionBehavior: conversionBehvior,
1716 visitedObjects);
1717 }
1718
1719 result = list;
1720 } else if (o->getPrototypeOf() == o->engine()->objectPrototype()->d()
1721 || (conversionBehvior == JSToQVariantConversionBehavior::Aggressive &&
1722 !o->as<QV4::FunctionObject>())) {
1723 /* FunctionObject is excluded for historical reasons, even though
1724 objects with a custom prototype risk losing information
1725 But the Aggressive path is used only in QJSValue::toVariant
1726 which is documented to be lossy
1727 */
1728 result = objectToVariantMap(o, visitedObjects, conversionBehvior);
1729 } else {
1730 // If it's not a plain object, we can only save it as QJSValue.
1731 result = QVariant::fromValue(value: QJSValuePrivate::fromReturnedValue(d: o->asReturnedValue()));
1732 }
1733
1734 visitedObjects->remove(value: o->d());
1735 return result;
1736}
1737
1738/*!
1739 \internal
1740
1741 Transform the given \a metaType and \a ptr into a JavaScript representation.
1742 */
1743QV4::ReturnedValue ExecutionEngine::fromData(
1744 QMetaType metaType, const void *ptr,
1745 QV4::Heap::Object *container, int property, uint flags)
1746{
1747 const auto createSequence = [&](const QMetaSequence metaSequence) {
1748 QV4::Scope scope(this);
1749 QV4::Scoped<Sequence> sequence(scope);
1750 if (container) {
1751 return QV4::SequencePrototype::newSequence(
1752 engine: this, type: metaType, metaSequence, data: ptr,
1753 object: container, propertyIndex: property, flags: Heap::ReferenceObject::Flags(flags));
1754 } else {
1755 return QV4::SequencePrototype::fromData(engine: this, type: metaType, metaSequence, data: ptr);
1756 }
1757 };
1758
1759 const int type = metaType.id();
1760 if (type < QMetaType::User) {
1761 switch (QMetaType::Type(type)) {
1762 case QMetaType::UnknownType:
1763 case QMetaType::Void:
1764 return QV4::Encode::undefined();
1765 case QMetaType::Nullptr:
1766 case QMetaType::VoidStar:
1767 return QV4::Encode::null();
1768 case QMetaType::Bool:
1769 return QV4::Encode(*reinterpret_cast<const bool*>(ptr));
1770 case QMetaType::Int:
1771 return QV4::Encode(*reinterpret_cast<const int*>(ptr));
1772 case QMetaType::UInt:
1773 return QV4::Encode(*reinterpret_cast<const uint*>(ptr));
1774 case QMetaType::Long:
1775 return QV4::Encode((double)*reinterpret_cast<const long *>(ptr));
1776 case QMetaType::ULong:
1777 return QV4::Encode((double)*reinterpret_cast<const ulong *>(ptr));
1778 case QMetaType::LongLong:
1779 return QV4::Encode((double)*reinterpret_cast<const qlonglong*>(ptr));
1780 case QMetaType::ULongLong:
1781 return QV4::Encode((double)*reinterpret_cast<const qulonglong*>(ptr));
1782 case QMetaType::Double:
1783 return QV4::Encode(*reinterpret_cast<const double*>(ptr));
1784 case QMetaType::QString:
1785 return newString(s: *reinterpret_cast<const QString*>(ptr))->asReturnedValue();
1786 case QMetaType::QByteArray:
1787 return newArrayBuffer(array: *reinterpret_cast<const QByteArray*>(ptr))->asReturnedValue();
1788 case QMetaType::Float:
1789 return QV4::Encode(*reinterpret_cast<const float*>(ptr));
1790 case QMetaType::Short:
1791 return QV4::Encode((int)*reinterpret_cast<const short*>(ptr));
1792 case QMetaType::UShort:
1793 return QV4::Encode((int)*reinterpret_cast<const unsigned short*>(ptr));
1794 case QMetaType::Char:
1795 return QV4::Encode((int)*reinterpret_cast<const char*>(ptr));
1796 case QMetaType::UChar:
1797 return QV4::Encode((int)*reinterpret_cast<const unsigned char*>(ptr));
1798 case QMetaType::SChar:
1799 return QV4::Encode((int)*reinterpret_cast<const signed char*>(ptr));
1800 case QMetaType::QChar:
1801 return newString(s: *reinterpret_cast<const QChar *>(ptr))->asReturnedValue();
1802 case QMetaType::Char16:
1803 return newString(s: QChar(*reinterpret_cast<const char16_t *>(ptr)))->asReturnedValue();
1804 case QMetaType::QDateTime:
1805 return QV4::Encode(newDateObject(
1806 dateTime: *reinterpret_cast<const QDateTime *>(ptr),
1807 parent: container, index: property, flags));
1808 case QMetaType::QDate:
1809 return QV4::Encode(newDateObject(
1810 date: *reinterpret_cast<const QDate *>(ptr),
1811 parent: container, index: property, flags));
1812 case QMetaType::QTime:
1813 return QV4::Encode(newDateObject(
1814 time: *reinterpret_cast<const QTime *>(ptr),
1815 parent: container, index: property, flags));
1816#if QT_CONFIG(regularexpression)
1817 case QMetaType::QRegularExpression:
1818 return QV4::Encode(newRegExpObject(re: *reinterpret_cast<const QRegularExpression *>(ptr)));
1819#endif
1820 case QMetaType::QObjectStar:
1821 return QV4::QObjectWrapper::wrap(engine: this, object: *reinterpret_cast<QObject* const *>(ptr));
1822 case QMetaType::QStringList:
1823 return createSequence(QMetaSequence::fromContainer<QStringList>());
1824 case QMetaType::QVariantList:
1825 return createSequence(QMetaSequence::fromContainer<QVariantList>());
1826 case QMetaType::QVariantMap:
1827 return variantMapToJS(v4: this, vmap: *reinterpret_cast<const QVariantMap *>(ptr));
1828 case QMetaType::QJsonValue:
1829 return QV4::JsonObject::fromJsonValue(engine: this, value: *reinterpret_cast<const QJsonValue *>(ptr));
1830 case QMetaType::QJsonObject:
1831 return QV4::JsonObject::fromJsonObject(engine: this, object: *reinterpret_cast<const QJsonObject *>(ptr));
1832 case QMetaType::QJsonArray:
1833 return QV4::JsonObject::fromJsonArray(engine: this, array: *reinterpret_cast<const QJsonArray *>(ptr));
1834 case QMetaType::QPixmap:
1835 case QMetaType::QImage:
1836 // Scarce value types
1837 return QV4::Encode(newVariantObject(type: metaType, data: ptr));
1838 default:
1839 break;
1840 }
1841 }
1842
1843 if (metaType.flags() & QMetaType::IsEnumeration)
1844 return fromData(metaType: metaType.underlyingType(), ptr, container, property, flags);
1845
1846 QV4::Scope scope(this);
1847 if (metaType == QMetaType::fromType<QQmlListReference>()) {
1848 typedef QQmlListReferencePrivate QDLRP;
1849 QDLRP *p = QDLRP::get(ref: (QQmlListReference*)const_cast<void *>(ptr));
1850 if (p->object)
1851 return QV4::QmlListWrapper::create(engine: scope.engine, prop: p->property, propType: p->propertyType);
1852 else
1853 return QV4::Encode::null();
1854 } else if (auto flags = metaType.flags(); flags & QMetaType::IsQmlList) {
1855 // casting to QQmlListProperty<QObject> is slightly nasty, but it's the
1856 // same QQmlListReference does.
1857 const auto *p = static_cast<const QQmlListProperty<QObject> *>(ptr);
1858 if (p->object)
1859 return QV4::QmlListWrapper::create(engine: scope.engine, prop: *p, propType: metaType);
1860 else
1861 return QV4::Encode::null();
1862 } else if (metaType == QMetaType::fromType<QJSValue>()) {
1863 return QJSValuePrivate::convertToReturnedValue(
1864 e: this, jsval: *reinterpret_cast<const QJSValue *>(ptr));
1865 } else if (metaType == QMetaType::fromType<QList<QObject *> >()) {
1866 // XXX Can this be made more by using Array as a prototype and implementing
1867 // directly against QList<QObject*>?
1868 const QList<QObject *> &list = *(const QList<QObject *>*)ptr;
1869 QV4::ScopedArrayObject a(scope, newArrayObject());
1870 a->arrayReserve(n: list.size());
1871 QV4::ScopedValue v(scope);
1872 for (int ii = 0; ii < list.size(); ++ii)
1873 a->arrayPut(index: ii, value: (v = QV4::QObjectWrapper::wrap(engine: this, object: list.at(i: ii))));
1874 a->setArrayLengthUnchecked(list.size());
1875 return a.asReturnedValue();
1876 } else if (auto flags = metaType.flags(); flags & QMetaType::PointerToQObject) {
1877 if (flags.testFlag(flag: QMetaType::IsConst))
1878 return QV4::QObjectWrapper::wrapConst(engine: this, object: *reinterpret_cast<QObject* const *>(ptr));
1879 else
1880 return QV4::QObjectWrapper::wrap(engine: this, object: *reinterpret_cast<QObject* const *>(ptr));
1881 } else if (metaType == QMetaType::fromType<QJSPrimitiveValue>()) {
1882 const QJSPrimitiveValue *primitive = static_cast<const QJSPrimitiveValue *>(ptr);
1883 switch (primitive->type()) {
1884 case QJSPrimitiveValue::Boolean:
1885 return Encode(primitive->asBoolean());
1886 case QJSPrimitiveValue::Integer:
1887 return Encode(primitive->asInteger());
1888 case QJSPrimitiveValue::String:
1889 return newString(s: primitive->asString())->asReturnedValue();
1890 case QJSPrimitiveValue::Undefined:
1891 return Encode::undefined();
1892 case QJSPrimitiveValue::Null:
1893 return Encode::null();
1894 case QJSPrimitiveValue::Double:
1895 return Encode(primitive->asDouble());
1896 }
1897 }
1898
1899 if (const QMetaObject *vtmo = QQmlMetaType::metaObjectForValueType(type: metaType)) {
1900 if (container) {
1901 return QV4::QQmlValueTypeWrapper::create(
1902 engine: this, data: ptr, metaObject: vtmo, type: metaType,
1903 object: container, property, flags: Heap::ReferenceObject::Flags(flags));
1904 } else {
1905 return QV4::QQmlValueTypeWrapper::create(engine: this, ptr, metaObject: vtmo, type: metaType);
1906 }
1907 }
1908
1909 const QQmlType listType = QQmlMetaType::qmlListType(metaType);
1910 if (listType.isSequentialContainer())
1911 return createSequence(listType.listMetaSequence());
1912
1913 QSequentialIterable iterable;
1914 if (QMetaType::convert(fromType: metaType, from: ptr, toType: QMetaType::fromType<QSequentialIterable>(), to: &iterable)) {
1915
1916 // If the resulting iterable is useful for anything, turn it into a QV4::Sequence.
1917 const QMetaSequence sequence = iterable.metaContainer();
1918 if (sequence.hasSize() && sequence.canGetValueAtIndex())
1919 return createSequence(sequence);
1920
1921 // As a last resort, try to read the contents of the container via an iterator
1922 // and build a JS array from them.
1923 if (sequence.hasConstIterator() && sequence.canGetValueAtConstIterator()) {
1924 QV4::ScopedArrayObject a(scope, newArrayObject());
1925 for (auto it = iterable.constBegin(), end = iterable.constEnd(); it != end; ++it)
1926 a->push_back(v: fromVariant(*it));
1927 return a.asReturnedValue();
1928 }
1929 }
1930
1931 return QV4::Encode(newVariantObject(type: metaType, data: ptr));
1932}
1933
1934QV4::ReturnedValue QV4::ExecutionEngine::fromVariant(const QVariant &variant)
1935{
1936 return fromData(metaType: variant.metaType(), ptr: variant.constData());
1937}
1938
1939ReturnedValue ExecutionEngine::fromVariant(
1940 const QVariant &variant, Heap::Object *parent, int property, uint flags)
1941{
1942 return fromData(metaType: variant.metaType(), ptr: variant.constData(), container: parent, property, flags);
1943}
1944
1945QVariantMap ExecutionEngine::variantMapFromJS(const Object *o)
1946{
1947 Q_ASSERT(o);
1948 V4ObjectSet visitedObjects;
1949 visitedObjects.insert(value: o->d());
1950 return objectToVariantMap(o, visitedObjects: &visitedObjects, conversionBehvior: JSToQVariantConversionBehavior::Safish);
1951}
1952
1953// Converts a QVariantMap to JS.
1954// The result is a new Object object with property names being
1955// the keys of the QVariantMap, and values being the values of
1956// the QVariantMap converted to JS, recursively.
1957static QV4::ReturnedValue variantMapToJS(QV4::ExecutionEngine *v4, const QVariantMap &vmap)
1958{
1959 QV4::Scope scope(v4);
1960 QV4::ScopedObject o(scope, v4->newObject());
1961 QV4::ScopedString s(scope);
1962 QV4::ScopedPropertyKey key(scope);
1963 QV4::ScopedValue v(scope);
1964 for (QVariantMap::const_iterator it = vmap.constBegin(), cend = vmap.constEnd(); it != cend; ++it) {
1965 s = v4->newIdentifier(text: it.key());
1966 key = s->propertyKey();
1967 v = variantToJS(v4, value: it.value());
1968 if (key->isArrayIndex())
1969 o->arraySet(index: key->asArrayIndex(), value: v);
1970 else
1971 o->insertMember(s, v);
1972 }
1973 return o.asReturnedValue();
1974}
1975
1976// Converts the meta-type defined by the given type and data to JS.
1977// Returns the value if conversion succeeded, an empty handle otherwise.
1978QV4::ReturnedValue ExecutionEngine::metaTypeToJS(QMetaType type, const void *data)
1979{
1980 Q_ASSERT(data != nullptr);
1981
1982 if (type == QMetaType::fromType<QVariant>()) {
1983 // unwrap it: this is tested in QJSEngine, and makes the most sense for
1984 // end-user code too.
1985 return fromVariant(variant: *reinterpret_cast<const QVariant*>(data));
1986 } else if (type == QMetaType::fromType<QUrl>()) {
1987 // Create a proper URL object here, rather than a variant.
1988 return newUrlObject(url: *reinterpret_cast<const QUrl *>(data))->asReturnedValue();
1989 }
1990
1991 return fromData(metaType: type, ptr: data);
1992}
1993
1994int ExecutionEngine::maxJSStackSize() const
1995{
1996 return s_maxJSStackSize;
1997}
1998
1999int ExecutionEngine::maxGCStackSize() const
2000{
2001 return s_maxGCStackSize;
2002}
2003
2004/*!
2005 \internal
2006 Returns \a length converted to int if its safe to
2007 pass to \c Scope::alloc.
2008 Otherwise it throws a RangeError, and returns 0.
2009 */
2010int ExecutionEngine::safeForAllocLength(qint64 len64)
2011{
2012 if (len64 < 0ll || len64 > qint64(std::numeric_limits<int>::max())) {
2013 throwRangeError(QStringLiteral("Invalid array length."));
2014 return 0;
2015 }
2016 if (len64 > qint64(this->jsStackLimit - this->jsStackTop)) {
2017 throwRangeError(QStringLiteral("Array too large for apply()."));
2018 return 0;
2019 }
2020 return len64;
2021}
2022
2023ReturnedValue ExecutionEngine::global()
2024{
2025 return globalObject->asReturnedValue();
2026}
2027
2028QQmlRefPointer<ExecutableCompilationUnit> ExecutionEngine::compileModule(const QUrl &url)
2029{
2030 QQmlMetaType::CachedUnitLookupError cacheError = QQmlMetaType::CachedUnitLookupError::NoError;
2031 const DiskCacheOptions options = diskCacheOptions();
2032 if (const QQmlPrivate::CachedQmlUnit *cachedUnit = (options & DiskCache::Aot)
2033 ? QQmlMetaType::findCachedCompilationUnit(
2034 uri: url,
2035 mode: (options & DiskCache::AotByteCode)
2036 ? QQmlMetaType::AcceptUntyped
2037 : QQmlMetaType::RequireFullyTyped,
2038 status: &cacheError)
2039 : nullptr) {
2040 return executableCompilationUnit(
2041 unit: QQml::makeRefPointer<QV4::CompiledData::CompilationUnit>(
2042 args: cachedUnit->qmlData, args: cachedUnit->aotCompiledFunctions, args: url.fileName(),
2043 args: url.toString()));
2044 }
2045
2046 QFile f(QQmlFile::urlToLocalFileOrQrc(url));
2047 if (!f.open(flags: QIODevice::ReadOnly)) {
2048 throwError(QStringLiteral("Could not open module %1 for reading").arg(a: url.toString()));
2049 return nullptr;
2050 }
2051
2052 const QDateTime timeStamp = QFileInfo(f).lastModified();
2053
2054 const QString sourceCode = QString::fromUtf8(ba: f.readAll());
2055 f.close();
2056
2057 return compileModule(url, sourceCode, sourceTimeStamp: timeStamp);
2058}
2059
2060
2061QQmlRefPointer<ExecutableCompilationUnit> ExecutionEngine::compileModule(
2062 const QUrl &url, const QString &sourceCode, const QDateTime &sourceTimeStamp)
2063{
2064 QList<QQmlJS::DiagnosticMessage> diagnostics;
2065 auto unit = Compiler::Codegen::compileModule(/*debugMode*/debugger() != nullptr, url: url.toString(),
2066 sourceCode, sourceTimeStamp, diagnostics: &diagnostics);
2067 for (const QQmlJS::DiagnosticMessage &m : diagnostics) {
2068 if (m.isError()) {
2069 throwSyntaxError(message: m.message, fileName: url.toString(), line: m.loc.startLine, column: m.loc.startColumn);
2070 return nullptr;
2071 } else {
2072 qWarning() << url << ':' << m.loc.startLine << ':' << m.loc.startColumn
2073 << ": warning: " << m.message;
2074 }
2075 }
2076
2077 return insertCompilationUnit(unit: std::move(unit));
2078}
2079
2080QQmlRefPointer<ExecutableCompilationUnit> ExecutionEngine::compilationUnitForUrl(const QUrl &url) const
2081{
2082 // Gives the _most recently inserted_ CU of that URL. That's what we want.
2083 return m_compilationUnits.value(key: url);
2084}
2085
2086QQmlRefPointer<ExecutableCompilationUnit> ExecutionEngine::executableCompilationUnit(
2087 QQmlRefPointer<CompiledData::CompilationUnit> &&unit)
2088{
2089 const QUrl url = unit->finalUrl();
2090 auto [begin, end] = std::as_const(t&: m_compilationUnits).equal_range(key: url);
2091
2092 for (auto it = begin; it != end; ++it) {
2093 if ((*it)->baseCompilationUnit() == unit)
2094 return *it;
2095 }
2096
2097 auto executableUnit = m_compilationUnits.insert(
2098 key: url, value: ExecutableCompilationUnit::create(compilationUnit: std::move(unit), engine: this));
2099 // runtime data should not be initialized yet, so we don't need to mark the CU
2100 Q_ASSERT(!(*executableUnit)->runtimeStrings);
2101 return *executableUnit;
2102}
2103
2104QQmlRefPointer<ExecutableCompilationUnit> ExecutionEngine::insertCompilationUnit(QQmlRefPointer<CompiledData::CompilationUnit> &&unit) {
2105 QUrl url = unit->finalUrl();
2106 auto executableUnit = ExecutableCompilationUnit::create(compilationUnit: std::move(unit), engine: this);
2107 /* Compilation Units stored in the engine are part of the gc roots,
2108 so we don't trigger any write-barrier when they are added. Use
2109 markCustom to make sure they are still marked when we insert them */
2110 QV4::WriteBarrier::markCustom(engine: this, markFunction: [&executableUnit](QV4::MarkStack *ms) {
2111 executableUnit->markObjects(markStack: ms);
2112 });
2113 return *m_compilationUnits.insert(key: std::move(url), value: std::move(executableUnit));
2114}
2115
2116void ExecutionEngine::trimCompilationUnits()
2117{
2118 for (auto it = m_compilationUnits.begin(); it != m_compilationUnits.end();) {
2119 if ((*it)->count() == 1)
2120 it = m_compilationUnits.erase(it);
2121 else
2122 ++it;
2123 }
2124}
2125
2126ExecutionEngine::Module ExecutionEngine::moduleForUrl(
2127 const QUrl &url, const ExecutableCompilationUnit *referrer) const
2128{
2129 const auto nativeModule = nativeModules.find(key: url);
2130 if (nativeModule != nativeModules.end())
2131 return Module { .compiled: nullptr, .native: *nativeModule };
2132
2133 const QUrl resolved = referrer
2134 ? referrer->finalUrl().resolved(relative: QQmlTypeLoader::normalize(unNormalizedUrl: url))
2135 : QQmlTypeLoader::normalize(unNormalizedUrl: url);
2136 auto existingModule = m_compilationUnits.find(key: resolved);
2137 if (existingModule == m_compilationUnits.end())
2138 return Module { .compiled: nullptr, .native: nullptr };
2139 return Module { .compiled: *existingModule, .native: nullptr };
2140}
2141
2142ExecutionEngine::Module ExecutionEngine::loadModule(const QUrl &url, const ExecutableCompilationUnit *referrer)
2143{
2144 const auto nativeModule = nativeModules.constFind(key: url);
2145 if (nativeModule != nativeModules.cend())
2146 return Module { .compiled: nullptr, .native: *nativeModule };
2147
2148 const QUrl resolved = referrer
2149 ? referrer->finalUrl().resolved(relative: QQmlTypeLoader::normalize(unNormalizedUrl: url))
2150 : QQmlTypeLoader::normalize(unNormalizedUrl: url);
2151 auto existingModule = m_compilationUnits.constFind(key: resolved);
2152 if (existingModule != m_compilationUnits.cend())
2153 return Module { .compiled: *existingModule, .native: nullptr };
2154
2155 auto newModule = compileModule(url: resolved);
2156 Q_ASSERT(!newModule || m_compilationUnits.contains(resolved, newModule));
2157
2158 return Module { .compiled: newModule, .native: nullptr };
2159}
2160
2161QV4::Value *ExecutionEngine::registerNativeModule(const QUrl &url, const QV4::Value &module)
2162{
2163 const auto existingModule = nativeModules.constFind(key: url);
2164 if (existingModule != nativeModules.cend())
2165 return nullptr;
2166
2167 QV4::Value *val = this->memoryManager->m_persistentValues->allocate();
2168 *val = module.asReturnedValue();
2169 nativeModules.insert(key: url, value: val);
2170
2171 // Make sure the type loader doesn't try to resolve the script anymore.
2172 if (m_qmlEngine)
2173 QQmlEnginePrivate::get(e: m_qmlEngine)->typeLoader.injectScript(relativeUrl: url);
2174
2175 return val;
2176}
2177
2178static ExecutionEngine::DiskCacheOptions transFormDiskCache(const char *v)
2179{
2180 using DiskCache = ExecutionEngine::DiskCache;
2181
2182 if (v == nullptr)
2183 return DiskCache::Enabled;
2184
2185 ExecutionEngine::DiskCacheOptions result = DiskCache::Disabled;
2186 const QList<QByteArray> options = QByteArray(v).split(sep: ',');
2187 for (const QByteArray &option : options) {
2188 if (option == "aot-bytecode")
2189 result |= DiskCache::AotByteCode;
2190 else if (option == "aot-native")
2191 result |= DiskCache::AotNative;
2192 else if (option == "aot")
2193 result |= DiskCache::Aot;
2194 else if (option == "qmlc-read")
2195 result |= DiskCache::QmlcRead;
2196 else if (option == "qmlc-write")
2197 result |= DiskCache::QmlcWrite;
2198 else if (option == "qmlc")
2199 result |= DiskCache::Qmlc;
2200 else
2201 qWarning() << "Ignoring unknown option to QML_DISK_CACHE:" << option;
2202 }
2203
2204 return result;
2205}
2206
2207ExecutionEngine::DiskCacheOptions ExecutionEngine::diskCacheOptions() const
2208{
2209 if (forceDiskCache())
2210 return DiskCache::Enabled;
2211 if (disableDiskCache() || debugger())
2212 return DiskCache::Disabled;
2213 static const DiskCacheOptions options = qmlGetConfigOption<
2214 DiskCacheOptions, transFormDiskCache>(var: "QML_DISK_CACHE");
2215 return hasPreview.loadAcquire()
2216 ? (options & ~DiskCacheOptions(DiskCache::Aot)) // Disable AOT if preview enabled
2217 : options;
2218}
2219
2220void ExecutionEngine::callInContext(QV4::Function *function, QObject *self,
2221 QV4::ExecutionContext *context, int argc, void **args,
2222 QMetaType *types)
2223{
2224 if (!args) {
2225 Q_ASSERT(argc == 0);
2226 void *dummyArgs[] = { nullptr };
2227 QMetaType dummyTypes[] = { QMetaType::fromType<void>() };
2228 function->call(thisObject: self, a: dummyArgs, types: dummyTypes, argc, context);
2229 return;
2230 }
2231 Q_ASSERT(types); // both args and types must be present
2232 // implicitly sets the return value, which is args[0]
2233 function->call(thisObject: self, a: args, types, argc, context);
2234}
2235
2236QV4::ReturnedValue ExecutionEngine::callInContext(QV4::Function *function, QObject *self,
2237 QV4::ExecutionContext *context, int argc,
2238 const QV4::Value *argv)
2239{
2240 QV4::Scope scope(this);
2241 QV4::ScopedObject jsSelf(scope, QV4::QObjectWrapper::wrap(engine: this, object: self));
2242 Q_ASSERT(jsSelf);
2243 return function->call(thisObject: jsSelf, argv, argc, context);
2244}
2245
2246void ExecutionEngine::initQmlGlobalObject()
2247{
2248 initializeGlobal();
2249 lockObject(value: *globalObject);
2250}
2251
2252void ExecutionEngine::initializeGlobal()
2253{
2254 createQtObject();
2255
2256 QV4::GlobalExtensions::init(globalObject, extensions: QJSEngine::AllExtensions);
2257
2258#if QT_CONFIG(qml_locale)
2259 QQmlLocale::registerStringLocaleCompare(engine: this);
2260 QQmlDateExtension::registerExtension(engine: this);
2261 QQmlNumberExtension::registerExtension(engine: this);
2262#endif
2263
2264#if QT_CONFIG(qml_xml_http_request)
2265 qt_add_domexceptions(e: this);
2266 m_xmlHttpRequestData = qt_add_qmlxmlhttprequest(engine: this);
2267#endif
2268
2269 qt_add_sqlexceptions(engine: this);
2270
2271 {
2272 for (uint i = 0; i < globalObject->internalClass()->size; ++i) {
2273 if (globalObject->internalClass()->nameMap.at(i).isString()) {
2274 QV4::PropertyKey id = globalObject->internalClass()->nameMap.at(i);
2275 m_illegalNames.insert(value: id.toQString());
2276 }
2277 }
2278 }
2279}
2280
2281void ExecutionEngine::createQtObject()
2282{
2283 QV4::Scope scope(this);
2284 QtObject *qtObject = new QtObject(this);
2285 QJSEngine::setObjectOwnership(qtObject, QJSEngine::JavaScriptOwnership);
2286
2287 QV4::ScopedObject qtObjectWrapper(
2288 scope, QV4::QObjectWrapper::wrap(engine: this, object: qtObject));
2289 QV4::ScopedObject qtNamespaceWrapper(
2290 scope, QV4::QMetaObjectWrapper::create(engine: this, metaObject: &Qt::staticMetaObject));
2291 QV4::ScopedObject qtObjectProtoWrapper(
2292 scope, qtObjectWrapper->getPrototypeOf());
2293
2294 qtNamespaceWrapper->setPrototypeOf(qtObjectProtoWrapper);
2295 qtObjectWrapper->setPrototypeOf(qtNamespaceWrapper);
2296
2297 globalObject->defineDefaultProperty(QStringLiteral("Qt"), value: qtObjectWrapper);
2298}
2299
2300const QSet<QString> &ExecutionEngine::illegalNames() const
2301{
2302 return m_illegalNames;
2303}
2304
2305void ExecutionEngine::setQmlEngine(QQmlEngine *engine)
2306{
2307 // Second stage of initialization. We're updating some more prototypes here.
2308 isInitialized = false;
2309 m_qmlEngine = engine;
2310 initQmlGlobalObject();
2311 isInitialized = true;
2312}
2313
2314static void freeze_recursive(QV4::ExecutionEngine *v4, QV4::Object *object)
2315{
2316 if (object->as<QV4::QObjectWrapper>() || object->internalClass()->isFrozen())
2317 return;
2318
2319 QV4::Scope scope(v4);
2320
2321 bool instanceOfObject = false;
2322 QV4::ScopedObject p(scope, object->getPrototypeOf());
2323 while (p) {
2324 if (p->d() == v4->objectPrototype()->d()) {
2325 instanceOfObject = true;
2326 break;
2327 }
2328 p = p->getPrototypeOf();
2329 }
2330 if (!instanceOfObject)
2331 return;
2332
2333 Heap::InternalClass *frozen = object->internalClass()->frozen();
2334 object->setInternalClass(frozen); // Immediately assign frozen to prevent it from getting GC'd
2335
2336 QV4::ScopedObject o(scope);
2337 for (uint i = 0; i < frozen->size; ++i) {
2338 if (!frozen->nameMap.at(i).isStringOrSymbol())
2339 continue;
2340 o = *object->propertyData(index: i);
2341 if (o)
2342 freeze_recursive(v4, object: o);
2343 }
2344}
2345
2346void ExecutionEngine::freezeObject(const QV4::Value &value)
2347{
2348 QV4::Scope scope(this);
2349 QV4::ScopedObject o(scope, value);
2350 freeze_recursive(v4: this, object: o);
2351}
2352
2353void ExecutionEngine::lockObject(const QV4::Value &value)
2354{
2355 QV4::Scope scope(this);
2356 ScopedObject object(scope, value);
2357 if (!object)
2358 return;
2359
2360 std::vector<Heap::Object *> stack { object->d() };
2361
2362 // Methods meant to be overridden
2363 const PropertyKey writableMembers[] = {
2364 id_toString()->propertyKey(),
2365 id_toLocaleString()->propertyKey(),
2366 id_valueOf()->propertyKey(),
2367 id_constructor()->propertyKey()
2368 };
2369 const auto writableBegin = std::begin(arr: writableMembers);
2370 const auto writableEnd = std::end(arr: writableMembers);
2371
2372 while (!stack.empty()) {
2373 object = stack.back();
2374 stack.pop_back();
2375
2376 if (object->as<QV4::QObjectWrapper>() || object->internalClass()->isLocked())
2377 continue;
2378
2379 Scoped<InternalClass> locked(scope, object->internalClass()->locked());
2380 QV4::ScopedObject member(scope);
2381
2382 // Taking this copy is cheap. It's refcounted. This avoids keeping a reference
2383 // to the original IC.
2384 const SharedInternalClassData<PropertyKey> nameMap = locked->d()->nameMap;
2385
2386 for (uint i = 0, end = locked->d()->size; i < end; ++i) {
2387 const PropertyKey key = nameMap.at(i);
2388 if (!key.isStringOrSymbol())
2389 continue;
2390 if ((member = *object->propertyData(index: i))) {
2391 stack.push_back(x: member->d());
2392 if (std::find(first: writableBegin, last: writableEnd, val: key) == writableEnd) {
2393 PropertyAttributes attributes = locked->d()->find(id: key).attributes;
2394 attributes.setConfigurable(false);
2395 attributes.setWritable(false);
2396 locked = locked->changeMember(identifier: key, data: attributes);
2397 }
2398 }
2399 }
2400
2401 object->setInternalClass(locked->d());
2402 }
2403}
2404
2405void ExecutionEngine::startTimer(const QString &timerName)
2406{
2407 if (!m_time.isValid())
2408 m_time.start();
2409 m_startedTimers[timerName] = m_time.elapsed();
2410}
2411
2412qint64 ExecutionEngine::stopTimer(const QString &timerName, bool *wasRunning)
2413{
2414 if (!m_startedTimers.contains(key: timerName)) {
2415 *wasRunning = false;
2416 return 0;
2417 }
2418 *wasRunning = true;
2419 qint64 startedAt = m_startedTimers.take(key: timerName);
2420 return m_time.elapsed() - startedAt;
2421}
2422
2423int ExecutionEngine::consoleCountHelper(const QString &file, quint16 line, quint16 column)
2424{
2425 const QString key = file + QString::number(line) + QString::number(column);
2426 int number = m_consoleCount.value(key, defaultValue: 0);
2427 number++;
2428 m_consoleCount.insert(key, value: number);
2429 return number;
2430}
2431
2432void ExecutionEngine::setExtensionData(int index, Deletable *data)
2433{
2434 if (m_extensionData.size() <= index)
2435 m_extensionData.resize(size: index + 1);
2436
2437 if (m_extensionData.at(i: index))
2438 delete m_extensionData.at(i: index);
2439
2440 m_extensionData[index] = data;
2441}
2442
2443template<typename Source>
2444bool convertToIterable(QMetaType metaType, void *data, Source *sequence)
2445{
2446 QSequentialIterable iterable;
2447 if (!QMetaType::view(fromType: metaType, from: data, toType: QMetaType::fromType<QSequentialIterable>(), to: &iterable))
2448 return false;
2449
2450 const QMetaType elementMetaType = iterable.valueMetaType();
2451 for (qsizetype i = 0, end = sequence->getLength(); i < end; ++i) {
2452 QVariant element(elementMetaType);
2453 ExecutionEngine::metaTypeFromJS(value: sequence->get(i), type: elementMetaType, data: element.data());
2454 iterable.addValue(value: element, position: QSequentialIterable::AtEnd);
2455 }
2456 return true;
2457}
2458
2459/*!
2460 * \internal
2461 *
2462 * Converts a JS value to a meta-type.
2463 * \a data must point to a default-constructed instance of \a metaType.
2464 * Returns \c true if conversion succeeded, \c false otherwise. In the latter case,
2465 * \a data is not modified.
2466 */
2467bool ExecutionEngine::metaTypeFromJS(const Value &value, QMetaType metaType, void *data)
2468{
2469 // check if it's one of the types we know
2470 switch (metaType.id()) {
2471 case QMetaType::Bool:
2472 *reinterpret_cast<bool*>(data) = value.toBoolean();
2473 return true;
2474 case QMetaType::Int:
2475 *reinterpret_cast<int*>(data) = value.toInt32();
2476 return true;
2477 case QMetaType::UInt:
2478 *reinterpret_cast<uint*>(data) = value.toUInt32();
2479 return true;
2480 case QMetaType::Long:
2481 *reinterpret_cast<long*>(data) = long(value.toInteger());
2482 return true;
2483 case QMetaType::ULong:
2484 *reinterpret_cast<ulong*>(data) = ulong(value.toInteger());
2485 return true;
2486 case QMetaType::LongLong:
2487 *reinterpret_cast<qlonglong*>(data) = qlonglong(value.toInteger());
2488 return true;
2489 case QMetaType::ULongLong:
2490 *reinterpret_cast<qulonglong*>(data) = qulonglong(value.toInteger());
2491 return true;
2492 case QMetaType::Double:
2493 *reinterpret_cast<double*>(data) = value.toNumber();
2494 return true;
2495 case QMetaType::QString:
2496 if (value.isUndefined())
2497 *reinterpret_cast<QString*>(data) = QStringLiteral("undefined");
2498 else if (value.isNull())
2499 *reinterpret_cast<QString*>(data) = QStringLiteral("null");
2500 else
2501 *reinterpret_cast<QString*>(data) = value.toQString();
2502 return true;
2503 case QMetaType::QByteArray:
2504 if (const ArrayBuffer *ab = value.as<ArrayBuffer>()) {
2505 *reinterpret_cast<QByteArray*>(data) = ab->asByteArray();
2506 } else if (const String *string = value.as<String>()) {
2507 *reinterpret_cast<QByteArray*>(data) = string->toQString().toUtf8();
2508 } else if (const ArrayObject *ao = value.as<ArrayObject>()) {
2509 // Since QByteArray is sequentially iterable, we have to construct it from a JS Array.
2510 QByteArray result;
2511 const qint64 length = ao->getLength();
2512 result.reserve(asize: length);
2513 for (qint64 i = 0; i < length; ++i) {
2514 char value = 0;
2515 ExecutionEngine::metaTypeFromJS(value: ao->get(idx: i), metaType: QMetaType::fromType<char>(), data: &value);
2516 result.push_back(c: value);
2517 }
2518 *reinterpret_cast<QByteArray*>(data) = std::move(result);
2519 } else {
2520 *reinterpret_cast<QByteArray*>(data) = QByteArray();
2521 }
2522 return true;
2523 case QMetaType::Float:
2524 *reinterpret_cast<float*>(data) = value.toNumber();
2525 return true;
2526 case QMetaType::Short:
2527 *reinterpret_cast<short*>(data) = short(value.toInt32());
2528 return true;
2529 case QMetaType::UShort:
2530 *reinterpret_cast<unsigned short*>(data) = value.toUInt16();
2531 return true;
2532 case QMetaType::Char:
2533 *reinterpret_cast<char*>(data) = char(value.toInt32());
2534 return true;
2535 case QMetaType::UChar:
2536 *reinterpret_cast<unsigned char*>(data) = (unsigned char)(value.toInt32());
2537 return true;
2538 case QMetaType::SChar:
2539 *reinterpret_cast<signed char*>(data) = (signed char)(value.toInt32());
2540 return true;
2541 case QMetaType::QChar:
2542 if (String *s = value.stringValue()) {
2543 QString str = s->toQString();
2544 *reinterpret_cast<QChar*>(data) = str.isEmpty() ? QChar() : str.at(i: 0);
2545 } else {
2546 *reinterpret_cast<QChar*>(data) = QChar(ushort(value.toUInt16()));
2547 }
2548 return true;
2549 case QMetaType::QDateTime:
2550 if (const QV4::DateObject *d = value.as<DateObject>()) {
2551 *reinterpret_cast<QDateTime *>(data) = d->toQDateTime();
2552 return true;
2553 } break;
2554 case QMetaType::QDate:
2555 if (const QV4::DateObject *d = value.as<DateObject>()) {
2556 *reinterpret_cast<QDate *>(data) = DateObject::dateTimeToDate(dateTime: d->toQDateTime());
2557 return true;
2558 } break;
2559 case QMetaType::QTime:
2560 if (const QV4::DateObject *d = value.as<DateObject>()) {
2561 *reinterpret_cast<QTime *>(data) = d->toQDateTime().time();
2562 return true;
2563 } break;
2564 case QMetaType::QUrl:
2565 if (String *s = value.stringValue()) {
2566 *reinterpret_cast<QUrl *>(data) = QUrl(s->toQString());
2567 return true;
2568 } else if (const QV4::UrlObject *d = value.as<UrlObject>()) {
2569 *reinterpret_cast<QUrl *>(data) = d->toQUrl();
2570 return true;
2571 } else if (const QV4::VariantObject *d = value.as<VariantObject>()) {
2572 const QVariant *variant = &d->d()->data();
2573 if (variant->metaType() == QMetaType::fromType<QUrl>()) {
2574 *reinterpret_cast<QUrl *>(data)
2575 = *reinterpret_cast<const QUrl *>(variant->constData());
2576 return true;
2577 }
2578 }
2579 break;
2580#if QT_CONFIG(regularexpression)
2581 case QMetaType::QRegularExpression:
2582 if (const QV4::RegExpObject *r = value.as<QV4::RegExpObject>()) {
2583 *reinterpret_cast<QRegularExpression *>(data) = r->toQRegularExpression();
2584 return true;
2585 } break;
2586#endif
2587 case QMetaType::QObjectStar: {
2588 if (value.isNull()) {
2589 *reinterpret_cast<QObject* *>(data) = nullptr;
2590 return true;
2591 }
2592 if (value.as<QV4::QObjectWrapper>()) {
2593 *reinterpret_cast<QObject* *>(data) = qtObjectFromJS(value);
2594 return true;
2595 }
2596 break;
2597 }
2598 case QMetaType::QStringList: {
2599 const QV4::ArrayObject *a = value.as<QV4::ArrayObject>();
2600 if (a) {
2601 *reinterpret_cast<QStringList *>(data) = a->toQStringList();
2602 return true;
2603 }
2604 break;
2605 }
2606 case QMetaType::QVariantList: {
2607 const QV4::ArrayObject *a = value.as<QV4::ArrayObject>();
2608 if (a) {
2609 *reinterpret_cast<QVariantList *>(data) = ExecutionEngine::toVariant(
2610 value: *a, /*typeHint*/QMetaType{}, /*createJSValueForObjectsAndSymbols*/false)
2611 .toList();
2612 return true;
2613 }
2614 break;
2615 }
2616 case QMetaType::QVariantMap: {
2617 const QV4::Object *o = value.as<QV4::Object>();
2618 if (o) {
2619 *reinterpret_cast<QVariantMap *>(data) = o->engine()->variantMapFromJS(o);
2620 return true;
2621 }
2622 break;
2623 }
2624 case QMetaType::QVariant:
2625 if (value.as<QV4::Managed>()) {
2626 *reinterpret_cast<QVariant*>(data) = ExecutionEngine::toVariant(
2627 value, /*typeHint*/QMetaType{}, /*createJSValueForObjectsAndSymbols*/false);
2628 } else if (value.isNull()) {
2629 *reinterpret_cast<QVariant*>(data) = QVariant::fromValue(value: nullptr);
2630 } else if (value.isUndefined()) {
2631 *reinterpret_cast<QVariant*>(data) = QVariant();
2632 } else if (value.isBoolean()) {
2633 *reinterpret_cast<QVariant*>(data) = QVariant(value.booleanValue());
2634 } else if (value.isInteger()) {
2635 *reinterpret_cast<QVariant*>(data) = QVariant(value.integerValue());
2636 } else if (value.isDouble()) {
2637 *reinterpret_cast<QVariant*>(data) = QVariant(value.doubleValue());
2638 }
2639 return true;
2640 case QMetaType::QJsonValue:
2641 *reinterpret_cast<QJsonValue *>(data) = QV4::JsonObject::toJsonValue(value);
2642 return true;
2643 case QMetaType::QJsonObject: {
2644 *reinterpret_cast<QJsonObject *>(data) = QV4::JsonObject::toJsonObject(o: value.as<Object>());
2645 return true;
2646 }
2647 case QMetaType::QJsonArray: {
2648 const QV4::ArrayObject *a = value.as<ArrayObject>();
2649 if (a) {
2650 *reinterpret_cast<QJsonArray *>(data) = JsonObject::toJsonArray(o: a);
2651 return true;
2652 }
2653 break;
2654 }
2655 default:
2656 break;
2657 }
2658
2659 if (metaType.flags() & QMetaType::IsEnumeration) {
2660 *reinterpret_cast<int *>(data) = value.toInt32();
2661 return true;
2662 }
2663
2664 if (const QV4::QmlListWrapper *wrapper = value.as<QV4::QmlListWrapper>()) {
2665 if (metaType == QMetaType::fromType<QQmlListReference>()) {
2666 *reinterpret_cast<QQmlListReference *>(data) = wrapper->toListReference();
2667 return true;
2668 }
2669
2670 const auto wrapperPrivate = wrapper->d();
2671 if (wrapperPrivate->propertyType() == metaType) {
2672 *reinterpret_cast<QQmlListProperty<QObject> *>(data) = *wrapperPrivate->property();
2673 return true;
2674 }
2675 }
2676
2677 if (const QQmlValueTypeWrapper *vtw = value.as<QQmlValueTypeWrapper>()) {
2678 const QMetaType valueType = vtw->type();
2679 if (valueType == metaType)
2680 return vtw->toGadget(data);
2681
2682 Heap::QQmlValueTypeWrapper *d = vtw->d();
2683 if (d->isReference())
2684 d->readReference();
2685
2686 if (void *gadgetPtr = d->gadgetPtr()) {
2687 if (QQmlValueTypeProvider::populateValueType(
2688 targetMetaType: metaType, target: data, sourceMetaType: valueType, source: gadgetPtr, engine: vtw->engine())) {
2689 return true;
2690 }
2691 if (QMetaType::canConvert(fromType: valueType, toType: metaType))
2692 return QMetaType::convert(fromType: valueType, from: gadgetPtr, toType: metaType, to: data);
2693 } else {
2694 QVariant empty(valueType);
2695 if (QQmlValueTypeProvider::populateValueType(
2696 targetMetaType: metaType, target: data, sourceMetaType: valueType, source: empty.data(), engine: vtw->engine())) {
2697 return true;
2698 }
2699 if (QMetaType::canConvert(fromType: valueType, toType: metaType))
2700 return QMetaType::convert(fromType: valueType, from: empty.data(), toType: metaType, to: data);
2701 }
2702 }
2703
2704 // Try to use magic; for compatibility with qjsvalue_cast.
2705
2706 if (convertToNativeQObject(value, targetType: metaType, result: reinterpret_cast<void **>(data)))
2707 return true;
2708
2709 const bool isPointer = (metaType.flags() & QMetaType::IsPointer);
2710 const QV4::VariantObject *variantObject = value.as<QV4::VariantObject>();
2711 if (variantObject) {
2712 // Actually a reference, because we're poking it for its data() below and we want
2713 // the _original_ data, not some copy.
2714 QVariant &var = variantObject->d()->data();
2715
2716 if (var.metaType() == metaType) {
2717 metaType.destruct(data);
2718 metaType.construct(where: data, copy: var.data());
2719 return true;
2720 }
2721
2722 if (isPointer) {
2723 const QByteArray pointedToTypeName = QByteArray(metaType.name()).chopped(len: 1);
2724 const QMetaType valueType = QMetaType::fromName(name: pointedToTypeName);
2725
2726 if (valueType == var.metaType()) {
2727 // ### Qt7: Remove this. Returning pointers to potentially gc'd data is crazy.
2728 // We have T t, T* is requested, so return &t.
2729 *reinterpret_cast<const void **>(data) = var.data();
2730 return true;
2731 } else if (Object *o = value.objectValue()) {
2732 // Look in the prototype chain.
2733 QV4::Scope scope(o->engine());
2734 QV4::ScopedObject proto(scope, o->getPrototypeOf());
2735 while (proto) {
2736 bool canCast = false;
2737 if (QV4::VariantObject *vo = proto->as<QV4::VariantObject>()) {
2738 const QVariant &v = vo->d()->data();
2739 canCast = (metaType == v.metaType());
2740 }
2741 else if (proto->as<QV4::QObjectWrapper>()) {
2742 QV4::ScopedObject p(scope, proto.getPointer());
2743 if (QObject *qobject = qtObjectFromJS(value: p)) {
2744 if (const QMetaObject *metaObject = metaType.metaObject())
2745 canCast = metaObject->cast(obj: qobject) != nullptr;
2746 else
2747 canCast = qobject->qt_metacast(pointedToTypeName);
2748 }
2749 }
2750 if (canCast) {
2751 const QMetaType varType = var.metaType();
2752 if (varType.flags() & QMetaType::IsPointer) {
2753 *reinterpret_cast<const void **>(data)
2754 = *reinterpret_cast<void *const *>(var.data());
2755 } else {
2756 *reinterpret_cast<const void **>(data) = var.data();
2757 }
2758 return true;
2759 }
2760 proto = proto->getPrototypeOf();
2761 }
2762 }
2763 } else if (QQmlValueTypeProvider::populateValueType(
2764 targetMetaType: metaType, target: data, sourceMetaType: var.metaType(), source: var.data(), engine: variantObject->engine())) {
2765 return true;
2766 }
2767 } else if (value.isNull() && isPointer) {
2768 *reinterpret_cast<void* *>(data) = nullptr;
2769 return true;
2770 } else if (metaType == QMetaType::fromType<QJSValue>()) {
2771 QJSValuePrivate::setValue(jsval: reinterpret_cast<QJSValue*>(data), v: value.asReturnedValue());
2772 return true;
2773 } else if (metaType == QMetaType::fromType<QJSPrimitiveValue>()) {
2774 *reinterpret_cast<QJSPrimitiveValue *>(data) = createPrimitive(v: &value);
2775 return true;
2776 } else if (!isPointer) {
2777 const QV4::Managed *managed = value.as<QV4::Managed>();
2778 if (QQmlValueTypeProvider::populateValueType(
2779 targetMetaType: metaType, target: data, source: value, engine: managed ? managed->engine() : nullptr)) {
2780 return true;
2781 }
2782 }
2783
2784 if (const QV4::Sequence *sequence = value.as<Sequence>()) {
2785 const QVariant result = QV4::SequencePrototype::toVariant(object: sequence);
2786 if (result.metaType() == metaType) {
2787 metaType.destruct(data);
2788 metaType.construct(where: data, copy: result.constData());
2789 return true;
2790 }
2791
2792 if (convertToIterable(metaType, data, sequence))
2793 return true;
2794 }
2795
2796 if (const QV4::ArrayObject *array = value.as<ArrayObject>()) {
2797 if (convertToIterable(metaType, data, sequence: array))
2798 return true;
2799 }
2800
2801 return false;
2802}
2803
2804static bool convertToNativeQObject(const QV4::Value &value, QMetaType targetType, void **result)
2805{
2806 if (!(targetType.flags() & QMetaType::IsPointer))
2807 return false;
2808 if (QObject *qobject = qtObjectFromJS(value)) {
2809 // If the target type has a metaObject, use that for casting.
2810 if (const QMetaObject *targetMetaObject = targetType.metaObject()) {
2811 if (QObject *instance = targetMetaObject->cast(obj: qobject)) {
2812 *result = instance;
2813 return true;
2814 }
2815 return false;
2816 }
2817
2818 // We have to call the generated qt_metacast rather than metaObject->cast() here so that
2819 // it works for types without QMetaObject, such as QStandardItem.
2820 const QByteArray targetTypeName = targetType.name();
2821 const int start = targetTypeName.startsWith(bv: "const ") ? 6 : 0;
2822 const QByteArray className = targetTypeName.mid(index: start, len: targetTypeName.size() - start - 1);
2823 if (void *instance = qobject->qt_metacast(className)) {
2824 *result = instance;
2825 return true;
2826 }
2827 }
2828 return false;
2829}
2830
2831static QObject *qtObjectFromJS(const QV4::Value &value)
2832{
2833 if (!value.isObject())
2834 return nullptr;
2835
2836 QV4::Scope scope(value.as<QV4::Managed>()->engine());
2837 QV4::Scoped<QV4::VariantObject> v(scope, value);
2838
2839 if (v) {
2840 QVariant variant = v->d()->data();
2841 int type = variant.userType();
2842 if (type == QMetaType::QObjectStar)
2843 return *reinterpret_cast<QObject* const *>(variant.constData());
2844 }
2845 QV4::Scoped<QV4::QObjectWrapper> wrapper(scope, value);
2846 if (wrapper)
2847 return wrapper->object();
2848
2849 QV4::Scoped<QV4::QQmlTypeWrapper> typeWrapper(scope, value);
2850 if (typeWrapper)
2851 return typeWrapper->object();
2852
2853 return nullptr;
2854}
2855
2856struct QV4EngineRegistrationData
2857{
2858 QV4EngineRegistrationData() : extensionCount(0) {}
2859
2860 QMutex mutex;
2861 int extensionCount;
2862};
2863Q_GLOBAL_STATIC(QV4EngineRegistrationData, registrationData);
2864
2865QMutex *ExecutionEngine::registrationMutex()
2866{
2867 return &registrationData()->mutex;
2868}
2869
2870int ExecutionEngine::registerExtension()
2871{
2872 return registrationData()->extensionCount++;
2873}
2874
2875#if QT_CONFIG(qml_network)
2876QNetworkAccessManager *QV4::detail::getNetworkAccessManager(ExecutionEngine *engine)
2877{
2878 return engine->qmlEngine()->networkAccessManager();
2879}
2880#endif // qml_network
2881
2882QT_END_NAMESPACE
2883

Provided by KDAB

Privacy Policy
Learn Advanced QML with KDAB
Find out more

source code of qtdeclarative/src/qml/jsruntime/qv4engine.cpp