Changeset 11527 in webkit for trunk/JavaScriptCore/kjs/array_object.cpp

Timestamp:

Dec 10, 2005, 6:06:17 PM (19 years ago)

Author:

darin

Message:

JavaScriptCore:

Rubber stamped by Maciej.

• did long-promised KJS renaming:

ValueImp -> JSValue
ObjectImp -> JSObject
AllocatedValueImp -> JSCell

A renaming to get a class out of the way

KJS::Bindings::JSObject -> JavaJSObject

and some other "imp-reduction" renaming

*InstanceImp -> *Instance
*ProtoFuncImp -> *ProtoFunc
*PrototypeImp -> *Prototype
ArgumentsImp -> Arguments
RuntimeArrayImp -> RuntimeArray
RuntimeMethodImp -> RuntimeMethod

• most files and functions

WebCore:

Rubber stamped by Maciej.

• updated for KJS class renaming

• many files and functions

File:

• trunk/JavaScriptCore/kjs/array_object.cpp (modified) (46 diffs)

trunk/JavaScriptCore/kjs/array_object.cpp

@@ -41 +41 @@
 using namespace KJS;
 
-// ------------------------------ ArrayInstanceImp -----------------------------
+// ------------------------------ ArrayInstance -----------------------------
 
 const unsigned sparseArrayCutoff = 10000;
 
-const ClassInfo ArrayInstanceImp::info = {"Array", 0, 0, 0};
-
-ArrayInstanceImp::ArrayInstanceImp(ObjectImp *proto, unsigned initialLength)
-  : ObjectImp(proto)
+const ClassInfo ArrayInstance::info = {"Array", 0, 0, 0};
+
+ArrayInstance::ArrayInstance(JSObject *proto, unsigned initialLength)
+  : JSObject(proto)
   , length(initialLength)
   , storageLength(initialLength < sparseArrayCutoff ? initialLength : 0)
   , capacity(storageLength)
-  , storage(capacity ? (ValueImp **)fastCalloc(capacity, sizeof(ValueImp *)) : 0)
-{
-}
-
-ArrayInstanceImp::ArrayInstanceImp(ObjectImp *proto, const List &list)
-  : ObjectImp(proto)
+  , storage(capacity ? (JSValue **)fastCalloc(capacity, sizeof(JSValue *)) : 0)
+{
+}
+
+ArrayInstance::ArrayInstance(JSObject *proto, const List &list)
+  : JSObject(proto)
   , length(list.size())
   , storageLength(length)
   , capacity(storageLength)
-  , storage(capacity ? (ValueImp **)fastMalloc(sizeof(ValueImp *) * capacity) : 0)
+  , storage(capacity ? (JSValue **)fastMalloc(sizeof(JSValue *) * capacity) : 0)
 {
   ListIterator it = list.begin();
@@ -70 +70 @@
 }
 
-ArrayInstanceImp::~ArrayInstanceImp()
+ArrayInstance::~ArrayInstance()
 {
   fastFree(storage);
 }
 
-ValueImp *ArrayInstanceImp::lengthGetter(ExecState *exec, const Identifier& propertyName, const PropertySlot& slot)
-{
-  return jsNumber(static_cast<ArrayInstanceImp *>(slot.slotBase())->length);
-}
-
-bool ArrayInstanceImp::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
+JSValue *ArrayInstance::lengthGetter(ExecState *exec, const Identifier& propertyName, const PropertySlot& slot)
+{
+  return jsNumber(static_cast<ArrayInstance *>(slot.slotBase())->length);
+}
+
+bool ArrayInstance::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
 {
   if (propertyName == lengthPropertyName) {
@@ -93 +93 @@
       return false;
     if (index < storageLength) {
-      ValueImp *v = storage[index];
+      JSValue *v = storage[index];
       if (!v || v->isUndefined())
         return false;      
@@ -101 +101 @@
   }
 
-  return ObjectImp::getOwnPropertySlot(exec, propertyName, slot);
-}
-
-bool ArrayInstanceImp::getOwnPropertySlot(ExecState *exec, unsigned index, PropertySlot& slot)
+  return JSObject::getOwnPropertySlot(exec, propertyName, slot);
+}
+
+bool ArrayInstance::getOwnPropertySlot(ExecState *exec, unsigned index, PropertySlot& slot)
 {
   if (index >= length)
     return false;
   if (index < storageLength) {
-    ValueImp *v = storage[index];
+    JSValue *v = storage[index];
     if (!v || v->isUndefined())
       return false;
@@ -116 +116 @@
   }
 
-  return ObjectImp::getOwnPropertySlot(exec, index, slot);
+  return JSObject::getOwnPropertySlot(exec, index, slot);
 }
 
 // Special implementation of [[Put]] - see ECMA 15.4.5.1
-void ArrayInstanceImp::put(ExecState *exec, const Identifier &propertyName, ValueImp *value, int attr)
+void ArrayInstance::put(ExecState *exec, const Identifier &propertyName, JSValue *value, int attr)
 {
   if (propertyName == lengthPropertyName) {
@@ -134 +134 @@
   }
   
-  ObjectImp::put(exec, propertyName, value, attr);
-}
-
-void ArrayInstanceImp::put(ExecState *exec, unsigned index, ValueImp *value, int attr)
+  JSObject::put(exec, propertyName, value, attr);
+}
+
+void ArrayInstance::put(ExecState *exec, unsigned index, JSValue *value, int attr)
 {
   if (index < sparseArrayCutoff && index >= storageLength) {
@@ -153 +153 @@
   
   assert(index >= sparseArrayCutoff);
-  ObjectImp::put(exec, Identifier::from(index), value, attr);
-}
-
-bool ArrayInstanceImp::deleteProperty(ExecState *exec, const Identifier &propertyName)
+  JSObject::put(exec, Identifier::from(index), value, attr);
+}
+
+bool ArrayInstance::deleteProperty(ExecState *exec, const Identifier &propertyName)
 {
   if (propertyName == lengthPropertyName)
@@ -172 +172 @@
   }
   
-  return ObjectImp::deleteProperty(exec, propertyName);
-}
-
-bool ArrayInstanceImp::deleteProperty(ExecState *exec, unsigned index)
+  return JSObject::deleteProperty(exec, propertyName);
+}
+
+bool ArrayInstance::deleteProperty(ExecState *exec, unsigned index)
 {
   if (index >= length)
@@ -184 +184 @@
   }
   
-  return ObjectImp::deleteProperty(exec, Identifier::from(index));
-}
-
-ReferenceList ArrayInstanceImp::propList(ExecState *exec, bool recursive)
-{
-  ReferenceList properties = ObjectImp::propList(exec,recursive);
+  return JSObject::deleteProperty(exec, Identifier::from(index));
+}
+
+ReferenceList ArrayInstance::propList(ExecState *exec, bool recursive)
+{
+  ReferenceList properties = JSObject::propList(exec,recursive);
 
   // avoid fetching this every time through the loop
-  ValueImp *undefined = jsUndefined();
+  JSValue *undefined = jsUndefined();
 
   for (unsigned i = 0; i < storageLength; ++i) {
-    ValueImp *imp = storage[i];
+    JSValue *imp = storage[i];
     if (imp && imp != undefined) {
       properties.append(Reference(this, i));
@@ -203 +203 @@
 }
 
-void ArrayInstanceImp::resizeStorage(unsigned newLength)
+void ArrayInstance::resizeStorage(unsigned newLength)
 {
     if (newLength < storageLength) {
-      memset(storage + newLength, 0, sizeof(ValueImp *) * (storageLength - newLength));
+      memset(storage + newLength, 0, sizeof(JSValue *) * (storageLength - newLength));
     }
     if (newLength > capacity) {
@@ -218 +218 @@
         }
       }
-      storage = (ValueImp **)fastRealloc(storage, newCapacity * sizeof (ValueImp *));
-      memset(storage + capacity, 0, sizeof(ValueImp *) * (newCapacity - capacity));
+      storage = (JSValue **)fastRealloc(storage, newCapacity * sizeof (JSValue *));
+      memset(storage + capacity, 0, sizeof(JSValue *) * (newCapacity - capacity));
       capacity = newCapacity;
     }
@@ -225 +225 @@
 }
 
-void ArrayInstanceImp::setLength(unsigned newLength, ExecState *exec)
+void ArrayInstance::setLength(unsigned newLength, ExecState *exec)
 {
   if (newLength <= storageLength) {
@@ -250 +250 @@
 }
 
-void ArrayInstanceImp::mark()
-{
-  ObjectImp::mark();
+void ArrayInstance::mark()
+{
+  JSObject::mark();
   unsigned l = storageLength;
   for (unsigned i = 0; i < l; ++i) {
-    ValueImp *imp = storage[i];
+    JSValue *imp = storage[i];
     if (imp && !imp->marked())
       imp->mark();
@@ -266 +266 @@
 {
     ExecState *exec = execForCompareByStringForQSort;
-    ValueImp *va = *(ValueImp **)a;
-    ValueImp *vb = *(ValueImp **)b;
+    JSValue *va = *(JSValue **)a;
+    JSValue *vb = *(JSValue **)b;
     if (va->isUndefined()) {
         return vb->isUndefined() ? 0 : 1;
@@ -277 +277 @@
 }
 
-void ArrayInstanceImp::sort(ExecState *exec)
+void ArrayInstance::sort(ExecState *exec)
 {
     int lengthNotIncludingUndefined = pushUndefinedObjectsToEnd(exec);
     
     execForCompareByStringForQSort = exec;
-    qsort(storage, lengthNotIncludingUndefined, sizeof(ValueImp *), compareByStringForQSort);
+    qsort(storage, lengthNotIncludingUndefined, sizeof(JSValue *), compareByStringForQSort);
     execForCompareByStringForQSort = 0;
 }
 
 struct CompareWithCompareFunctionArguments {
-    CompareWithCompareFunctionArguments(ExecState *e, ObjectImp *cf)
+    CompareWithCompareFunctionArguments(ExecState *e, JSObject *cf)
         : exec(e)
         , compareFunction(cf)
@@ -297 +297 @@
 
     ExecState *exec;
-    ObjectImp *compareFunction;
+    JSObject *compareFunction;
     List arguments;
-    ObjectImp *globalObject;
+    JSObject *globalObject;
 };
 
@@ -308 +308 @@
     CompareWithCompareFunctionArguments *args = compareWithCompareFunctionArguments;
 
-    ValueImp *va = *(ValueImp **)a;
-    ValueImp *vb = *(ValueImp **)b;
+    JSValue *va = *(JSValue **)a;
+    JSValue *vb = *(JSValue **)b;
     if (va->isUndefined()) {
         return vb->isUndefined() ? 0 : 1;
@@ -325 +325 @@
 }
 
-void ArrayInstanceImp::sort(ExecState *exec, ObjectImp *compareFunction)
+void ArrayInstance::sort(ExecState *exec, JSObject *compareFunction)
 {
     int lengthNotIncludingUndefined = pushUndefinedObjectsToEnd(exec);
@@ -331 +331 @@
     CompareWithCompareFunctionArguments args(exec, compareFunction);
     compareWithCompareFunctionArguments = &args;
-    qsort(storage, lengthNotIncludingUndefined, sizeof(ValueImp *), compareWithCompareFunctionForQSort);
+    qsort(storage, lengthNotIncludingUndefined, sizeof(JSValue *), compareWithCompareFunctionForQSort);
     compareWithCompareFunctionArguments = 0;
 }
 
-unsigned ArrayInstanceImp::pushUndefinedObjectsToEnd(ExecState *exec)
-{
-    ValueImp *undefined = jsUndefined();
+unsigned ArrayInstance::pushUndefinedObjectsToEnd(ExecState *exec)
+{
+    JSValue *undefined = jsUndefined();
 
     unsigned o = 0;
     
     for (unsigned i = 0; i != storageLength; ++i) {
-        ValueImp *v = storage[i];
+        JSValue *v = storage[i];
         if (v && v != undefined) {
             if (o != i)
@@ -362 +362 @@
       Reference ref = it++;
       storage[o] = ref.getValue(exec);
-      ObjectImp::deleteProperty(exec, ref.getPropertyName(exec));
+      JSObject::deleteProperty(exec, ref.getPropertyName(exec));
       o++;
     }
     
     if (newLength != storageLength)
-        memset(storage + o, 0, sizeof(ValueImp *) * (storageLength - o));
+        memset(storage + o, 0, sizeof(JSValue *) * (storageLength - o));
     
     return o;
 }
 
-// ------------------------------ ArrayPrototypeImp ----------------------------
-
-const ClassInfo ArrayPrototypeImp::info = {"Array", &ArrayInstanceImp::info, &arrayTable, 0};
+// ------------------------------ ArrayPrototype ----------------------------
+
+const ClassInfo ArrayPrototype::info = {"Array", &ArrayInstance::info, &arrayTable, 0};
 
 /* Source for array_object.lut.h
 @begin arrayTable 16
-  toString       ArrayProtoFuncImp::ToString       DontEnum|Function 0
-  toLocaleString ArrayProtoFuncImp::ToLocaleString DontEnum|Function 0
-  concat         ArrayProtoFuncImp::Concat         DontEnum|Function 1
-  join           ArrayProtoFuncImp::Join           DontEnum|Function 1
-  pop            ArrayProtoFuncImp::Pop            DontEnum|Function 0
-  push           ArrayProtoFuncImp::Push           DontEnum|Function 1
-  reverse        ArrayProtoFuncImp::Reverse        DontEnum|Function 0
-  shift          ArrayProtoFuncImp::Shift          DontEnum|Function 0
-  slice          ArrayProtoFuncImp::Slice          DontEnum|Function 2
-  sort           ArrayProtoFuncImp::Sort           DontEnum|Function 1
-  splice         ArrayProtoFuncImp::Splice         DontEnum|Function 2
-  unshift        ArrayProtoFuncImp::UnShift        DontEnum|Function 1
-  every          ArrayProtoFuncImp::Every          DontEnum|Function 5
-  forEach        ArrayProtoFuncImp::ForEach        DontEnum|Function 5
-  some           ArrayProtoFuncImp::Some           DontEnum|Function 5
+  toString       ArrayProtoFunc::ToString       DontEnum|Function 0
+  toLocaleString ArrayProtoFunc::ToLocaleString DontEnum|Function 0
+  concat         ArrayProtoFunc::Concat         DontEnum|Function 1
+  join           ArrayProtoFunc::Join           DontEnum|Function 1
+  pop            ArrayProtoFunc::Pop            DontEnum|Function 0
+  push           ArrayProtoFunc::Push           DontEnum|Function 1
+  reverse        ArrayProtoFunc::Reverse        DontEnum|Function 0
+  shift          ArrayProtoFunc::Shift          DontEnum|Function 0
+  slice          ArrayProtoFunc::Slice          DontEnum|Function 2
+  sort           ArrayProtoFunc::Sort           DontEnum|Function 1
+  splice         ArrayProtoFunc::Splice         DontEnum|Function 2
+  unshift        ArrayProtoFunc::UnShift        DontEnum|Function 1
+  every          ArrayProtoFunc::Every          DontEnum|Function 5
+  forEach        ArrayProtoFunc::ForEach        DontEnum|Function 5
+  some           ArrayProtoFunc::Some           DontEnum|Function 5
 @end
 */
 
 // ECMA 15.4.4
-ArrayPrototypeImp::ArrayPrototypeImp(ExecState *exec,
-                                     ObjectPrototypeImp *objProto)
-  : ArrayInstanceImp(objProto, 0)
+ArrayPrototype::ArrayPrototype(ExecState *exec,
+                                     ObjectPrototype *objProto)
+  : ArrayInstance(objProto, 0)
 {
   setInternalValue(jsNull());
 }
 
-bool ArrayPrototypeImp::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
-{
-  return getStaticFunctionSlot<ArrayProtoFuncImp, ArrayInstanceImp>(exec, &arrayTable, this, propertyName, slot);
-}
-
-// ------------------------------ ArrayProtoFuncImp ----------------------------
-
-ArrayProtoFuncImp::ArrayProtoFuncImp(ExecState *exec, int i, int len)
+bool ArrayPrototype::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
+{
+  return getStaticFunctionSlot<ArrayProtoFunc, ArrayInstance>(exec, &arrayTable, this, propertyName, slot);
+}
+
+// ------------------------------ ArrayProtoFunc ----------------------------
+
+ArrayProtoFunc::ArrayProtoFunc(ExecState *exec, int i, int len)
   : InternalFunctionImp(
-    static_cast<FunctionPrototypeImp*>(exec->lexicalInterpreter()->builtinFunctionPrototype())
+    static_cast<FunctionPrototype*>(exec->lexicalInterpreter()->builtinFunctionPrototype())
     ), id(i)
 {
@@ -419 +419 @@
 }
 
-bool ArrayProtoFuncImp::implementsCall() const
+bool ArrayProtoFunc::implementsCall() const
 {
   return true;
 }
 
-static ValueImp *getProperty(ExecState *exec, ObjectImp *obj, unsigned index)
+static JSValue *getProperty(ExecState *exec, JSObject *obj, unsigned index)
 {
     PropertySlot slot;
@@ -433 +433 @@
 
 // ECMA 15.4.4
-ValueImp *ArrayProtoFuncImp::callAsFunction(ExecState *exec, ObjectImp *thisObj, const List &args)
+JSValue *ArrayProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
 {
   unsigned length = thisObj->get(exec,lengthPropertyName)->toUInt32(exec);
 
-  ValueImp *result = 0; // work around gcc 4.0 bug in uninitialized variable warning
+  JSValue *result = 0; // work around gcc 4.0 bug in uninitialized variable warning
   
   switch (id) {
@@ -443 +443 @@
   case ToString:
 
-    if (!thisObj->inherits(&ArrayInstanceImp::info))
+    if (!thisObj->inherits(&ArrayInstance::info))
       return throwError(exec, TypeError);
 
     // fall through
   case Join: {
-    static HashSet< ObjectImp*, PointerHash<ObjectImp*> > visitedElems;
+    static HashSet< JSObject*, PointerHash<JSObject*> > visitedElems;
     if (visitedElems.contains(thisObj))
       return jsString("");
@@ -461 +461 @@
         str += separator;
       
-      ValueImp *element = thisObj->get(exec, k);
+      JSValue *element = thisObj->get(exec, k);
       if (element->isUndefinedOrNull())
         continue;
@@ -467 +467 @@
       bool fallback = false;
       if (id == ToLocaleString) {
-        ObjectImp *o = element->toObject(exec);
-        ValueImp *conversionFunction = o->get(exec, toLocaleStringPropertyName);
-        if (conversionFunction->isObject() && static_cast<ObjectImp *>(conversionFunction)->implementsCall()) {
-          str += static_cast<ObjectImp *>(conversionFunction)->call(exec, o, List())->toString(exec);
+        JSObject *o = element->toObject(exec);
+        JSValue *conversionFunction = o->get(exec, toLocaleStringPropertyName);
+        if (conversionFunction->isObject() && static_cast<JSObject *>(conversionFunction)->implementsCall()) {
+          str += static_cast<JSObject *>(conversionFunction)->call(exec, o, List())->toString(exec);
         } else {
           // try toString() fallback
@@ -479 +479 @@
       if (id == ToString || id == Join || fallback) {
         if (element->isObject()) {
-          ObjectImp *o = static_cast<ObjectImp *>(element);
-          ValueImp *conversionFunction = o->get(exec, toStringPropertyName);
-          if (conversionFunction->isObject() && static_cast<ObjectImp *>(conversionFunction)->implementsCall()) {
-            str += static_cast<ObjectImp *>(conversionFunction)->call(exec, o, List())->toString(exec);
+          JSObject *o = static_cast<JSObject *>(element);
+          JSValue *conversionFunction = o->get(exec, toStringPropertyName);
+          if (conversionFunction->isObject() && static_cast<JSObject *>(conversionFunction)->implementsCall()) {
+            str += static_cast<JSObject *>(conversionFunction)->call(exec, o, List())->toString(exec);
           } else {
             return throwError(exec, RangeError, "Can't convert " + o->className() + " object to string");
@@ -499 +499 @@
   }
   case Concat: {
-    ObjectImp *arr = static_cast<ObjectImp *>(exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty()));
+    JSObject *arr = static_cast<JSObject *>(exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty()));
     int n = 0;
-    ValueImp *curArg = thisObj;
-    ObjectImp *curObj = static_cast<ObjectImp *>(thisObj);
+    JSValue *curArg = thisObj;
+    JSObject *curObj = static_cast<JSObject *>(thisObj);
     ListIterator it = args.begin();
     for (;;) {
       if (curArg->isObject() &&
-          curObj->inherits(&ArrayInstanceImp::info)) {
+          curObj->inherits(&ArrayInstance::info)) {
         unsigned int k = 0;
         // Older versions tried to optimize out getting the length of thisObj
@@ -512 +512 @@
         length = curObj->get(exec,lengthPropertyName)->toUInt32(exec);
         while (k < length) {
-          if (ValueImp *v = getProperty(exec, curObj, k))
+          if (JSValue *v = getProperty(exec, curObj, k))
             arr->put(exec, n, v);
           n++;
@@ -524 +524 @@
         break;
       curArg = *it;
-      curObj = static_cast<ObjectImp *>(it++); // may be 0
+      curObj = static_cast<JSObject *>(it++); // may be 0
     }
     arr->put(exec,lengthPropertyName, jsNumber(n), DontEnum | DontDelete);
@@ -555 +555 @@
     for (unsigned int k = 0; k < middle; k++) {
       unsigned lk1 = length - k - 1;
-      ValueImp *obj2 = getProperty(exec, thisObj, lk1);
-      ValueImp *obj = getProperty(exec, thisObj, k);
+      JSValue *obj2 = getProperty(exec, thisObj, lk1);
+      JSValue *obj = getProperty(exec, thisObj, k);
 
       if (obj2) 
@@ -578 +578 @@
       result = thisObj->get(exec, 0);
       for(unsigned int k = 1; k < length; k++) {
-        if (ValueImp *obj = getProperty(exec, thisObj, k))
+        if (JSValue *obj = getProperty(exec, thisObj, k))
           thisObj->put(exec, k-1, obj);
         else
@@ -592 +592 @@
 
     // We return a new array
-    ObjectImp *resObj = static_cast<ObjectImp *>(exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty()));
+    JSObject *resObj = static_cast<JSObject *>(exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty()));
     result = resObj;
     double begin = 0;
@@ -624 +624 @@
     int e = static_cast<int>(end);
     for(int k = b; k < e; k++, n++) {
-      if (ValueImp *v = getProperty(exec, thisObj, k))
+      if (JSValue *v = getProperty(exec, thisObj, k))
         resObj->put(exec, n, v);
     }
@@ -636 +636 @@
       printf("KJS Array::Sort: %d: %s\n", i, thisObj->get(exec, i)->toString(exec).ascii() );
 #endif
-    ObjectImp *sortFunction = NULL;
+    JSObject *sortFunction = NULL;
     if (!args[0]->isUndefined())
       {
@@ -644 +644 @@
       }
     
-    if (thisObj->classInfo() == &ArrayInstanceImp::info) {
+    if (thisObj->classInfo() == &ArrayInstance::info) {
       if (sortFunction)
-        ((ArrayInstanceImp *)thisObj)->sort(exec, sortFunction);
+        ((ArrayInstance *)thisObj)->sort(exec, sortFunction);
       else
-        ((ArrayInstanceImp *)thisObj)->sort(exec);
+        ((ArrayInstance *)thisObj)->sort(exec);
       result = thisObj;
       break;
@@ -663 +663 @@
     for ( unsigned int i = 0 ; i<length-1 ; ++i )
       {
-        ValueImp *iObj = thisObj->get(exec,i);
+        JSValue *iObj = thisObj->get(exec,i);
         unsigned int themin = i;
-        ValueImp *minObj = iObj;
+        JSValue *minObj = iObj;
         for ( unsigned int j = i+1 ; j<length ; ++j )
           {
-            ValueImp *jObj = thisObj->get(exec,j);
+            JSValue *jObj = thisObj->get(exec,j);
             double cmp;
             if (jObj->isUndefined()) {
@@ -706 +706 @@
   case Splice: {
     // 15.4.4.12 - oh boy this is huge
-    ObjectImp *resObj = static_cast<ObjectImp *>(exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty()));
+    JSObject *resObj = static_cast<JSObject *>(exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty()));
     result = resObj;
     int begin = args[0]->toUInt32(exec);
@@ -717 +717 @@
     //printf( "Splicing from %d, deleteCount=%d \n", begin, deleteCount );
     for(unsigned int k = 0; k < deleteCount; k++) {
-      if (ValueImp *v = getProperty(exec, thisObj, k+begin))
+      if (JSValue *v = getProperty(exec, thisObj, k+begin))
         resObj->put(exec, k, v);
     }
@@ -729 +729 @@
         for ( unsigned int k = begin; k < length - deleteCount; ++k )
         {
-          if (ValueImp *v = getProperty(exec, thisObj, k+deleteCount))
+          if (JSValue *v = getProperty(exec, thisObj, k+deleteCount))
             thisObj->put(exec, k+additionalArgs, v);
           else
@@ -741 +741 @@
         for ( unsigned int k = length - deleteCount; (int)k > begin; --k )
         {
-          if (ValueImp *obj = getProperty(exec, thisObj, k + deleteCount - 1))
+          if (JSValue *obj = getProperty(exec, thisObj, k + deleteCount - 1))
             thisObj->put(exec, k + additionalArgs - 1, obj);
           else
@@ -759 +759 @@
     for ( unsigned int k = length; k > 0; --k )
     {
-      if (ValueImp *v = getProperty(exec, thisObj, k - 1))
+      if (JSValue *v = getProperty(exec, thisObj, k - 1))
         thisObj->put(exec, k+nrArgs-1, v);
       else
@@ -778 +778 @@
     //http://developer-test.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:some
     
-    ObjectImp *eachFunction = args[0]->toObject(exec);
+    JSObject *eachFunction = args[0]->toObject(exec);
     
     if (!eachFunction->implementsCall())
       return throwError(exec, TypeError);
     
-    ObjectImp *applyThis = args[1]->isUndefinedOrNull() ? exec->dynamicInterpreter()->globalObject() :  args[1]->toObject(exec);
+    JSObject *applyThis = args[1]->isUndefinedOrNull() ? exec->dynamicInterpreter()->globalObject() :  args[1]->toObject(exec);
     
     if (id == Some || id == Every)
@@ -823 +823 @@
 
 ArrayObjectImp::ArrayObjectImp(ExecState *exec,
-                               FunctionPrototypeImp *funcProto,
-                               ArrayPrototypeImp *arrayProto)
+                               FunctionPrototype *funcProto,
+                               ArrayPrototype *arrayProto)
   : InternalFunctionImp(funcProto)
 {
@@ -840 +840 @@
 
 // ECMA 15.4.2
-ObjectImp *ArrayObjectImp::construct(ExecState *exec, const List &args)
+JSObject *ArrayObjectImp::construct(ExecState *exec, const List &args)
 {
   // a single numeric argument denotes the array size (!)
@@ -847 +847 @@
     if (n != args[0]->toNumber(exec))
       return throwError(exec, RangeError, "Array size is not a small enough positive integer.");
-    return new ArrayInstanceImp(exec->lexicalInterpreter()->builtinArrayPrototype(), n);
+    return new ArrayInstance(exec->lexicalInterpreter()->builtinArrayPrototype(), n);
   }
 
   // otherwise the array is constructed with the arguments in it
-  return new ArrayInstanceImp(exec->lexicalInterpreter()->builtinArrayPrototype(), args);
+  return new ArrayInstance(exec->lexicalInterpreter()->builtinArrayPrototype(), args);
 }
 
@@ -860 +860 @@
 
 // ECMA 15.6.1
-ValueImp *ArrayObjectImp::callAsFunction(ExecState *exec, ObjectImp */*thisObj*/, const List &args)
+JSValue *ArrayObjectImp::callAsFunction(ExecState *exec, JSObject */*thisObj*/, const List &args)
 {
   // equivalent to 'new Array(....)'