Changeset 18912 in webkit for trunk/JavaScriptCore/kjs

Timestamp:

Jan 17, 2007, 11:34:43 AM (18 years ago)

Author:

ap

Message:

Reviewed by Maciej.

​http://bugs.webkit.org/show_bug.cgi?id=12268
Give object prototypes their own names

JavaScriptCore:

• kjs/lookup.h: Append "Prototype" to ClassName in KJS_IMPLEMENT_PROTOTYPE.

WebCore:

• bindings/scripts/CodeGeneratorJS.pm: Append "Proto" to interface name for the prototype's ClassInfo.

• bindings/js/JSHTMLInputElementBase.cpp: (WebCore::JSHTMLInputElementBasePrototypeFunction::callAsFunction): (WebCore::JSHTMLInputElementBase::JSHTMLInputElementBase):
• bindings/js/JSHTMLInputElementBase.h:
• bindings/js/JSXMLHttpRequest.cpp: (KJS::JSXMLHttpRequestConstructorImp::JSXMLHttpRequestConstructorImp): (KJS::JSXMLHttpRequest::JSXMLHttpRequest): (KJS::JSXMLHttpRequestPrototypeFunction::callAsFunction):
• bindings/js/JSXMLHttpRequest.h:
• bindings/js/JSXSLTProcessor.cpp: (KJS::JSXSLTProcessor::JSXSLTProcessor): (KJS::XSLTProcessorPrototypeFunction::callAsFunction): (KJS::XSLTProcessorConstructorImp::XSLTProcessorConstructorImp):
• bindings/js/kjs_css.cpp: (KJS::DOMCSSStyleDeclaration::DOMCSSStyleDeclaration): (KJS::DOMCSSStyleDeclarationPrototypeFunction::callAsFunction): (KJS::DOMMediaList::DOMMediaList): (KJS::KJS::DOMMediaListPrototypeFunction::callAsFunction): (KJS::DOMCSSStyleSheet::DOMCSSStyleSheet): (KJS::DOMCSSStyleSheetPrototypeFunction::callAsFunction): (KJS::DOMCSSValue::DOMCSSValue): (KJS::DOMCSSValuePrototypeFunction::callAsFunction):
• bindings/js/kjs_css.h:
• bindings/js/kjs_dom.cpp: (KJS::DOMNode::DOMNode): (KJS::DOMNodePrototypeFunction::callAsFunction): (KJS::DOMEventTargetNode::DOMEventTargetNode): (KJS::DOMEventTargetNodePrototypeFunction::callAsFunction): (KJS::DOMNamedNodeMap::DOMNamedNodeMap): (KJS::DOMNamedNodeMapPrototypeFunction::callAsFunction):
• bindings/js/kjs_dom.h:
• bindings/js/kjs_domnode.h:
• bindings/js/kjs_events.cpp: (KJS::DOMEvent::DOMEvent): (KJS::DOMEventPrototypeFunction::callAsFunction): (KJS::Clipboard::Clipboard): (KJS::ClipboardPrototypeFunction::callAsFunction):
• bindings/js/kjs_events.h:
• bindings/js/kjs_html.cpp: (KJS::JSHTMLDocumentPrototypeFunction::callAsFunction): (KJS::): (KJS::JSHTMLDocument::JSHTMLDocument): (KJS::JSHTMLElementPrototypeFunction::callAsFunction): (KJS::JSHTMLElement::JSHTMLElement): (KJS::JSHTMLCollection::JSHTMLCollection): (KJS::JSHTMLCollectionPrototypeFunction::callAsFunction):
• bindings/js/kjs_html.h:
• bindings/js/kjs_navigator.cpp:
• bindings/js/kjs_traversal.cpp: (KJS::DOMNodeFilter::DOMNodeFilter): (KJS::DOMNodeFilterPrototypeFunction::callAsFunction):
• bindings/js/kjs_window.cpp: (KJS::Window::clear): Changed Proto to Prototype, and ProtoFunc to PrototypeFunction.

LayoutTests:

• fast/dom/Window/window-properties-expected.txt:
• fast/dom/prototype-chain-expected.txt:
• fast/events/event-view-toString-expected.txt:
• fast/events/mouseclick-target-and-positioning-expected.txt:
• fast/tokenizer/external-script-document-write-expected.checksum:
• fast/tokenizer/external-script-document-write-expected.png:
• fast/tokenizer/external-script-document-write-expected.txt: Updated the results.

File:

• trunk/JavaScriptCore/kjs/lookup.h (modified) (3 diffs)

trunk/JavaScriptCore/kjs/lookup.h

@@ -297 +297 @@
  * the functions for a type of objects).
  * Sorry for this not being very readable, but it actually saves much copy-n-paste.
- * ParentProto is not our base class, it's the object we use as fallback.
+ * ParentPrototype is not our base class, it's the object we use as fallback.
  * The reason for this is that there should only be ONE DOMNode.hasAttributes (e.g.),
  * not one in each derived class. So we link the (unique) prototypes between them.
  *
- * Using those macros is very simple: define the hashtable (e.g. "DOMNodeProtoTable"), then
- * KJS_DEFINE_PROTOTYPE(DOMNodeProto)
- * KJS_IMPLEMENT_PROTOFUNC(DOMNodeProtoFunc)
- * KJS_IMPLEMENT_PROTOTYPE("DOMNode", DOMNodeProto,DOMNodeProtoFunc)
- * and use DOMNodeProto::self(exec) as prototype in the DOMNode constructor.
- * If the prototype has a "parent prototype", e.g. DOMElementProto falls back on DOMNodeProto,
- * then the first line will use KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE, with DOMNodeProto as the second argument.
+ * Using those macros is very simple: define the hashtable (e.g. "DOMNodePrototypeTable"), then
+ * KJS_DEFINE_PROTOTYPE(DOMNodePrototype)
+ * KJS_IMPLEMENT_PROTOFUNC(DOMNodePrototypeFunction)
+ * KJS_IMPLEMENT_PROTOTYPE("DOMNode", DOMNodePrototype, DOMNodePrototypeFunction)
+ * and use DOMNodePrototype::self(exec) as prototype in the DOMNode constructor.
+ * If the prototype has a "parent prototype", e.g. DOMElementPrototype falls back on DOMNodePrototype,
+ * then the first line will use KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE, with DOMNodePrototype as the second argument.
  */
 
 // These macros assume that a prototype's only properties are functions
-#define KJS_DEFINE_PROTOTYPE(ClassProto) \
-  class ClassProto : public KJS::JSObject { \
+#define KJS_DEFINE_PROTOTYPE(ClassPrototype) \
+  class ClassPrototype : public KJS::JSObject { \
   public: \
     static KJS::JSObject* self(KJS::ExecState* exec); \
@@ -318 +318 @@
     static const KJS::ClassInfo info; \
     bool getOwnPropertySlot(KJS::ExecState* , const KJS::Identifier&, KJS::PropertySlot&); \
-    ClassProto(KJS::ExecState* exec) \
+    ClassPrototype(KJS::ExecState* exec) \
       : KJS::JSObject(exec->lexicalInterpreter()->builtinObjectPrototype()) { } \
     \
   };
 
-#define KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(ClassProto, ClassProtoProto) \
-    class ClassProto : public KJS::JSObject { \
+#define KJS_DEFINE_PROTOTYPE_WITH_PROTOTYPE(ClassPrototype, ClassPrototypePrototype) \
+    class ClassPrototype : public KJS::JSObject { \
     public: \
         static KJS::JSObject* self(KJS::ExecState* exec); \
@@ -330 +330 @@
         static const KJS::ClassInfo info; \
         bool getOwnPropertySlot(KJS::ExecState*, const KJS::Identifier&, KJS::PropertySlot&); \
-        ClassProto(KJS::ExecState* exec) \
-            : KJS::JSObject(ClassProtoProto::self(exec)) { } \
+        ClassPrototype(KJS::ExecState* exec) \
+            : KJS::JSObject(ClassPrototypePrototype::self(exec)) { } \
     \
     };
 
-#define KJS_IMPLEMENT_PROTOTYPE(ClassName, ClassProto, ClassFunc) \
-    const ClassInfo ClassProto::info = { ClassName, 0, &ClassProto##Table, 0 }; \
-    JSObject* ClassProto::self(ExecState* exec) \
+#define KJS_IMPLEMENT_PROTOTYPE(ClassName, ClassPrototype, ClassFunction) \
+    const ClassInfo ClassPrototype::info = { ClassName"Prototype", 0, &ClassPrototype##Table, 0 }; \
+    JSObject* ClassPrototype::self(ExecState* exec) \
     { \
-        return KJS::cacheGlobalObject<ClassProto>(exec, "[[" ClassName ".prototype]]"); \
+        return KJS::cacheGlobalObject<ClassPrototype>(exec, "[[" ClassName ".prototype]]"); \
     } \
-    bool ClassProto::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) \
+    bool ClassPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) \
     { \
-      return getStaticFunctionSlot<ClassFunc, JSObject>(exec, &ClassProto##Table, this, propertyName, slot); \
+      return getStaticFunctionSlot<ClassFunction, JSObject>(exec, &ClassPrototype##Table, this, propertyName, slot); \
     }
 
-#define KJS_IMPLEMENT_PROTOFUNC(ClassFunc) \
-  class ClassFunc : public InternalFunctionImp { \
+#define KJS_IMPLEMENT_PROTOTYPE_FUNCTION(ClassFunction) \
+  class ClassFunction : public InternalFunctionImp { \
   public: \
-    ClassFunc(ExecState* exec, int i, int len, const Identifier& name) \
+    ClassFunction(ExecState* exec, int i, int len, const Identifier& name) \
       : InternalFunctionImp(static_cast<FunctionPrototype*>(exec->lexicalInterpreter()->builtinFunctionPrototype()), name) \
       , id(i) \