Roll out r108309, r108323, and r108326
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSFunction.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
4  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
5  *  Copyright (C) 2007 Maks Orlovich
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Library General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Library General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Library General Public License
18  *  along with this library; see the file COPYING.LIB.  If not, write to
19  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  *  Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #ifndef JSFunction_h
25 #define JSFunction_h
26
27 #include "JSObject.h"
28
29 namespace JSC {
30
31     class ExecutableBase;
32     class FunctionExecutable;
33     class FunctionPrototype;
34     class JSActivation;
35     class JSGlobalObject;
36     class NativeExecutable;
37     class SourceCode;
38     namespace DFG {
39     class SpeculativeJIT;
40     class JITCompiler;
41     }
42
43     JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
44
45     JS_EXPORT_PRIVATE UString getCalculatedDisplayName(CallFrame*, JSObject*);
46     
47     class JSFunction : public JSNonFinalObject {
48         friend class JIT;
49         friend class DFG::SpeculativeJIT;
50         friend class DFG::JITCompiler;
51         friend class JSGlobalData;
52
53     public:
54         typedef JSNonFinalObject Base;
55
56         JS_EXPORT_PRIVATE static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
57         static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeExecutable* nativeExecutable);
58
59         static JSFunction* create(ExecState* exec, FunctionExecutable* executable, ScopeChainNode* scopeChain)
60         {
61             JSFunction* function = new (NotNull, allocateCell<JSFunction>(*exec->heap())) JSFunction(exec, executable, scopeChain);
62             ASSERT(function->structure()->globalObject());
63             function->finishCreation(exec, executable, scopeChain);
64             return function;
65         }
66         
67         JS_EXPORT_PRIVATE const UString& name(ExecState*);
68         JS_EXPORT_PRIVATE const UString displayName(ExecState*);
69         const UString calculatedDisplayName(ExecState*);
70
71         ScopeChainNode* scope()
72         {
73             ASSERT(!isHostFunctionNonInline());
74             return m_scopeChain.get();
75         }
76         // This method may be called for host functins, in which case it
77         // will return an arbitrary value. This should only be used for
78         // optimized paths in which the return value does not matter for
79         // host functions, and checking whether the function is a host
80         // function is deemed too expensive.
81         ScopeChainNode* scopeUnchecked()
82         {
83             return m_scopeChain.get();
84         }
85         void setScope(JSGlobalData& globalData, ScopeChainNode* scopeChain)
86         {
87             ASSERT(!isHostFunctionNonInline());
88             m_scopeChain.set(globalData, this, scopeChain);
89         }
90
91         ExecutableBase* executable() const { return m_executable.get(); }
92
93         // To call either of these methods include Executable.h
94         inline bool isHostFunction() const;
95         FunctionExecutable* jsExecutable() const;
96
97         JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
98
99         static JS_EXPORTDATA const ClassInfo s_info;
100
101         static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype) 
102         {
103             ASSERT(globalObject);
104             return Structure::create(globalData, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), &s_info); 
105         }
106
107         NativeFunction nativeFunction();
108         NativeFunction nativeConstructor();
109
110         static ConstructType getConstructData(JSCell*, ConstructData&);
111         static CallType getCallData(JSCell*, CallData&);
112
113         static inline size_t offsetOfScopeChain()
114         {
115             return OBJECT_OFFSETOF(JSFunction, m_scopeChain);
116         }
117
118         static inline size_t offsetOfExecutable()
119         {
120             return OBJECT_OFFSETOF(JSFunction, m_executable);
121         }
122
123     protected:
124         const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
125
126         JS_EXPORT_PRIVATE JSFunction(ExecState*, JSGlobalObject*, Structure*);
127         JSFunction(ExecState*, FunctionExecutable*, ScopeChainNode*);
128         
129         void finishCreation(ExecState*, NativeExecutable*, int length, const Identifier& name);
130         void finishCreation(ExecState*, FunctionExecutable*, ScopeChainNode*);
131
132         static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
133         static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
134         static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode = ExcludeDontEnumProperties);
135
136         static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
137
138         static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
139
140         static void visitChildren(JSCell*, SlotVisitor&);
141
142     private:
143         JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
144
145         static JSValue argumentsGetter(ExecState*, JSValue, const Identifier&);
146         static JSValue callerGetter(ExecState*, JSValue, const Identifier&);
147         static JSValue lengthGetter(ExecState*, JSValue, const Identifier&);
148
149         WriteBarrier<ExecutableBase> m_executable;
150         WriteBarrier<ScopeChainNode> m_scopeChain;
151     };
152
153     JSFunction* asFunction(JSValue);
154
155     inline JSFunction* asFunction(JSValue value)
156     {
157         ASSERT(asObject(value)->inherits(&JSFunction::s_info));
158         return static_cast<JSFunction*>(asObject(value));
159     }
160
161 } // namespace JSC
162
163 #endif // JSFunction_h