#ifndef JSFunction_h
#define JSFunction_h
#include "InternalFunction.h"
#include "JSObject.h"
namespace JSC {
class ExecutableBase;
class FunctionExecutable;
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*);
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;
public:
typedef JSNonFinalObject Base;
JS_EXPORT_PRIVATE static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, Intrinsic = NoIntrinsic, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
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();
}
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;
JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
static JS_EXPORTDATA const ClassInfo s_info;
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 nativeConstructor();
static ConstructType getConstructData(JSCell*, ConstructData&);
static CallType getCallData(JSCell*, CallData&);
static inline size_t offsetOfScopeChain()
{
return OBJECT_OFFSETOF(JSFunction, m_scopeChain);
}
static inline size_t offsetOfExecutable()
{
return OBJECT_OFFSETOF(JSFunction, m_executable);
}
protected:
const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
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*);
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);
static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
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&);
WriteBarrier<ExecutableBase> m_executable;
WriteBarrier<ScopeChainNode> m_scopeChain;
};
inline bool JSValue::isFunction() const
{
return isCell() && (asCell()->inherits(&JSFunction::s_info) || asCell()->inherits(&InternalFunction::s_info));
}
}
#endif // JSFunction_h