Changeset 15133 in webkit for trunk/JavaScriptCore/API


Ignore:
Timestamp:
Jul 1, 2006, 9:06:07 PM (19 years ago)
Author:
ggaren
Message:

Reviewed by Maciej.


  • Phase 2 in the JS API.


  • Added support for specifying static tables of values -- this should obviate the need for using complicated callbacks for most lookups.


  • API objects are now created with classes (JSClassRef) -- in order to support static values, and in order to prevent API objects from storing their data inline, and thus falling into the oversized (read: slow and prone to giving Maciej the frowny face) heap.


  • Added two specialized JSObject subclasses -- JSCallbackFunction and JSCallbackConstructor -- to allow JSFunctionMake and JSConstructorMake to continue to work with the new class model. Another solution to this problem would be to create a custom class object for each function and constructor you make. This solution is more code but also more efficient.


  • Substantially beefed up the minidom example to demonstrate and test a lot of these techniques. Its output is still pretty haphazard, though.


  • Gave the <kjs/ preface to some includes -- I'm told this matters to building on some versions of Linux.


  • Implemented JSValueIsInstanceOf and JSValueIsObjectOfClass


  • Removed GetDescription callback. Something in the class datastructure should take care of this.
  • API/JSBase.h:
  • API/JSCallbackConstructor.cpp: Added. (KJS::): (KJS::JSCallbackConstructor::JSCallbackConstructor): (KJS::JSCallbackConstructor::implementsConstruct): (KJS::JSCallbackConstructor::construct): (KJS::JSCallbackConstructor::setPrivate): (KJS::JSCallbackConstructor::getPrivate):
  • API/JSCallbackConstructor.h: Added. (KJS::JSCallbackConstructor::classInfo):
  • API/JSCallbackFunction.cpp: Added. (KJS::): (KJS::JSCallbackFunction::JSCallbackFunction): (KJS::JSCallbackFunction::implementsCall): (KJS::JSCallbackFunction::callAsFunction): (KJS::JSCallbackFunction::setPrivate): (KJS::JSCallbackFunction::getPrivate):
  • API/JSCallbackFunction.h: Added. (KJS::JSCallbackFunction::classInfo):
  • API/JSCallbackObject.cpp: (KJS::): (KJS::JSCallbackObject::JSCallbackObject): (KJS::JSCallbackObject::init): (KJS::JSCallbackObject::~JSCallbackObject): (KJS::JSCallbackObject::className): (KJS::JSCallbackObject::getOwnPropertySlot): (KJS::JSCallbackObject::put): (KJS::JSCallbackObject::deleteProperty): (KJS::JSCallbackObject::implementsConstruct): (KJS::JSCallbackObject::construct): (KJS::JSCallbackObject::implementsCall): (KJS::JSCallbackObject::callAsFunction): (KJS::JSCallbackObject::getPropertyList): (KJS::JSCallbackObject::toBoolean): (KJS::JSCallbackObject::toNumber): (KJS::JSCallbackObject::toString): (KJS::JSCallbackObject::inherits): (KJS::JSCallbackObject::staticValueGetter): (KJS::JSCallbackObject::staticFunctionGetter): (KJS::JSCallbackObject::callbackGetter):
  • API/JSCallbackObject.h:
  • API/JSCharBufferRef.cpp:
  • API/JSClassRef.cpp: Added. (JSClassCreate): (JSClassRetain): (JSClassRelease):
  • API/JSClassRef.h: Added. (StaticValueEntry::StaticValueEntry): (StaticFunctionEntry::StaticFunctionEntry): (JSClass::JSClass):
  • API/JSContextRef.cpp: (JSContextCreate): (JSEvaluate):
  • API/JSContextRef.h:
  • API/JSNode.c: Added. (JSNodePrototype_appendChild): (JSNodePrototype_removeChild): (JSNodePrototype_replaceChild): (JSNodePrototype_class): (JSNode_getNodeType): (JSNode_getChildNodes): (JSNode_getFirstChild): (JSNode_finalize): (JSNode_class): (JSNode_prototype): (JSNode_new): (JSNode_construct):
  • API/JSNode.h: Added.
  • API/JSNodeList.c: Added. (JSNodeListPrototype_item): (JSNodeListPrototype_class): (JSNodeList_length): (JSNodeList_getProperty): (JSNodeList_finalize): (JSNodeList_class): (JSNodeList_prototype): (JSNodeList_new):
  • API/JSNodeList.h: Added.
  • API/JSObjectRef.cpp: (JSObjectMake): (JSFunctionMake): (JSConstructorMake): (JSPropertyEnumerator::JSPropertyEnumerator): (JSObjectCreatePropertyEnumerator): (JSPropertyEnumeratorGetNext): (JSPropertyEnumeratorRetain): (JSPropertyEnumeratorRelease):
  • API/JSObjectRef.h: (JSObjectCallbacks::):
  • API/JSValueRef.cpp: (JSValueIsObjectOfClass): (JSValueIsInstanceOf):
  • API/JSValueRef.h:
  • API/Node.c: Added. (Node_new): (Node_appendChild): (Node_removeChild): (Node_replaceChild): (Node_ref): (Node_deref):
  • API/Node.h: Added.
  • API/NodeList.c: Added. (NodeList_new): (NodeList_length): (NodeList_item): (NodeList_ref): (NodeList_deref):
  • API/NodeList.h: Added.
  • API/minidom.c: (main): (print): (createStringWithContentsOfFile):
  • API/minidom.js:
  • API/testapi.c: (assertEqualsAsCharacters): (MyObject_getProperty): (MyObject_class): (myConstructor_callAsConstructor): (main):
  • API/testapi.js:
  • JavaScriptCore.xcodeproj/project.pbxproj:
Location:
trunk/JavaScriptCore/API
Files:
14 added
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/API/JSBase.h

    r15096 r15133  
    3131typedef struct __JSContext* JSContextRef;
    3232typedef struct __JSCharBuffer* JSCharBufferRef;
     33typedef struct __JSClass* JSClassRef;
    3334typedef struct __JSPropertyList* JSPropertyListRef;
    34 typedef struct __JSPropertyListEnumerator* JSPropertyListEnumeratorRef;
     35typedef struct __JSPropertyEnumerator* JSPropertyEnumeratorRef;
    3536
    3637/* Base type of all JS values, and polymorphic functions on them */

  • trunk/JavaScriptCore/API/JSCallbackObject.cpp

    r14951 r15133  
    2828#include "JSCallbackObject.h"
    2929#include "JSCharBufferRef.h"
     30#include "JSClassRef.h"
    3031#include "JSObjectRef.h"
    3132#include "internal.h"
     33#include "reference.h"
    3234#include "reference_list.h"
    3335
    3436namespace KJS {
    3537
    36 const ClassInfo JSCallbackObject::info = { "JSCallbackObject", 0, 0, 0 };
    37 
    38 JSCallbackObject::JSCallbackObject(const JSObjectCallbacks* callbacks)
     38const ClassInfo JSCallbackObject::info = { "CallbackObject", 0, 0, 0 };
     39
     40JSCallbackObject::JSCallbackObject(JSClassRef jsClass)
    3941    : JSObject()
    40     , m_privateData(0)
    41     , m_callbacks(*callbacks)
    42 {
     42{
     43    init(jsClass);
     44}
     45
     46JSCallbackObject::JSCallbackObject(JSClassRef jsClass, JSObject* prototype)
     47    : JSObject(prototype)
     48{
     49    init(jsClass);
     50}
     51
     52void JSCallbackObject::init(JSClassRef jsClass)
     53{
     54    m_privateData = 0;
     55    m_class = JSClassRetain(jsClass);
     56
    4357    JSObjectRef thisRef = toRef(this);
    4458   
    4559    do {
    46         if (JSInitializeCallback initialize = callbacks->initialize)
     60        if (JSInitializeCallback initialize = jsClass->callbacks.initialize)
    4761            initialize(thisRef);
    48     } while ((callbacks = callbacks->parentCallbacks));
    49 }
    50 
    51 JSCallbackObject::JSCallbackObject(const JSObjectCallbacks* callbacks, JSObject* prototype)
    52     : JSObject(prototype)
    53     , m_privateData(0)
    54     , m_callbacks(*callbacks)
    55 {
    56     JSObjectRef thisRef = toRef(this);
    57    
    58     do {
    59         if (JSInitializeCallback initialize = callbacks->initialize)
    60             initialize(thisRef);
    61     } while ((callbacks = callbacks->parentCallbacks));
     62    } while ((jsClass = jsClass->parent));
    6263}
    6364
    … …  
    6667    JSObjectRef thisRef = toRef(this);
    6768   
    68     for (JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks)
    69         if (JSFinalizeCallback finalize = callbacks->finalize)
     69    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent)
     70        if (JSFinalizeCallback finalize = jsClass->callbacks.finalize)
    7071            finalize(thisRef);
     72   
     73    JSClassRelease(m_class);
    7174}
    7275
    7376UString JSCallbackObject::className() const
    7477{
    75     JSObjectRef thisRef = toRef(this);
    76    
    77     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    78         if (JSCopyDescriptionCallback copyDescriptionCallback = callbacks->copyDescription) {
    79             JSCharBufferRef descriptionBuf = copyDescriptionCallback(thisRef);
    80             UString description(toJS(descriptionBuf));
    81             JSCharBufferRelease(descriptionBuf);
    82             return description;
    83         }
    84     }
    85    
    86     return JSObject::className();
     78    return classInfo()->className;
    8779}
    8880
    … …  
    9183    JSObjectRef thisRef = toRef(this);
    9284    JSCharBufferRef propertyNameRef = toRef(propertyName.ustring().rep());
    93 
    94     // optional optimization for cases when we only need to know if the property exists, not its value
    95     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    96         if (JSHasPropertyCallback hasPropertyCallback = callbacks->hasProperty) {
     85   
     86    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     87        // optional optimization to bypass getProperty in cases when we only need to know if the property exists
     88        if (JSHasPropertyCallback hasPropertyCallback = jsClass->callbacks.hasProperty) {
    9789            if (hasPropertyCallback(thisRef, propertyNameRef)) {
    98                 slot.setCustom(0, callbackGetter);
    99                 return true;
    100             }
    101         }
    102     }
    103    
    104     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    105         if (JSGetPropertyCallback getPropertyCallback = callbacks->getProperty) {
     90                slot.setCustom(this, callbackGetter);
     91                return true;
     92            }
     93        } else if (JSGetPropertyCallback getPropertyCallback = jsClass->callbacks.getProperty) {
    10694            JSValueRef returnValue;
    107             if (getPropertyCallback(thisRef, propertyNameRef, &returnValue)) {
    108                 slot.setCustom(reinterpret_cast<JSObject*>(returnValue), cachedValueGetter); // cache the value so we don't have to compute it again
    109                 return true;
    110             }
    111         }
    112     }
     95            if (getPropertyCallback(toRef(exec), thisRef, propertyNameRef, &returnValue)) {
     96                // cache the value so we don't have to compute it again
     97                // FIXME: This violates the PropertySlot design a little bit.
     98                // We should either use this optimization everywhere, or nowhere.
     99                slot.setCustom(reinterpret_cast<JSObject*>(returnValue), cachedValueGetter);
     100                return true;
     101            }
     102        }
     103
     104        if (__JSClass::StaticValuesTable* staticValues = jsClass->staticValues) {
     105            if (StaticValueEntry* entry = staticValues->get(propertyName.ustring().rep())) {
     106                if (entry->getProperty) {
     107                    slot.setCustom(this, staticValueGetter);
     108                    return true;
     109                }
     110            }
     111        }
     112       
     113        if (__JSClass::StaticFunctionsTable* staticFunctions = jsClass->staticFunctions) {
     114            if (staticFunctions->contains(propertyName.ustring().rep())) {
     115                slot.setCustom(this, staticFunctionGetter);
     116                return true;
     117            }
     118        }
     119    }
     120
    113121    return JSObject::getOwnPropertySlot(exec, propertyName, slot);
    114122}
    … …  
    124132    JSCharBufferRef propertyNameRef = toRef(propertyName.ustring().rep());
    125133
    126     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    127         if (JSSetPropertyCallback setPropertyCallback = callbacks->setProperty) {
     134    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     135        if (JSSetPropertyCallback setPropertyCallback = jsClass->callbacks.setProperty) {
    128136            if (setPropertyCallback(thisRef, propertyNameRef, value))
    129137                return;
    130138        }
     139   
     140        if (__JSClass::StaticValuesTable* staticValues = jsClass->staticValues) {
     141            if (StaticValueEntry* entry = staticValues->get(propertyName.ustring().rep())) {
     142                if (entry->attributes & kJSPropertyAttributeReadOnly)
     143                    return;
     144                if (JSSetPropertyCallback setPropertyCallback = entry->setProperty) {
     145                    if (setPropertyCallback(thisRef, propertyNameRef, value))
     146                        return;
     147                }
     148            }
     149        }
     150       
     151        if (__JSClass::StaticFunctionsTable* staticFunctions = jsClass->staticFunctions) {
     152            if (StaticFunctionEntry* entry = staticFunctions->get(propertyName.ustring().rep())) {
     153                if (entry->attributes & kJSPropertyAttributeReadOnly)
     154                    return;
     155                putDirect(propertyName, value, attr); // put as override property
     156                return;
     157            }
     158        }
    131159    }
    132160    return JSObject::put(exec, propertyName, value, attr);
    … …  
    143171    JSCharBufferRef propertyNameRef = toRef(propertyName.ustring().rep());
    144172   
    145     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    146         if (JSDeletePropertyCallback deletePropertyCallback = callbacks->deleteProperty) {
     173    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     174        if (JSDeletePropertyCallback deletePropertyCallback = jsClass->callbacks.deleteProperty) {
    147175            if (deletePropertyCallback(thisRef, propertyNameRef))
    148176                return true;
    149177        }
     178
     179        if (__JSClass::StaticValuesTable* staticValues = jsClass->staticValues) {
     180            if (StaticValueEntry* entry = staticValues->get(propertyName.ustring().rep())) {
     181                if (entry->attributes & kJSPropertyAttributeDontDelete)
     182                    return false;
     183                return true;
     184            }
     185        }
     186       
     187        if (__JSClass::StaticFunctionsTable* staticFunctions = jsClass->staticFunctions) {
     188            if (StaticFunctionEntry* entry = staticFunctions->get(propertyName.ustring().rep())) {
     189                if (entry->attributes & kJSPropertyAttributeDontDelete)
     190                    return false;
     191                return true;
     192            }
     193        }
    150194    }
    151195    return JSObject::deleteProperty(exec, propertyName);
    … …  
    159203bool JSCallbackObject::implementsConstruct() const
    160204{
    161     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks)
    162         if (callbacks->callAsConstructor)
     205    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent)
     206        if (jsClass->callbacks.callAsConstructor)
    163207            return true;
    164208
    … …  
    171215    JSObjectRef thisRef = toRef(this);
    172216   
    173     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    174         if (JSCallAsConstructorCallback callAsConstructorCallback = callbacks->callAsConstructor) {
     217    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     218        if (JSCallAsConstructorCallback callAsConstructorCallback = jsClass->callbacks.callAsConstructor) {
    175219            size_t argc = args.size();
    176220            JSValueRef argv[argc];
    … …  
    181225    }
    182226   
    183     ASSERT(false);
     227    ASSERT(0); // implementsConstruct should prevent us from reaching here
    184228    return 0;
    185229}
    … …  
    187231bool JSCallbackObject::implementsCall() const
    188232{
    189     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks)
    190         if (callbacks->callAsFunction)
     233    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent)
     234        if (jsClass->callbacks.callAsFunction)
    191235            return true;
    192236   
    … …  
    200244    JSObjectRef thisObjRef = toRef(thisObj);
    201245
    202     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    203         if (JSCallAsFunctionCallback callAsFunctionCallback = callbacks->callAsFunction) {
     246    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     247        if (JSCallAsFunctionCallback callAsFunctionCallback = jsClass->callbacks.callAsFunction) {
    204248            size_t argc = args.size();
    205249            JSValueRef argv[argc];
    … …  
    210254    }
    211255
    212     ASSERT(false);
     256    ASSERT(0); // implementsCall should prevent us from reaching here
    213257    return 0;
    214258}
    … …  
    218262    JSObjectRef thisRef = toRef(this);
    219263
    220     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks)
    221         if (JSGetPropertyListCallback getPropertyListCallback = callbacks->getPropertyList)
     264    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     265        if (JSGetPropertyListCallback getPropertyListCallback = jsClass->callbacks.getPropertyList)
    222266            getPropertyListCallback(thisRef, toRef(&propertyList));
    223267
     268        if (__JSClass::StaticValuesTable* staticValues = jsClass->staticValues) {
     269            typedef __JSClass::StaticValuesTable::const_iterator iterator;
     270            iterator end = staticValues->end();
     271            for (iterator it = staticValues->begin(); it != end; ++it) {
     272                UString::Rep* name = it->first.get();
     273                StaticValueEntry* entry = it->second;
     274                if (entry->getProperty && !(entry->attributes & kJSPropertyAttributeDontEnum))
     275                    propertyList.append(Reference(this, Identifier(name)));
     276            }
     277        }
     278
     279        if (__JSClass::StaticFunctionsTable* staticFunctions = jsClass->staticFunctions) {
     280            typedef __JSClass::StaticFunctionsTable::const_iterator iterator;
     281            iterator end = staticFunctions->end();
     282            for (iterator it = staticFunctions->begin(); it != end; ++it) {
     283                UString::Rep* name = it->first.get();
     284                StaticFunctionEntry* entry = it->second;
     285                if (!(entry->attributes & kJSPropertyAttributeDontEnum))
     286                    propertyList.append(Reference(this, Identifier(name)));
     287            }
     288        }
     289    }
     290
    224291    JSObject::getPropertyList(exec, propertyList, recursive);
    225292}
    … …  
    229296    JSObjectRef thisRef = toRef(this);
    230297
    231     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    232         if (JSConvertToTypeCallback convertToTypeCallback = callbacks->convertToType) {
     298    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     299        if (JSConvertToTypeCallback convertToTypeCallback = jsClass->callbacks.convertToType) {
    233300            JSValueRef returnValue;
    234301            if (convertToTypeCallback(thisRef, kJSTypeBoolean, &returnValue))
    … …  
    243310    JSObjectRef thisRef = toRef(this);
    244311
    245     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    246         if (JSConvertToTypeCallback convertToTypeCallback = callbacks->convertToType) {
     312    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     313        if (JSConvertToTypeCallback convertToTypeCallback = jsClass->callbacks.convertToType) {
    247314            JSValueRef returnValue;
    248315            if (convertToTypeCallback(thisRef, kJSTypeNumber, &returnValue))
    … …  
    257324    JSObjectRef thisRef = toRef(this);
    258325
    259     for (const JSObjectCallbacks* callbacks = &m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    260         if (JSConvertToTypeCallback convertToTypeCallback = callbacks->convertToType) {
     326    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent) {
     327        if (JSConvertToTypeCallback convertToTypeCallback = jsClass->callbacks.convertToType) {
    261328            JSValueRef returnValue;
    262329            if (convertToTypeCallback(thisRef, kJSTypeString, &returnValue))
    … …  
    277344}
    278345
     346bool JSCallbackObject::inherits(JSClassRef c) const
     347{
     348    for (JSClassRef jsClass = m_class; jsClass; jsClass = jsClass->parent)
     349        if (jsClass == c)
     350            return true;
     351    return false;
     352}
     353
    279354JSValue* JSCallbackObject::cachedValueGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot)
    280355{
    … …  
    284359}
    285360
    286 JSValue* JSCallbackObject::callbackGetter(ExecState*, JSObject* originalObject, const Identifier& propertyName, const PropertySlot&)
    287 {
    288     ASSERT(originalObject->inherits(&JSCallbackObject::info));
    289     JSObjectRef thisRef = toRef(originalObject);
    290     JSCharBufferRef propertyNameRef= toRef(propertyName.ustring().rep());
    291 
    292     for (const JSObjectCallbacks* callbacks = &static_cast<JSCallbackObject*>(originalObject)->m_callbacks; callbacks; callbacks = callbacks->parentCallbacks) {
    293         if (JSGetPropertyCallback getPropertyCallback = callbacks->getProperty) {
    294             JSValueRef returnValue;
    295             if (getPropertyCallback(thisRef, propertyNameRef, &returnValue)) {
     361JSValue* JSCallbackObject::staticValueGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
     362{
     363    ASSERT(slot.slotBase()->inherits(&JSCallbackObject::info));
     364    JSCallbackObject* thisObj = static_cast<JSCallbackObject*>(slot.slotBase());
     365
     366    JSObjectRef thisRef = toRef(thisObj);
     367    JSCharBufferRef propertyNameRef = toRef(propertyName.ustring().rep());
     368
     369    for (JSClassRef jsClass = thisObj->m_class; jsClass; jsClass = jsClass->parent) {
     370        JSValueRef returnValue;
     371       
     372        if (__JSClass::StaticValuesTable* staticValues = jsClass->staticValues)
     373            if (StaticValueEntry* entry = staticValues->get(propertyName.ustring().rep()))
     374                if (JSGetPropertyCallback getPropertyCallback = entry->getProperty)
     375                    if (getPropertyCallback(toRef(exec), thisRef, propertyNameRef, &returnValue))
     376                        return toJS(returnValue);
     377    }
     378
     379    return jsUndefined();
     380}
     381
     382JSValue* JSCallbackObject::staticFunctionGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
     383{
     384    ASSERT(slot.slotBase()->inherits(&JSCallbackObject::info));
     385    JSCallbackObject* thisObj = static_cast<JSCallbackObject*>(slot.slotBase());
     386
     387    if (JSValue* cachedOrOverrideValue = thisObj->getDirect(propertyName))
     388        return toJS(cachedOrOverrideValue);
     389
     390    for (JSClassRef jsClass = thisObj->m_class; jsClass; jsClass = jsClass->parent) {
     391        if (__JSClass::StaticFunctionsTable* staticFunctions = jsClass->staticFunctions) {
     392            if (StaticFunctionEntry* entry = staticFunctions->get(propertyName.ustring().rep())) {
     393                JSValue* v = toJS(JSFunctionMake(toRef(exec), entry->callAsFunction));
     394                thisObj->putDirect(propertyName, v, entry->attributes);
     395                return v;
     396            }
     397        }
     398    }
     399
     400    return jsUndefined();
     401}
     402
     403JSValue* JSCallbackObject::callbackGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
     404{
     405    ASSERT(slot.slotBase()->inherits(&JSCallbackObject::info));
     406    JSCallbackObject* thisObj = static_cast<JSCallbackObject*>(slot.slotBase());
     407
     408    JSObjectRef thisRef = toRef(thisObj);
     409    JSCharBufferRef propertyNameRef = toRef(propertyName.ustring().rep());
     410
     411    for (JSClassRef jsClass = thisObj->m_class; jsClass; jsClass = jsClass->parent) {
     412        JSValueRef returnValue;
     413
     414        if (JSGetPropertyCallback getPropertyCallback = jsClass->callbacks.getProperty)
     415            if (getPropertyCallback(toRef(exec), thisRef, propertyNameRef, &returnValue))
    296416                return toJS(returnValue);
    297             }
    298         }
    299417    }
    300418

  • trunk/JavaScriptCore/API/JSCallbackObject.h

    r14951 r15133  
    3737{
    3838public:
    39     JSCallbackObject(const JSObjectCallbacks* callbacks);
    40     JSCallbackObject(const JSObjectCallbacks* callbacks, JSObject* prototype);
     39    JSCallbackObject(JSClassRef globalObjectClass);
     40    JSCallbackObject(JSClassRef globalObjectClass, JSObject* prototype);
    4141    virtual ~JSCallbackObject();
    4242       
    … …  
    6969    virtual const ClassInfo *classInfo() const { return &info; }
    7070    static const ClassInfo info;
     71
     72    bool inherits(JSClassRef) const;
    7173   
    7274private:
    … …  
    7476    JSCallbackObject(const JSCallbackObject&);
    7577
     78    void init(JSClassRef jsClass);
     79   
    7680    static JSValue* cachedValueGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
     81    static JSValue* staticValueGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot);
     82    static JSValue* staticFunctionGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot);
    7783    static JSValue* callbackGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
     84   
    7885    void* m_privateData;
    79     JSObjectCallbacks m_callbacks;
     86    JSClassRef m_class;
    8087};
    8188

  • trunk/JavaScriptCore/API/JSCharBufferRef.cpp

    r14951 r15133  
    2828#include "JSCharBufferRef.h"
    2929
    30 #include <JavaScriptCore/JSLock.h>
    31 #include <JavaScriptCore/JSType.h>
    32 #include <JavaScriptCore/internal.h>
    33 #include <JavaScriptCore/operations.h>
    34 #include <JavaScriptCore/ustring.h>
    35 #include <JavaScriptCore/value.h>
     30#include <kjs/JSLock.h>
     31#include <kjs/JSType.h>
     32#include <kjs/internal.h>
     33#include <kjs/operations.h>
     34#include <kjs/ustring.h>
     35#include <kjs/value.h>
    3636
    3737using namespace KJS;

  • trunk/JavaScriptCore/API/JSContextRef.cpp

    r14951 r15133  
    3535using namespace KJS;
    3636
    37 JSContextRef JSContextCreate(const JSObjectCallbacks* globalObjectCallbacks, JSObjectRef globalObjectPrototype)
     37JSContextRef JSContextCreate(JSClassRef globalObjectClass, JSObjectRef globalObjectPrototype)
    3838{
    3939    JSLock lock;
    … …  
    4242
    4343    JSObject* globalObject;
    44     if (globalObjectCallbacks == &kJSObjectCallbacksNone) // slightly more efficient
     44    if (globalObjectClass) {
     45        if (jsPrototype)
     46            globalObject = new JSCallbackObject(globalObjectClass, jsPrototype);
     47        else
     48            globalObject = new JSCallbackObject(globalObjectClass);
     49    } else {
     50        // creates a slightly more efficient object
    4551        if (jsPrototype)
    4652            globalObject = new JSObject(jsPrototype);
    4753        else
    4854            globalObject = new JSObject();
    49     else if (jsPrototype)
    50         globalObject = new JSCallbackObject(globalObjectCallbacks, jsPrototype);
    51     else
    52         globalObject = new JSCallbackObject(globalObjectCallbacks);
     55    }
    5356
    5457    Interpreter* interpreter = new Interpreter(globalObject); // adds the built-in object prototype to the global object
    … …  
    7881    Completion completion = exec->dynamicInterpreter()->evaluate(UString(sourceURLRep), startingLineNumber, UString(scriptRep), jsThisValue);
    7982
    80     *returnValue = toRef(completion.value());
     83    if (returnValue)
     84        *returnValue = completion.value() ? toRef(completion.value()) : toRef(jsUndefined());
     85
    8186    return completion.complType() != Throw;
    8287}

  • trunk/JavaScriptCore/API/JSContextRef.h

    r14951 r15133  
    3535#endif
    3636
    37 JSContextRef JSContextCreate(const JSObjectCallbacks* globalObjectCallbacks, JSObjectRef globalObjectPrototype);
     37JSContextRef JSContextCreate(JSClassRef globalObjectClass, JSObjectRef globalObjectPrototype);
    3838void JSContextDestroy(JSContextRef context);
    3939

  • trunk/JavaScriptCore/API/JSObjectRef.cpp

    r15043 r15133  
    2828#include "JSValueRef.h"
    2929#include "JSObjectRef.h"
     30#include "JSCallbackConstructor.h"
     31#include "JSCallbackFunction.h"
    3032#include "JSCallbackObject.h"
    3133
    … …  
    3638
    3739using namespace KJS;
    38 
    39 const JSObjectCallbacks kJSObjectCallbacksNone = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    4040
    4141JSObjectRef JSValueToObject(JSContextRef context, JSValueRef value)
    … …  
    5252}   
    5353
    54 JSObjectRef JSObjectMake(JSContextRef context, const JSObjectCallbacks* callbacks, JSObjectRef prototype)
     54JSObjectRef JSObjectMake(JSContextRef context, JSClassRef jsClass, JSObjectRef prototype)
    5555{
    5656    JSLock lock;
    … …  
    6262        jsPrototype = exec->lexicalInterpreter()->builtinObjectPrototype();
    6363
    64     if (callbacks == &kJSObjectCallbacksNone)
     64    if (!jsClass)
    6565        return toRef(new JSObject(jsPrototype)); // slightly more efficient
    6666    else
    67         return toRef(new JSCallbackObject(callbacks, jsPrototype));
     67        return toRef(new JSCallbackObject(jsClass, jsPrototype));
    6868}
    6969
    7070JSObjectRef JSFunctionMake(JSContextRef context, JSCallAsFunctionCallback callback)
    7171{
    72     ExecState* exec = toJS(context);
    73     JSObjectCallbacks callbacks = kJSObjectCallbacksNone;
    74     callbacks.callAsFunction = callback;
    75 
    76     return JSObjectMake(context, &callbacks, toRef(exec->lexicalInterpreter()->builtinFunctionPrototype()));
     72    JSLock lock;
     73    ExecState* exec = toJS(context);
     74    return toRef(new JSCallbackFunction(exec, callback));
    7775}
    7876
    7977JSObjectRef JSConstructorMake(JSContextRef context, JSCallAsConstructorCallback callback)
    8078{
    81     ExecState* exec = toJS(context);
    82     JSObjectCallbacks callbacks = kJSObjectCallbacksNone;
    83     callbacks.callAsConstructor = callback;
    84    
    85     return JSObjectMake(context, &callbacks, toRef(exec->lexicalInterpreter()->builtinObjectPrototype()));
     79    JSLock lock;
     80    ExecState* exec = toJS(context);
     81    return toRef(new JSCallbackConstructor(exec, callback));
    8682}
    8783
    … …  
    224220}
    225221
    226 struct __JSPropertyListEnumerator
    227 {
    228     __JSPropertyListEnumerator() : refCount(0), iterator(list.end())
     222struct __JSPropertyEnumerator
     223{
     224    __JSPropertyEnumerator() : refCount(0), iterator(list.end())
    229225    {
    230226    }
    … …  
    235231};
    236232
    237 JSPropertyListEnumeratorRef JSObjectCreatePropertyEnumerator(JSContextRef context, JSObjectRef object)
    238 {
    239     JSLock lock;
    240     ExecState* exec = toJS(context);
    241     JSObject* jsObject = toJS(object);
    242    
    243     JSPropertyListEnumeratorRef enumerator = new __JSPropertyListEnumerator();
     233JSPropertyEnumeratorRef JSObjectCreatePropertyEnumerator(JSContextRef context, JSObjectRef object)
     234{
     235    JSLock lock;
     236    ExecState* exec = toJS(context);
     237    JSObject* jsObject = toJS(object);
     238   
     239    JSPropertyEnumeratorRef enumerator = new __JSPropertyEnumerator();
    244240    jsObject->getPropertyList(exec, enumerator->list);
    245241    enumerator->iterator = enumerator->list.begin();
    246242   
    247     return enumerator;
    248 }
    249 
    250 JSCharBufferRef JSPropertyEnumeratorGetNext(JSContextRef context, JSPropertyListEnumeratorRef enumerator)
     243    return JSPropertyEnumeratorRetain(enumerator);
     244}
     245
     246JSCharBufferRef JSPropertyEnumeratorGetNext(JSContextRef context, JSPropertyEnumeratorRef enumerator)
    251247{
    252248    ExecState* exec = toJS(context);
    … …  
    259255}
    260256
    261 JSPropertyListEnumeratorRef JSPropertyEnumeratorRetain(JSPropertyListEnumeratorRef enumerator)
     257JSPropertyEnumeratorRef JSPropertyEnumeratorRetain(JSPropertyEnumeratorRef enumerator)
    262258{
    263259    ++enumerator->refCount;
    … …  
    265261}
    266262
    267 void JSPropertyEnumeratorRelease(JSPropertyListEnumeratorRef enumerator)
     263void JSPropertyEnumeratorRelease(JSPropertyEnumeratorRef enumerator)
    268264{
    269265    if (--enumerator->refCount == 0)

  • trunk/JavaScriptCore/API/JSObjectRef.h

    r15043 r15133  
    2929
    3030#include "JSBase.h"
     31#include "JSValueRef.h"
    3132
    3233#ifdef __cplusplus
    … …  
    4849(*JSFinalizeCallback)           (JSObjectRef object);
    4950
    50 typedef JSCharBufferRef
    51 (*JSCopyDescriptionCallback)    (JSObjectRef object);
    52 
    5351typedef bool
    5452(*JSHasPropertyCallback)        (JSObjectRef object, JSCharBufferRef propertyName);
    5553
    5654typedef bool
    57 (*JSGetPropertyCallback)        (JSObjectRef object, JSCharBufferRef propertyName, JSValueRef* returnValue);
     55(*JSGetPropertyCallback)        (JSContextRef context, JSObjectRef object, JSCharBufferRef propertyName, JSValueRef* returnValue);
    5856
    5957typedef bool
    … …  
    7775typedef struct __JSObjectCallbacks {
    7876    int                         version; // current (and only) version is 0
    79     struct __JSObjectCallbacks* parentCallbacks; // pass NULL for the default object callbacks
    8077    JSInitializeCallback        initialize;
    8178    JSFinalizeCallback          finalize;
    82     JSCopyDescriptionCallback   copyDescription;
    8379    JSHasPropertyCallback       hasProperty;
    8480    JSGetPropertyCallback       getProperty;
    … …  
    9389extern const JSObjectCallbacks kJSObjectCallbacksNone;
    9490
     91typedef struct {
     92    const char* const name; // FIXME: convert UTF8
     93    JSGetPropertyCallback getProperty;
     94    JSSetPropertyCallback setProperty;
     95    JSPropertyAttributes attributes;
     96} JSStaticValue;
     97
     98typedef struct {
     99    const char* const name; // FIXME: convert UTF8
     100    JSCallAsFunctionCallback callAsFunction;
     101    JSPropertyAttributes attributes;
     102} JSStaticFunction;
     103
     104JSClassRef JSClassCreate(JSContextRef context, JSStaticValue* staticValues, JSStaticFunction* staticFunctions, const JSObjectCallbacks* callbacks, JSClassRef parentClass);
     105void JSClassRelease(JSClassRef jsClass);
     106JSClassRef JSClassRetain(JSClassRef jsClass);
     107
    95108// pass NULL as prototype to get the built-in object prototype
    96 JSObjectRef JSObjectMake(JSContextRef context, const JSObjectCallbacks* callbacks, JSObjectRef prototype);
     109JSObjectRef JSObjectMake(JSContextRef context, JSClassRef jsClass, JSObjectRef prototype);
    97110
    98111// Will be assigned the built-in function prototype
    … …  
    120133
    121134// Used for enumerating the names of an object's properties like a for...in loop would
    122 JSPropertyListEnumeratorRef JSObjectCreatePropertyEnumerator(JSContextRef context, JSObjectRef object);
    123 JSPropertyListEnumeratorRef JSPropertyEnumeratorRetain(JSPropertyListEnumeratorRef enumerator);
    124 void JSPropertyEnumeratorRelease(JSPropertyListEnumeratorRef enumerator);
    125 JSCharBufferRef JSPropertyEnumeratorGetNext(JSContextRef context, JSPropertyListEnumeratorRef enumerator);
     135JSPropertyEnumeratorRef JSObjectCreatePropertyEnumerator(JSContextRef context, JSObjectRef object);
     136JSPropertyEnumeratorRef JSPropertyEnumeratorRetain(JSPropertyEnumeratorRef enumerator);
     137void JSPropertyEnumeratorRelease(JSPropertyEnumeratorRef enumerator);
     138JSCharBufferRef JSPropertyEnumeratorGetNext(JSContextRef context, JSPropertyEnumeratorRef enumerator);
    126139
    127140// Used for adding property names to a for...in enumeration

  • trunk/JavaScriptCore/API/JSValueRef.cpp

    r14951 r15133  
    2525 */
    2626
     27#include "APICast.h"
     28#include "JSCallbackObject.h"
    2729#include "JSValueRef.h"
    28 #include "APICast.h"
    29 #include <JavaScriptCore/JSType.h>
    30 #include <JavaScriptCore/internal.h>
    31 #include <JavaScriptCore/operations.h>
    32 #include <JavaScriptCore/protect.h>
    33 #include <JavaScriptCore/ustring.h>
    34 #include <JavaScriptCore/value.h>
     30
     31#include <kjs/JSType.h>
     32#include <kjs/internal.h>
     33#include <kjs/operations.h>
     34#include <kjs/protect.h>
     35#include <kjs/ustring.h>
     36#include <kjs/value.h>
    3537
    3638#include <wtf/Assertions.h>
    … …  
    98100}
    99101
     102bool JSValueIsObjectOfClass(JSValueRef value, JSClassRef jsClass)
     103{
     104    JSValue* jsValue = toJS(value);
     105   
     106    if (JSObject* o = jsValue->getObject())
     107        if (o->inherits(&JSCallbackObject::info))
     108            return static_cast<JSCallbackObject*>(o)->inherits(jsClass);
     109    return false;
     110}
     111
    100112bool JSValueIsEqual(JSContextRef context, JSValueRef a, JSValueRef b)
    101113{
    … …  
    124136}
    125137
     138bool JSValueIsInstanceOf(JSContextRef context, JSValueRef value, JSObjectRef object)
     139{
     140    ExecState* exec = toJS(context);
     141    JSValue* jsValue = toJS(value);
     142    JSObject* jsObject = toJS(object);
     143    if (!jsObject->implementsHasInstance())
     144        return false;
     145    bool result = jsObject->hasInstance(exec, jsValue);
     146    if (exec->hadException())
     147        exec->clearException();
     148    return result;
     149}
     150
    126151JSValueRef JSUndefinedMake()
    127152{

  • trunk/JavaScriptCore/API/JSValueRef.h

    r15096 r15133  
    108108*/
    109109bool JSValueIsObject(JSValueRef value);
     110bool JSValueIsObjectOfClass(JSValueRef value, JSClassRef jsClass);
    110111
    111112// Comparing values
    … …  
    140141  @result        true if value is an instance of object
    141142*/
    142 bool JSValueIsInstanceOf(JSValueRef value, JSObjectRef object);
     143bool JSValueIsInstanceOf(JSContextRef context, JSValueRef value, JSObjectRef object);
    143144
    144145// Creating values

  • trunk/JavaScriptCore/API/minidom.c

    r14951 r15133  
    2626
    2727#include "JavaScriptCore.h"
     28#include "JSNode.h"
    2829#include <wtf/UnusedParam.h>
     30
     31static char* createStringWithContentsOfFile(const char* fileName);
     32static JSValueRef print(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argc, JSValueRef argv[]);
    2933
    3034int main(int argc, char* argv[])
    … …  
    3337    UNUSED_PARAM(argv);
    3438   
     39    JSContextRef context = JSContextCreate(NULL, NULL);
     40    JSObjectRef globalObject = JSContextGetGlobalObject(context);
     41   
     42    JSCharBufferRef printBuf = JSCharBufferCreateUTF8("print");
     43    JSObjectSetProperty(context, globalObject, printBuf, JSFunctionMake(context, print), kJSPropertyAttributeNone);
     44    JSCharBufferRelease(printBuf);
     45   
     46    JSCharBufferRef nodeBuf = JSCharBufferCreateUTF8("Node");
     47    JSObjectSetProperty(context, globalObject, nodeBuf, JSConstructorMake(context, JSNode_construct), kJSPropertyAttributeNone);
     48    JSCharBufferRelease(nodeBuf);
     49   
     50    char* script = createStringWithContentsOfFile("minidom.js");
     51    JSCharBufferRef scriptBuf = JSCharBufferCreateUTF8(script);
     52    JSValueRef result;
     53    JSEvaluate(context, globalObject, scriptBuf, NULL, 0, &result);
     54
     55    if (JSValueIsUndefined(result))
     56        printf("PASS: Test script executed successfully.\n");
     57    else {
     58        printf("FAIL: Test script returned unexcpected value:\n");
     59        JSCharBufferRef resultBuf = JSValueCopyStringValue(context, result);
     60        CFStringRef resultCF = CFStringCreateWithJSCharBuffer(kCFAllocatorDefault, resultBuf);
     61        CFShow(resultCF);
     62        CFRelease(resultCF);
     63        JSCharBufferRelease(resultBuf);
     64    }
     65    JSCharBufferRelease(scriptBuf);
     66    free(script);
     67
     68#if 0 // used for leak/finalize debugging   
     69    int i;
     70    for (i = 0; i < 1000; i++) {
     71        JSObjectRef o = JSObjectMake(context, NULL, NULL);
     72        (void)o;
     73    }
     74    JSGCCollect();
     75#endif
     76   
     77    JSContextDestroy(context);
     78    printf("PASS: Program exited normally.\n");
    3579    return 0;
    3680}
     81
     82static JSValueRef print(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argc, JSValueRef argv[])
     83{
     84    if (argc > 0) {
     85        JSCharBufferRef stringBuf = JSValueCopyStringValue(context, argv[0]);
     86        size_t numChars = JSCharBufferGetMaxLengthUTF8(stringBuf);
     87        char string[numChars];
     88        JSCharBufferGetCharactersUTF8(stringBuf, string, numChars);
     89        printf("%s\n", string);
     90    }
     91   
     92    return JSUndefinedMake();
     93}
     94
     95static char* createStringWithContentsOfFile(const char* fileName)
     96{
     97    char* buffer;
     98   
     99    int buffer_size = 0;
     100    int buffer_capacity = 1024;
     101    buffer = (char*)malloc(buffer_capacity);
     102   
     103    FILE* f = fopen(fileName, "r");
     104    if (!f) {
     105        fprintf(stderr, "Could not open file: %s\n", fileName);
     106        return 0;
     107    }
     108   
     109    while (!feof(f) && !ferror(f)) {
     110        buffer_size += fread(buffer + buffer_size, 1, buffer_capacity - buffer_size, f);
     111        if (buffer_size == buffer_capacity) { // guarantees space for trailing '\0'
     112            buffer_capacity *= 2;
     113            buffer = (char*)realloc(buffer, buffer_capacity);
     114            assert(buffer);
     115        }
     116       
     117        assert(buffer_size < buffer_capacity);
     118    }
     119    fclose(f);
     120    buffer[buffer_size] = '\0';
     121   
     122    return buffer;
     123}

  • trunk/JavaScriptCore/API/minidom.js

    r14951 r15133  
    2626
    2727// For browser-based testing
    28 if (window) {
     28if (typeof window != 'undefined') {
    2929    /*
    3030    The methods and constructors below approximate what that the native host should provide
    … …  
    6060    }
    6161
    62     Node.prototype.tag = "Node";
     62    Node.prototype.nodeType = "Node";
    6363
    6464    Node.prototype.appendChild = function(child) {
    … …  
    7474
    7575        printSpaces(numSpaces);
    76         print('<' + this.tag + '>' + '\n');
     76        print('<' + this.nodeType + '>' + '\n');
    7777       
    7878        var childNodesLength = this.childNodes.length;
    … …  
    8181       
    8282        printSpaces(numSpaces);
    83         print('</' + this.tag + '>\n');
     83        print('</' + this.nodeType + '>\n');
    8484    }
    8585
    … …  
    9191    TextNode.prototype = new Node();
    9292   
    93     TextNode.prototype.tag = "Text";
     93    TextNode.prototype.nodeType = "Text";
    9494   
    9595    TextNode.prototype.serialize = function(numSpaces) {
    … …  
    105105    Element.prototype = new Node();
    106106   
    107     Element.prototype.tag = "Element";
     107    Element.prototype.nodeType = "Element";
    108108
    109109    RootElement = function()
    … …  
    113113    RootElement.prototype = new Element();
    114114
    115     RootElement.prototype.tag = "Root";
     115    RootElement.prototype.nodeType = "Root";
    116116   
    117117    HeroElement = function()
    … …  
    121121    HeroElement.prototype = new Element();
    122122
    123     HeroElement.prototype.tag = "Hero";
     123    HeroElement.prototype.nodeType = "Hero";
    124124
    125125    VillainElement = function()
    … …  
    129129    VillainElement.prototype = new Element();
    130130
    131     VillainElement.prototype.tag = "Villain";
     131    VillainElement.prototype.nodeType = "Villain";
    132132
    133133    NameElement = function()
    … …  
    137137    NameElement.prototype = new Element();
    138138
    139     NameElement.prototype.tag = "Name";
     139    NameElement.prototype.nodeType = "Name";
    140140
    141141    WeaponElement = function()
    … …  
    145145    WeaponElement.prototype = new Element();
    146146
    147     WeaponElement.prototype.tag = "Weapon";
     147    WeaponElement.prototype.nodeType = "Weapon";
    148148
    149149    Document = function()
    … …  
    168168function test()
    169169{
     170    print("Node is " + Node);
     171    for (var p in Node)
     172        print(p + ": " + Node[p]);
     173   
     174    node = new Node();
     175    print("node is " + node);
     176    for (var p in node)
     177        print(p + ": " + node[p]);
     178
     179    child1 = new Node();
     180    child2 = new Node();
     181    child3 = new Node();
     182   
     183    node.appendChild(child1);
     184    node.appendChild(child2);
     185
     186    for (var i = 0; i < node.childNodes.length + 1; i++) {
     187        print("item " + i + ": " + node.childNodes.item(i));
     188    }
     189   
     190    for (var i = 0; i < node.childNodes.length + 1; i++) {
     191        print(i + ": " + node.childNodes[i]);
     192    }
     193
     194    node.removeChild(child1);
     195    node.replaceChild(child3, child2);
     196   
     197    for (var i = 0; i < node.childNodes.length + 1; i++) {
     198        print("item " + i + ": " + node.childNodes.item(i));
     199    }
     200
     201    for (var i = 0; i < node.childNodes.length + 1; i++) {
     202        print(i + ": " + node.childNodes[i]);
     203    }
     204
     205    try {
     206        node.appendChild(null);
     207    } catch(e) {
     208        print("caught: " + e);
     209    }
     210   
     211    try {
     212        var o = new Object();
     213        o.appendChild = node.appendChild;
     214        o.appendChild(node);
     215    } catch(e) {
     216        print("caught: " + e);
     217    }
     218   
     219    try {
     220        node.appendChild();
     221    } catch(e) {
     222        print("caught: " + e);
     223    }
     224
     225    /*
    170226    var element, name, weapon;
    171227   
    … …  
    173229    document.appendChild(document.createElement('Root'));
    174230
    175     /* Tank Girl */
     231    // Tank Girl
    176232    element = document.createElement('Hero');
    177233
    … …  
    195251
    196252
    197     /* Skeletor */
     253    // Skeletor
    198254    element = document.createElement('Villain');
    199255
    … …  
    212268    document.firstChild.appendChild(element);
    213269
    214     /* Serialize */
     270    // Serialize
    215271    document.serialize();
     272    */
    216273}
     274
     275test();

  • trunk/JavaScriptCore/API/testapi.c

    r15043 r15133  
    108108    CFRelease(expectedValueAsCFString);
    109109   
    110     assert(memcmp(jsBuffer, cfBuffer, cfLength * sizeof(UniChar)) == 0);
    111     assert(jsLength == (size_t)cfLength);
     110    if (memcmp(jsBuffer, cfBuffer, cfLength * sizeof(UniChar)) != 0)
     111        fprintf(stderr, "assertEqualsAsCharacters failed: jsBuffer != cfBuffer\n");
     112   
     113    if (jsLength != (size_t)cfLength)
     114        fprintf(stderr, "assertEqualsAsCharacters failed: jsLength(%ld) != cfLength(%ld)\n", jsLength, cfLength);
    112115   
    113116    JSCharBufferRelease(valueAsString);
    … …  
    125128    UNUSED_PARAM(object);
    126129    didInitialize = true;
    127 }
    128 
    129 static JSCharBufferRef MyObject_copyDescription(JSObjectRef object)
    130 {
    131     UNUSED_PARAM(object);
    132     return JSCharBufferCreateUTF8("MyObject");
    133130}
    134131
    … …  
    146143}
    147144
    148 static bool MyObject_getProperty(JSObjectRef object, JSCharBufferRef propertyName, JSValueRef* returnValue)
    149 {
     145static bool MyObject_getProperty(JSContextRef context, JSObjectRef object, JSCharBufferRef propertyName, JSValueRef* returnValue)
     146{
     147    UNUSED_PARAM(context);
    150148    UNUSED_PARAM(object);
    151149   
    … …  
    252250}
    253251
    254 JSObjectCallbacks MyObjectCallbacks = {
    255     0,
     252JSObjectCallbacks MyObject_callbacks = {
    256253    0,
    257254    &MyObject_initialize,
    258255    &MyObject_finalize,
    259     &MyObject_copyDescription,
    260256    &MyObject_hasProperty,
    261257    &MyObject_getProperty,
    … …  
    268264};
    269265
     266static JSClassRef MyObject_class(JSContextRef context)
     267{
     268    static JSClassRef jsClass;
     269    if (!jsClass) {
     270        jsClass = JSClassCreate(context, NULL, NULL, &MyObject_callbacks, NULL);
     271    }
     272   
     273    return jsClass;
     274}
     275
    270276static JSValueRef print_callAsFunction(JSContextRef context, JSObjectRef functionObject, JSObjectRef thisObject, size_t argc, JSValueRef argv[])
    271277{
    … …  
    289295    UNUSED_PARAM(constructorObject);
    290296   
    291     JSObjectRef result = JSObjectMake(context, &kJSObjectCallbacksNone, 0);
     297    JSObjectRef result = JSObjectMake(context, NULL, 0);
    292298    if (argc > 0) {
    293299        JSCharBufferRef valueBuffer = JSCharBufferCreateUTF8("value");
    … …  
    306312    UNUSED_PARAM(argv);
    307313   
    308     context = JSContextCreate(&kJSObjectCallbacksNone, 0);
     314    context = JSContextCreate(NULL, NULL);
    309315
    310316    JSValueRef jsUndefined = JSUndefinedMake();
    … …  
    468474    // GDB says jsGlobalValue actually ends up being marked by the stack crawl, so this
    469475    // exercise is a bit academic. Not sure why that happens, or how to avoid it.
    470     jsGlobalValue = JSObjectMake(context, &kJSObjectCallbacksNone, 0);
     476    jsGlobalValue = JSObjectMake(context, NULL, 0);
    471477    JSGCCollect();
    472478    assert(JSValueIsObject(jsGlobalValue));
    … …  
    507513    JSCharBufferRelease(badSyntaxBuf);
    508514
    509     JSObjectRef myObject = JSObjectMake(context, &MyObjectCallbacks, 0);
     515    JSCharBufferRef arrayBuf = JSCharBufferCreateUTF8("Array");
     516    JSValueRef v;
     517    assert(JSObjectGetProperty(context, globalObject, arrayBuf, &v));
     518    JSObjectRef arrayConstructor = JSValueToObject(context, v);
     519    JSCharBufferRelease(arrayBuf);
     520    JSValueRef arrayObject;
     521    assert(JSObjectCallAsConstructor(context, arrayConstructor, 0, NULL, &arrayObject));
     522    assert(JSValueIsInstanceOf(context, arrayObject, arrayConstructor));
     523    assert(!JSValueIsInstanceOf(context, JSNullMake(), arrayConstructor));
     524   
     525    JSObjectRef myObject = JSObjectMake(context, MyObject_class(context), NULL);
    510526    assert(didInitialize);
    511527    JSCharBufferRef myObjectBuf = JSCharBufferCreateUTF8("MyObject");
    … …  
    538554
    539555    // Allocate a few dummies so that at least one will be collected
    540     JSObjectMake(context, &MyObjectCallbacks, 0);
    541     JSObjectMake(context, &MyObjectCallbacks, 0);
     556    JSObjectMake(context, MyObject_class(context), 0);
     557    JSObjectMake(context, MyObject_class(context), 0);
    542558    JSGCCollect();
    543559    assert(didFinalize);
    544560
    545561    JSContextDestroy(context);
    546     printf("PASS: All assertions passed.\n");
     562    printf("PASS: Program exited normally.\n");
    547563    return 0;
    548564}

  • trunk/JavaScriptCore/API/testapi.js

    r15043 r15133  
    3434    }
    3535   
    36     if (evalA == b || isNaN(evalA) && isNaN(b))
     36    if (evalA == b || isNaN(evalA) && typeof evalA == 'number' && isNaN(b) && typeof b == 'number')
    3737        print("PASS: " + a + " should be " + b + " and is.", "green");
    3838    else
    … …  
    7575shouldBe("MyObject ? 1 : 0", 0); // toBoolean
    7676shouldBe("+MyObject", 1); // toNumber
    77 shouldBe("(MyObject + '').indexOf('MyObject') != -1", true); // toString
     77shouldBe("(MyObject.toString())", "[object CallbackObject]"); // toString
    7878shouldBe("MyObject - 0", NaN); // toPrimitive
    7979
Note: See TracChangeset for help on using the changeset viewer.