bool InferredTypeTable::willStoreValue( VM& vm, PropertyName propertyName, JSValue value, StoredPropertyAge age) { // The algorithm here relies on the fact that only one thread modifies the hash map. if (age == OldProperty) { TableType::iterator iter = m_table.find(propertyName.uid()); if (iter == m_table.end() || !iter->value) return false; // Absence on replace => top. if (iter->value->willStoreValue(vm, propertyName, value)) return true; iter->value.clear(); return false; } TableType::AddResult result; { ConcurrentJSLocker locker(m_lock); result = m_table.add(propertyName.uid(), WriteBarrier<InferredType>()); } if (result.isNewEntry) { InferredType* inferredType = InferredType::create(vm); WTF::storeStoreFence(); result.iterator->value.set(vm, this, inferredType); } else if (!result.iterator->value) return false; if (result.iterator->value->willStoreValue(vm, propertyName, value)) return true; result.iterator->value.clear(); return false; }
bool JSModuleNamespaceObject::getOwnPropertySlot(JSObject* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot) { // http://www.ecma-international.org/ecma-262/6.0/#sec-module-namespace-exotic-objects-getownproperty-p JSModuleNamespaceObject* thisObject = jsCast<JSModuleNamespaceObject*>(cell); // step 1. // If the property name is a symbol, we don't look into the imported bindings. // It may return the descriptor with writable: true, but namespace objects does not allow it in [[Set]] / [[DefineOwnProperty]] side. if (propertyName.isSymbol()) return JSObject::getOwnPropertySlot(thisObject, exec, propertyName, slot); if (!thisObject->m_exports.contains(propertyName.uid())) return false; // https://esdiscuss.org/topic/march-24-meeting-notes // http://www.ecma-international.org/ecma-262/6.0/#sec-module-namespace-exotic-objects-getownproperty-p // section 9.4.6.5, step 6. // This property will be seen as writable: true, enumerable:true, configurable: false. // But this does not mean that this property is writable by users. // // In JSC, getOwnPropertySlot is not designed to throw any errors. But looking up the value from the module // environment may throw error if the loaded variable is the TDZ value. To workaround, we set the custom // getter function. When it is called, it looks up the variable and throws an error if the variable is not // initialized. slot.setCustom(thisObject, DontDelete, callbackGetter); return true; }
void InferredTypeTable::makeTop(VM& vm, PropertyName propertyName, StoredPropertyAge age) { // The algorithm here relies on the fact that only one thread modifies the hash map. if (age == OldProperty) { TableType::iterator iter = m_table.find(propertyName.uid()); if (iter == m_table.end()) return; // Absence on replace => top. InferredType* entryValue = iter->value.get(); if (!entryValue) return; entryValue->makeTop(vm, propertyName); iter->value.clear(); return; } TableType::AddResult result; { ConcurrentJSLocker locker(m_lock); result = m_table.add(propertyName.uid(), WriteBarrier<InferredType>()); } if (!result.iterator->value) return; result.iterator->value->makeTop(vm, propertyName); result.iterator->value.clear(); }
inline_t bool Library::RegisterPropertyNameInternal(const PropertyName & propertyName, bool checkForDuplicates) { if (checkForDuplicates && (m_propertyNameTable.find(propertyName.GetName()) != m_propertyNameTable.end())) return false; m_propertyNameTable.insert(std::make_pair(propertyName.GetName(), propertyName)); if (propertyName.GetPartCount() > m_maxPropertyParts) m_maxPropertyParts = propertyName.GetPartCount(); return true; }
void PropertyEditorQmlBackend::setValue(const QmlObjectNode & qmlObjectNode, const PropertyName &name, const QVariant &value) { PropertyName propertyName = name; propertyName.replace('.', '_'); PropertyEditorValue *propertyValue = qobject_cast<PropertyEditorValue*>(variantToQObject(m_backendValuesPropertyMap.value(propertyName))); if (propertyValue) { propertyValue->setValue(value); if (!qmlObjectNode.hasBindingProperty(name)) propertyValue->setExpression(value.toString()); else propertyValue->setExpression(qmlObjectNode.expression(name)); } }
static NPIdentifier npIdentifierFromIdentifier(PropertyName propertyName) { String name(propertyName.publicName()); if (name.isNull()) return 0; return static_cast<NPIdentifier>(IdentifierRep::get(name.utf8().data())); }
inline bool JSLexicalEnvironment::symbolTablePut(ExecState* exec, PropertyName propertyName, JSValue value, bool shouldThrow) { VM& vm = exec->vm(); ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this)); WriteBarrierBase<Unknown>* reg; WatchpointSet* set; { GCSafeConcurrentJITLocker locker(symbolTable()->m_lock, exec->vm().heap); SymbolTable::Map::iterator iter = symbolTable()->find(locker, propertyName.uid()); if (iter == symbolTable()->end(locker)) return false; ASSERT(!iter->value.isNull()); if (iter->value.isReadOnly()) { if (shouldThrow) throwTypeError(exec, StrictModeReadonlyPropertyWriteError); return true; } ScopeOffset offset = iter->value.scopeOffset(); // Defend against the inspector asking for a var after it has been optimized out. if (!isValid(offset)) return false; set = iter->value.watchpointSet(); reg = &variableAt(offset); } reg->set(vm, this, value); if (set) set->invalidate(VariableWriteFireDetail(this, propertyName)); // Don't mess around - if we had found this statically, we would have invalidated it. return true; }
bool JSStorage::putDelegate(ExecState* state, PropertyName propertyName, JSValue value, PutPropertySlot&, bool& putResult) { VM& vm = state->vm(); auto scope = DECLARE_THROW_SCOPE(vm); // Only perform the custom put if the object doesn't have a native property by this name. // Since hasProperty() would end up calling canGetItemsForName() and be fooled, we need to check // the native property slots manually. PropertySlot slot { this, PropertySlot::InternalMethodType::GetOwnProperty }; JSValue prototype = this->getPrototypeDirect(); if (prototype.isObject() && asObject(prototype)->getPropertySlot(state, propertyName, slot)) return false; if (propertyName.isSymbol()) return false; String stringValue = value.toWTFString(state); RETURN_IF_EXCEPTION(scope, true); auto setItemResult = wrapped().setItem(propertyNameToString(propertyName), stringValue); if (setItemResult.hasException()) { propagateException(*state, scope, setItemResult.releaseException()); return true; } putResult = true; return true; }
bool JSStorage::putDelegate(ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot&) { // Only perform the custom put if the object doesn't have a native property by this name. // Since hasProperty() would end up calling canGetItemsForName() and be fooled, we need to check // the native property slots manually. PropertySlot slot(this); if (getStaticValueSlot<JSStorage, Base>(exec, *s_info.staticPropHashTable, this, propertyName, slot)) return false; JSValue prototype = this->prototype(); if (prototype.isObject() && asObject(prototype)->getPropertySlot(exec, propertyName, slot)) return false; if (propertyName.isSymbol()) return false; String stringValue = value.toString(exec)->value(exec); if (exec->hadException()) return true; ExceptionCode ec = 0; wrapped().setItem(propertyNameToString(propertyName), stringValue, ec); setDOMException(exec, ec); return true; }
bool Arguments::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor) { Arguments* thisObject = jsCast<Arguments*>(object); unsigned i = propertyName.asIndex(); if (i < thisObject->d->numArguments && (!thisObject->d->deletedArguments || !thisObject->d->deletedArguments[i])) { ASSERT(i < PropertyName::NotAnIndex); descriptor.setDescriptor(thisObject->argument(i).get(), None); return true; } if (propertyName == exec->propertyNames().length && LIKELY(!thisObject->d->overrodeLength)) { descriptor.setDescriptor(jsNumber(thisObject->d->numArguments), DontEnum); return true; } if (propertyName == exec->propertyNames().callee && LIKELY(!thisObject->d->overrodeCallee)) { if (!thisObject->d->isStrictMode) { descriptor.setDescriptor(thisObject->d->callee.get(), DontEnum); return true; } thisObject->createStrictModeCalleeIfNecessary(exec); } if (propertyName == exec->propertyNames().caller && thisObject->d->isStrictMode) thisObject->createStrictModeCallerIfNecessary(exec); return JSObject::getOwnPropertyDescriptor(thisObject, exec, propertyName, descriptor); }
void Arguments::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot) { Arguments* thisObject = jsCast<Arguments*>(cell); unsigned i = propertyName.asIndex(); if (i < thisObject->d->numArguments && (!thisObject->d->deletedArguments || !thisObject->d->deletedArguments[i])) { ASSERT(i < PropertyName::NotAnIndex); thisObject->argument(i).set(exec->globalData(), thisObject, value); return; } if (propertyName == exec->propertyNames().length && !thisObject->d->overrodeLength) { thisObject->d->overrodeLength = true; thisObject->putDirect(exec->globalData(), propertyName, value, DontEnum); return; } if (propertyName == exec->propertyNames().callee && !thisObject->d->overrodeCallee) { if (!thisObject->d->isStrictMode) { thisObject->d->overrodeCallee = true; thisObject->putDirect(exec->globalData(), propertyName, value, DontEnum); return; } thisObject->createStrictModeCalleeIfNecessary(exec); } if (propertyName == exec->propertyNames().caller && thisObject->d->isStrictMode) thisObject->createStrictModeCallerIfNecessary(exec); JSObject::put(thisObject, exec, propertyName, value, slot); }
bool Arguments::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot) { Arguments* thisObject = jsCast<Arguments*>(cell); unsigned i = propertyName.asIndex(); if (i < thisObject->d->numArguments && (!thisObject->d->deletedArguments || !thisObject->d->deletedArguments[i])) { ASSERT(i < PropertyName::NotAnIndex); slot.setValue(thisObject->argument(i).get()); return true; } if (propertyName == exec->propertyNames().length && LIKELY(!thisObject->d->overrodeLength)) { slot.setValue(jsNumber(thisObject->d->numArguments)); return true; } if (propertyName == exec->propertyNames().callee && LIKELY(!thisObject->d->overrodeCallee)) { if (!thisObject->d->isStrictMode) { slot.setValue(thisObject->d->callee.get()); return true; } thisObject->createStrictModeCalleeIfNecessary(exec); } if (propertyName == exec->propertyNames().caller && thisObject->d->isStrictMode) thisObject->createStrictModeCallerIfNecessary(exec); return JSObject::getOwnPropertySlot(thisObject, exec, propertyName, slot); }
bool JSHTMLDocument::nameGetter(ExecState* exec, PropertyName propertyName, JSValue& value) { auto& document = wrapped(); AtomicStringImpl* atomicPropertyName = propertyName.publicName(); if (!atomicPropertyName || !document.hasDocumentNamedItem(*atomicPropertyName)) return false; if (UNLIKELY(document.documentNamedItemContainsMultipleElements(*atomicPropertyName))) { Ref<HTMLCollection> collection = document.documentNamedItems(atomicPropertyName); ASSERT(collection->length() > 1); value = toJS(exec, globalObject(), WTF::getPtr(collection)); return true; } Element* element = document.documentNamedItem(*atomicPropertyName); if (UNLIKELY(is<HTMLIFrameElement>(*element))) { if (Frame* frame = downcast<HTMLIFrameElement>(*element).contentFrame()) { value = toJS(exec, frame); return true; } } value = toJS(exec, globalObject(), element); return true; }
bool JSStorage::putDelegate(ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot&, bool& putResult) { // Only perform the custom put if the object doesn't have a native property by this name. // Since hasProperty() would end up calling canGetItemsForName() and be fooled, we need to check // the native property slots manually. PropertySlot slot(this, PropertySlot::InternalMethodType::GetOwnProperty); static_assert(!hasStaticPropertyTable, "This function does not handle static instance properties"); JSValue prototype = this->getPrototypeDirect(); if (prototype.isObject() && asObject(prototype)->getPropertySlot(exec, propertyName, slot)) return false; if (propertyName.isSymbol()) return false; String stringValue = value.toString(exec)->value(exec); if (exec->hadException()) { // The return value indicates whether putDelegate() should handle the put operation (which // if true, tells the caller not to execute the generic put). It does not indicate whether // putDelegate() did successfully complete the operation or not (which it didn't in this // case due to the exception). putResult = false; return true; } ExceptionCode ec = 0; wrapped().setItem(propertyNameToString(propertyName), stringValue, ec); setDOMException(exec, ec); putResult = !ec; return true; }
bool Arguments::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName) { if (exec->vm().isInDefineOwnProperty()) return Base::deleteProperty(cell, exec, propertyName); Arguments* thisObject = jsCast<Arguments*>(cell); unsigned i = propertyName.asIndex(); if (i < thisObject->m_numArguments) { RELEASE_ASSERT(i < PropertyName::NotAnIndex); if (!Base::deleteProperty(cell, exec, propertyName)) return false; if (thisObject->tryDeleteArgument(exec->vm(), i)) return true; } if (propertyName == exec->propertyNames().length && !thisObject->m_overrodeLength) { thisObject->m_overrodeLength = true; return true; } if (propertyName == exec->propertyNames().callee && !thisObject->m_overrodeCallee) { if (!thisObject->m_isStrictMode) { thisObject->m_overrodeCallee = true; return true; } thisObject->createStrictModeCalleeIfNecessary(exec); } if (propertyName == exec->propertyNames().caller && thisObject->m_isStrictMode) thisObject->createStrictModeCallerIfNecessary(exec); return JSObject::deleteProperty(thisObject, exec, propertyName); }
void Arguments::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot) { Arguments* thisObject = jsCast<Arguments*>(cell); unsigned i = propertyName.asIndex(); if (thisObject->trySetArgument(exec->vm(), i, value)) return; if (propertyName == exec->propertyNames().length && !thisObject->m_overrodeLength) { thisObject->m_overrodeLength = true; thisObject->putDirect(exec->vm(), propertyName, value, DontEnum); return; } if (propertyName == exec->propertyNames().callee && !thisObject->m_overrodeCallee) { if (!thisObject->m_isStrictMode) { thisObject->m_overrodeCallee = true; thisObject->putDirect(exec->vm(), propertyName, value, DontEnum); return; } thisObject->createStrictModeCalleeIfNecessary(exec); } if (propertyName == exec->propertyNames().caller && thisObject->m_isStrictMode) thisObject->createStrictModeCallerIfNecessary(exec); JSObject::put(thisObject, exec, propertyName, value, slot); }
bool JSTestEventTarget::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor) { JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(object); ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info); const HashEntry* entry = JSTestEventTargetTable.entry(exec, propertyName); if (entry) { PropertySlot slot(thisObject); slot.setCustom(thisObject, entry->propertyGetter()); descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes()); return true; } unsigned index = propertyName.asIndex(); if (index != PropertyName::NotAnIndex && index < static_cast<TestEventTarget*>(thisObject->impl())->length()) { PropertySlot slot(thisObject); slot.setCustomIndex(thisObject, index, indexGetter); descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly); return true; } if (canGetItemsForName(exec, static_cast<TestEventTarget*>(thisObject->impl()), propertyName)) { PropertySlot slot(thisObject); slot.setCustom(thisObject, nameGetter); descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum); return true; } return getStaticValueDescriptor<JSTestEventTarget, Base>(exec, &JSTestEventTargetTable, thisObject, propertyName, descriptor); }
bool Structure::prototypeChainMayInterceptStoreTo(JSGlobalData& globalData, PropertyName propertyName) { unsigned i = propertyName.asIndex(); if (i != PropertyName::NotAnIndex) return anyObjectInChainMayInterceptIndexedAccesses(); for (Structure* current = this; ;) { JSValue prototype = current->storedPrototype(); if (prototype.isNull()) return false; current = prototype.asCell()->structure(); unsigned attributes; JSCell* specificValue; PropertyOffset offset = current->get(globalData, propertyName, attributes, specificValue); if (!JSC::isValidOffset(offset)) continue; if (attributes & (ReadOnly | Accessor)) return true; return false; } }
static MidiByte getByte(const Event &e, const PropertyName &name) { long value = -1; try { value = e.get<Int>(name); } catch (...) { } if (value < 0 || value > 255) throw MIDIValueOutOfRange(name.getName()); return MidiByte(value); }
MethodList JavaClass::methodsNamed(PropertyName propertyName, Instance*) const { MethodList* methodList = m_methods.get(propertyName.publicName()); if (methodList) return *methodList; return MethodList(); }
bool QmlRefactoring::removeProperty(int parentLocation, const PropertyName &name) { if (parentLocation < 0 || name.isEmpty()) return false; RemovePropertyVisitor visit(*textModifier, parentLocation, QString::fromUtf8(name)); return visit(qmlDocument->qmlProgram()); }
bool JSSymbolTableObject::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName) { JSSymbolTableObject* thisObject = jsCast<JSSymbolTableObject*>(cell); if (thisObject->symbolTable()->contains(propertyName.publicName())) return false; return JSObject::deleteProperty(thisObject, exec, propertyName); }
static void removeAliasExports(const QmlObjectNode &node) { PropertyName propertyName = node.id().toUtf8(); ModelNode rootNode = node.view()->rootModelNode(); bool hasAliasExport = !propertyName.isEmpty() && rootNode.isValid() && rootNode.hasBindingProperty(propertyName) && rootNode.bindingProperty(propertyName).isAliasExport(); if (hasAliasExport) rootNode.removeProperty(propertyName); foreach (const ModelNode &childNode, node.modelNode().directSubModelNodes()) { removeAliasExports(childNode); } }
EncodedJSValue JSNPObject::methodGetter(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue, PropertyName propertyName) { JSNPObject* thisObj = jsCast<JSNPObject*>(JSValue::decode(slotBase)); ASSERT_GC_OBJECT_INHERITS(thisObj, info()); if (!thisObj->m_npObject) return JSValue::encode(throwInvalidAccessError(exec)); NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName); return JSValue::encode(JSNPMethod::create(exec, thisObj->globalObject(), propertyName.publicName(), npIdentifier)); }
bool JSFloat64Array::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot) { JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell); ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info); unsigned index = propertyName.asIndex(); if (index != PropertyName::NotAnIndex && index < static_cast<Float64Array*>(thisObject->impl())->length()) { slot.setValue(thisObject->getByIndex(exec, index)); return true; } return getStaticValueSlot<JSFloat64Array, Base>(exec, getJSFloat64ArrayTable(exec), thisObject, propertyName, slot); }
void JSFloat64Array::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot) { JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell); ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info); unsigned index = propertyName.asIndex(); if (index != PropertyName::NotAnIndex) { thisObject->indexSetter(exec, index, value); return; } Base::put(thisObject, exec, propertyName, value, slot); }
bool JSFloat64Array::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor) { JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(object); ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info); unsigned index = propertyName.asIndex(); if (index != PropertyName::NotAnIndex && index < static_cast<Float64Array*>(thisObject->impl())->length()) { descriptor.setDescriptor(thisObject->getByIndex(exec, index), DontDelete); return true; } return getStaticValueDescriptor<JSFloat64Array, Base>(exec, getJSFloat64ArrayTable(exec), thisObject, propertyName, descriptor); }
JSValue JSNPObject::methodGetter(ExecState* exec, JSValue slotBase, PropertyName methodName) { JSNPObject* thisObj = static_cast<JSNPObject*>(asObject(slotBase)); ASSERT_GC_OBJECT_INHERITS(thisObj, &s_info); if (!thisObj->m_npObject) return throwInvalidAccessError(exec); NPIdentifier npIdentifier = npIdentifierFromIdentifier(methodName); return JSNPMethod::create(exec, thisObj->globalObject(), methodName.ustring(), npIdentifier); }
inline bool JSActivation::symbolTableGet(PropertyName propertyName, PropertySlot& slot) { SymbolTableEntry entry = symbolTable().inlineGet(propertyName.impl()); if (entry.isNull()) return false; if (m_isTornOff && entry.getIndex() >= m_numCapturedVars) return false; slot.setValue(registerAt(entry.getIndex()).get()); return true; }
string Event::getAsString(const PropertyName &name) const // throw (NoData) { PropertyMap::const_iterator i; const PropertyMap *map = find(name, i); if (map) { return i->second->unparse(); } else { throw NoData(name.getName(), __FILE__, __LINE__); } }