1// Copyright (C) 2016 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
4#include "qv4object_p.h"
5
6#include <private/qv4argumentsobject_p.h>
7#include <private/qv4identifiertable_p.h>
8#include <private/qv4jscall_p.h>
9#include <private/qv4lookup_p.h>
10#include <private/qv4memberdata_p.h>
11#include <private/qv4mm_p.h>
12#include <private/qv4proxy_p.h>
13#include <private/qv4scopedvalue_p.h>
14#include <private/qv4stackframe_p.h>
15#include <private/qv4stringobject_p.h>
16#include <private/qv4symbol_p.h>
17
18#include <QtCore/qloggingcategory.h>
19
20#include <stdint.h>
21
22using namespace QV4;
23using namespace Qt::Literals::StringLiterals;
24
25Q_LOGGING_CATEGORY(lcJavaScriptGlobals, "qt.qml.js.globals")
26
27DEFINE_OBJECT_VTABLE(Object);
28
29void Object::setInternalClass(Heap::InternalClass *ic)
30{
31 Q_ASSERT(ic && ic->vtable);
32 Heap::Object *p = d();
33
34 if (ic->numRedundantTransitions < p->internalClass.get()->numRedundantTransitions) {
35 // IC was rebuilt. The indices are different now. We need to move everything.
36
37 Scope scope(engine());
38
39 // We allocate before setting the new IC. Protect it from GC.
40 Scoped<InternalClass> newIC(scope, ic);
41
42 // Pick the members of the old IC that are still valid in the new IC.
43 // Order them by index in memberData (or inline data).
44 Scoped<MemberData> newMembers(scope, MemberData::allocate(e: scope.engine, n: ic->size));
45 for (uint i = 0; i < ic->size; ++i) {
46 // Note that some members might have been deleted. The key may be invalid.
47 const PropertyKey key = ic->nameMap.at(i);
48 newMembers->set(e: scope.engine, index: i, v: key.isValid() ? get(id: key) : Encode::undefined());
49 }
50
51 p->internalClass.set(e: scope.engine, newVal: ic);
52 const uint nInline = p->vtable()->nInlineProperties;
53
54 if (ic->size > nInline)
55 p->memberData.set(e: scope.engine, newVal: MemberData::allocate(e: ic->engine, n: ic->size - nInline));
56 else
57 p->memberData.set(e: scope.engine, newVal: nullptr);
58
59 const auto &memberValues = newMembers->d()->values;
60 for (uint i = 0; i < ic->size; ++i)
61 setProperty(index: i, v: memberValues[i]);
62 } else {
63 // The old indices are still the same. No need to move any values.
64 // We may need to re-allocate, though.
65
66 p->internalClass.set(e: ic->engine, newVal: ic);
67 const uint nInline = p->vtable()->nInlineProperties;
68 if (ic->size > nInline) {
69 const uint requiredSize = ic->size - nInline;
70 if ((p->memberData ? p->memberData->values.size : 0) < requiredSize) {
71 p->memberData.set(e: ic->engine, newVal: MemberData::allocate(
72 e: ic->engine, n: requiredSize, old: p->memberData));
73 }
74 }
75 }
76
77 // Before the engine is done initializing, we cannot have any lookups.
78 // Therefore, there is no point in updating the proto IDs.
79 if (ic->engine->isInitialized && ic->isUsedAsProto())
80 ic->updateProtoUsage(o: p);
81
82}
83
84void Object::getProperty(const InternalClassEntry &entry, Property *p) const
85{
86 p->value = *propertyData(index: entry.index);
87 if (entry.attributes.isAccessor())
88 p->set = *propertyData(index: entry.setterIndex);
89}
90
91void Object::setProperty(const InternalClassEntry &entry, const Property *p)
92{
93 setProperty(index: entry.index, v: p->value);
94 if (entry.attributes.isAccessor())
95 setProperty(index: entry.setterIndex, v: p->set);
96}
97
98void Heap::Object::setUsedAsProto()
99{
100 internalClass.set(e: internalClass->engine, newVal: internalClass->asProtoClass());
101}
102
103ReturnedValue Object::getValueAccessor(const Value *thisObject, const Value &v, PropertyAttributes attrs)
104{
105 if (!attrs.isAccessor())
106 return v.asReturnedValue();
107 const QV4::FunctionObject *f = v.as<FunctionObject>();
108 if (!f)
109 return Encode::undefined();
110
111 Scope scope(f->engine());
112 JSCallArguments jsCallData(scope);
113 if (thisObject)
114 *jsCallData.thisObject = *thisObject;
115 return checkedResult(v4: scope.engine, result: f->call(data: jsCallData));
116}
117
118bool Object::putValue(uint memberIndex, PropertyAttributes attrs, const Value &value)
119{
120 Heap::InternalClass *ic = internalClass();
121 if (ic->engine->hasException)
122 return false;
123
124 if (attrs.isAccessor()) {
125 const FunctionObject *set = propertyData(index: memberIndex)->as<FunctionObject>();
126 if (set) {
127 Scope scope(ic->engine);
128 ScopedFunctionObject setter(scope, set);
129 JSCallArguments jsCallData(scope, 1);
130 jsCallData.args[0] = value;
131 *jsCallData.thisObject = this;
132 setter->call(data: jsCallData);
133 return !ic->engine->hasException;
134 }
135 return false;
136 }
137
138 if (!attrs.isWritable())
139 return false;
140
141 setProperty(index: memberIndex, v: value);
142 return true;
143}
144
145void Object::defineDefaultProperty(const QString &name, const Value &value, PropertyAttributes attributes)
146{
147 ExecutionEngine *e = engine();
148 Scope scope(e);
149 ScopedString s(scope, e->newIdentifier(text: name));
150 defineDefaultProperty(name: s, value, attributes);
151}
152
153void Object::defineDefaultProperty(const QString &name, VTable::Call code,
154 int argumentCount, PropertyAttributes attributes)
155{
156 ExecutionEngine *e = engine();
157 Scope scope(e);
158 ScopedString s(scope, e->newIdentifier(text: name));
159 ScopedFunctionObject function(scope, FunctionObject::createBuiltinFunction(engine: e, nameOrSymbol: s, code, argumentCount));
160 defineDefaultProperty(name: s, value: function, attributes);
161}
162
163void Object::defineDefaultProperty(StringOrSymbol *nameOrSymbol, VTable::Call code,
164 int argumentCount, PropertyAttributes attributes)
165{
166 ExecutionEngine *e = engine();
167 Scope scope(e);
168 ScopedFunctionObject function(scope, FunctionObject::createBuiltinFunction(engine: e, nameOrSymbol, code, argumentCount));
169 defineDefaultProperty(name: nameOrSymbol, value: function, attributes);
170}
171
172void Object::defineAccessorProperty(const QString &name, VTable::Call getter, VTable::Call setter)
173{
174 ExecutionEngine *e = engine();
175 Scope scope(e);
176 ScopedString s(scope, e->newIdentifier(text: name));
177 defineAccessorProperty(name: s, getter, setter);
178}
179
180void Object::defineAccessorProperty(StringOrSymbol *name, VTable::Call getter, VTable::Call setter)
181{
182 ExecutionEngine *v4 = engine();
183 QV4::Scope scope(v4);
184 ScopedProperty p(scope);
185 QString n = name->toQString();
186 if (!n.isEmpty() && n.at(i: 0) == '@'_L1)
187 n = '['_L1 + QStringView{n}.mid(pos: 1) + ']'_L1;
188 if (getter) {
189 ScopedString getName(scope, v4->newString(s: "get "_L1 + n));
190 p->setGetter(ScopedFunctionObject(scope, FunctionObject::createBuiltinFunction(engine: v4, nameOrSymbol: getName, code: getter, argumentCount: 0)));
191 } else {
192 p->setGetter(nullptr);
193 }
194 if (setter) {
195 ScopedString setName(scope, v4->newString(s: "set "_L1 + n));
196 p->setSetter(ScopedFunctionObject(scope, FunctionObject::createBuiltinFunction(engine: v4, nameOrSymbol: setName, code: setter, argumentCount: 0)));
197 } else {
198 p->setSetter(nullptr);
199 }
200 insertMember(s: name, p, attributes: QV4::Attr_Accessor|QV4::Attr_NotEnumerable);
201}
202
203
204
205void Object::defineReadonlyProperty(const QString &name, const Value &value)
206{
207 QV4::ExecutionEngine *e = engine();
208 Scope scope(e);
209 ScopedString s(scope, e->newIdentifier(text: name));
210 defineReadonlyProperty(name: s, value);
211}
212
213void Object::defineReadonlyProperty(String *name, const Value &value)
214{
215 insertMember(s: name, v: value, attributes: Attr_ReadOnly);
216}
217
218void Object::defineReadonlyConfigurableProperty(const QString &name, const Value &value)
219{
220 QV4::ExecutionEngine *e = engine();
221 Scope scope(e);
222 ScopedString s(scope, e->newIdentifier(text: name));
223 defineReadonlyConfigurableProperty(name: s, value);
224}
225
226void Object::defineReadonlyConfigurableProperty(StringOrSymbol *name, const Value &value)
227{
228 insertMember(s: name, v: value, attributes: Attr_ReadOnly_ButConfigurable);
229}
230
231void Object::addSymbolSpecies()
232{
233 Scope scope(engine());
234 ScopedProperty p(scope);
235 p->setGetter(scope.engine->getSymbolSpecies());
236 p->setSetter(nullptr);
237 insertMember(s: scope.engine->symbol_species(), p, attributes: QV4::Attr_Accessor|QV4::Attr_NotWritable|QV4::Attr_NotEnumerable);
238}
239
240void Heap::Object::markObjects(Heap::Base *b, MarkStack *stack)
241{
242 Base::markObjects(b, stack);
243 Object *o = static_cast<Object *>(b);
244 if (o->memberData)
245 o->memberData->mark(markStack: stack);
246 if (o->arrayData)
247 o->arrayData->mark(markStack: stack);
248 uint nInline = o->vtable()->nInlineProperties;
249 Value *v = reinterpret_cast<Value *>(o) + o->vtable()->inlinePropertyOffset;
250 const Value *end = v + nInline;
251 while (v < end) {
252 v->mark(markStack: stack);
253 ++v;
254 }
255}
256
257void Object::insertMember(StringOrSymbol *s, const Property *p, PropertyAttributes attributes)
258{
259 InternalClassEntry idx;
260 PropertyKey key = s->toPropertyKey();
261 Heap::InternalClass::addMember(object: this, id: key, data: attributes, entry: &idx);
262
263 setProperty(index: idx.index, v: p->value);
264 if (attributes.isAccessor())
265 setProperty(index: idx.setterIndex, v: p->set);
266}
267
268void Object::setPrototypeUnchecked(const Object *p)
269{
270 setInternalClass(internalClass()->changePrototype(proto: p ? p->d() : nullptr));
271}
272
273// Section 8.12.2
274PropertyIndex Object::getValueOrSetter(PropertyKey id, PropertyAttributes *attrs)
275{
276 if (id.isArrayIndex()) {
277 uint index = id.asArrayIndex();
278 Heap::Object *o = d();
279 while (o) {
280 if (o->arrayData) {
281 uint idx = o->arrayData->mappedIndex(index);
282 if (idx != UINT_MAX) {
283 *attrs = o->arrayData->attributes(i: index);
284 return { .base: o->arrayData , .slot: o->arrayData->values.values + (attrs->isAccessor() ? idx + SetterOffset : idx) };
285 }
286 }
287 if (o->vtable()->type == Type_StringObject) {
288 if (index < static_cast<const Heap::StringObject *>(o)->length()) {
289 // this is an evil hack, but it works, as the method is only ever called from put,
290 // where we don't use the returned pointer there for non writable attributes
291 *attrs = (Attr_NotWritable|Attr_NotConfigurable);
292 return { .base: reinterpret_cast<Heap::ArrayData *>(0x1), .slot: nullptr };
293 }
294 }
295 o = o->prototype();
296 }
297 } else {
298 Heap::Object *o = d();
299 while (o) {
300 auto idx = o->internalClass->findValueOrSetter(id);
301 if (idx.isValid()) {
302 *attrs = idx.attrs;
303 return o->writablePropertyData(index: idx.index);
304 }
305
306 o = o->prototype();
307 }
308 }
309 *attrs = Attr_Invalid;
310 return { .base: nullptr, .slot: nullptr };
311}
312
313ReturnedValue Object::virtualGet(const Managed *m, PropertyKey id, const Value *receiver, bool *hasProperty)
314{
315 return static_cast<const Object *>(m)->internalGet(id, receiver, hasProperty);
316}
317
318bool Object::virtualPut(Managed *m, PropertyKey id, const Value &value, Value *receiver)
319{
320 return static_cast<Object *>(m)->internalPut(id, value, receiver);
321}
322
323bool Object::virtualDeleteProperty(Managed *m, PropertyKey id)
324{
325 return static_cast<Object *>(m)->internalDeleteProperty(id);
326}
327
328PropertyKey ObjectOwnPropertyKeyIterator::next(const Object *o, Property *pd, PropertyAttributes *attrs)
329{
330 if (arrayIndex != UINT_MAX && o->arrayData()) {
331 SparseArrayNode *arrayNode = nullptr;
332 if (o->arrayType() == Heap::ArrayData::Sparse) {
333 SparseArray *sparse = o->arrayData()->sparse;
334 arrayNode = arrayIndex ? sparse->lowerBound(akey: arrayIndex) : sparse->begin();
335 }
336
337 // sparse arrays
338 if (arrayNode) {
339 while (arrayNode != o->sparseEnd()) {
340 uint k = arrayNode->key();
341 uint pidx = arrayNode->value;
342 Heap::SparseArrayData *sa = o->d()->arrayData.cast<Heap::SparseArrayData>();
343 const Property *p = reinterpret_cast<const Property *>(sa->values.data() + pidx);
344 arrayNode = arrayNode->nextNode();
345 PropertyAttributes a = sa->attrs ? sa->attrs[pidx] : Attr_Data;
346 arrayIndex = k + 1;
347 if (pd)
348 pd->copy(other: p, attrs: a);
349 if (attrs)
350 *attrs = a;
351 return PropertyKey::fromArrayIndex(idx: k);
352 }
353 arrayIndex = UINT_MAX;
354 }
355 // dense arrays
356 while (arrayIndex < o->d()->arrayData->values.size) {
357 Heap::SimpleArrayData *sa = o->d()->arrayData.cast<Heap::SimpleArrayData>();
358 const Value &val = sa->data(index: arrayIndex);
359 PropertyAttributes a = o->arrayData()->attributes(i: arrayIndex);
360 int index = arrayIndex;
361 ++arrayIndex;
362 if (!val.isEmpty()) {
363 if (pd)
364 pd->value = val;
365 if (attrs)
366 *attrs = a;
367 return PropertyKey::fromArrayIndex(idx: index);
368 }
369 }
370 arrayIndex = UINT_MAX;
371 }
372
373 while (true) {
374 while (memberIndex < o->internalClass()->size) {
375 PropertyKey n = o->internalClass()->nameMap.at(i: memberIndex);
376 ++memberIndex;
377 if (!n.isStringOrSymbol())
378 // accessor properties have a dummy entry with n == 0
379 continue;
380 if (!iterateOverSymbols && n.isSymbol())
381 continue;
382 if (iterateOverSymbols && !n.isSymbol())
383 continue;
384
385 InternalClassEntry e = o->internalClass()->find(id: n);
386 if (!e.isValid())
387 continue;
388 if (pd) {
389 pd->value = *o->propertyData(index: e.index);
390 if (e.attributes.isAccessor())
391 pd->set = *o->propertyData(index: e.setterIndex);
392 }
393 if (attrs)
394 *attrs = e.attributes;
395 return n;
396 }
397 if (iterateOverSymbols)
398 break;
399 iterateOverSymbols = true;
400 memberIndex = 0;
401 }
402
403 return PropertyKey::invalid();
404}
405
406OwnPropertyKeyIterator *Object::virtualOwnPropertyKeys(const Object *o, Value *target)
407{
408 *target = *o;
409 return new ObjectOwnPropertyKeyIterator;
410}
411
412// Section 8.12.3
413ReturnedValue Object::internalGet(PropertyKey id, const Value *receiver, bool *hasProperty) const
414{
415 Heap::Object *o = d();
416
417 if (id.isArrayIndex()) {
418 const uint index = id.asArrayIndex();
419 Scope scope(this);
420 PropertyAttributes attrs;
421 ScopedProperty pd(scope);
422 while (1) {
423 if (o->arrayData && o->arrayData->getProperty(index, p: pd, attrs: &attrs)) {
424 if (hasProperty)
425 *hasProperty = true;
426 return Object::getValue(thisObject: receiver, v: pd->value, attrs);
427 }
428 if (o->internalClass->vtable->type == Type_StringObject) {
429 ScopedString str(scope, static_cast<Heap::StringObject *>(o)->getIndex(index));
430 if (str) {
431 attrs = (Attr_NotWritable|Attr_NotConfigurable);
432 if (hasProperty)
433 *hasProperty = true;
434 return str.asReturnedValue();
435 }
436 }
437 o = o->prototype();
438 if (!o || o->internalClass->vtable->get != Object::virtualGet)
439 break;
440 }
441 } else {
442 while (1) {
443 auto idx = o->internalClass->findValueOrGetter(id);
444 if (idx.isValid()) {
445 if (hasProperty)
446 *hasProperty = true;
447 return Object::getValue(thisObject: receiver, v: *o->propertyData(index: idx.index), attrs: idx.attrs);
448 }
449 o = o->prototype();
450 if (!o || o->internalClass->vtable->get != Object::virtualGet)
451 break;
452 }
453 }
454
455 if (o) {
456 const Value v = Value::fromHeapObject(m: o);
457 const Object &obj = static_cast<const Object &>(v);
458 return obj.get(id, receiver, hasProperty);
459 }
460
461 if (hasProperty)
462 *hasProperty = false;
463 return Encode::undefined();
464}
465
466// Section 8.12.5
467bool Object::internalPut(PropertyKey id, const Value &value, Value *receiver)
468{
469 Scope scope(this);
470 if (scope.hasException())
471 return false;
472
473 Object *r = receiver->objectValue();
474 if (r && r->d() == d()) {
475 // receiver and this object are the same
476 if (d()->internalClass->vtable->getOwnProperty == Object::virtualGetOwnProperty) {
477 // This object standard methods in the vtable, so we can take a shortcut
478 // and avoid the calls to getOwnProperty and defineOwnProperty
479
480 PropertyAttributes attrs;
481 PropertyIndex propertyIndex{.base: nullptr, .slot: nullptr};
482
483 if (id.isArrayIndex()) {
484 if (arrayData())
485 propertyIndex = arrayData()->getValueOrSetter(index: id.asArrayIndex(), attrs: &attrs);
486 } else {
487 auto member = internalClass()->findValueOrSetter(id);
488 if (member.isValid()) {
489 attrs = member.attrs;
490 propertyIndex = d()->writablePropertyData(index: member.index);
491 }
492 }
493
494 if (!propertyIndex.isNull() && !attrs.isAccessor()) {
495 if (!attrs.isWritable())
496 return false;
497 else if (isArrayObject() && id == scope.engine->id_length()->propertyKey()) {
498 bool ok;
499 uint l = value.asArrayLength(ok: &ok);
500 if (!ok) {
501 scope.engine->throwRangeError(value);
502 return false;
503 }
504 ok = setArrayLength(l);
505 if (!ok)
506 return false;
507 } else {
508 propertyIndex.set(e: scope.engine, newVal: value);
509 }
510 return true;
511 }
512 }
513 }
514
515 ScopedProperty p(scope);
516 PropertyAttributes attrs;
517 attrs = getOwnProperty(id, p);
518 if (attrs == Attr_Invalid) {
519 ScopedObject p(scope, getPrototypeOf());
520 if (p)
521 return p->put(id, v: value, receiver);
522 attrs = Attr_Data;
523 }
524
525 if (attrs.isAccessor()) {
526 ScopedFunctionObject setter(scope, p->setter());
527 if (!setter)
528 return false;
529 JSCallArguments jsCallData(scope, 1);
530 jsCallData.args[0] = value;
531 *jsCallData.thisObject = *receiver;
532 setter->call(data: jsCallData);
533 return !scope.hasException();
534 }
535
536 // Data property
537 if (!attrs.isWritable())
538 return false;
539 if (!r)
540 return false;
541 attrs = r->getOwnProperty(id, p);
542
543 if (attrs != Attr_Invalid) {
544 if (attrs.isAccessor() || !attrs.isWritable())
545 return false;
546 } else {
547 if (!r->isExtensible())
548 return false;
549 attrs = Attr_Data;
550 }
551
552 if (r->internalClass()->vtable->defineOwnProperty == virtualDefineOwnProperty) {
553 // standard object, we can avoid some more checks
554 if (id.isArrayIndex()) {
555 r->arraySet(index: id.asArrayIndex(), value);
556 } else {
557 ScopedStringOrSymbol s(scope, id.asStringOrSymbol());
558 r->insertMember(s, v: value);
559 }
560 return true;
561 }
562
563 p->value = value;
564 return r->defineOwnProperty(id, p, attrs);
565}
566
567// Section 8.12.7
568bool Object::internalDeleteProperty(PropertyKey id)
569{
570 if (internalClass()->engine->hasException)
571 return false;
572
573 if (id.isArrayIndex()) {
574 uint index = id.asArrayIndex();
575 Scope scope(engine());
576 if (scope.hasException())
577 return false;
578
579 Scoped<ArrayData> ad(scope, arrayData());
580 if (!ad || ad->vtable()->del(this, index))
581 return true;
582
583 return false;
584 }
585
586 auto memberIdx = internalClass()->findValueOrGetter(id);
587 if (memberIdx.isValid()) {
588 if (memberIdx.attrs.isConfigurable()) {
589 Heap::InternalClass::removeMember(object: this, identifier: id);
590 return true;
591 }
592 return false;
593 }
594
595 return true;
596}
597
598bool Object::internalDefineOwnProperty(ExecutionEngine *engine, uint index, const InternalClassEntry *memberEntry, const Property *p, PropertyAttributes attrs)
599{
600 // clause 5
601 if (attrs.isEmpty())
602 return true;
603
604 Scope scope(engine);
605 ScopedProperty current(scope);
606 PropertyAttributes cattrs;
607 if (memberEntry) {
608 getProperty(entry: *memberEntry, p: current);
609 cattrs = memberEntry->attributes;
610 } else if (arrayData()) {
611 arrayData()->getProperty(index, p: current, attrs: &cattrs);
612 cattrs = arrayData()->attributes(i: index);
613 }
614
615 // clause 6
616 if (p->isSubset(attrs, other: current, otherAttrs: cattrs))
617 return true;
618
619 // clause 7
620 if (!cattrs.isConfigurable()) {
621 if (attrs.isConfigurable())
622 return false;
623 if (attrs.hasEnumerable() && attrs.isEnumerable() != cattrs.isEnumerable())
624 return false;
625 }
626
627 // clause 8
628 if (attrs.isGeneric() || current->value.isEmpty())
629 goto accept;
630
631 // clause 9
632 if (cattrs.isData() != attrs.isData()) {
633 // 9a
634 if (!cattrs.isConfigurable())
635 return false;
636 if (cattrs.isData()) {
637 // 9b
638 cattrs.setType(PropertyAttributes::Accessor);
639 cattrs.clearWritable();
640 if (!memberEntry) {
641 // need to convert the array and the slot
642 initSparseArray();
643 Q_ASSERT(arrayData());
644 setArrayAttributes(i: index, a: cattrs);
645 }
646 current->setGetter(nullptr);
647 current->setSetter(nullptr);
648 } else {
649 // 9c
650 cattrs.setType(PropertyAttributes::Data);
651 cattrs.setWritable(false);
652 if (!memberEntry) {
653 // need to convert the array and the slot
654 setArrayAttributes(i: index, a: cattrs);
655 }
656 current->value = Value::undefinedValue();
657 }
658 } else if (cattrs.isData() && attrs.isData()) { // clause 10
659 if (!cattrs.isConfigurable() && !cattrs.isWritable()) {
660 if (attrs.isWritable() || !current->value.sameValue(other: p->value))
661 return false;
662 }
663 } else { // clause 10
664 Q_ASSERT(cattrs.isAccessor() && attrs.isAccessor());
665 if (!cattrs.isConfigurable()) {
666 if (!p->value.isEmpty() && current->value.rawValue() != p->value.rawValue())
667 return false;
668 if (!p->set.isEmpty() && current->set.rawValue() != p->set.rawValue())
669 return false;
670 }
671 }
672
673 accept:
674
675 current->merge(attrs&: cattrs, other: p, otherAttrs: attrs);
676 if (memberEntry) {
677 PropertyKey key = internalClass()->nameMap.at(i: memberEntry->index);
678 InternalClassEntry e;
679 Heap::InternalClass::changeMember(object: this, id: key, data: cattrs, entry: &e);
680 setProperty(entry: e, p: current);
681 } else {
682 setArrayAttributes(i: index, a: cattrs);
683 arrayData()->setProperty(e: scope.engine, index, p: current);
684 }
685 return true;
686}
687
688void Object::copyArrayData(Object *other)
689{
690 Q_ASSERT(isArrayObject());
691 Scope scope(engine());
692
693 if (other->protoHasArray() || ArgumentsObject::isNonStrictArgumentsObject(m: other) ||
694 (other->arrayType() == Heap::ArrayData::Sparse && other->arrayData()->attrs)) {
695 uint len = other->getLength();
696 Q_ASSERT(len);
697
698 ScopedValue v(scope);
699 for (uint i = 0; i < len; ++i) {
700 arraySet(index: i, value: (v = other->get(idx: i)));
701 }
702 } else if (!other->arrayData()) {
703 ;
704 } else {
705 Q_ASSERT(!arrayData() && other->arrayData());
706 ArrayData::realloc(o: this, newType: static_cast<ArrayData::Type>(other->d()->arrayData->type),
707 alloc: other->d()->arrayData->values.alloc, enforceAttributes: false);
708 if (other->arrayType() == Heap::ArrayData::Sparse) {
709 Heap::ArrayData *od = other->d()->arrayData;
710 Heap::ArrayData *dd = d()->arrayData;
711 dd->sparse = new SparseArray(*od->sparse);
712 } else {
713 Heap::ArrayData *dd = d()->arrayData;
714 dd->values.size = other->d()->arrayData->values.size;
715 dd->offset = other->d()->arrayData->offset;
716 }
717 // ### need a write barrier
718 memcpy(dest: d()->arrayData->values.values, src: other->d()->arrayData->values.values, n: other->d()->arrayData->values.alloc*sizeof(Value));
719 }
720 setArrayLengthUnchecked(other->getLength());
721}
722
723qint64 Object::virtualGetLength(const Managed *m)
724{
725 Scope scope(static_cast<const Object *>(m)->engine());
726 ScopedValue v(scope, static_cast<Object *>(const_cast<Managed *>(m))->get(name: scope.engine->id_length()));
727 return v->toLength();
728}
729
730// 'var' is 'V' in 15.3.5.3.
731ReturnedValue Object::virtualInstanceOf(const Object *typeObject, const Value &var)
732{
733 QV4::ExecutionEngine *engine = typeObject->internalClass()->engine;
734
735 // 15.3.5.3, Assume F is a Function object.
736 const FunctionObject *function = typeObject->as<FunctionObject>();
737 if (!function)
738 return engine->throwTypeError();
739
740 return checkedInstanceOf(engine, typeObject: function, var);
741}
742
743ReturnedValue Object::virtualResolveLookupGetter(const Object *object, ExecutionEngine *engine, Lookup *lookup)
744{
745 // Otherwise we cannot trust the protoIds
746 Q_ASSERT(engine->isInitialized);
747
748 Heap::Object *obj = object->d();
749 PropertyKey name = engine->identifierTable->asPropertyKey(str: engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[lookup->nameIndex]);
750 if (object->as<QV4::ProxyObject>()) {
751 // proxies invalidate assumptions that we normally maek in lookups
752 // so we always need to use the fallback path
753 lookup->getter = Lookup::getterFallback;
754 return lookup->getter(lookup, engine, *object);
755 }
756 if (name.isArrayIndex()) {
757 lookup->indexedLookup.index = name.asArrayIndex();
758 lookup->getter = Lookup::getterIndexed;
759 return lookup->getter(lookup, engine, *object);
760 }
761
762 auto index = obj->internalClass->findValueOrGetter(id: name);
763 if (index.isValid()) {
764 PropertyAttributes attrs = index.attrs;
765 uint nInline = obj->vtable()->nInlineProperties;
766 if (attrs.isData()) {
767 if (index.index < obj->vtable()->nInlineProperties) {
768 index.index += obj->vtable()->inlinePropertyOffset;
769 lookup->getter = Lookup::getter0Inline;
770 } else {
771 index.index -= nInline;
772 lookup->getter = Lookup::getter0MemberData;
773 }
774 } else {
775 lookup->getter = Lookup::getterAccessor;
776 }
777 lookup->objectLookup.ic.set(engine, heapObject: obj->internalClass.get());
778 lookup->objectLookup.offset = index.index;
779 return lookup->getter(lookup, engine, *object);
780 }
781
782 lookup->protoLookup.protoId = obj->internalClass->protoId;
783 lookup->resolveProtoGetter(name, proto: obj->prototype());
784 return lookup->getter(lookup, engine, *object);
785}
786
787bool Object::virtualResolveLookupSetter(Object *object, ExecutionEngine *engine, Lookup *lookup, const Value &value)
788{
789 // Otherwise we cannot trust the protoIds
790 Q_ASSERT(engine->isInitialized);
791
792 Scope scope(engine);
793 ScopedString name(scope, scope.engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[lookup->nameIndex]);
794
795 Heap::InternalClass *c = object->internalClass();
796 PropertyKey key = name->toPropertyKey();
797 auto idx = c->findValueOrSetter(id: key);
798 if (idx.isValid()) {
799 if (object->isArrayObject() && idx.index == Heap::ArrayObject::LengthPropertyIndex) {
800 Q_ASSERT(!idx.attrs.isAccessor());
801 lookup->setter = Lookup::arrayLengthSetter;
802 return lookup->setter(lookup, engine, *object, value);
803 } else if (idx.attrs.isData() && idx.attrs.isWritable()) {
804 lookup->objectLookup.ic.set(engine, heapObject: object->internalClass());
805 lookup->objectLookup.index = idx.index;
806 const auto nInline = object->d()->vtable()->nInlineProperties;
807 if (idx.index < nInline) {
808 lookup->setter = Lookup::setter0Inline;
809 lookup->objectLookup.offset = idx.index + object->d()->vtable()->inlinePropertyOffset;
810 } else {
811 lookup->setter = Lookup::setter0MemberData;
812 lookup->objectLookup.offset = idx.index - nInline;
813 }
814 return lookup->setter(lookup, engine, *object, value);
815 } else {
816 // ### handle setter
817 lookup->setter = Lookup::setterFallback;
818 }
819 return lookup->setter(lookup, engine, *object, value);
820 }
821
822 lookup->insertionLookup.protoId = c->protoId;
823 if (!object->put(id: key, v: value)) {
824 lookup->setter = Lookup::setterFallback;
825 return false;
826 }
827
828 if (object->internalClass() == c) {
829 // ### setter in the prototype, should handle this
830 lookup->setter = Lookup::setterFallback;
831 return true;
832 }
833 idx = object->internalClass()->findValueOrSetter(id: key);
834 if (!idx.isValid() || idx.attrs.isAccessor()) { // ### can this even happen?
835 lookup->setter = Lookup::setterFallback;
836 return false;
837 }
838 lookup->insertionLookup.newClass.set(engine, heapObject: object->internalClass());
839 lookup->insertionLookup.offset = idx.index;
840 lookup->setter = Lookup::setterInsert;
841 return true;
842}
843
844/*!
845 * \internal
846 *
847 * This method is modeled after \l{QMetaObject::metacall}. It takes a JavaScript
848 * \a object and performs \a call on it, using \a index as identifier for the
849 * property/method/etc to be used and \a a as arguments. Like
850 * \l{QMetaObject::metacall} this method is overly generic in order to reduce the
851 * API surface. On a plain Object it does nothing and returns 0. Specific
852 * objects can override it and do some meaningful work. If the metacall succeeds
853 * they should return a non-0 value. Otherwise they should return 0.
854 *
855 * Most prominently, \l QMetaObject::ReadProperty and \l QMetaObject::WriteProperty
856 * calls can be used to manipulate properties of QObjects and Q_GADGETs wrapped
857 * by QV4::QObjectWrapper, QV4::QQmlTypeWrapper and QV4::QQmlValueTypeWrapper.
858 * They can also be used to manipulate elements in QV4::Sequence.
859 */
860int Object::virtualMetacall(Object *object, QMetaObject::Call call, int index, void **a)
861{
862 Q_UNUSED(object);
863 Q_UNUSED(call);
864 Q_UNUSED(index);
865 Q_UNUSED(a);
866 return 0;
867}
868
869ReturnedValue Object::checkedInstanceOf(ExecutionEngine *engine, const FunctionObject *f, const Value &var)
870{
871 Scope scope(engine);
872 if (f->isBoundFunction()) {
873 ScopedValue v(scope, static_cast<const BoundFunction *>(f)->target());
874 f = v->as<FunctionObject>();
875 }
876
877 // 15.3.5.3, 1: HasInstance can only be used on an object
878 const Object *lhs = var.as<Object>();
879 if (!lhs)
880 return Encode(false);
881
882 // 15.3.5.3, 2
883 Value p = Value::fromReturnedValue(val: f->protoProperty());
884 const Object *o = p.objectValue();
885 if (!o) // 15.3.5.3, 3
886 return f->engine()->throwTypeError();
887
888 Heap::Object *v = lhs->d();
889
890 // 15.3.5.3, 4
891 while (v) {
892 // 15.3.5.3, 4, a
893 v = v->prototype();
894
895 // 15.3.5.3, 4, b
896 if (!v)
897 break; // will return false
898
899 // 15.3.5.3, 4, c
900 else if (o->d() == v)
901 return Encode(true);
902 }
903
904 return Encode(false);
905}
906
907bool Object::virtualHasProperty(const Managed *m, PropertyKey id)
908{
909 Scope scope(m->engine());
910 ScopedObject o(scope, m);
911 ScopedProperty p(scope);
912
913 if (o->getOwnProperty(id, p) != Attr_Invalid)
914 return true;
915
916 o = o->getPrototypeOf();
917 if (o)
918 return o->hasProperty(id);
919
920 return false;
921}
922
923PropertyAttributes Object::virtualGetOwnProperty(const Managed *m, PropertyKey id, Property *p)
924{
925 PropertyAttributes attrs;
926 const Object *o = static_cast<const Object *>(m);
927 if (id.isArrayIndex()) {
928 uint index = id.asArrayIndex();
929 if (o->arrayData()) {
930 if (o->arrayData()->getProperty(index, p, attrs: &attrs))
931 return attrs;
932 }
933 } else {
934 Q_ASSERT(id.asStringOrSymbol());
935
936 auto member = o->internalClass()->find(id);
937 if (member.isValid()) {
938 attrs = member.attributes;
939 if (p) {
940 p->value = *o->propertyData(index: member.index);
941 if (attrs.isAccessor())
942 p->set = *o->propertyData(index: member.setterIndex);
943 }
944 return attrs;
945 }
946 }
947
948 return Attr_Invalid;
949}
950
951bool Object::virtualDefineOwnProperty(Managed *m, PropertyKey id, const Property *p, PropertyAttributes attrs)
952{
953 Object *o = static_cast<Object *>(m);
954 Scope scope(o);
955
956 if (id.isArrayIndex()) {
957 uint index = id.asArrayIndex();
958
959 bool hasProperty = false;
960
961 if (o->arrayData()) {
962 hasProperty = o->arrayData()->mappedIndex(index) != UINT_MAX;
963 if (!hasProperty && o->isStringObject())
964 hasProperty = (index < static_cast<StringObject *>(o)->length());
965 }
966
967 if (!hasProperty) {
968 if (!o->isExtensible())
969 return false;
970
971 ScopedProperty pp(scope);
972 pp->copy(other: p, attrs);
973 pp->fullyPopulated(attrs: &attrs);
974 if (attrs == Attr_Data) {
975 ScopedValue v(scope, pp->value);
976 o->arraySet(index, value: v);
977 } else {
978 o->arraySet(index, p: pp, attributes: attrs);
979 }
980 return true;
981 }
982
983 return o->internalDefineOwnProperty(engine: scope.engine, index, memberEntry: nullptr, p, attrs);
984 }
985
986 Scoped<InternalClass> ic(scope, o->internalClass());
987 auto memberIndex = ic->d()->find(id);
988
989 if (!memberIndex.isValid()) {
990 if (!o->isExtensible())
991 return false;
992
993 // If the IC is locked, you're not allowed to shadow any unconfigurable properties.
994 if (ic->d()->isLocked()) {
995 while (Heap::Object *prototype = ic->d()->prototype) {
996 ic = prototype->internalClass;
997 const auto entry = ic->d()->find(id);
998 if (entry.isValid()) {
999 if (entry.attributes.isConfigurable())
1000 break;
1001 qCWarning(lcJavaScriptGlobals).noquote()
1002 << QStringLiteral("You cannot shadow the locked property "
1003 "'%1' in QML.").arg(a: id.toQString());
1004 return false;
1005 }
1006 }
1007 }
1008
1009 Scoped<StringOrSymbol> name(scope, id.asStringOrSymbol());
1010 ScopedProperty pd(scope);
1011 pd->copy(other: p, attrs);
1012 pd->fullyPopulated(attrs: &attrs);
1013 o->insertMember(s: name, p: pd, attributes: attrs);
1014 return true;
1015 }
1016
1017 return o->internalDefineOwnProperty(engine: scope.engine, UINT_MAX, memberEntry: &memberIndex, p, attrs);
1018}
1019
1020bool Object::virtualIsExtensible(const Managed *m)
1021{
1022 return m->d()->internalClass->isExtensible();
1023}
1024
1025bool Object::virtualPreventExtensions(Managed *m)
1026{
1027 Q_ASSERT(m->isObject());
1028 Object *o = static_cast<Object *>(m);
1029 o->setInternalClass(o->internalClass()->nonExtensible());
1030 return true;
1031}
1032
1033Heap::Object *Object::virtualGetPrototypeOf(const Managed *m)
1034{
1035 return m->internalClass()->prototype;
1036}
1037
1038bool Object::virtualSetPrototypeOf(Managed *m, const Object *proto)
1039{
1040 Q_ASSERT(m->isObject());
1041 Object *o = static_cast<Object *>(m);
1042 Heap::InternalClass *ic = o->internalClass();
1043 Heap::Object *current = ic->prototype;
1044 Heap::Object *protod = proto ? proto->d() : nullptr;
1045 if (current == protod)
1046 return true;
1047 if (!ic->isExtensible() || ic->isLocked())
1048 return false;
1049 Heap::Object *p = protod;
1050 while (p) {
1051 if (p == o->d())
1052 return false;
1053 if (p->vtable()->getPrototypeOf != Object::staticVTable()->getPrototypeOf)
1054 break;
1055 p = p->prototype();
1056 }
1057 o->setInternalClass(ic->changePrototype(proto: protod));
1058 return true;
1059}
1060
1061bool Object::setArrayLength(uint newLen)
1062{
1063 Q_ASSERT(isArrayObject());
1064 if (!internalClass()->propertyData[Heap::ArrayObject::LengthPropertyIndex].isWritable())
1065 return false;
1066 uint oldLen = getLength();
1067 bool ok = true;
1068 if (newLen < oldLen) {
1069 if (arrayData()) {
1070 uint l = arrayData()->vtable()->truncate(this, newLen);
1071 if (l != newLen)
1072 ok = false;
1073 newLen = l;
1074 }
1075 } else {
1076 if (newLen >= 0x100000)
1077 initSparseArray();
1078 else
1079 ArrayData::realloc(o: this, newType: arrayType(), alloc: newLen, enforceAttributes: false);
1080 }
1081 setArrayLengthUnchecked(newLen);
1082 return ok;
1083}
1084
1085void Object::initSparseArray()
1086{
1087 if (arrayType() == Heap::ArrayData::Sparse)
1088 return;
1089
1090 ArrayData::realloc(o: this, newType: Heap::ArrayData::Sparse, alloc: 0, enforceAttributes: false);
1091}
1092
1093bool Object::isConcatSpreadable() const
1094{
1095 Scope scope(this);
1096 ScopedValue spreadable(scope, get(name: scope.engine->symbol_isConcatSpreadable()));
1097 if (!spreadable->isUndefined())
1098 return spreadable->toBoolean();
1099 return isArray();
1100}
1101
1102bool Object::isArray() const
1103{
1104 if (isArrayObject())
1105 return true;
1106 if (vtable() == ProxyObject::staticVTable()) {
1107 const ProxyObject *p = static_cast<const ProxyObject *>(this);
1108 Scope scope(this);
1109 if (!p->d()->handler) {
1110 scope.engine->throwTypeError();
1111 return false;
1112 }
1113 ScopedObject o(scope, p->d()->target);
1114 return o->isArray();
1115 }
1116 return false;
1117}
1118
1119const FunctionObject *Object::speciesConstructor(Scope &scope, const FunctionObject *defaultConstructor) const
1120{
1121 ScopedValue C(scope, get(name: scope.engine->id_constructor()));
1122 if (C->isUndefined())
1123 return defaultConstructor;
1124 const Object *c = C->objectValue();
1125 if (!c) {
1126 scope.engine->throwTypeError();
1127 return nullptr;
1128 }
1129 ScopedValue S(scope, c->get(name: scope.engine->symbol_species()));
1130 if (S->isNullOrUndefined())
1131 return defaultConstructor;
1132 const FunctionObject *f = S->as<FunctionObject>();
1133 if (!f || !f->isConstructor()) {
1134 scope.engine->throwTypeError();
1135 return nullptr;
1136 }
1137 Q_ASSERT(f->isFunctionObject());
1138 return static_cast<const FunctionObject *>(f);
1139}
1140
1141bool Object::setProtoFromNewTarget(const Value *newTarget)
1142{
1143 if (!newTarget || newTarget->isUndefined())
1144 return false;
1145
1146 Q_ASSERT(newTarget->isFunctionObject());
1147 Scope scope(this);
1148 ScopedObject proto(scope, static_cast<const FunctionObject *>(newTarget)->protoProperty());
1149 if (proto) {
1150 setPrototypeOf(proto);
1151 return true;
1152 }
1153 return false;
1154}
1155
1156
1157DEFINE_OBJECT_VTABLE(ArrayObject);
1158
1159void Heap::ArrayObject::init(const QStringList &list)
1160{
1161 Object::init();
1162 commonInit();
1163 Scope scope(internalClass->engine);
1164 ScopedObject a(scope, this);
1165
1166 // Converts a QStringList to JS.
1167 // The result is a new Array object with length equal to the length
1168 // of the QStringList, and the elements being the QStringList's
1169 // elements converted to JS Strings.
1170 int len = list.size();
1171 a->arrayReserve(n: len);
1172 ScopedValue v(scope);
1173 for (int ii = 0; ii < len; ++ii)
1174 a->arrayPut(index: ii, value: (v = scope.engine->newString(s: list.at(i: ii))));
1175 a->setArrayLengthUnchecked(len);
1176}
1177
1178qint64 ArrayObject::virtualGetLength(const Managed *m)
1179{
1180 const ArrayObject *a = static_cast<const ArrayObject *>(m);
1181 return a->propertyData(index: Heap::ArrayObject::LengthPropertyIndex)->toLength();
1182}
1183
1184QStringList ArrayObject::toQStringList() const
1185{
1186 QStringList result;
1187
1188 QV4::ExecutionEngine *engine = internalClass()->engine;
1189 Scope scope(engine);
1190 ScopedValue v(scope);
1191
1192 uint length = getLength();
1193 result.reserve(asize: length);
1194 for (uint i = 0; i < length; ++i) {
1195 v = const_cast<ArrayObject *>(this)->get(idx: i);
1196 result.append(t: v->toQStringNoThrow());
1197 }
1198 return result;
1199}
1200
1201bool ArrayObject::virtualDefineOwnProperty(Managed *m, PropertyKey id, const Property *p, PropertyAttributes attrs)
1202{
1203 Q_ASSERT(m->isArrayObject());
1204 ArrayObject *a = static_cast<ArrayObject *>(m);
1205
1206 if (id.isArrayIndex()) {
1207 uint index = id.asArrayIndex();
1208 uint len = a->getLength();
1209 if (index >= len && !a->internalClass()->propertyData[Heap::ArrayObject::LengthPropertyIndex].isWritable())
1210 return false;
1211
1212 bool succeeded = Object::virtualDefineOwnProperty(m, id, p, attrs);
1213 if (!succeeded)
1214 return false;
1215
1216 if (index >= len)
1217 a->setArrayLengthUnchecked(index + 1);
1218
1219 return true;
1220 }
1221
1222 ExecutionEngine *engine = m->engine();
1223 if (id == engine->id_length()->propertyKey()) {
1224 Scope scope(engine);
1225 Q_ASSERT(a->internalClass()->verifyIndex(engine->id_length()->propertyKey(), Heap::ArrayObject::LengthPropertyIndex));
1226 ScopedProperty lp(scope);
1227 InternalClassEntry e = a->internalClass()->find(id: scope.engine->id_length()->propertyKey());
1228 a->getProperty(entry: e, p: lp);
1229 if (attrs.isEmpty() || p->isSubset(attrs, other: lp, otherAttrs: e.attributes))
1230 return true;
1231 if (!e.attributes.isWritable() || attrs.type() == PropertyAttributes::Accessor || attrs.isConfigurable() || attrs.isEnumerable())
1232 return false;
1233 bool succeeded = true;
1234 if (attrs.type() == PropertyAttributes::Data) {
1235 bool ok;
1236 uint l = p->value.asArrayLength(ok: &ok);
1237 if (!ok) {
1238 ScopedValue v(scope, p->value);
1239 engine->throwRangeError(value: v);
1240 return false;
1241 }
1242 succeeded = a->setArrayLength(l);
1243 }
1244 if (attrs.hasWritable() && !attrs.isWritable()) {
1245 e.attributes.setWritable(false);
1246 Heap::InternalClass::changeMember(object: a, id: engine->id_length()->propertyKey(), data: e.attributes);
1247 }
1248 if (!succeeded)
1249 return false;
1250 return true;
1251 }
1252 return Object::virtualDefineOwnProperty(m, id, p, attrs);
1253}
1254

Provided by KDAB

Privacy Policy
Start learning QML with our Intro Training
Find out more

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