#pragma once

#include "APICast.h"

#include "Error.h"

#include "ExceptionHelpers.h"

#include "Integrity.h"

#include "JSCallbackFunction.h"

#include "JSClassRef.h"

#include "JSFunction.h"

#include "JSLock.h"

#include "JSObjectRef.h"

#include "JSString.h"

#include "OpaqueJSString.h"

#include "PropertyNameArray.h"

#include <wtf/Vector.h>

namespace JSC {

inline PreferredPrimitiveType toPreferredPrimitiveType(JSGlobalObject*, JSValue);

template <class Parent>

inline JSCallbackObject<Parent>* JSCallbackObject<Parent>::asCallbackObject(JSValue value)

{

ASSERT(asObject(value)->inheritsSlow(info()));

return uncheckedDowncast<JSCallbackObject>(asObject(value));

}

template <class Parent>

inline JSCallbackObject<Parent>* JSCallbackObject<Parent>::asCallbackObject(EncodedJSValue encodedValue)

{

JSValue value = JSValue::decode(encodedValue);

ASSERT(asObject(value)->inheritsSlow(info()));

return uncheckedDowncast<JSCallbackObject>(asObject(value));

}

template <class Parent>

JSCallbackObject<Parent>::JSCallbackObject(JSGlobalObject* globalObject, Structure* structure, JSClassRef jsClass, void* data)

: Parent(getVM(globalObject), structure)

, m_callbackObjectData(makeUnique<JSCallbackObjectData>(data, jsClass))

{

}

template <class Parent>

JSCallbackObject<Parent>::JSCallbackObject(VM& vm, JSClassRef jsClass, Structure* structure)

: Parent(vm, structure)

, m_callbackObjectData(makeUnique<JSCallbackObjectData>(nullptr, jsClass))

{

}

template <class Parent>

JSCallbackObject<Parent>::~JSCallbackObject()

{

VM& vm = this->HeapCell::vm();

vm.currentlyDestructingCallbackObject = this;

ASSERT(m_classInfo);

vm.currentlyDestructingCallbackObjectClassInfo = m_classInfo;

JSObjectRef thisRef = toRef(static_cast<JSObject*>(this));

for (JSClassRef jsClass = classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectFinalizeCallback finalize = jsClass->finalize)

finalize(thisRef);

}

vm.currentlyDestructingCallbackObject = nullptr;

vm.currentlyDestructingCallbackObjectClassInfo = nullptr;

}

template <class Parent>

void JSCallbackObject<Parent>::finishCreation(JSGlobalObject* globalObject)

{

VM& vm = getVM(globalObject);

Base::finishCreation(vm);

ASSERT(Parent::inherits(info()));

init(globalObject);

}

template <class Parent>

void JSCallbackObject<Parent>::finishCreation(VM& vm)

{

ASSERT(Parent::inherits(info()));

ASSERT(Parent::isGlobalObject());

Base::finishCreation(vm);

init(static_cast<JSGlobalObject*>(this));

}

template <class Parent>

void JSCallbackObject<Parent>::init(JSGlobalObject* globalObject)

{

ASSERT(globalObject);

VM& vm = getVM(globalObject);

bool hasConvertToType = false;

Vector<JSObjectInitializeCallback, 16> initRoutines;

JSClassRef jsClass = classRef();

do {

if (jsClass->convertToType)

hasConvertToType = true;

if (JSObjectInitializeCallback initialize = jsClass->initialize)

initRoutines.append(initialize);

} while ((jsClass = jsClass->parentClass));

if (hasConvertToType) {

this->putDirect(vm, vm.propertyNames->toPrimitiveSymbol,

JSFunction::create(vm, globalObject, 1, "[Symbol.toPrimitive]"_s, customToPrimitive, ImplementationVisibility::Public),

static_cast<unsigned>(PropertyAttribute::DontEnum));

}

// initialize from base to derived

for (int i = static_cast<int>(initRoutines.size()) - 1; i >= 0; i--) {

JSLock::DropAllLocks dropAllLocks(globalObject);

JSObjectInitializeCallback initialize = initRoutines[i];

initialize(toRef(globalObject), toRef(static_cast<JSObject*>(this)));

}

m_classInfo = this->classInfo();

}

template <class Parent>

bool JSCallbackObject<Parent>::getOwnPropertySlot(JSObject* object, JSGlobalObject* globalObject, PropertyName propertyName, PropertySlot& slot)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(object);

JSContextRef ctx = toRef(globalObject);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObject));

RefPtr<OpaqueJSString> propertyNameRef;

if (StringImpl* name = propertyName.uid()) {

unsigned attributes = PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum;

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

// optional optimization to bypass getProperty in cases when we only need to know if the property exists

if (JSObjectHasPropertyCallback hasProperty = jsClass->hasProperty) {

if (!propertyNameRef)

propertyNameRef = OpaqueJSString::tryCreate(name);

JSLock::DropAllLocks dropAllLocks(globalObject);

if (hasProperty(ctx, thisRef, propertyNameRef.get())) {

slot.setCustom(thisObject, attributes, getCallbackGetter());

return true;

}

} else if (JSObjectGetPropertyCallback getProperty = jsClass->getProperty) {

if (!propertyNameRef)

propertyNameRef = OpaqueJSString::tryCreate(name);

JSValueRef exception = nullptr;

JSValueRef value;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

value = getProperty(ctx, thisRef, propertyNameRef.get(), &exception);

}

if (exception) {

throwException(globalObject, scope, toJS(globalObject, exception));

slot.setValue(thisObject, attributes, jsUndefined());

return true;

}

if (value) {

slot.setValue(thisObject, attributes, toJS(globalObject, value));

return true;

}

}

if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {

if (staticValues->contains(name)) {

JSValue value = thisObject->getStaticValue(globalObject, propertyName);

RETURN_IF_EXCEPTION(scope, false);

if (value) {

slot.setValue(thisObject, attributes, value);

return true;

}

}

}

if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {

if (staticFunctions->contains(name)) {

slot.setCustom(thisObject, attributes, getStaticFunctionGetter());

return true;

}

}

}

}

bool found = Parent::getOwnPropertySlot(thisObject, globalObject, propertyName, slot);

RETURN_IF_EXCEPTION(scope, false);

if (found)

return true;

if (propertyName.uid() == vm.propertyNames->toStringTagSymbol.impl()) {

String className = thisObject->classRef()->className();

if (className.isEmpty())

className = thisObject->className();

slot.setValue(thisObject, static_cast<unsigned>(PropertyAttribute::DontEnum), jsString(vm, WTF::move(className)));

return true;

}

return false;

}

template <class Parent>

bool JSCallbackObject<Parent>::getOwnPropertySlotByIndex(JSObject* object, JSGlobalObject* globalObject, unsigned propertyName, PropertySlot& slot)

{

VM& vm = getVM(globalObject);

return object->methodTable()->getOwnPropertySlot(object, globalObject, Identifier::from(vm, propertyName), slot);

}

template <class Parent>

EncodedJSValue JSCallbackObject<Parent>::customToPrimitive(JSGlobalObject* globalObject, CallFrame* callFrame)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObject = dynamicDowncast<JSCallbackObject>(callFrame->thisValue());

if (!thisObject)

return throwVMTypeError(globalObject, scope, "JSCallbackObject[Symbol.toPrimitive] method called on incompatible |this| value."_s);

PreferredPrimitiveType hint = toPreferredPrimitiveType(globalObject, callFrame->argument(0));

RETURN_IF_EXCEPTION(scope, { });

JSContextRef ctx = toRef(globalObject);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObject));

::JSType jsHint = hint == PreferString ? kJSTypeString : kJSTypeNumber;

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectConvertToTypeCallback convertToType = jsClass->convertToType) {

JSValueRef exception = nullptr;

JSValueRef result = convertToType(ctx, thisRef, jsHint, &exception);

if (exception)

return throwVMError(globalObject, scope, toJS(globalObject, exception));

if (result) {

JSValue jsResult = toJS(globalObject, result);

if (jsResult.isObject()) [[unlikely]]

return JSValue::encode(asObject(jsResult)->ordinaryToPrimitive(globalObject, hint));

return JSValue::encode(jsResult);

}

}

}

RELEASE_AND_RETURN(scope, JSValue::encode(thisObject->ordinaryToPrimitive(globalObject, hint)));

}

template <class Parent>

bool JSCallbackObject<Parent>::put(JSCell* cell, JSGlobalObject* globalObject, PropertyName propertyName, JSValue value, PutPropertySlot& slot)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(cell);

JSContextRef ctx = toRef(globalObject);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObject));

RefPtr<OpaqueJSString> propertyNameRef;

JSValueRef valueRef = toRef(globalObject, value);

if (isThisValueAltered(slot, thisObject)) [[unlikely]]

RELEASE_AND_RETURN(scope, Parent::put(thisObject, globalObject, propertyName, value, slot));

if (StringImpl* name = propertyName.uid()) {

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectSetPropertyCallback setProperty = jsClass->setProperty) {

if (!propertyNameRef)

propertyNameRef = OpaqueJSString::tryCreate(name);

JSValueRef exception = nullptr;

bool result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = setProperty(ctx, thisRef, propertyNameRef.get(), valueRef, &exception);

}

if (exception)

throwException(globalObject, scope, toJS(globalObject, exception));

if (result || exception)

return result;

}

if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {

if (StaticValueEntry* entry = staticValues->get(name)) {

if (entry->attributes & kJSPropertyAttributeReadOnly)

return false;

if (JSObjectSetPropertyCallback setProperty = entry->setProperty) {

JSValueRef exception = nullptr;

bool result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = setProperty(ctx, thisRef, entry->propertyNameRef.get(), valueRef, &exception);

}

if (exception)

throwException(globalObject, scope, toJS(globalObject, exception));

if (result || exception)

return result;

}

}

}

if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {

if (StaticFunctionEntry* entry = staticFunctions->get(name)) {

PropertySlot getSlot(thisObject, PropertySlot::InternalMethodType::VMInquiry, &vm);

bool found = Parent::getOwnPropertySlot(thisObject, globalObject, propertyName, getSlot);

RETURN_IF_EXCEPTION(scope, false);

getSlot.disallowVMEntry.reset();

if (found)

RELEASE_AND_RETURN(scope, Parent::put(thisObject, globalObject, propertyName, value, slot));

if (entry->attributes & kJSPropertyAttributeReadOnly)

return false;

return thisObject->JSCallbackObject<Parent>::putDirect(vm, propertyName, value); // put as override property

}

}

}

}

RELEASE_AND_RETURN(scope, Parent::put(thisObject, globalObject, propertyName, value, slot));

}

template <class Parent>

bool JSCallbackObject<Parent>::putByIndex(JSCell* cell, JSGlobalObject* globalObject, unsigned propertyIndex, JSValue value, bool shouldThrow)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(cell);

JSContextRef ctx = toRef(globalObject);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObject));

RefPtr<OpaqueJSString> propertyNameRef;

JSValueRef valueRef = toRef(globalObject, value);

Identifier propertyName = Identifier::from(vm, propertyIndex);

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectSetPropertyCallback setProperty = jsClass->setProperty) {

if (!propertyNameRef)

propertyNameRef = OpaqueJSString::tryCreate(propertyName.impl());

JSValueRef exception = nullptr;

bool result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = setProperty(ctx, thisRef, propertyNameRef.get(), valueRef, &exception);

}

if (exception)

throwException(globalObject, scope, toJS(globalObject, exception));

if (result || exception)

return result;

}

if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {

if (StaticValueEntry* entry = staticValues->get(propertyName.impl())) {

if (entry->attributes & kJSPropertyAttributeReadOnly)

return false;

if (JSObjectSetPropertyCallback setProperty = entry->setProperty) {

JSValueRef exception = nullptr;

bool result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = setProperty(ctx, thisRef, entry->propertyNameRef.get(), valueRef, &exception);

}

if (exception)

throwException(globalObject, scope, toJS(globalObject, exception));

if (result || exception)

return result;

}

}

}

if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {

if (StaticFunctionEntry* entry = staticFunctions->get(propertyName.impl())) {

if (entry->attributes & kJSPropertyAttributeReadOnly)

return false;

break;

}

}

}

RELEASE_AND_RETURN(scope, Parent::putByIndex(thisObject, globalObject, propertyIndex, value, shouldThrow));

}

template <class Parent>

bool JSCallbackObject<Parent>::deleteProperty(JSCell* cell, JSGlobalObject* globalObject, PropertyName propertyName, DeletePropertySlot& slot)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(cell);

JSContextRef ctx = toRef(globalObject);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObject));

RefPtr<OpaqueJSString> propertyNameRef;

if (StringImpl* name = propertyName.uid()) {

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectDeletePropertyCallback deleteProperty = jsClass->deleteProperty) {

if (!propertyNameRef)

propertyNameRef = OpaqueJSString::tryCreate(name);

JSValueRef exception = nullptr;

bool result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = deleteProperty(ctx, thisRef, propertyNameRef.get(), &exception);

}

if (exception)

throwException(globalObject, scope, toJS(globalObject, exception));

if (result || exception)

return true;

}

if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {

if (StaticValueEntry* entry = staticValues->get(name)) {

if (entry->attributes & kJSPropertyAttributeDontDelete)

return false;

return true;

}

}

if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {

if (StaticFunctionEntry* entry = staticFunctions->get(name)) {

if (entry->attributes & kJSPropertyAttributeDontDelete)

return false;

return true;

}

}

}

}

static_assert(std::is_final_v<JSCallbackObject<Parent>>, "Ensure no derived classes have custom deletePropertyByIndex implementation");

if (std::optional<uint32_t> index = parseIndex(propertyName))

RELEASE_AND_RETURN(scope, Parent::deletePropertyByIndex(thisObject, globalObject, index.value()));

RELEASE_AND_RETURN(scope, Parent::deleteProperty(thisObject, globalObject, propertyName, slot));

}

template <class Parent>

bool JSCallbackObject<Parent>::deletePropertyByIndex(JSCell* cell, JSGlobalObject* globalObject, unsigned propertyName)

{

VM& vm = getVM(globalObject);

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(cell);

return JSCell::deleteProperty(thisObject, globalObject, Identifier::from(vm, propertyName));

}

template <class Parent>

CallData JSCallbackObject<Parent>::getConstructData(JSCell* cell)

{

CallData constructData;

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(cell);

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (jsClass->callAsConstructor) {

constructData.type = CallData::Type::Native;

constructData.native.function = getConstructFunction();

constructData.native.isBoundFunction = false;

constructData.native.isWasm = false;

break;

}

}

return constructData;

}

template <class Parent>

EncodedJSValue JSCallbackObject<Parent>::constructImpl(JSGlobalObject* globalObject, CallFrame* callFrame)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSObject* constructor = callFrame->jsCallee();

JSContextRef execRef = toRef(globalObject);

JSObjectRef constructorRef = toRef(constructor);

for (JSClassRef jsClass = uncheckedDowncast<JSCallbackObject<Parent>>(constructor)->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectCallAsConstructorCallback callAsConstructor = jsClass->callAsConstructor) {

#if CPU(ADDRESS64)

auto argumentsSpan = Integrity::audit(callFrame->argumentsSpan());

JSValueRef* argumentsSpanData = std::bit_cast<JSValueRef*>(argumentsSpan.data());

#else

// It is safe to use a Vector here because the values are protected by their source

// location in the call frame arguments on the stack.

Vector<JSValueRef, 16> arguments(callFrame->argumentCount(), [&](size_t i) {

return toRef(globalObject, callFrame->uncheckedArgument(i));

});

auto argumentsSpan = arguments.span();

auto* argumentsSpanData = argumentsSpan.data();

#endif

JSValueRef exception = nullptr;

JSObject* result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = toJS(callAsConstructor(execRef, constructorRef, argumentsSpan.size(), argumentsSpanData, &exception));

}

if (exception) {

throwException(globalObject, scope, toJS(globalObject, exception));

return JSValue::encode(jsUndefined());

}

return JSValue::encode(result);

}

}

RELEASE_ASSERT_NOT_REACHED(); // getConstructData should prevent us from reaching here

return JSValue::encode(JSValue());

}

template <class Parent>

bool JSCallbackObject<Parent>::customHasInstance(JSObject* object, JSGlobalObject* globalObject, JSValue value)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(object);

JSContextRef execRef = toRef(globalObject);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObject));

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectHasInstanceCallback hasInstance = jsClass->hasInstance) {

JSValueRef valueRef = toRef(globalObject, value);

JSValueRef exception = nullptr;

bool result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = hasInstance(execRef, thisRef, valueRef, &exception);

}

if (exception)

throwException(globalObject, scope, toJS(globalObject, exception));

return result;

}

}

return false;

}

template <class Parent>

CallData JSCallbackObject<Parent>::getCallData(JSCell* cell)

{

CallData callData;

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(cell);

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (jsClass->callAsFunction) {

callData.type = CallData::Type::Native;

callData.native.function = getCallFunction();

callData.native.isBoundFunction = false;

callData.native.isWasm = false;

break;

}

}

return callData;

}

template <class Parent>

EncodedJSValue JSCallbackObject<Parent>::callImpl(JSGlobalObject* globalObject, CallFrame* callFrame)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSContextRef execRef = toRef(globalObject);

JSObjectRef functionRef = toRef(callFrame->jsCallee());

JSObjectRef thisObjRef = toRef(uncheckedDowncast<JSObject>(callFrame->thisValue().toThis(globalObject, ECMAMode::sloppy())));

for (JSClassRef jsClass = uncheckedDowncast<JSCallbackObject<Parent>>(toJS(functionRef))->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectCallAsFunctionCallback callAsFunction = jsClass->callAsFunction) {

#if CPU(ADDRESS64)

auto argumentsSpan = Integrity::audit(callFrame->argumentsSpan());

JSValueRef* argumentsSpanData = std::bit_cast<JSValueRef*>(argumentsSpan.data());

#else

// It is safe to use a Vector here because the values are protected by their source

// location in the call frame arguments on the stack.

Vector<JSValueRef, 16> arguments(callFrame->argumentCount(), [&](size_t i) {

return toRef(globalObject, callFrame->uncheckedArgument(i));

});

auto argumentsSpan = arguments.span();

auto* argumentsSpanData = argumentsSpan.data();

#endif

JSValueRef exception = nullptr;

JSValue result;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

result = toJS(globalObject, callAsFunction(execRef, functionRef, thisObjRef, argumentsSpan.size(), argumentsSpanData, &exception));

}

if (exception) {

throwException(globalObject, scope, toJS(globalObject, exception));

return JSValue::encode(jsUndefined());

}

return JSValue::encode(result);

}

}

RELEASE_ASSERT_NOT_REACHED(); // getCallData should prevent us from reaching here

return JSValue::encode(JSValue());

}

template <class Parent>

void JSCallbackObject<Parent>::getOwnSpecialPropertyNames(JSObject* object, JSGlobalObject* globalObject, PropertyNameArrayBuilder& propertyNames, DontEnumPropertiesMode mode)

{

VM& vm = getVM(globalObject);

JSCallbackObject* thisObject = uncheckedDowncast<JSCallbackObject>(object);

JSContextRef execRef = toRef(globalObject);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObject));

for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectGetPropertyNamesCallback getPropertyNames = jsClass->getPropertyNames) {

JSLock::DropAllLocks dropAllLocks(globalObject);

getPropertyNames(execRef, thisRef, toRef(&propertyNames));

}

if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {

typedef OpaqueJSClassStaticValuesTable::const_iterator iterator;

iterator end = staticValues->end();

for (iterator it = staticValues->begin(); it != end; ++it) {

StringImpl* name = it->key.get();

StaticValueEntry* entry = it->value.get();

if (entry->getProperty && (mode == DontEnumPropertiesMode::Include || !(entry->attributes & kJSPropertyAttributeDontEnum))) {

ASSERT(!name->isSymbol());

propertyNames.add(Identifier::fromString(vm, String(name)));

}

}

}

if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {

typedef OpaqueJSClassStaticFunctionsTable::const_iterator iterator;

iterator end = staticFunctions->end();

for (iterator it = staticFunctions->begin(); it != end; ++it) {

StringImpl* name = it->key.get();

StaticFunctionEntry* entry = it->value.get();

if (mode == DontEnumPropertiesMode::Include || !(entry->attributes & kJSPropertyAttributeDontEnum)) {

ASSERT(!name->isSymbol());

propertyNames.add(Identifier::fromString(vm, String(name)));

}

}

}

}

}

template <class Parent>

void JSCallbackObject<Parent>::setPrivate(void* data)

{

m_callbackObjectData->privateData = data;

}

template <class Parent>

void* JSCallbackObject<Parent>::getPrivate()

{

return m_callbackObjectData->privateData;

}

template <class Parent>

bool JSCallbackObject<Parent>::inherits(JSClassRef c) const

{

for (JSClassRef jsClass = classRef(); jsClass; jsClass = jsClass->parentClass) {

if (jsClass == c)

return true;

}

return false;

}

template <class Parent>

JSValue JSCallbackObject<Parent>::getStaticValue(JSGlobalObject* globalObject, PropertyName propertyName)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(this));

if (StringImpl* name = propertyName.uid()) {

for (JSClassRef jsClass = classRef(); jsClass; jsClass = jsClass->parentClass) {

if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {

if (StaticValueEntry* entry = staticValues->get(name)) {

if (JSObjectGetPropertyCallback getProperty = entry->getProperty) {

JSValueRef exception = nullptr;

JSValueRef value;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

value = getProperty(toRef(globalObject), thisRef, entry->propertyNameRef.get(), &exception);

}

if (exception) {

throwException(globalObject, scope, toJS(globalObject, exception));

return jsUndefined();

}

if (value)

return toJS(globalObject, value);

}

}

}

}

}

return JSValue();

}

template <class Parent>

EncodedJSValue JSCallbackObject<Parent>::staticFunctionGetterImpl(JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObj = asCallbackObject(thisValue);

// Check for cached or override property.

PropertySlot slot2(thisObj, PropertySlot::InternalMethodType::VMInquiry, &vm);

bool found = Parent::getOwnPropertySlot(thisObj, globalObject, propertyName, slot2);

RETURN_IF_EXCEPTION(scope, { });

slot2.disallowVMEntry.reset();

if (found)

return JSValue::encode(slot2.getValue(globalObject, propertyName));

if (StringImpl* name = propertyName.uid()) {

for (JSClassRef jsClass = thisObj->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {

if (StaticFunctionEntry* entry = staticFunctions->get(name)) {

if (JSObjectCallAsFunctionCallback callAsFunction = entry->callAsFunction) {

JSObject* o = JSCallbackFunction::create(vm, thisObj->realm(), callAsFunction, name);

thisObj->putDirect(vm, propertyName, o, entry->attributes);

return JSValue::encode(o);

}

}

}

}

}

return JSValue::encode(throwException(globalObject, scope, createReferenceError(globalObject, "Static function property defined with NULL callAsFunction callback."_s)));

}

template <class Parent>

EncodedJSValue JSCallbackObject<Parent>::callbackGetterImpl(JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSCallbackObject* thisObj = asCallbackObject(thisValue);

JSObjectRef thisRef = toRef(static_cast<JSObject*>(thisObj));

RefPtr<OpaqueJSString> propertyNameRef;

if (StringImpl* name = propertyName.uid()) {

for (JSClassRef jsClass = thisObj->classRef(); jsClass; jsClass = jsClass->parentClass) {

if (JSObjectGetPropertyCallback getProperty = jsClass->getProperty) {

if (!propertyNameRef)

propertyNameRef = OpaqueJSString::tryCreate(name);

JSValueRef exception = nullptr;

JSValueRef value;

{

JSLock::DropAllLocks dropAllLocks(globalObject);

value = getProperty(toRef(globalObject), thisRef, propertyNameRef.get(), &exception);

}

if (exception) {

throwException(globalObject, scope, toJS(globalObject, exception));

return JSValue::encode(jsUndefined());

}

if (value)

return JSValue::encode(toJS(globalObject, value));

}

}

}

return JSValue::encode(throwException(globalObject, scope, createReferenceError(globalObject, "hasProperty callback returned true for a property that doesn't exist."_s)));

}

} // namespace JSC