JavaScriptCore-7601.1.46.3.tar.gz
[apple/javascriptcore.git] / API / JSClassRef.cpp
0 / 212 (  0%)
CommitLineData
1/*
2 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "config.h"
27#include "JSClassRef.h"
28
29#include "APICast.h"
30#include "Identifier.h"
31#include "InitializeThreading.h"
32#include "JSCallbackObject.h"
33#include "JSGlobalObject.h"
34#include "JSObjectRef.h"
35#include "ObjectPrototype.h"
36#include "JSCInlines.h"
37#include <wtf/text/StringHash.h>
38#include <wtf/unicode/UTF8.h>
39
40using namespace std;
41using namespace JSC;
42using namespace WTF::Unicode;
43
44const JSClassDefinition kJSClassDefinitionEmpty = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
45
46OpaqueJSClass::OpaqueJSClass(const JSClassDefinition* definition, OpaqueJSClass* protoClass)
47 : parentClass(definition->parentClass)
48 , prototypeClass(0)
49 , initialize(definition->initialize)
50 , finalize(definition->finalize)
51 , hasProperty(definition->hasProperty)
52 , getProperty(definition->getProperty)
53 , setProperty(definition->setProperty)
54 , deleteProperty(definition->deleteProperty)
55 , getPropertyNames(definition->getPropertyNames)
56 , callAsFunction(definition->callAsFunction)
57 , callAsConstructor(definition->callAsConstructor)
58 , hasInstance(definition->hasInstance)
59 , convertToType(definition->convertToType)
60 , m_className(String::fromUTF8(definition->className))
61{
62 initializeThreading();
63
64 if (const JSStaticValue* staticValue = definition->staticValues) {
65 m_staticValues = std::make_unique<OpaqueJSClassStaticValuesTable>();
66 while (staticValue->name) {
67 String valueName = String::fromUTF8(staticValue->name);
68 if (!valueName.isNull())
69 m_staticValues->set(valueName.impl(), std::make_unique<StaticValueEntry>(staticValue->getProperty, staticValue->setProperty, staticValue->attributes, valueName));
70 ++staticValue;
71 }
72 }
73
74 if (const JSStaticFunction* staticFunction = definition->staticFunctions) {
75 m_staticFunctions = std::make_unique<OpaqueJSClassStaticFunctionsTable>();
76 while (staticFunction->name) {
77 String functionName = String::fromUTF8(staticFunction->name);
78 if (!functionName.isNull())
79 m_staticFunctions->set(functionName.impl(), std::make_unique<StaticFunctionEntry>(staticFunction->callAsFunction, staticFunction->attributes));
80 ++staticFunction;
81 }
82 }
83
84 if (protoClass)
85 prototypeClass = JSClassRetain(protoClass);
86}
87
88OpaqueJSClass::~OpaqueJSClass()
89{
90 // The empty string is shared across threads & is an identifier, in all other cases we should have done a deep copy in className(), below.
91 ASSERT(!m_className.length() || !m_className.impl()->isAtomic());
92
93#ifndef NDEBUG
94 if (m_staticValues) {
95 OpaqueJSClassStaticValuesTable::const_iterator end = m_staticValues->end();
96 for (OpaqueJSClassStaticValuesTable::const_iterator it = m_staticValues->begin(); it != end; ++it)
97 ASSERT(!it->key->isAtomic());
98 }
99
100 if (m_staticFunctions) {
101 OpaqueJSClassStaticFunctionsTable::const_iterator end = m_staticFunctions->end();
102 for (OpaqueJSClassStaticFunctionsTable::const_iterator it = m_staticFunctions->begin(); it != end; ++it)
103 ASSERT(!it->key->isAtomic());
104 }
105#endif
106
107 if (prototypeClass)
108 JSClassRelease(prototypeClass);
109}
110
111Ref<OpaqueJSClass> OpaqueJSClass::createNoAutomaticPrototype(const JSClassDefinition* definition)
112{
113 return adoptRef(*new OpaqueJSClass(definition, 0));
114}
115
116Ref<OpaqueJSClass> OpaqueJSClass::create(const JSClassDefinition* clientDefinition)
117{
118 JSClassDefinition definition = *clientDefinition; // Avoid modifying client copy.
119
120 JSClassDefinition protoDefinition = kJSClassDefinitionEmpty;
121 protoDefinition.finalize = 0;
122 swap(definition.staticFunctions, protoDefinition.staticFunctions); // Move static functions to the prototype.
123
124 // We are supposed to use JSClassRetain/Release but since we know that we currently have
125 // the only reference to this class object we cheat and use a RefPtr instead.
126 RefPtr<OpaqueJSClass> protoClass = adoptRef(new OpaqueJSClass(&protoDefinition, 0));
127 return adoptRef(*new OpaqueJSClass(&definition, protoClass.get()));
128}
129
130OpaqueJSClassContextData::OpaqueJSClassContextData(JSC::VM&, OpaqueJSClass* jsClass)
131 : m_class(jsClass)
132{
133 if (jsClass->m_staticValues) {
134 staticValues = std::make_unique<OpaqueJSClassStaticValuesTable>();
135 OpaqueJSClassStaticValuesTable::const_iterator end = jsClass->m_staticValues->end();
136 for (OpaqueJSClassStaticValuesTable::const_iterator it = jsClass->m_staticValues->begin(); it != end; ++it) {
137 ASSERT(!it->key->isAtomic());
138 String valueName = it->key->isolatedCopy();
139 staticValues->add(valueName.impl(), std::make_unique<StaticValueEntry>(it->value->getProperty, it->value->setProperty, it->value->attributes, valueName));
140 }
141 }
142
143 if (jsClass->m_staticFunctions) {
144 staticFunctions = std::make_unique<OpaqueJSClassStaticFunctionsTable>();
145 OpaqueJSClassStaticFunctionsTable::const_iterator end = jsClass->m_staticFunctions->end();
146 for (OpaqueJSClassStaticFunctionsTable::const_iterator it = jsClass->m_staticFunctions->begin(); it != end; ++it) {
147 ASSERT(!it->key->isAtomic());
148 staticFunctions->add(it->key->isolatedCopy(), std::make_unique<StaticFunctionEntry>(it->value->callAsFunction, it->value->attributes));
149 }
150 }
151}
152
153OpaqueJSClassContextData& OpaqueJSClass::contextData(ExecState* exec)
154{
155 std::unique_ptr<OpaqueJSClassContextData>& contextData = exec->lexicalGlobalObject()->opaqueJSClassData().add(this, nullptr).iterator->value;
156 if (!contextData)
157 contextData = std::make_unique<OpaqueJSClassContextData>(exec->vm(), this);
158 return *contextData;
159}
160
161String OpaqueJSClass::className()
162{
163 // Make a deep copy, so that the caller has no chance to put the original into AtomicStringTable.
164 return m_className.isolatedCopy();
165}
166
167OpaqueJSClassStaticValuesTable* OpaqueJSClass::staticValues(JSC::ExecState* exec)
168{
169 return contextData(exec).staticValues.get();
170}
171
172OpaqueJSClassStaticFunctionsTable* OpaqueJSClass::staticFunctions(JSC::ExecState* exec)
173{
174 return contextData(exec).staticFunctions.get();
175}
176
177/*!
178// Doc here in case we make this public. (Hopefully we won't.)
179@function
180 @abstract Returns the prototype that will be used when constructing an object with a given class.
181 @param ctx The execution context to use.
182 @param jsClass A JSClass whose prototype you want to get.
183 @result The JSObject prototype that was automatically generated for jsClass, or NULL if no prototype was automatically generated. This is the prototype that will be used when constructing an object using jsClass.
184*/
185JSObject* OpaqueJSClass::prototype(ExecState* exec)
186{
187 /* Class (C++) and prototype (JS) inheritance are parallel, so:
188 * (C++) | (JS)
189 * ParentClass | ParentClassPrototype
190 * ^ | ^
191 * | | |
192 * DerivedClass | DerivedClassPrototype
193 */
194
195 if (!prototypeClass)
196 return 0;
197
198 OpaqueJSClassContextData& jsClassData = contextData(exec);
199
200 if (JSObject* prototype = jsClassData.cachedPrototype.get())
201 return prototype;
202
203 // Recursive, but should be good enough for our purposes
204 JSObject* prototype = JSCallbackObject<JSDestructibleObject>::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->callbackObjectStructure(), prototypeClass, &jsClassData); // set jsClassData as the object's private data, so it can clear our reference on destruction
205 if (parentClass) {
206 if (JSObject* parentPrototype = parentClass->prototype(exec))
207 prototype->setPrototype(exec->vm(), parentPrototype);
208 }
209
210 jsClassData.cachedPrototype = Weak<JSObject>(prototype);
211 return prototype;
212}