X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/9dae56ea45a0f5f8136a5c93d6f3a7f99399ca73..ed1e77d3adeb83d26fd1dfb16dd84cabdcefd250:/API/JSCallbackObject.h?ds=inline diff --git a/API/JSCallbackObject.h b/API/JSCallbackObject.h index 9001c43..33b4262 100644 --- a/API/JSCallbackObject.h +++ b/API/JSCallbackObject.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved. * Copyright (C) 2007 Eric Seidel * * Redistribution and use in source and binary forms, with or without @@ -11,10 +11,10 @@ * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR @@ -33,77 +33,186 @@ namespace JSC { -template -class JSCallbackObject : public Base { +struct JSCallbackObjectData { + WTF_MAKE_FAST_ALLOCATED; public: - JSCallbackObject(ExecState*, PassRefPtr, JSClassRef, void* data); - JSCallbackObject(JSClassRef); - virtual ~JSCallbackObject(); + JSCallbackObjectData(void* privateData, JSClassRef jsClass) + : privateData(privateData) + , jsClass(jsClass) + { + JSClassRetain(jsClass); + } + + ~JSCallbackObjectData() + { + JSClassRelease(jsClass); + } + + JSValue getPrivateProperty(const Identifier& propertyName) const + { + if (!m_privateProperties) + return JSValue(); + return m_privateProperties->getPrivateProperty(propertyName); + } + + void setPrivateProperty(VM& vm, JSCell* owner, const Identifier& propertyName, JSValue value) + { + if (!m_privateProperties) + m_privateProperties = std::make_unique(); + m_privateProperties->setPrivateProperty(vm, owner, propertyName, value); + } + + void deletePrivateProperty(const Identifier& propertyName) + { + if (!m_privateProperties) + return; + m_privateProperties->deletePrivateProperty(propertyName); + } + + void visitChildren(SlotVisitor& visitor) + { + if (!m_privateProperties) + return; + m_privateProperties->visitChildren(visitor); + } + + void* privateData; + JSClassRef jsClass; + struct JSPrivatePropertyMap { + JSValue getPrivateProperty(const Identifier& propertyName) const + { + PrivatePropertyMap::const_iterator location = m_propertyMap.find(propertyName.impl()); + if (location == m_propertyMap.end()) + return JSValue(); + return location->value.get(); + } + + void setPrivateProperty(VM& vm, JSCell* owner, const Identifier& propertyName, JSValue value) + { + WriteBarrier empty; + m_propertyMap.add(propertyName.impl(), empty).iterator->value.set(vm, owner, value); + } + + void deletePrivateProperty(const Identifier& propertyName) + { + m_propertyMap.remove(propertyName.impl()); + } + + void visitChildren(SlotVisitor& visitor) + { + for (PrivatePropertyMap::iterator ptr = m_propertyMap.begin(); ptr != m_propertyMap.end(); ++ptr) { + if (ptr->value) + visitor.append(&ptr->value); + } + } + + private: + typedef HashMap, WriteBarrier, IdentifierRepHash> PrivatePropertyMap; + PrivatePropertyMap m_propertyMap; + }; + std::unique_ptr m_privateProperties; +}; + + +template +class JSCallbackObject : public Parent { +protected: + JSCallbackObject(ExecState*, Structure*, JSClassRef, void* data); + JSCallbackObject(VM&, JSClassRef, Structure*); + + void finishCreation(ExecState*); + void finishCreation(VM&); + +public: + typedef Parent Base; + static const unsigned StructureFlags = Base::StructureFlags | ProhibitsPropertyCaching | OverridesGetOwnPropertySlot | InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | ImplementsHasInstance | OverridesHasInstance | OverridesGetPropertyNames | TypeOfShouldCallGetCallData; + + ~JSCallbackObject(); + + static JSCallbackObject* create(ExecState* exec, JSGlobalObject* globalObject, Structure* structure, JSClassRef classRef, void* data) + { + ASSERT_UNUSED(globalObject, !structure->globalObject() || structure->globalObject() == globalObject); + JSCallbackObject* callbackObject = new (NotNull, allocateCell(*exec->heap())) JSCallbackObject(exec, structure, classRef, data); + callbackObject->finishCreation(exec); + return callbackObject; + } + static JSCallbackObject* create(VM&, JSClassRef, Structure*); + + static const bool needsDestruction; + static void destroy(JSCell* cell) + { + static_cast(cell)->JSCallbackObject::~JSCallbackObject(); + } void setPrivate(void* data); void* getPrivate(); - static const ClassInfo info; + DECLARE_INFO; JSClassRef classRef() const { return m_callbackObjectData->jsClass; } bool inherits(JSClassRef) const; - static PassRefPtr createStructure(JSValuePtr proto) - { - return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | OverridesHasInstance)); + static Structure* createStructure(VM&, JSGlobalObject*, JSValue); + + JSValue getPrivateProperty(const Identifier& propertyName) const + { + return m_callbackObjectData->getPrivateProperty(propertyName); + } + + void setPrivateProperty(VM& vm, const Identifier& propertyName, JSValue value) + { + m_callbackObjectData->setPrivateProperty(vm, this, propertyName, value); + } + + void deletePrivateProperty(const Identifier& propertyName) + { + m_callbackObjectData->deletePrivateProperty(propertyName); } + using Parent::methodTable; + private: - virtual UString className() const; + static String className(const JSObject*); - virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&); - virtual bool getOwnPropertySlot(ExecState*, unsigned, PropertySlot&); + static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType); + + static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&); + static bool getOwnPropertySlotByIndex(JSObject*, ExecState*, unsigned propertyName, PropertySlot&); - virtual void put(ExecState*, const Identifier&, JSValuePtr, PutPropertySlot&); + static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&); + static void putByIndex(JSCell*, ExecState*, unsigned, JSValue, bool shouldThrow); - virtual bool deleteProperty(ExecState*, const Identifier&); - virtual bool deleteProperty(ExecState*, unsigned); + static bool deleteProperty(JSCell*, ExecState*, PropertyName); + static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned); - virtual bool hasInstance(ExecState* exec, JSValuePtr value, JSValuePtr proto); + static bool customHasInstance(JSObject*, ExecState*, JSValue); - virtual void getPropertyNames(ExecState*, PropertyNameArray&); + static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode); - virtual double toNumber(ExecState*) const; - virtual UString toString(ExecState*) const; + static ConstructType getConstructData(JSCell*, ConstructData&); + static CallType getCallData(JSCell*, CallData&); - virtual ConstructType getConstructData(ConstructData&); - virtual CallType getCallData(CallData&); - virtual const ClassInfo* classInfo() const { return &info; } + static void visitChildren(JSCell* cell, SlotVisitor& visitor) + { + JSCallbackObject* thisObject = jsCast(cell); + ASSERT_GC_OBJECT_INHERITS((static_cast(thisObject)), JSCallbackObject::info()); + Parent::visitChildren(thisObject, visitor); + thisObject->m_callbackObjectData->visitChildren(visitor); + } void init(ExecState*); - static JSCallbackObject* asCallbackObject(JSValuePtr); + static JSCallbackObject* asCallbackObject(JSValue); + static JSCallbackObject* asCallbackObject(EncodedJSValue); - static JSValuePtr call(ExecState*, JSObject* functionObject, JSValuePtr thisValue, const ArgList&); - static JSObject* construct(ExecState*, JSObject* constructor, const ArgList&); + static EncodedJSValue JSC_HOST_CALL call(ExecState*); + static EncodedJSValue JSC_HOST_CALL construct(ExecState*); - static JSValuePtr staticValueGetter(ExecState*, const Identifier&, const PropertySlot&); - static JSValuePtr staticFunctionGetter(ExecState*, const Identifier&, const PropertySlot&); - static JSValuePtr callbackGetter(ExecState*, const Identifier&, const PropertySlot&); - - struct JSCallbackObjectData { - JSCallbackObjectData(void* privateData, JSClassRef jsClass) - : privateData(privateData) - , jsClass(jsClass) - { - JSClassRetain(jsClass); - } - - ~JSCallbackObjectData() - { - JSClassRelease(jsClass); - } - - void* privateData; - JSClassRef jsClass; - }; - - OwnPtr m_callbackObjectData; + JSValue getStaticValue(ExecState*, PropertyName); + static EncodedJSValue staticFunctionGetter(ExecState*, JSObject*, EncodedJSValue, PropertyName); + static EncodedJSValue callbackGetter(ExecState*, JSObject*, EncodedJSValue, PropertyName); + + std::unique_ptr m_callbackObjectData; }; } // namespace JSC