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 COMPUTER, 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 COMPUTER, 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 "JSCallbackObject.h"
31 #include "JSObjectRef.h"
32 #include <runtime/InitializeThreading.h>
33 #include <runtime/JSGlobalObject.h>
34 #include <runtime/ObjectPrototype.h>
35 #include <runtime/Identifier.h>
36 #include <wtf/unicode/UTF8.h>
37
38 using namespace std;
39 using namespace JSC;
40 using namespace WTF::Unicode;
41
42 const JSClassDefinition kJSClassDefinitionEmpty = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
43
tryCreateStringFromUTF8(const char * string)44 static inline UString tryCreateStringFromUTF8(const char* string)
45 {
46 if (!string)
47 return UString::null();
48
49 size_t length = strlen(string);
50 Vector<UChar, 1024> buffer(length);
51 UChar* p = buffer.data();
52 if (conversionOK != convertUTF8ToUTF16(&string, string + length, &p, p + length))
53 return UString::null();
54
55 return UString(buffer.data(), p - buffer.data());
56 }
57
OpaqueJSClass(const JSClassDefinition * definition,OpaqueJSClass * protoClass)58 OpaqueJSClass::OpaqueJSClass(const JSClassDefinition* definition, OpaqueJSClass* protoClass)
59 : parentClass(definition->parentClass)
60 , prototypeClass(0)
61 , initialize(definition->initialize)
62 , finalize(definition->finalize)
63 , hasProperty(definition->hasProperty)
64 , getProperty(definition->getProperty)
65 , setProperty(definition->setProperty)
66 , deleteProperty(definition->deleteProperty)
67 , getPropertyNames(definition->getPropertyNames)
68 , callAsFunction(definition->callAsFunction)
69 , callAsConstructor(definition->callAsConstructor)
70 , hasInstance(definition->hasInstance)
71 , convertToType(definition->convertToType)
72 , m_className(tryCreateStringFromUTF8(definition->className))
73 , m_staticValues(0)
74 , m_staticFunctions(0)
75 {
76 initializeThreading();
77
78 if (const JSStaticValue* staticValue = definition->staticValues) {
79 m_staticValues = new OpaqueJSClassStaticValuesTable();
80 while (staticValue->name) {
81 UString valueName = tryCreateStringFromUTF8(staticValue->name);
82 if (!valueName.isNull()) {
83 // Use a local variable here to sidestep an RVCT compiler bug.
84 StaticValueEntry* entry = new StaticValueEntry(staticValue->getProperty, staticValue->setProperty, staticValue->attributes);
85 m_staticValues->add(valueName.rep()->ref(), entry);
86 }
87 ++staticValue;
88 }
89 }
90
91 if (const JSStaticFunction* staticFunction = definition->staticFunctions) {
92 m_staticFunctions = new OpaqueJSClassStaticFunctionsTable();
93 while (staticFunction->name) {
94 UString functionName = tryCreateStringFromUTF8(staticFunction->name);
95 if (!functionName.isNull()) {
96 // Use a local variable here to sidestep an RVCT compiler bug.
97 StaticFunctionEntry* entry = new StaticFunctionEntry(staticFunction->callAsFunction, staticFunction->attributes);
98 m_staticFunctions->add(functionName.rep()->ref(), entry);
99 }
100 ++staticFunction;
101 }
102 }
103
104 if (protoClass)
105 prototypeClass = JSClassRetain(protoClass);
106 }
107
~OpaqueJSClass()108 OpaqueJSClass::~OpaqueJSClass()
109 {
110 ASSERT(!m_className.rep()->isIdentifier());
111
112 if (m_staticValues) {
113 OpaqueJSClassStaticValuesTable::const_iterator end = m_staticValues->end();
114 for (OpaqueJSClassStaticValuesTable::const_iterator it = m_staticValues->begin(); it != end; ++it) {
115 ASSERT(!it->first->isIdentifier());
116 delete it->second;
117 }
118 delete m_staticValues;
119 }
120
121 if (m_staticFunctions) {
122 OpaqueJSClassStaticFunctionsTable::const_iterator end = m_staticFunctions->end();
123 for (OpaqueJSClassStaticFunctionsTable::const_iterator it = m_staticFunctions->begin(); it != end; ++it) {
124 ASSERT(!it->first->isIdentifier());
125 delete it->second;
126 }
127 delete m_staticFunctions;
128 }
129
130 if (prototypeClass)
131 JSClassRelease(prototypeClass);
132 }
133
createNoAutomaticPrototype(const JSClassDefinition * definition)134 PassRefPtr<OpaqueJSClass> OpaqueJSClass::createNoAutomaticPrototype(const JSClassDefinition* definition)
135 {
136 return adoptRef(new OpaqueJSClass(definition, 0));
137 }
138
clearReferenceToPrototype(JSObjectRef prototype)139 static void clearReferenceToPrototype(JSObjectRef prototype)
140 {
141 OpaqueJSClassContextData* jsClassData = static_cast<OpaqueJSClassContextData*>(JSObjectGetPrivate(prototype));
142 ASSERT(jsClassData);
143 jsClassData->cachedPrototype.clear(toJS(prototype));
144 }
145
create(const JSClassDefinition * clientDefinition)146 PassRefPtr<OpaqueJSClass> OpaqueJSClass::create(const JSClassDefinition* clientDefinition)
147 {
148 JSClassDefinition definition = *clientDefinition; // Avoid modifying client copy.
149
150 JSClassDefinition protoDefinition = kJSClassDefinitionEmpty;
151 protoDefinition.finalize = clearReferenceToPrototype;
152 swap(definition.staticFunctions, protoDefinition.staticFunctions); // Move static functions to the prototype.
153
154 // We are supposed to use JSClassRetain/Release but since we know that we currently have
155 // the only reference to this class object we cheat and use a RefPtr instead.
156 RefPtr<OpaqueJSClass> protoClass = adoptRef(new OpaqueJSClass(&protoDefinition, 0));
157 return adoptRef(new OpaqueJSClass(&definition, protoClass.get()));
158 }
159
OpaqueJSClassContextData(OpaqueJSClass * jsClass)160 OpaqueJSClassContextData::OpaqueJSClassContextData(OpaqueJSClass* jsClass)
161 : m_class(jsClass)
162 {
163 if (jsClass->m_staticValues) {
164 staticValues = new OpaqueJSClassStaticValuesTable;
165 OpaqueJSClassStaticValuesTable::const_iterator end = jsClass->m_staticValues->end();
166 for (OpaqueJSClassStaticValuesTable::const_iterator it = jsClass->m_staticValues->begin(); it != end; ++it) {
167 ASSERT(!it->first->isIdentifier());
168 // Use a local variable here to sidestep an RVCT compiler bug.
169 StaticValueEntry* entry = new StaticValueEntry(it->second->getProperty, it->second->setProperty, it->second->attributes);
170 staticValues->add(UString::Rep::create(it->first->data(), it->first->size()), entry);
171 }
172 } else
173 staticValues = 0;
174
175 if (jsClass->m_staticFunctions) {
176 staticFunctions = new OpaqueJSClassStaticFunctionsTable;
177 OpaqueJSClassStaticFunctionsTable::const_iterator end = jsClass->m_staticFunctions->end();
178 for (OpaqueJSClassStaticFunctionsTable::const_iterator it = jsClass->m_staticFunctions->begin(); it != end; ++it) {
179 ASSERT(!it->first->isIdentifier());
180 // Use a local variable here to sidestep an RVCT compiler bug.
181 StaticFunctionEntry* entry = new StaticFunctionEntry(it->second->callAsFunction, it->second->attributes);
182 staticFunctions->add(UString::Rep::create(it->first->data(), it->first->size()), entry);
183 }
184
185 } else
186 staticFunctions = 0;
187 }
188
~OpaqueJSClassContextData()189 OpaqueJSClassContextData::~OpaqueJSClassContextData()
190 {
191 if (staticValues) {
192 deleteAllValues(*staticValues);
193 delete staticValues;
194 }
195
196 if (staticFunctions) {
197 deleteAllValues(*staticFunctions);
198 delete staticFunctions;
199 }
200 }
201
contextData(ExecState * exec)202 OpaqueJSClassContextData& OpaqueJSClass::contextData(ExecState* exec)
203 {
204 OpaqueJSClassContextData*& contextData = exec->globalData().opaqueJSClassData.add(this, 0).first->second;
205 if (!contextData)
206 contextData = new OpaqueJSClassContextData(this);
207 return *contextData;
208 }
209
className()210 UString OpaqueJSClass::className()
211 {
212 // Make a deep copy, so that the caller has no chance to put the original into IdentifierTable.
213 return UString(m_className.data(), m_className.size());
214 }
215
staticValues(JSC::ExecState * exec)216 OpaqueJSClassStaticValuesTable* OpaqueJSClass::staticValues(JSC::ExecState* exec)
217 {
218 OpaqueJSClassContextData& jsClassData = contextData(exec);
219 return jsClassData.staticValues;
220 }
221
staticFunctions(JSC::ExecState * exec)222 OpaqueJSClassStaticFunctionsTable* OpaqueJSClass::staticFunctions(JSC::ExecState* exec)
223 {
224 OpaqueJSClassContextData& jsClassData = contextData(exec);
225 return jsClassData.staticFunctions;
226 }
227
228 /*!
229 // Doc here in case we make this public. (Hopefully we won't.)
230 @function
231 @abstract Returns the prototype that will be used when constructing an object with a given class.
232 @param ctx The execution context to use.
233 @param jsClass A JSClass whose prototype you want to get.
234 @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.
235 */
prototype(ExecState * exec)236 JSObject* OpaqueJSClass::prototype(ExecState* exec)
237 {
238 /* Class (C++) and prototype (JS) inheritance are parallel, so:
239 * (C++) | (JS)
240 * ParentClass | ParentClassPrototype
241 * ^ | ^
242 * | | |
243 * DerivedClass | DerivedClassPrototype
244 */
245
246 if (!prototypeClass)
247 return 0;
248
249 OpaqueJSClassContextData& jsClassData = contextData(exec);
250
251 if (!jsClassData.cachedPrototype) {
252 // Recursive, but should be good enough for our purposes
253 jsClassData.cachedPrototype = new (exec) JSCallbackObject<JSObject>(exec, exec->lexicalGlobalObject()->callbackObjectStructure(), prototypeClass, &jsClassData); // set jsClassData as the object's private data, so it can clear our reference on destruction
254 if (parentClass) {
255 if (JSObject* prototype = parentClass->prototype(exec))
256 jsClassData.cachedPrototype->setPrototype(prototype);
257 }
258 }
259 return jsClassData.cachedPrototype.get();
260 }
261