Changeset 15497 in webkit for trunk/JavaScriptCore/API/JSClassRef.cpp

Timestamp:

Jul 17, 2006, 9:33:46 PM (19 years ago)

Author:

ggaren

Message:

Reviewed by Maciej.

• Added automatic prototype creation for classes.

A class stores a weak reference to a prototype, which is cleared when
the prototype is garbage collected, to avoid a reference cycle.

We now have an attributes field in JSClassDefinition, that currently is
used only to override automatic prototype creation when you want to manage your
own prototypes, but can be extended in the future for other nefarious purposes.

Similarly, we have JSObjectMake and JSObjectMakeWithPrototype, the latter
allowing you to manage your own prototypes.

JSObjectMakeConstructor is more interesting now, able to make a constructor
on your behalf if you just give it a class.

• Removed bogus old code from minidom.js.

• Tweaked the headerdocs.

• Added more GC testing, which caught some leaks, and tested more funny edge cases in lookup, which caught a lookup bug. Removed some testing we used to do with MyObject because it was redundant with the new, cool stuff.

While fixing the lookup bug I retracted this change:

"If a static setProperty callback returns 'false', to indicate that the
property was not set, we no longer forward the set request up the class
chain, because that's almost certainly not what the programmer expected."

Returning false when setting a static property is a little silly, but you can see
it being useful when shadowing a base class's static properties, and, regardless
of usefullness, this is the defined behavior of the setProperty callback.

• Plus a little ASCII art, for the kids.

File:

• trunk/JavaScriptCore/API/JSClassRef.cpp (modified) (4 diffs)

trunk/JavaScriptCore/API/JSClassRef.cpp

@@ -25 +25 @@
  */
 
+#include "APICast.h"
+#include "JSCallbackObject.h"
 #include "JSClassRef.h"
 #include "JSObjectRef.h"
@@ -31 +33 @@
 using namespace KJS;
 
-const JSClassDefinition kJSClassDefinitionNull = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+const JSClassDefinition kJSClassDefinitionEmpty = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-OpaqueJSClass::OpaqueJSClass(JSClassDefinition* definition) 
+OpaqueJSClass::OpaqueJSClass(const JSClassDefinition* definition, OpaqueJSClass* protoClass) 
     : refCount(0)
     , className(definition->className)
     , parentClass(definition->parentClass)
+    , prototypeClass(0)
     , staticValues(0)
     , staticFunctions(0)
@@ -68 +71 @@
         }
     }
+        
+    if (protoClass)
+        prototypeClass = JSClassRetain(protoClass);
 }
 
@@ -81 +87 @@
         delete staticFunctions;
     }
+    
+    if (prototypeClass)
+        JSClassRelease(prototypeClass);
 }
+
+JSClassRef OpaqueJSClass::createNoPrototype(const JSClassDefinition* definition)
+{
+    return new OpaqueJSClass(definition, 0);
+}
+
+void clearReferenceToPrototype(JSObjectRef prototype)
+{
+    OpaqueJSClass* jsClass = static_cast<OpaqueJSClass*>(JSObjectGetPrivate(prototype));
+    ASSERT(jsClass);
+    jsClass->cachedPrototype = 0;
+}
+
+JSClassRef OpaqueJSClass::create(const JSClassDefinition* definition)
+{
+    if (JSStaticFunction* staticFunctions = definition->staticFunctions) {
+        // copy functions into a prototype class
+        JSClassDefinition protoDefinition = kJSClassDefinitionEmpty;
+        protoDefinition.staticFunctions = staticFunctions;
+        protoDefinition.finalize = clearReferenceToPrototype;
+        OpaqueJSClass* protoClass = new OpaqueJSClass(&protoDefinition, 0);
+
+        // remove functions from the original definition
+        JSClassDefinition objectDefinition = *definition;
+        objectDefinition.staticFunctions = 0;
+        return new OpaqueJSClass(&objectDefinition, protoClass);
+    }
+
+    return new OpaqueJSClass(definition, 0);
+}
+
+/*!
+// Doc here in case we make this public. (Hopefully we won't.)
+@function
+ @abstract Returns the prototype that will be used when constructing an object with a given class.
+ @param ctx The execution context to use.
+ @param jsClass A JSClass whose prototype you want to get.
+ @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.
+*/
+JSObject* OpaqueJSClass::prototype(JSContextRef ctx)
+{
+    /* Class (C++) and prototype (JS) inheritance are parallel, so:
+     *     (C++)      |        (JS)
+     *   ParentClass  |   ParentClassPrototype
+     *       ^        |          ^
+     *       |        |          |
+     *  DerivedClass  |  DerivedClassPrototype
+     */
+    
+    if (!prototypeClass)
+        return 0;
+    
+    ExecState* exec = toJS(ctx);
+    
+    if (!cachedPrototype) {
+        // Recursive, but should be good enough for our purposes
+        JSObject* parentPrototype = 0;
+        if (parentClass)
+            parentPrototype = parentClass->prototype(ctx); // can be null
+        if (!parentPrototype)
+            parentPrototype = exec->dynamicInterpreter()->builtinObjectPrototype();
+        cachedPrototype = new JSCallbackObject(exec, prototypeClass, parentPrototype, this); // set ourself as the object's private data, so it can clear our reference on destruction
+    }
+    return cachedPrototype;
+}