#define JSFunction_h
#include "InternalFunction.h"
+#include "JSObject.h"
namespace JSC {
class FunctionPrototype;
class JSActivation;
class JSGlobalObject;
+ class LLIntOffsetsExtractor;
class NativeExecutable;
+ class SourceCode;
+ namespace DFG {
+ class SpeculativeJIT;
+ class JITCompiler;
+ }
+
+ JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
- class JSFunction : public InternalFunction {
+ JS_EXPORT_PRIVATE UString getCalculatedDisplayName(CallFrame*, JSObject*);
+
+ class JSFunction : public JSNonFinalObject {
friend class JIT;
+ friend class DFG::SpeculativeJIT;
+ friend class DFG::JITCompiler;
friend class JSGlobalData;
- typedef InternalFunction Base;
-
public:
- JSFunction(ExecState*, NonNullPassRefPtr<Structure>, int length, const Identifier&, NativeFunction);
- JSFunction(ExecState*, NonNullPassRefPtr<Structure>, int length, const Identifier&, NativeExecutable*, NativeFunction);
- JSFunction(ExecState*, NonNullPassRefPtr<FunctionExecutable>, ScopeChainNode*);
- virtual ~JSFunction();
+ typedef JSNonFinalObject Base;
- JSObject* construct(ExecState*, const ArgList&);
- JSValue call(ExecState*, JSValue thisValue, const ArgList&);
+ JS_EXPORT_PRIVATE static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
- void setScope(const ScopeChain& scopeChain) { setScopeChain(scopeChain); }
- ScopeChain& scope() { return scopeChain(); }
+ static JSFunction* create(ExecState* exec, FunctionExecutable* executable, ScopeChainNode* scopeChain)
+ {
+ JSFunction* function = new (NotNull, allocateCell<JSFunction>(*exec->heap())) JSFunction(exec, executable, scopeChain);
+ ASSERT(function->structure()->globalObject());
+ function->finishCreation(exec, executable, scopeChain);
+ return function;
+ }
+
+ JS_EXPORT_PRIVATE const UString& name(ExecState*);
+ JS_EXPORT_PRIVATE const UString displayName(ExecState*);
+ const UString calculatedDisplayName(ExecState*);
+
+ ScopeChainNode* scope()
+ {
+ ASSERT(!isHostFunctionNonInline());
+ return m_scopeChain.get();
+ }
+ // This method may be called for host functins, in which case it
+ // will return an arbitrary value. This should only be used for
+ // optimized paths in which the return value does not matter for
+ // host functions, and checking whether the function is a host
+ // function is deemed too expensive.
+ ScopeChainNode* scopeUnchecked()
+ {
+ return m_scopeChain.get();
+ }
+ void setScope(JSGlobalData& globalData, ScopeChainNode* scopeChain)
+ {
+ ASSERT(!isHostFunctionNonInline());
+ m_scopeChain.set(globalData, this, scopeChain);
+ }
ExecutableBase* executable() const { return m_executable.get(); }
inline bool isHostFunction() const;
FunctionExecutable* jsExecutable() const;
- static JS_EXPORTDATA const ClassInfo info;
+ JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
+
+ static JS_EXPORTDATA const ClassInfo s_info;
- static PassRefPtr<Structure> createStructure(JSValue prototype)
- {
- return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount);
+ static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype)
+ {
+ ASSERT(globalObject);
+ return Structure::create(globalData, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), &s_info);
}
- NativeFunction nativeFunction()
+ NativeFunction nativeFunction();
+ NativeFunction nativeConstructor();
+
+ static ConstructType getConstructData(JSCell*, ConstructData&);
+ static CallType getCallData(JSCell*, CallData&);
+
+ static inline size_t offsetOfScopeChain()
{
- return *WTF::bitwise_cast<NativeFunction*>(m_data);
+ return OBJECT_OFFSETOF(JSFunction, m_scopeChain);
}
- virtual ConstructType getConstructData(ConstructData&);
- virtual CallType getCallData(CallData&);
+ static inline size_t offsetOfExecutable()
+ {
+ return OBJECT_OFFSETOF(JSFunction, m_executable);
+ }
protected:
- const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesMarkChildren | OverridesGetPropertyNames | InternalFunction::StructureFlags;
+ const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
- private:
- JSFunction(NonNullPassRefPtr<Structure>);
+ JS_EXPORT_PRIVATE JSFunction(ExecState*, JSGlobalObject*, Structure*);
+ JSFunction(ExecState*, FunctionExecutable*, ScopeChainNode*);
+
+ void finishCreation(ExecState*, NativeExecutable*, int length, const Identifier& name);
+ void finishCreation(ExecState*, FunctionExecutable*, ScopeChainNode*);
- bool isHostFunctionNonInline() const;
+ static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
+ static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
+ static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode = ExcludeDontEnumProperties);
+ static bool defineOwnProperty(JSObject*, ExecState*, const Identifier& propertyName, PropertyDescriptor&, bool shouldThrow);
- virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
- virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
- virtual void getOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode mode = ExcludeDontEnumProperties);
- virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
- virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
+ static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
- virtual void markChildren(MarkStack&);
+ static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
- virtual const ClassInfo* classInfo() const { return &info; }
+ static void visitChildren(JSCell*, SlotVisitor&);
+
+ private:
+ friend class LLIntOffsetsExtractor;
+
+ JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
static JSValue argumentsGetter(ExecState*, JSValue, const Identifier&);
static JSValue callerGetter(ExecState*, JSValue, const Identifier&);
static JSValue lengthGetter(ExecState*, JSValue, const Identifier&);
- RefPtr<ExecutableBase> m_executable;
- ScopeChain& scopeChain()
- {
- ASSERT(!isHostFunctionNonInline());
- return *WTF::bitwise_cast<ScopeChain*>(m_data);
- }
- void clearScopeChain()
- {
- ASSERT(!isHostFunctionNonInline());
- new (m_data) ScopeChain(NoScopeChain());
- }
- void setScopeChain(ScopeChainNode* sc)
- {
- ASSERT(!isHostFunctionNonInline());
- new (m_data) ScopeChain(sc);
- }
- void setScopeChain(const ScopeChain& sc)
- {
- ASSERT(!isHostFunctionNonInline());
- *WTF::bitwise_cast<ScopeChain*>(m_data) = sc;
- }
- void setNativeFunction(NativeFunction func)
- {
- *WTF::bitwise_cast<NativeFunction*>(m_data) = func;
- }
- unsigned char m_data[sizeof(void*)];
+ WriteBarrier<ExecutableBase> m_executable;
+ WriteBarrier<ScopeChainNode> m_scopeChain;
};
- JSFunction* asFunction(JSValue);
-
- inline JSFunction* asFunction(JSValue value)
+ inline bool JSValue::isFunction() const
{
- ASSERT(asObject(value)->inherits(&JSFunction::info));
- return static_cast<JSFunction*>(asObject(value));
+ return isCell() && (asCell()->inherits(&JSFunction::s_info) || asCell()->inherits(&InternalFunction::s_info));
}
} // namespace JSC
projects / apple / javascriptcore.git / blobdiff