Changeset 1799 in webkit for trunk/JavaScriptCore/kjs

Timestamp:

Aug 12, 2002, 1:14:02 PM (23 years ago)

Author:

darin

Message:

top level:

• Tests/WebFoundation-Misc/ifnsurlextensions-test.m: (TestURLCommon): Add tests for the new WebNSURLExtras methods.

• Tests/libiftest/IFCheckLeaks.c: (IFCheckLeaksAtExit): Remove workaround for CFPreferences race condition; it's now in WebFoundation.

JavaScriptCore:

Speed improvements. 19% faster on cvs-js-performance, 1% on cvs-static-urls.

Use global string objects for length and other common property names rather
than constantly making and destroying them. Use integer versions of get() and
other related calls rather than always making a string.

Also get rid of many unneeded constructors, destructors, copy constructors, and
assignment operators. And make some functions non-virtual.

• kjs/internal.h:
• kjs/internal.cpp: (NumberImp::toUInt32): Implement. (ReferenceImp::ReferenceImp): Special case for numeric property names. (ReferenceImp::getPropertyName): Moved guts here from ValueImp. Handle numeric case. (ReferenceImp::getValue): Moved guts here from ValueImp. Handle numeric case. (ReferenceImp::putValue): Moved guts here from ValueImp. Handle numeric case. (ReferenceImp::deleteValue): Added. Handle numeric case.

• kjs/array_object.h:
• kjs/array_object.cpp: All-new array implementation that stores the elements in a C++ array rather than in a property map. (ArrayInstanceImp::ArrayInstanceImp): Allocate the C++ array. (ArrayInstanceImp::~ArrayInstanceImp): Delete the C++ array. (ArrayInstanceImp::get): Implement both the old version and the new overload that takes an unsigned index for speed. (ArrayInstanceImp::put): Implement both the old version and the new overload that takes an unsigned index for speed. (ArrayInstanceImp::hasProperty): Implement both the old version and the new overload that takes an unsigned index for speed. (ArrayInstanceImp::deleteProperty): Implement both the old version and the new overload that takes an unsigned index for speed. (ArrayInstanceImp::setLength): Added. Used by the above to resize the array. (ArrayInstanceImp::mark): Mark the elements of the array too. (ArrayPrototypeImp::ArrayPrototypeImp): Pass the length to the array instance constructor.

• kjs/bool_object.cpp:
• kjs/date_object.cpp:
• kjs/error_object.cpp:
• kjs/function.cpp:
• kjs/function_object.cpp:
• kjs/math_object.cpp:
• kjs/nodes.cpp:
• kjs/nodes.h:
• kjs/number_object.cpp:
• kjs/object_object.cpp:
• kjs/regexp_object.cpp:
• kjs/string_object.cpp:

• kjs/nodes2string.cpp: (SourceStream::operator<<): Add a special case for char now that you can't create a UString from a char implicitly.

• kjs/object.h:
• kjs/object.cpp: (ObjectImp::get): Call through to the string version if the numeric version is not implemented. (ObjectImp::put): Call through to the string version if the numeric version is not implemented. (ObjectImp::hasProperty): Call through to the string version if the numeric version is not implemented. (ObjectImp::deleteProperty): Call through to the string version if the numeric version is not implemented.

• kjs/types.h:
• kjs/types.cpp: (Reference::Reference): Added constructors for the numeric property name case.

• kjs/ustring.h: Made the constructor that turns a character into a string be explicit so we don't get numbers that turn themselves into strings.
• kjs/ustring.cpp: (UString::UString): Detect the empty string case, and use a shared empty string. (UString::find): Add an overload for single character finds. (UString::rfind): Add an overload for single character finds. (KJS::operator==): Fix bug where it would call strlen(0) if the first string was not null. Also handle non-ASCII characters consistently with the rest of the code by casting to unsigned char just in case.

• kjs/value.h: Make ValueImp and all subclasses non-copyable and non-assignable.
• kjs/value.cpp: (ValueImp::toUInt32): New interface, mainly useful so we can detect array indices and not turn them into strings and back. (ValueImp::toInteger): Use the new toUInt32. Probably can use more improvement. (ValueImp::toInt32): Use the new toUInt32. Probably can use more improvement. (ValueImp::toUInt16): Use the new toUInt32. Probably can use more improvement. (ValueImp::getBase): Remove handling of the Reference case. That's in ReferenceImp now. (ValueImp::getPropertyName): Remove handling of the Reference case. That's in ReferenceImp now. (ValueImp::getValue): Remove handling of the Reference case. That's in ReferenceImp now. (ValueImp::putValue): Remove handling of the Reference case. That's in ReferenceImp now. (ValueImp::deleteValue): Added. Used so we can do delete the same way we do put.

WebFoundation:

• CacheLoader.subproj/WebHTTPResourceLoader.m: (-[WebHTTPProtocolHandler createWFLoadRequest]): Fix handling of paths with queries and some other subtle path and port number handling issues by using _web_hostWithPort and _web_pathWithQuery.

• Misc.subproj/WebNSURLExtras.h:
• Misc.subproj/WebNSURLExtras.m: (-[NSURL _web_hostWithPort]): Added. (-[NSURL _web_pathWithQuery]): Added.

• CacheLoader.subproj/WebResourceLoad.m: (initLoader): Get some random preference before creating threads. This makes it impossible to run into the CFPreferences race condition.

WebCore:

• force-clean-timestamp: Need a full build because of KJS changes.
• khtml/ecma/kjs_window.h: Need to store an Object, not an ObjectImp, because there's no way to copy an ObjectImp. KJS changes caught this mistake.

Location:

trunk/JavaScriptCore/kjs

Files:

• array_object.cpp (modified) (25 diffs)
• array_object.h (modified) (1 diff)
• bool_object.cpp (modified) (3 diffs)
• date_object.cpp (modified) (4 diffs)
• error_object.cpp (modified) (4 diffs)
• function.cpp (modified) (3 diffs)
• function_object.cpp (modified) (6 diffs)
• internal.cpp (modified) (5 diffs)
• internal.h (modified) (11 diffs)
• math_object.cpp (modified) (1 diff)
• nodes.cpp (modified) (70 diffs)
• nodes.h (modified) (62 diffs)
• nodes2string.cpp (modified) (2 diffs)
• number_object.cpp (modified) (3 diffs)
• object.cpp (modified) (11 diffs)
• object.h (modified) (12 diffs)
• object_object.cpp (modified) (3 diffs)
• regexp_object.cpp (modified) (3 diffs)
• string_object.cpp (modified) (9 diffs)
• types.cpp (modified) (5 diffs)
• types.h (modified) (4 diffs)
• ustring.cpp (modified) (10 diffs)
• ustring.h (modified) (5 diffs)
• value.cpp (modified) (13 diffs)
• value.h (modified) (16 diffs)

trunk/JavaScriptCore/kjs/array_object.cpp

@@ -40 +40 @@
 const ClassInfo ArrayInstanceImp::info = {"Array", 0, 0, 0};
 
-ArrayInstanceImp::ArrayInstanceImp(const Object &proto)
+ArrayInstanceImp::ArrayInstanceImp(const Object &proto, unsigned initialLength)
   : ObjectImp(proto)
-{
+  , length(initialLength)
+  , capacity(length)
+  , storage(length ? new Undefined[length] : 0)
+{
+}
+
+ArrayInstanceImp::ArrayInstanceImp(const Object &proto, const List &list)
+  : ObjectImp(proto)
+  , length(list.size())
+  , capacity(length)
+  , storage(length ? new Undefined[length] : 0)
+{
+  ListIterator it = list.begin();
+  const unsigned l = length;
+  for (unsigned i = 0; i < l; ++i) {
+    storage[i] = it++;
+  }
+}
+
+ArrayInstanceImp::~ArrayInstanceImp()
+{
+  delete [] storage;
+}
+
+Value ArrayInstanceImp::get(ExecState *exec, const UString &propertyName) const
+{
+  if (propertyName == lengthPropertyName)
+    return Number(length);
+
+  bool ok;
+  unsigned index = propertyName.toULong(&ok);
+  if (ok) {
+    if (index >= length)
+      return Undefined();
+    return storage[index];
+  }
+
+  return ObjectImp::get(exec, propertyName);
+}
+
+Value ArrayInstanceImp::get(ExecState *exec, unsigned index) const
+{
+  if (index >= length)
+    return Undefined();
+  return storage[index];
 }
 
@@ -48 +92 @@
 void ArrayInstanceImp::put(ExecState *exec, const UString &propertyName, const Value &value, int attr)
 {
-  if ((attr == None || attr == DontDelete) && !canPut(exec,propertyName))
+  if (propertyName == lengthPropertyName) {
+    setLength(value.toUInt32(exec));
     return;
-
-  if (hasProperty(exec,propertyName)) {
-    if (propertyName == "length") {
-      Value len = get(exec,"length");
-      unsigned int oldLen = len.toUInt32(exec);
-      unsigned int newLen = value.toUInt32(exec);
-      // shrink array
-      for (unsigned int u = newLen; u < oldLen; u++) {
-        UString p = UString::from(u);
-        if (hasOwnProperty(exec, p))
-          deleteProperty(exec, p);
-      }
-      ObjectImp::put(exec, "length", Number(newLen), DontEnum | DontDelete);
-      return;
-    }
-    //    put(p, v);
-  } //  } else
-    ObjectImp::put(exec, propertyName, value, attr);
-
-  // array index ?
-  unsigned int idx;
-  if (!sscanf(propertyName.cstring().c_str(), "%u", &idx)) /* TODO */
+  }
+  
+  bool ok;
+  unsigned index = propertyName.toULong(&ok);
+  if (ok) {
+    setLength(index + 1);
+    storage[index] = value;
     return;
-
-  // do we need to update/create the length property ?
-  if (hasOwnProperty(exec, "length")) {
-    Value len = get(exec, "length");
-    if (idx < len.toUInt32(exec))
-      return;
-  }
-
-  ObjectImp::put(exec, "length", Number(idx+1), DontDelete | DontEnum);
-}
-
-void ArrayInstanceImp::putDirect(ExecState *exec, const UString &propertyName, const Value &value, int attr)
-{
-  ObjectImp::put(exec,propertyName,value,attr);
-}
-
-bool ArrayInstanceImp::hasOwnProperty(ExecState *exec,
-                                      const UString &propertyName)
-{
-  // disable this object's prototype temporarily for the hasProperty() call
-  Value protoBackup = prototype();
-  setPrototype(Undefined());
-  bool b = hasProperty(exec, propertyName);
-  setPrototype(protoBackup);
-  return b;
+  }
+  
+  ObjectImp::put(exec, propertyName, value, attr);
+}
+
+void ArrayInstanceImp::put(ExecState *exec, unsigned index, const Value &value, int attr)
+{
+  setLength(index + 1);
+  storage[index] = value;
+}
+
+bool ArrayInstanceImp::hasProperty(ExecState *exec, const UString &propertyName) const
+{
+  if (propertyName == lengthPropertyName)
+    return true;
+  
+  bool ok;
+  unsigned index = propertyName.toULong(&ok);
+  if (ok) {
+    if (index >= length)
+      return false;
+    return !storage[index].isA(UndefinedType);
+  }
+  
+  return ObjectImp::hasProperty(exec, propertyName);
+}
+
+bool ArrayInstanceImp::hasProperty(ExecState *exec, unsigned index) const
+{
+  if (index >= length)
+    return false;
+  return !storage[index].isA(UndefinedType);
+}
+
+bool ArrayInstanceImp::deleteProperty(ExecState *exec, const UString &propertyName)
+{
+  if (propertyName == lengthPropertyName)
+    return false;
+  
+  bool ok;
+  unsigned index = propertyName.toULong(&ok);
+  if (ok) {
+    if (index >= length)
+      return true;
+    storage[index] = Undefined();
+    return true;
+  }
+  
+  return ObjectImp::deleteProperty(exec, propertyName);
+}
+
+bool ArrayInstanceImp::deleteProperty(ExecState *exec, unsigned index)
+{
+  if (index >= length)
+    return true;
+  storage[index] = Undefined();
+  return true;
+}
+
+void ArrayInstanceImp::setLength(unsigned newLength)
+{
+  if (newLength < length) {
+    const unsigned l = length;
+    for (unsigned i = newLength; i < l; ++i)
+      storage[i] = Undefined();
+  }
+  if (newLength > capacity) {
+    unsigned newCapacity = (newLength * 3 + 1) / 2;
+    Value *newStorage = new Undefined [newCapacity];
+    const unsigned l = length;
+    for (unsigned i = 0; i < l; ++i)
+      newStorage[i] = storage[i];
+    delete [] storage;
+    storage = newStorage;
+    capacity = newCapacity;
+  }
+  length = newLength;
+}
+
+void ArrayInstanceImp::mark()
+{
+  ObjectImp::mark();
+  const unsigned l = length;
+  for (unsigned i = 0; i < l; ++i) {
+    ValueImp *imp = storage[i].imp();
+    if (!imp->marked())
+      imp->mark();
+  }
 }
 
@@ -124 +217 @@
 ArrayPrototypeImp::ArrayPrototypeImp(ExecState *exec,
                                      ObjectPrototypeImp *objProto)
-  : ArrayInstanceImp(Object(objProto))
+  : ArrayInstanceImp(Object(objProto), 0)
 {
   Value protect(this);
   setInternalValue(Null());
-
-  // The constructor will be added later, by InterpreterImp, once ArrayObjectImp has been constructed.
-  put(exec,"length", Number(0), DontEnum | DontDelete);
 }
 
@@ -147 +237 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -158 +248 @@
 Value ArrayProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &args)
 {
-  unsigned int length = thisObj.get(exec,"length").toUInt32(exec);
+  unsigned int length = thisObj.get(exec,lengthPropertyName).toUInt32(exec);
 
   Value result;
@@ -184 +274 @@
       if (k >= 1)
         str += separator;
-      Value element = thisObj.get(exec,UString::from(k));
+      Value element = thisObj.get(exec,k);
       if (element.type() != UndefinedType && element.type() != NullType)
         str += element.toString(exec);
@@ -202 +292 @@
         unsigned int k = 0;
         if (n > 0)
-          length = curObj.get(exec,"length").toUInt32(exec);
+          length = curObj.get(exec,lengthPropertyName).toUInt32(exec);
         while (k < length) {
-          UString p = UString::from(k);
-          if (curObj.hasProperty(exec,p))
-            arr.put(exec,UString::from(n), curObj.get(exec,p));
+          if (curObj.hasProperty(exec,k))
+            arr.put(exec, n, curObj.get(exec, k));
           n++;
           k++;
         }
       } else {
-        arr.put(exec,UString::from(n), curArg);
+        arr.put(exec, n, curArg);
         n++;
       }
@@ -219 +308 @@
       curObj = Object::dynamicCast(it++); // may be 0
     }
-    arr.put(exec,"length", Number(n), DontEnum | DontDelete);
+    arr.put(exec,lengthPropertyName, Number(n), DontEnum | DontDelete);
 
     result = arr;
@@ -225 +314 @@
   }
   case Pop:{
-
     if (length == 0) {
-      thisObj.put(exec, "length", Number(length), DontEnum | DontDelete);
+      thisObj.put(exec, lengthPropertyName, Number(length), DontEnum | DontDelete);
       result = Undefined();
     } else {
-      UString str = UString::from(length - 1);
-      result = thisObj.get(exec,str);
-      thisObj.deleteProperty(exec, str);
-      thisObj.put(exec, "length", Number(length - 1), DontEnum | DontDelete);
+      result = thisObj.get(exec, length - 1);
+      thisObj.put(exec, lengthPropertyName, Number(length - 1), DontEnum | DontDelete);
     }
     break;
@@ -239 +325 @@
   case Push: {
     for (int n = 0; n < args.size(); n++)
-      thisObj.put(exec,UString::from(length + n), args[n]);
+      thisObj.put(exec, length + n, args[n]);
     length += args.size();
-    thisObj.put(exec,"length", Number(length), DontEnum | DontDelete);
+    thisObj.put(exec,lengthPropertyName, Number(length), DontEnum | DontDelete);
     result = Number(length);
     break;
@@ -250 +336 @@
 
     for (unsigned int k = 0; k < middle; k++) {
-      UString str = UString::from(k);
-      UString str2 = UString::from(length - k - 1);
-      Value obj = thisObj.get(exec,str);
-      Value obj2 = thisObj.get(exec,str2);
-      if (thisObj.hasProperty(exec,str2)) {
-        if (thisObj.hasProperty(exec,str)) {
-          thisObj.put(exec, str, obj2);
-          thisObj.put(exec, str2, obj);
+      unsigned lk1 = length - k - 1;
+      Value obj = thisObj.get(exec,k);
+      Value obj2 = thisObj.get(exec,lk1);
+      if (thisObj.hasProperty(exec,lk1)) {
+        if (thisObj.hasProperty(exec,k)) {
+          thisObj.put(exec, k, obj2);
+          thisObj.put(exec, lk1, obj);
         } else {
-          thisObj.put(exec, str, obj2);
-          thisObj.deleteProperty(exec, str2);
+          thisObj.put(exec, k, obj2);
+          thisObj.deleteProperty(exec, lk1);
         }
       } else {
-        if (thisObj.hasProperty(exec, str)) {
-          thisObj.deleteProperty(exec, str);
-          thisObj.put(exec, str2, obj);
+        if (thisObj.hasProperty(exec, k)) {
+          thisObj.deleteProperty(exec, k);
+          thisObj.put(exec, lk1, obj);
         } else {
           // why delete something that's not there ? Strange.
-          thisObj.deleteProperty(exec, str);
-          thisObj.deleteProperty(exec, str2);
+          thisObj.deleteProperty(exec, k);
+          thisObj.deleteProperty(exec, lk1);
         }
       }
@@ -278 +363 @@
   case Shift: {
     if (length == 0) {
-      thisObj.put(exec, "length", Number(length), DontEnum | DontDelete);
+      thisObj.put(exec, lengthPropertyName, Number(length), DontEnum | DontDelete);
       result = Undefined();
     } else {
-      result = thisObj.get(exec, "0");
+      result = thisObj.get(exec, 0);
       for(unsigned int k = 1; k < length; k++) {
-        UString str = UString::from(k);
-        UString str2 = UString::from(k-1);
-        if (thisObj.hasProperty(exec, str)) {
-          Value obj = thisObj.get(exec, str);
-          thisObj.put(exec, str2, obj);
+        if (thisObj.hasProperty(exec, k)) {
+          Value obj = thisObj.get(exec, k);
+          thisObj.put(exec, k-1, obj);
         } else
-          thisObj.deleteProperty(exec, str2);
-      }
-      thisObj.deleteProperty(exec, UString::from(length - 1));
-      thisObj.put(exec, "length", Number(length - 1), DontEnum | DontDelete);
+          thisObj.deleteProperty(exec, k-1);
+      }
+      thisObj.deleteProperty(exec, length - 1);
+      thisObj.put(exec, lengthPropertyName, Number(length - 1), DontEnum | DontDelete);
     }
     break;
@@ -319 +402 @@
     //printf( "Slicing from %d to %d \n", begin, end );
     for(unsigned int k = 0; k < (unsigned int) end-begin; k++) {
-      UString str = UString::from(k+begin);
-      if (thisObj.hasProperty(exec,str)) {
-        UString str2 = UString::from(k);
-        Value obj = thisObj.get(exec, str);
-        resObj.put(exec, str2, obj);
-      }
-    }
-    resObj.put(exec, "length", Number(end - begin), DontEnum | DontDelete);
+      if (thisObj.hasProperty(exec,k+begin)) {
+        Value obj = thisObj.get(exec, k+begin);
+        resObj.put(exec, k, obj);
+      }
+    }
+    resObj.put(exec, lengthPropertyName, Number(end - begin), DontEnum | DontDelete);
     break;
   }
@@ -333 +414 @@
     printf("KJS Array::Sort length=%d\n", length);
     for ( unsigned int i = 0 ; i<length ; ++i )
-      printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(UString::from(i)).toString().value().ascii() );
+      printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(i).toString().value().ascii() );
 #endif
     Object sortFunction;
@@ -345 +426 @@
 
     if (length == 0) {
-      thisObj.put(exec, "length", Number(0), DontEnum | DontDelete);
+      thisObj.put(exec, lengthPropertyName, Number(0), DontEnum | DontDelete);
       result = Undefined();
       break;
@@ -354 +435 @@
     for ( unsigned int i = 0 ; i<length-1 ; ++i )
       {
-        Value iObj = thisObj.get(exec,UString::from(i));
+        Value iObj = thisObj.get(exec,i);
         unsigned int themin = i;
         Value minObj = iObj;
         for ( unsigned int j = i+1 ; j<length ; ++j )
           {
-            Value jObj = thisObj.get(exec,UString::from(j));
+            Value jObj = thisObj.get(exec,j);
             int cmp;
             if (jObj.type() == UndefinedType) {
@@ -384 +465 @@
           {
             //printf("KJS Array::Sort: swapping %d and %d\n", i, themin );
-            thisObj.put( exec, UString::from(i), minObj );
-            thisObj.put( exec, UString::from(themin), iObj );
+            thisObj.put( exec, i, minObj );
+            thisObj.put( exec, themin, iObj );
           }
       }
@@ -391 +472 @@
     printf("KJS Array::Sort -- Resulting array:\n");
     for ( unsigned int i = 0 ; i<length ; ++i )
-      printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(UString::from(i)).toString().value().ascii() );
+      printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(i).toString().value().ascii() );
 #endif
     result = thisObj;
@@ -409 +490 @@
     //printf( "Splicing from %d, deleteCount=%d \n", begin, deleteCount );
     for(unsigned int k = 0; k < deleteCount; k++) {
-      UString str = UString::from(k+begin);
-      if (thisObj.hasProperty(exec,str)) {
-        UString str2 = UString::from(k);
-        Value obj = thisObj.get(exec, str);
-        resObj.put(exec, str2, obj);
-      }
-    }
-    resObj.put(exec, "length", Number(deleteCount), DontEnum | DontDelete);
+      if (thisObj.hasProperty(exec,k+begin)) {
+        Value obj = thisObj.get(exec, k+begin);
+        resObj.put(exec, k, obj);
+      }
+    }
+    resObj.put(exec, lengthPropertyName, Number(deleteCount), DontEnum | DontDelete);
 
     unsigned int additionalArgs = maxInt( args.size() - 2, 0 );
@@ -425 +504 @@
         for ( unsigned int k = begin; k < length - deleteCount; ++k )
         {
-          UString str = UString::from(k+deleteCount);
-          UString str2 = UString::from(k+additionalArgs);
-          if (thisObj.hasProperty(exec,str)) {
-            Value obj = thisObj.get(exec, str);
-            thisObj.put(exec, str2, obj);
+          if (thisObj.hasProperty(exec,k+deleteCount)) {
+            Value obj = thisObj.get(exec, k+deleteCount);
+            thisObj.put(exec, k+additionalArgs, obj);
           }
           else
-            thisObj.deleteProperty(exec, str2);
+            thisObj.deleteProperty(exec, k+additionalArgs);
         }
         for ( unsigned int k = length ; k > length - deleteCount + additionalArgs; --k )
-          thisObj.deleteProperty(exec, UString::from(k-1));
+          thisObj.deleteProperty(exec, k-1);
       }
       else
@@ -441 +518 @@
         for ( unsigned int k = length - deleteCount; (int)k > begin; --k )
         {
-          UString str = UString::from(k+deleteCount-1);
-          UString str2 = UString::from(k+additionalArgs-1);
-          if (thisObj.hasProperty(exec,str)) {
-            Value obj = thisObj.get(exec, str);
-            thisObj.put(exec, str2, obj);
+          if (thisObj.hasProperty(exec,k+deleteCount-1)) {
+            Value obj = thisObj.get(exec, k+deleteCount-1);
+            thisObj.put(exec, k+additionalArgs-1, obj);
           }
           else
-            thisObj.deleteProperty(exec, str2);
+            thisObj.deleteProperty(exec, k+additionalArgs-1);
         }
       }
@@ -454 +529 @@
     for ( unsigned int k = 0; k < additionalArgs; ++k )
     {
-      thisObj.put(exec, UString::from(k+begin), args[k+2]);
-    }
-    thisObj.put(exec, "length", Number(length - deleteCount + additionalArgs), DontEnum | DontDelete);
+      thisObj.put(exec, k+begin, args[k+2]);
+    }
+    thisObj.put(exec, lengthPropertyName, Number(length - deleteCount + additionalArgs), DontEnum | DontDelete);
     break;
   }
@@ -463 +538 @@
     for ( unsigned int k = length; k > 0; --k )
     {
-      UString str = UString::from(k-1);
-      UString str2 = UString::from(k+nrArgs-1);
-      if (thisObj.hasProperty(exec,str)) {
-        Value obj = thisObj.get(exec, str);
-        thisObj.put(exec, str2, obj);
+      if (thisObj.hasProperty(exec,k-1)) {
+        Value obj = thisObj.get(exec, k-1);
+        thisObj.put(exec, k+nrArgs-1, obj);
       } else {
-        thisObj.deleteProperty(exec, str2);
+        thisObj.deleteProperty(exec, k+nrArgs-1);
       }
     }
     for ( unsigned int k = 0; k < nrArgs; ++k )
-      thisObj.put(exec, UString::from(k), args[k]);
+      thisObj.put(exec, k, args[k]);
     result = Number(length + nrArgs);
-    thisObj.put(exec, "length", result, DontEnum | DontDelete);
+    thisObj.put(exec, lengthPropertyName, result, DontEnum | DontDelete);
     break;
   }
@@ -494 +567 @@
   Value protect(this);
   // ECMA 15.4.3.1 Array.prototype
-  put(exec,"prototype", Object(arrayProto), DontEnum|DontDelete|ReadOnly);
+  put(exec,prototypePropertyName, Object(arrayProto), DontEnum|DontDelete|ReadOnly);
 
   // no. of arguments for constructor
-  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(1), ReadOnly|DontDelete|DontEnum);
 }
 
@@ -508 +581 @@
 Object ArrayObjectImp::construct(ExecState *exec, const List &args)
 {
-  Object result(new ArrayInstanceImp(exec->interpreter()->builtinArrayPrototype()));
-
-  unsigned int len;
-  ListIterator it = args.begin();
-  // a single argument might denote the array size
-  if (args.size() == 1 && it->type() == NumberType)
-    len = it->toUInt32(exec);
-  else {
-    // initialize array
-    len = args.size();
-    for (unsigned int u = 0; it != args.end(); it++, u++)
-      result.put(exec, UString::from(u), *it);
-  }
-
-  // array size
-  result.put(exec, "length", Number(len), DontEnum | DontDelete);
-  static_cast<ArrayInstanceImp*>(result.imp())->putDirect(exec, "length", Number(len), DontEnum | DontDelete);
-
-  return result;
+  // a single numeric argument denotes the array size (!)
+  if (args.size() == 1 && args[0].type() == NumberType)
+    return Object(new ArrayInstanceImp(exec->interpreter()->builtinArrayPrototype(), args[0].toUInt32(exec)));
+
+  // otherwise the array is constructed with the arguments in it
+  return Object(new ArrayInstanceImp(exec->interpreter()->builtinArrayPrototype(), args));
 }
 

trunk/JavaScriptCore/kjs/array_object.h

@@ -30 +30 @@
   class ArrayInstanceImp : public ObjectImp {
   public:
-    ArrayInstanceImp(const Object &proto);
+    ArrayInstanceImp(const Object &proto, unsigned initialLength);
+    ArrayInstanceImp(const Object &proto, const List &initialValues);
+    ~ArrayInstanceImp();
 
+    virtual Value get(ExecState *exec, const UString &propertyName) const;
+    virtual Value get(ExecState *exec, unsigned propertyName) const;
     virtual void put(ExecState *exec, const UString &propertyName, const Value &value, int attr = None);
-    virtual void putDirect(ExecState *exec, const UString &propertyName, const Value &value, int attr = None);
-    /**
-     * A shallow hasProperty() variant that doesn't look at the prototype's
-     * properties.
-     */
-    virtual bool hasOwnProperty(ExecState *exec, const UString &propertyName);
+    virtual void put(ExecState *exec, unsigned propertyName, const Value &value, int attr = None);
+    virtual bool hasProperty(ExecState *exec, const UString &propertyName) const;
+    virtual bool hasProperty(ExecState *exec, unsigned propertyName) const;
+    virtual bool deleteProperty(ExecState *exec, const UString &propertyName);
+    virtual bool deleteProperty(ExecState *exec, unsigned propertyName);
+
+    virtual void mark();
 
     virtual const ClassInfo *classInfo() const { return &info; }
     static const ClassInfo info;
+    
+    unsigned getLength() const { return length; }
+    
+  private:
+    void setLength(unsigned newLength);
+    
+    unsigned length;
+    unsigned capacity;
+    Value *storage;
   };
 

trunk/JavaScriptCore/kjs/bool_object.cpp

@@ -53 +53 @@
   // The constructor will be added later by InterpreterImp::InterpreterImp()
 
-  put(exec,"toString", Object(new BooleanProtoFuncImp(exec,funcProto,BooleanProtoFuncImp::ToString,0)), DontEnum);
-  put(exec,"valueOf",  Object(new BooleanProtoFuncImp(exec,funcProto,BooleanProtoFuncImp::ValueOf,0)),  DontEnum);
+  put(exec,toStringPropertyName, Object(new BooleanProtoFuncImp(exec,funcProto,BooleanProtoFuncImp::ToString,0)), DontEnum);
+  put(exec,valueOfPropertyName,  Object(new BooleanProtoFuncImp(exec,funcProto,BooleanProtoFuncImp::ValueOf,0)),  DontEnum);
   setInternalValue(Boolean(false));
 }
@@ -66 +66 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -105 +105 @@
 {
   Value protect(this);
-  put(exec,"prototype", Object(booleanProto),DontEnum|DontDelete|ReadOnly);
+  put(exec,prototypePropertyName, Object(booleanProto),DontEnum|DontDelete|ReadOnly);
 
   // no. of arguments for constructor
-  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(1), ReadOnly|DontDelete|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/date_object.cpp

@@ -148 +148 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -322 +322 @@
   Value protect(this);
   // ECMA 15.9.4.1 Date.prototype
-  put(exec,"prototype", Object(dateProto), DontEnum|DontDelete|ReadOnly);
+  put(exec,prototypePropertyName, Object(dateProto), DontEnum|DontDelete|ReadOnly);
 
   put(exec,"parse", Object(new DateObjectFuncImp(exec,funcProto,DateObjectFuncImp::Parse, 1)), DontEnum);
@@ -328 +328 @@
 
   // no. of arguments for constructor
-  put(exec,"length", Number(7), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(7), ReadOnly|DontDelete|DontEnum);
 }
 
@@ -417 +417 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/error_object.cpp

@@ -44 +44 @@
   put(exec, "name",     String("Error"), DontEnum);
   put(exec, "message",  String("Unknown error"), DontEnum);
-  put(exec, "toString", Object(new ErrorProtoFuncImp(exec,funcProto)), DontEnum);
+  put(exec, toStringPropertyName, Object(new ErrorProtoFuncImp(exec,funcProto)), DontEnum);
 }
 
@@ -53 +53 @@
 {
   Value protect(this);
-  put(exec,"length",Number(0),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(0),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -87 +87 @@
   Value protect(this);
   // ECMA 15.11.3.1 Error.prototype
-  put(exec, "prototype", Object(errorProto), DontEnum|DontDelete|ReadOnly);
+  put(exec, prototypePropertyName, Object(errorProto), DontEnum|DontDelete|ReadOnly);
   //put(exec, "name", String(n));
 }
@@ -144 +144 @@
   proto = static_cast<ObjectImp*>(prot.imp());
 
-  put(exec,"length",Number(1),DontDelete|ReadOnly|DontEnum); // ECMA 15.11.7.5
-  put(exec,"prototype",prot);
+  put(exec,lengthPropertyName,Number(1),DontDelete|ReadOnly|DontEnum); // ECMA 15.11.7.5
+  put(exec,prototypePropertyName,prot);
 }
 

trunk/JavaScriptCore/kjs/function.cpp

@@ -275 +275 @@
 {
   Object proto;
-  Value p = get(exec,"prototype");
+  Value p = get(exec,prototypePropertyName);
   if (p.type() == ObjectType)
     proto = Object(static_cast<ObjectImp*>(p.imp()));
@@ -315 +315 @@
   Value protect(this);
   put(exec,"callee", Object(func), DontEnum);
-  put(exec,"length", Number(args.size()), DontEnum);
+  put(exec,lengthPropertyName, Number(args.size()), DontEnum);
   if (!args.isEmpty()) {
     ListIterator arg = args.begin();
     for (int i = 0; arg != args.end(); arg++, i++) {
-      put(exec,UString::from(i), *arg, DontEnum);
+      put(exec,i, *arg, DontEnum);
     }
   }
@@ -349 +349 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/function_object.cpp

@@ -41 +41 @@
 {
   Value protect(this);
-  put(exec, "toString", Object(new FunctionProtoFuncImp(exec, this, FunctionProtoFuncImp::ToString, 0)), DontEnum);
+  put(exec, toStringPropertyName, Object(new FunctionProtoFuncImp(exec, this, FunctionProtoFuncImp::ToString, 0)), DontEnum);
   put(exec, "apply",    Object(new FunctionProtoFuncImp(exec, this, FunctionProtoFuncImp::Apply,    2)), DontEnum);
   put(exec, "call",     Object(new FunctionProtoFuncImp(exec, this, FunctionProtoFuncImp::Call,     1)), DontEnum);
@@ -68 +68 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -130 +130 @@
 
         Object argArrayObj = Object::dynamicCast(argArray);
-        unsigned int length = argArrayObj.get(exec,"length").toUInt32(exec);
+        unsigned int length = argArrayObj.get(exec,lengthPropertyName).toUInt32(exec);
         for (unsigned int i = 0; i < length; i++)
-          applyArgs.append(argArrayObj.get(exec,UString::from(i)));
+          applyArgs.append(argArrayObj.get(exec,i));
       }
       else {
@@ -175 +175 @@
 {
   Value protect(this);
-  put(exec,"prototype", Object(funcProto), DontEnum|DontDelete|ReadOnly);
+  put(exec,prototypePropertyName, Object(funcProto), DontEnum|DontDelete|ReadOnly);
 
   // no. of arguments for constructor
-  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(1), ReadOnly|DontDelete|DontEnum);
 }
 
@@ -276 +276 @@
   }
 
-  fimp->put(exec,"length", Number(params),ReadOnly|DontDelete|DontEnum);
+  fimp->put(exec,lengthPropertyName, Number(params),ReadOnly|DontDelete|DontEnum);
   List consArgs;
 
@@ -283 +283 @@
   prototype.put(exec, "constructor",
                 Object(fimp), DontEnum|DontDelete|ReadOnly);
-  fimp->put(exec,"prototype",prototype,DontEnum|DontDelete|ReadOnly);
+  fimp->put(exec,prototypePropertyName,prototype,DontEnum|DontDelete|ReadOnly);
   fimp->put(exec,"arguments",Null(),DontEnum|DontDelete|ReadOnly);
   return ret;

trunk/JavaScriptCore/kjs/internal.cpp

@@ -193 +193 @@
 // ------------------------------ StringImp ------------------------------------
 
-StringImp::StringImp(const UString& v)
-  : val(v)
-{
-}
-
 Value StringImp::toPrimitive(ExecState */*exec*/, Type) const
 {
@@ -221 +216 @@
 {
   List args;
-  args.append(String(const_cast<StringImp*>(this)));
+  args.append(Value(const_cast<StringImp*>(this)));
   return Object::dynamicCast(exec->interpreter()->builtinString().construct(exec,args));
 }
 
 // ------------------------------ NumberImp ------------------------------------
-
-NumberImp::NumberImp(double v)
-  : val(v)
-{
-}
 
 Value NumberImp::toPrimitive(ExecState *, Type) const
@@ -259 +249 @@
 }
 
+bool NumberImp::toUInt32(unsigned& uint32) const
+{
+  uint32 = (unsigned)val;
+  return (double)uint32 == val;
+}
+
 // ------------------------------ ReferenceImp ---------------------------------
 
+ReferenceImp::ReferenceImp(const Value& v, unsigned p)
+  : base(v.imp()), propertyNameIsNumber(true), propertyNameAsNumber(p)
+{
+}
+
 ReferenceImp::ReferenceImp(const Value& v, const UString& p)
-  : base(v.imp()), prop(p)
+  : base(v.imp()), propertyNameIsNumber(false), prop(p)
 {
 }
@@ -306 +307 @@
   assert(false);
   return Object();
+}
+
+UString ReferenceImp::getPropertyName(ExecState *) const
+{
+  if (propertyNameIsNumber && prop.isNull())
+    prop = UString::from(propertyNameAsNumber);
+  return prop;
+}
+
+Value ReferenceImp::getValue(ExecState *exec) const
+{
+  Value o = getBase(exec);
+
+  if (o.isNull() || o.type() == NullType) {
+    UString m = I18N_NOOP("Can't find variable: ") + getPropertyName(exec);
+    Object err = Error::create(exec, ReferenceError, m.ascii());
+    exec->setException(err);
+    return err;
+  }
+
+  if (o.type() != ObjectType) {
+    UString m = I18N_NOOP("Base is not an object");
+    Object err = Error::create(exec, ReferenceError, m.ascii());
+    exec->setException(err);
+    return err;
+  }
+
+  if (propertyNameIsNumber)
+    return static_cast<ObjectImp*>(o.imp())->get(exec,propertyNameAsNumber);
+  return static_cast<ObjectImp*>(o.imp())->get(exec,prop);
+}
+
+void ReferenceImp::putValue(ExecState *exec, const Value& w)
+{
+#ifdef KJS_VERBOSE
+  printInfo(exec,(UString("setting property ")+getPropertyName(exec)).cstring().c_str(),w);
+#endif
+  Value o = getBase(exec);
+  if (o.type() == NullType)
+    o = exec->interpreter()->globalObject();
+
+  if (propertyNameIsNumber)
+    return static_cast<ObjectImp*>(o.imp())->put(exec,propertyNameAsNumber, w);
+  return static_cast<ObjectImp*>(o.imp())->put(exec,prop, w);
+}
+
+bool ReferenceImp::deleteValue(ExecState *exec)
+{
+  Value b = getBase(exec);
+
+  // The spec doesn't mention what to do if the base is null... just return true
+  if (b.type() != ObjectType) {
+    assert(b.type() == NullType);
+    return true;
+  }
+
+  if (propertyNameIsNumber)
+    return static_cast<ObjectImp*>(b.imp())->deleteProperty(exec,propertyNameAsNumber);
+  return static_cast<ObjectImp*>(b.imp())->deleteProperty(exec,prop);
 }
 
@@ -1120 +1180 @@
     return Boolean(false);
 
-  Value prot = get(exec,"prototype");
+  Value prot = get(exec,prototypePropertyName);
   if (prot.type() != ObjectType && prot.type() != NullType) {
     Object err = Error::create(exec, TypeError, "Invalid prototype encountered "

trunk/JavaScriptCore/kjs/internal.h

@@ -50 +50 @@
   class UndefinedImp : public ValueImp {
   public:
-    UndefinedImp() {}
-    virtual ~UndefinedImp() { }
-
     Type type() const { return UndefinedType; }
 
@@ -64 +61 @@
   };
 
+  inline Undefined::Undefined(UndefinedImp *imp) : Value(imp) { }
+
   class NullImp : public ValueImp {
   public:
-    NullImp() {}
-    virtual ~NullImp() { }
-
     Type type() const { return NullType; }
 
@@ -80 +76 @@
   };
 
+  inline Null::Null(NullImp *imp) : Value(imp) { }
+
   class BooleanImp : public ValueImp {
   public:
-    virtual ~BooleanImp() { }
     BooleanImp(bool v = false) : val(v) { }
     bool value() const { return val; }
@@ -99 +96 @@
     bool val;
   };
+  
+  inline Boolean::Boolean(BooleanImp *imp) : Value(imp) { }
 
   class StringImp : public ValueImp {
   public:
-    StringImp(const UString& v);
-    virtual ~StringImp() { }
+    StringImp(const UString& v) : val(v) { }
     UString value() const { return val; }
 
@@ -118 +116 @@
   };
 
+  inline String::String(StringImp *imp) : Value(imp) { }
+
   class NumberImp : public ValueImp {
   public:
-    NumberImp(double v);
-    virtual ~NumberImp() { }
+    NumberImp(double v) : val(v) { }
     double value() const { return val; }
 
@@ -132 +131 @@
     Object toObject(ExecState *exec) const;
 
+    virtual bool toUInt32(unsigned&) const;
+
   private:
     double val;
   };
+
+  inline Number::Number(NumberImp *imp) : Value(imp) { }
 
   // ---------------------------------------------------------------------------
@@ -142 +145 @@
   class ReferenceImp : public ValueImp {
   public:
-
     ReferenceImp(const Value& v, const UString& p);
-    virtual ~ReferenceImp() { }
+    ReferenceImp(const Value& v, unsigned p);
     virtual void mark();
 
@@ -153 +155 @@
     Object toObject(ExecState *exec) const;
 
-    Value getBase() const { return Value(base); }
-    UString getPropertyName() const { return prop; }
+    Value getBase(ExecState *) const { return Value(base); }
+    UString getPropertyName(ExecState *) const;
+    Value getValue(ExecState *exec) const;
+    void putValue(ExecState *exec, const Value& w);
+    bool deleteValue(ExecState *exec);
 
     Type type() const { return ReferenceType; }
@@ -160 +165 @@
   private:
     ValueImp *base;
-    UString prop;
-  };
+    bool propertyNameIsNumber;
+    unsigned propertyNameAsNumber;
+    mutable UString prop;
+  };
+  
+  inline Reference::Reference(ReferenceImp *imp) : Value(imp) { }
 
   class CompletionImp : public ValueImp {
@@ -186 +195 @@
     UString tar;
   };
+
+  inline Completion::Completion(CompletionImp *imp) : Value(imp) { }
 
   /**
@@ -244 +255 @@
     static ListImp *emptyList;
   };
+  
+  inline List::List(ListImp *imp) : Value(imp) { }
 
   /**

trunk/JavaScriptCore/kjs/math_object.cpp

@@ -131 +131 @@
 {
   Value protect(this);
-  put(exec,"length",Number(l),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(l),DontDelete|ReadOnly|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -118 +118 @@
 }
 
-StatementNode::~StatementNode()
-{
-}
-
 void StatementNode::setLoc(int line0, int line1, int sourceId)
 {
@@ -227 +223 @@
 // ------------------------------ GroupNode ------------------------------------
 
-GroupNode::~GroupNode()
-{
-}
-
 void GroupNode::ref()
 {
@@ -252 +244 @@
 
 // ------------------------------ ElisionNode ----------------------------------
-
-ElisionNode::~ElisionNode()
-{
-}
 
 void ElisionNode::ref()
@@ -281 +269 @@
 
 // ------------------------------ ElementNode ----------------------------------
-
-ElementNode::~ElementNode()
-{
-}
 
 void ElementNode::ref()
@@ -321 +305 @@
     KJS_CHECKEXCEPTIONVALUE
     val = node->evaluate(exec).getValue(exec);
-    length = array.get(exec,"length").toInt32(exec);
+    length = array.get(exec,lengthPropertyName).toInt32(exec);
   } else {
     Value newArr = exec->interpreter()->builtinArray().construct(exec,List::empty());
@@ -329 +313 @@
   }
 
-  array.put(exec, UString::from(elisionLen + length), val);
+  array.put(exec, elisionLen + length, val);
 
   return array;
@@ -335 +319 @@
 
 // ------------------------------ ArrayNode ------------------------------------
-
-ArrayNode::~ArrayNode()
-{
-}
 
 void ArrayNode::ref()
@@ -369 +349 @@
     array = Object(static_cast<ObjectImp*>(element->evaluate(exec).imp()));
     KJS_CHECKEXCEPTIONVALUE
-    length = opt ? array.get(exec,"length").toInt32(exec) : 0;
+    length = opt ? array.get(exec,lengthPropertyName).toInt32(exec) : 0;
   } else {
     Value newArr = exec->interpreter()->builtinArray().construct(exec,List::empty());
@@ -377 +357 @@
 
   if (opt)
-    array.put(exec,"length", Number(elisionLen + length), DontEnum | DontDelete);
+    array.put(exec,lengthPropertyName, Number(elisionLen + length), DontEnum | DontDelete);
 
   return array;
@@ -383 +363 @@
 
 // ------------------------------ ObjectLiteralNode ----------------------------
-
-ObjectLiteralNode::~ObjectLiteralNode()
-{
-}
 
 void ObjectLiteralNode::ref()
@@ -412 +388 @@
 
 // ------------------------------ PropertyValueNode ----------------------------
-
-PropertyValueNode::~PropertyValueNode()
-{
-}
 
 void PropertyValueNode::ref()
@@ -479 +451 @@
 // ------------------------------ AccessorNode1 --------------------------------
 
-AccessorNode1::~AccessorNode1()
-{
-}
-
 void AccessorNode1::ref()
 {
@@ -511 +479 @@
   Value v2 = e2.getValue(exec);
   Object o = v1.toObject(exec);
+  unsigned i;
+  if (v2.toUInt32(i))
+    return Reference(o, i);
   String s = v2.toString(exec);
   return Reference(o, s.value());
@@ -516 +487 @@
 
 // ------------------------------ AccessorNode2 --------------------------------
-
-AccessorNode2::~AccessorNode2()
-{
-}
 
 void AccessorNode2::ref()
@@ -553 +520 @@
 ArgumentListNode::ArgumentListNode(ArgumentListNode *l, Node *e)
   : list(l), expr(e)
-{
-}
-
-ArgumentListNode::~ArgumentListNode()
 {
 }
@@ -608 +571 @@
 }
 
-ArgumentsNode::~ArgumentsNode()
-{
-}
-
 void ArgumentsNode::ref()
 {
@@ -644 +603 @@
 
 // ECMA 11.2.2
-
-NewExprNode::~NewExprNode()
-{
-}
 
 void NewExprNode::ref()
@@ -694 +649 @@
 
 // ------------------------------ FunctionCallNode -----------------------------
-
-FunctionCallNode::~FunctionCallNode()
-{
-}
 
 void FunctionCallNode::ref()
@@ -788 +739 @@
 // ------------------------------ PostfixNode ----------------------------------
 
-PostfixNode::~PostfixNode()
-{
-}
-
 void PostfixNode::ref()
 {
@@ -824 +771 @@
 // ------------------------------ DeleteNode -----------------------------------
 
-DeleteNode::~DeleteNode()
-{
-}
-
 void DeleteNode::ref()
 {
@@ -847 +790 @@
   Value e = expr->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
-  if (e.type() != ReferenceType)
-    return Boolean(true);
-  Value b = e.getBase(exec);
-  UString n = e.getPropertyName(exec);
-
-  // The spec doesn't mention what to do if the base is null... just return true
-  if (b.type() != ObjectType) {
-    assert(b.type() == NullType);
-    return Boolean(true);
-  }
-
-  Object o = Object(static_cast<ObjectImp*>(b.imp()));
-
-  bool ret = o.deleteProperty(exec,n);
-
-  return Boolean(ret);
+  return Boolean(e.deleteValue(exec));
 }
 
 // ------------------------------ VoidNode -------------------------------------
-
-VoidNode::~VoidNode()
-{
-}
 
 void VoidNode::ref()
@@ -896 +820 @@
 
 // ------------------------------ TypeOfNode -----------------------------------
-
-TypeOfNode::~TypeOfNode()
-{
-}
 
 void TypeOfNode::ref()
@@ -957 +877 @@
 // ------------------------------ PrefixNode -----------------------------------
 
-PrefixNode::~PrefixNode()
-{
-}
-
 void PrefixNode::ref()
 {
@@ -993 +909 @@
 // ------------------------------ UnaryPlusNode --------------------------------
 
-UnaryPlusNode::~UnaryPlusNode()
-{
-}
-
 void UnaryPlusNode::ref()
 {
@@ -1023 +935 @@
 // ------------------------------ NegateNode -----------------------------------
 
-NegateNode::~NegateNode()
-{
-}
-
 void NegateNode::ref()
 {
@@ -1056 +964 @@
 // ------------------------------ BitwiseNotNode -------------------------------
 
-BitwiseNotNode::~BitwiseNotNode()
-{
-}
-
 void BitwiseNotNode::ref()
 {
@@ -1087 +991 @@
 // ------------------------------ LogicalNotNode -------------------------------
 
-LogicalNotNode::~LogicalNotNode()
-{
-}
-
 void LogicalNotNode::ref()
 {
@@ -1117 +1017 @@
 
 // ------------------------------ MultNode -------------------------------------
-
-MultNode::~MultNode()
-{
-}
 
 void MultNode::ref()
@@ -1156 +1052 @@
 // ------------------------------ AddNode --------------------------------------
 
-AddNode::~AddNode()
-{
-}
-
 void AddNode::ref()
 {
@@ -1193 +1085 @@
 
 // ------------------------------ ShiftNode ------------------------------------
-
-ShiftNode::~ShiftNode()
-{
-}
 
 void ShiftNode::ref()
@@ -1248 +1136 @@
 
 // ------------------------------ RelationalNode -------------------------------
-
-RelationalNode::~RelationalNode()
-{
-}
 
 void RelationalNode::ref()
@@ -1324 +1208 @@
 // ------------------------------ EqualNode ------------------------------------
 
-EqualNode::~EqualNode()
-{
-}
-
 void EqualNode::ref()
 {
@@ -1370 +1250 @@
 
 // ------------------------------ BitOperNode ----------------------------------
-
-BitOperNode::~BitOperNode()
-{
-}
 
 void BitOperNode::ref()
@@ -1417 +1293 @@
 // ------------------------------ BinaryLogicalNode ----------------------------
 
-BinaryLogicalNode::~BinaryLogicalNode()
-{
-}
-
 void BinaryLogicalNode::ref()
 {
@@ -1457 +1329 @@
 
 // ------------------------------ ConditionalNode ------------------------------
-
-ConditionalNode::~ConditionalNode()
-{
-}
 
 void ConditionalNode::ref()
@@ -1502 +1370 @@
 
 // ------------------------------ AssignNode -----------------------------------
-
-AssignNode::~AssignNode()
-{
-}
 
 void AssignNode::ref()
@@ -1597 +1461 @@
 // ------------------------------ CommaNode ------------------------------------
 
-CommaNode::~CommaNode()
-{
-}
-
 void CommaNode::ref()
 {
@@ -1632 +1492 @@
 
 // ------------------------------ StatListNode ---------------------------------
-
-StatListNode::~StatListNode()
-{
-}
 
 void StatListNode::ref()
@@ -1698 +1554 @@
 // ------------------------------ AssignExprNode -------------------------------
 
-AssignExprNode::~AssignExprNode()
-{
-}
-
 void AssignExprNode::ref()
 {
@@ -1726 +1578 @@
 VarDeclNode::VarDeclNode(const UString *id, AssignExprNode *in)
     : ident(*id), init(in)
-{
-}
-
-VarDeclNode::~VarDeclNode()
 {
 }
@@ -1781 +1629 @@
 // ------------------------------ VarDeclListNode ------------------------------
 
-VarDeclListNode::~VarDeclListNode()
-{
-}
-
 void VarDeclListNode::ref()
 {
@@ -1827 +1671 @@
 // ------------------------------ VarStatementNode -----------------------------
 
-VarStatementNode::~VarStatementNode()
-{
-}
-
 void VarStatementNode::ref()
 {
@@ -1863 +1703 @@
 // ------------------------------ BlockNode ------------------------------------
 
-BlockNode::~BlockNode()
-{
-}
-
 void BlockNode::ref()
 {
@@ -1907 +1743 @@
 
 // ------------------------------ ExprStatementNode ----------------------------
-
-ExprStatementNode::~ExprStatementNode()
-{
-}
 
 void ExprStatementNode::ref()
@@ -1939 +1771 @@
 
 // ------------------------------ IfNode ---------------------------------------
-
-IfNode::~IfNode()
-{
-}
 
 void IfNode::ref()
@@ -1997 +1825 @@
 
 // ------------------------------ DoWhileNode ----------------------------------
-
-DoWhileNode::~DoWhileNode()
-{
-}
 
 void DoWhileNode::ref()
@@ -2055 +1879 @@
 // ------------------------------ WhileNode ------------------------------------
 
-WhileNode::~WhileNode()
-{
-}
-
 void WhileNode::ref()
 {
@@ -2118 +1938 @@
 
 // ------------------------------ ForNode --------------------------------------
-
-ForNode::~ForNode()
-{
-}
 
 void ForNode::ref()
@@ -2212 +2028 @@
 }
 
-ForInNode::~ForInNode()
-{
-}
-
 void ForInNode::ref()
 {
@@ -2333 +2145 @@
 // ------------------------------ ReturnNode -----------------------------------
 
-ReturnNode::~ReturnNode()
-{
-}
-
 void ReturnNode::ref()
 {
@@ -2367 +2175 @@
 
 // ------------------------------ WithNode -------------------------------------
-
-WithNode::~WithNode()
-{
-}
 
 void WithNode::ref()
@@ -2414 +2218 @@
 // ------------------------------ CaseClauseNode -------------------------------
 
-CaseClauseNode::~CaseClauseNode()
-{
-}
-
 void CaseClauseNode::ref()
 {
@@ -2463 +2263 @@
 // ------------------------------ ClauseListNode -------------------------------
 
-ClauseListNode::~ClauseListNode()
-{
-}
-
 void ClauseListNode::ref()
 {
@@ -2512 +2308 @@
 
 // ------------------------------ CaseBlockNode --------------------------------
-
-CaseBlockNode::~CaseBlockNode()
-{
-}
 
 void CaseBlockNode::ref()
@@ -2620 +2412 @@
 // ------------------------------ SwitchNode -----------------------------------
 
-SwitchNode::~SwitchNode()
-{
-}
-
 void SwitchNode::ref()
 {
@@ -2664 +2452 @@
 
 // ------------------------------ LabelNode ------------------------------------
-
-LabelNode::~LabelNode()
-{
-}
 
 void LabelNode::ref()
@@ -2708 +2492 @@
 // ------------------------------ ThrowNode ------------------------------------
 
-ThrowNode::~ThrowNode()
-{
-}
-
 void ThrowNode::ref()
 {
@@ -2742 +2522 @@
 
 // ------------------------------ CatchNode ------------------------------------
-
-CatchNode::~CatchNode()
-{
-}
 
 void CatchNode::ref()
@@ -2791 +2567 @@
 // ------------------------------ FinallyNode ----------------------------------
 
-FinallyNode::~FinallyNode()
-{
-}
-
 void FinallyNode::ref()
 {
@@ -2821 +2593 @@
 
 // ------------------------------ TryNode --------------------------------------
-
-TryNode::~TryNode()
-{
-}
 
 void TryNode::ref()
@@ -2886 +2654 @@
 // ------------------------------ ParameterNode --------------------------------
 
-ParameterNode::~ParameterNode()
-{
-}
-
 void ParameterNode::ref()
 {
@@ -2931 +2695 @@
 }
 
-FunctionBodyNode::~FunctionBodyNode()
-{
-  //fprintf(stderr,"FunctionBodyNode::~FunctionBodyNode %p\n",this);
-}
-
 void FunctionBodyNode::ref()
 {
@@ -2977 +2736 @@
 
 // ------------------------------ FuncDeclNode ---------------------------------
-
-FuncDeclNode::~FuncDeclNode()
-{
-}
 
 void FuncDeclNode::ref()
@@ -3012 +2767 @@
   List empty;
   Value proto = exec->interpreter()->builtinObject().construct(exec,empty);
-  func.put(exec, "prototype", proto, Internal|DontDelete);
+  func.put(exec, prototypePropertyName, proto, Internal|DontDelete);
 
   int plen = 0;
@@ -3018 +2773 @@
     fimp->addParameter(p->ident());
 
-  func.put(exec, "length", Number(plen), ReadOnly|DontDelete|DontEnum);
+  func.put(exec, lengthPropertyName, Number(plen), ReadOnly|DontDelete|DontEnum);
 
   exec->context().imp()->variableObject().put(exec,ident,func);
@@ -3036 +2791 @@
 // ------------------------------ FuncExprNode ---------------------------------
 
-FuncExprNode::~FuncExprNode()
-{
-}
-
 void FuncExprNode::ref()
 {
@@ -3067 +2818 @@
   List empty;
   Value proto = exec->interpreter()->builtinObject().construct(exec,empty);
-  fimp->put(exec, "prototype", proto, Internal|DontDelete);
+  fimp->put(exec, prototypePropertyName, proto, Internal|DontDelete);
 
   int plen = 0;
   for(ParameterNode *p = param; p != 0L; p = p->nextParam(), plen++)
     fimp->addParameter(p->ident());
-  fimp->put(exec,"length", Number(plen), ReadOnly|DontDelete|DontEnum);
+  fimp->put(exec,lengthPropertyName, Number(plen), ReadOnly|DontDelete|DontEnum);
 
   return ret;
@@ -3078 +2829 @@
 
 // ------------------------------ SourceElementNode ----------------------------
-
-SourceElementNode::~SourceElementNode()
-{
-}
 
 void SourceElementNode::ref()
@@ -3124 +2871 @@
 
 // ------------------------------ SourceElementsNode ---------------------------
-
-SourceElementsNode::~SourceElementsNode()
-{
-}
 
 void SourceElementsNode::ref()
@@ -3188 +2931 @@
     //fprintf(stderr,"ProgramNode::ProgramNode %p\n",this);
 }
-
-ProgramNode::~ProgramNode() {
-    //fprintf(stderr,"ProgramNode::~ProgramNode %p\n",this);
-}

trunk/JavaScriptCore/kjs/nodes.h

@@ -112 +112 @@
   public:
     StatementNode();
-    ~StatementNode();
     void setLoc(int line0, int line1, int sourceId);
     int firstLine() const { return l0; }
@@ -197 +196 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~GroupNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const { group->streamTo(s); }
@@ -209 +207 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ElisionNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -223 +220 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ElementNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -241 +237 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ArrayNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -255 +250 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ObjectLiteralNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -268 +262 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~PropertyValueNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -291 +284 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~AccessorNode1();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -304 +296 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~AccessorNode2();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -318 +309 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ArgumentListNode();
     Value evaluate(ExecState *exec);
     List evaluateList(ExecState *exec);
@@ -332 +322 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ArgumentsNode();
     Value evaluate(ExecState *exec);
     List evaluateList(ExecState *exec);
@@ -346 +335 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~NewExprNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -359 +347 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~FunctionCallNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -372 +359 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~PostfixNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -385 +371 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~DeleteNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -397 +382 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~VoidNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -409 +393 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~TypeOfNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -421 +404 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~PrefixNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -434 +416 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~UnaryPlusNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -446 +427 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~NegateNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -458 +438 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~BitwiseNotNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -470 +449 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~LogicalNotNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -482 +460 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~MultNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -495 +472 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~AddNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -509 +485 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ShiftNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -523 +498 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~RelationalNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -537 +511 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~EqualNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -551 +524 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~BitOperNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -568 +540 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~BinaryLogicalNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -585 +556 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ConditionalNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -597 +567 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~AssignNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -611 +580 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~CommaNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -624 +592 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~StatListNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -638 +605 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~AssignExprNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -650 +616 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~VarDeclNode();
     Value evaluate(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -665 +630 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~VarDeclListNode();
     Value evaluate(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -679 +643 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~VarStatementNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -692 +655 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~BlockNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -712 +674 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ExprStatementNode();
     virtual Completion execute(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -725 +686 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~IfNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -739 +699 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~DoWhileNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -753 +712 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~WhileNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -768 +726 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ForNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -783 +740 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ForInNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -820 +776 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ReturnNode();
     virtual Completion execute(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -832 +787 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~WithNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -846 +800 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~CaseClauseNode();
     Value evaluate(ExecState *exec);
     Completion evalStatements(ExecState *exec);
@@ -861 +814 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ClauseListNode();
     ClauseListNode* append(CaseClauseNode *c);
     Value evaluate(ExecState *exec);
@@ -879 +831 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~CaseBlockNode();
     Value evaluate(ExecState *exec);
     Completion evalBlock(ExecState *exec, const Value& input);
@@ -895 +846 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~SwitchNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -909 +859 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~LabelNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -923 +872 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ThrowNode();
     virtual Completion execute(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -935 +883 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~CatchNode();
     virtual Completion execute(ExecState *exec);
     Completion execute(ExecState *exec, const Value &arg);
@@ -950 +897 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~FinallyNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -964 +910 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~TryNode();
     virtual Completion execute(ExecState *exec);
     virtual void processVarDecls(ExecState *exec);
@@ -980 +925 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~ParameterNode();
     Value evaluate(ExecState *exec);
     UString ident() { return id; }
@@ -996 +940 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~FunctionBodyNode();
     Completion execute(ExecState *exec);
     virtual void processFuncDecl(ExecState *exec);
@@ -1011 +954 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~FuncDeclNode();
     Completion execute(ExecState */*exec*/)
       { /* empty */ return Completion(); }
@@ -1028 +970 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~FuncExprNode();
     Value evaluate(ExecState *exec);
     virtual void streamTo(SourceStream &s) const;
@@ -1042 +983 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~SourceElementNode();
     Completion execute(ExecState *exec);
     virtual void processFuncDecl(ExecState *exec);
@@ -1060 +1000 @@
     virtual void ref();
     virtual bool deref();
-    virtual ~SourceElementsNode();
     Completion execute(ExecState *exec);
     virtual void processFuncDecl(ExecState *exec);
@@ -1073 +1012 @@
   public:
     ProgramNode(SourceElementsNode *s);
-    ~ProgramNode();
-  private:
-    // Disallow copy
-    ProgramNode(const ProgramNode &other);
   };
 

trunk/JavaScriptCore/kjs/nodes2string.cpp

@@ -35 +35 @@
     UString toString() const { return str; }
     SourceStream& operator<<(const KJS::UString &);
+    SourceStream& operator<<(char);
     SourceStream& operator<<(Format f);
     SourceStream& operator<<(const Node *);
@@ -44 +45 @@
 
 using namespace KJS;
+
+SourceStream& SourceStream::operator<<(char c)
+{
+  str += UString(c);
+  return *this;
+}
 
 SourceStream& SourceStream::operator<<(const KJS::UString &s)

trunk/JavaScriptCore/kjs/number_object.cpp

@@ -55 +55 @@
   // The constructor will be added later, after NumberObjectImp has been constructed
 
-  put(exec,"toString",       Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ToString,       1)), DontEnum);
+  put(exec,toStringPropertyName,       Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ToString,       1)), DontEnum);
   put(exec,"toLocaleString", Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ToLocaleString, 0)), DontEnum);
-  put(exec,"valueOf",        Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ValueOf,        0)), DontEnum);
+  put(exec,valueOfPropertyName,        Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ValueOf,        0)), DontEnum);
 }
 
@@ -68 +68 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -125 +125 @@
   Value protect(this);
   // Number.Prototype
-  put(exec,"prototype", Value(numberProto),DontEnum|DontDelete|ReadOnly);
+  put(exec,prototypePropertyName, Value(numberProto),DontEnum|DontDelete|ReadOnly);
 
   // no. of arguments for constructor
-  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(1), ReadOnly|DontDelete|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/object.cpp

@@ -39 +39 @@
 #include "property_map.h"
 
-using namespace KJS;
+namespace KJS {
+
+extern const UString lengthPropertyName("length");
+extern const UString prototypePropertyName("prototype");
+extern const UString toStringPropertyName("toString");
+extern const UString valueOfPropertyName("valueOf");
 
 // ------------------------------ Object ---------------------------------------
-
-Object::Object() : Value()
-{
-}
-
-Object::Object(ObjectImp *v) : Value(v)
-{
-}
-
-Object::Object(const Object &v) : Value(v)
-{
-}
-
-Object::~Object()
-{
-}
-
-Object& Object::operator=(const Object &v)
-{
-  Value::operator=(v);
-  return *this;
-}
-
-const ClassInfo *Object::classInfo() const
-{
-  return static_cast<ObjectImp*>(rep)->classInfo();
-}
-
-bool Object::inherits(const ClassInfo *cinfo) const
-{
-  return static_cast<ObjectImp*>(rep)->inherits(cinfo);
-}
 
 Object Object::dynamicCast(const Value &v)
@@ -81 +54 @@
 
   return Object(static_cast<ObjectImp*>(v.imp()));
-}
-
-Value Object::prototype() const
-{
-  return Value(static_cast<ObjectImp*>(rep)->prototype());
-}
-
-UString Object::className() const
-{
-  return static_cast<ObjectImp*>(rep)->className();
-}
-
-Value Object::get(ExecState *exec, const UString &propertyName) const
-{
-  return static_cast<ObjectImp*>(rep)->get(exec,propertyName);
-}
-
-void Object::put(ExecState *exec, const UString &propertyName, const Value &value, int attr)
-{
-  static_cast<ObjectImp*>(rep)->put(exec,propertyName,value,attr);
-}
-
-bool Object::canPut(ExecState *exec, const UString &propertyName) const
-{
-  return static_cast<ObjectImp*>(rep)->canPut(exec,propertyName);
-}
-
-bool Object::hasProperty(ExecState *exec, const UString &propertyName) const
-{
-  return static_cast<ObjectImp*>(rep)->hasProperty(exec, propertyName);
-}
-
-bool Object::deleteProperty(ExecState *exec, const UString &propertyName)
-{
-  return static_cast<ObjectImp*>(rep)->deleteProperty(exec,propertyName);
-}
-
-Value Object::defaultValue(ExecState *exec, Type hint) const
-{
-  return static_cast<ObjectImp*>(rep)->defaultValue(exec,hint);
-}
-
-bool Object::implementsConstruct() const
-{
-  return static_cast<ObjectImp*>(rep)->implementsConstruct();
-}
-
-Object Object::construct(ExecState *exec, const List &args)
-{
-  return static_cast<ObjectImp*>(rep)->construct(exec,args);
-}
-
-bool Object::implementsCall() const
-{
-  return static_cast<ObjectImp*>(rep)->implementsCall();
-}
-
-Value Object::call(ExecState *exec, Object &thisObj, const List &args)
-{
-  return static_cast<ObjectImp*>(rep)->call(exec,thisObj,args);
-}
-
-bool Object::implementsHasInstance() const
-{
-  return static_cast<ObjectImp*>(rep)->implementsHasInstance();
-}
-
-Boolean Object::hasInstance(ExecState *exec, const Value &value)
-{
-  return static_cast<ObjectImp*>(rep)->hasInstance(exec,value);
-}
-
-const List Object::scope() const
-{
-  return static_cast<ObjectImp*>(rep)->scope();
-}
-
-void Object::setScope(const List &s)
-{
-  static_cast<ObjectImp*>(rep)->setScope(s);
-}
-
-List Object::propList(ExecState *exec, bool recursive)
-{
-  return static_cast<ObjectImp*>(rep)->propList(exec,recursive);
-}
-
-Value Object::internalValue() const
-{
-  return static_cast<ObjectImp*>(rep)->internalValue();
-}
-
-void Object::setInternalValue(const Value &v)
-{
-  static_cast<ObjectImp*>(rep)->setInternalValue(v);
 }
 
@@ -294 +172 @@
 
   return proto.get(exec,propertyName);
+}
+
+Value ObjectImp::get(ExecState *exec, unsigned propertyName) const
+{
+  return get(exec, UString::from(propertyName));
 }
 
@@ -335 +218 @@
 }
 
+void ObjectImp::put(ExecState *exec, unsigned propertyName,
+                     const Value &value, int attr)
+{
+  put(exec, UString::from(propertyName), value, attr);
+}
+
 // ECMA 8.6.2.3
 bool ObjectImp::canPut(ExecState *, const UString &propertyName) const
@@ -367 +256 @@
   Object proto = Object::dynamicCast(prototype());
   return !proto.isNull() && proto.hasProperty(exec,propertyName);
+}
+
+bool ObjectImp::hasProperty(ExecState *exec, unsigned propertyName) const
+{
+  return hasProperty(exec, UString::from(propertyName));
 }
 
@@ -387 +281 @@
 }
 
+bool ObjectImp::deleteProperty(ExecState *exec, unsigned propertyName)
+{
+  return deleteProperty(exec, UString::from(propertyName));
+}
+
 void ObjectImp::deleteAllProperties( ExecState * )
 {
@@ -405 +304 @@
   Value v;
   if (hint == StringType)
-    v = get(exec,"toString");
+    v = get(exec,toStringPropertyName);
   else
-    v = get(exec,"valueOf");
+    v = get(exec,valueOfPropertyName);
 
   if (v.type() == ObjectType) {
@@ -424 +323 @@
 
   if (hint == StringType)
-    v = get(exec,"valueOf");
+    v = get(exec,valueOfPropertyName);
   else
-    v = get(exec,"toString");
+    v = get(exec,toStringPropertyName);
 
   if (v.type() == ObjectType) {
@@ -546 +445 @@
 }
 
-// The following functions simply call the corresponding functions in ValueImp
-// but are overridden in case of future needs
-
 Value ObjectImp::toPrimitive(ExecState *exec, Type preferredType) const
 {
@@ -565 +461 @@
     return 0.0;
   return prim.toNumber(exec);
-}
-
-int ObjectImp::toInteger(ExecState *exec) const
-{
-  return ValueImp::toInteger(exec);
-}
-
-int ObjectImp::toInt32(ExecState *exec) const
-{
-  return ValueImp::toInt32(exec);
-}
-
-unsigned int ObjectImp::toUInt32(ExecState *exec) const
-{
-  return ValueImp::toUInt32(exec);
-}
-
-unsigned short ObjectImp::toUInt16(ExecState *exec) const
-{
-  return ValueImp::toUInt16(exec);
 }
 
@@ -670 +546 @@
 }
 
+} // namespace KJS

trunk/JavaScriptCore/kjs/object.h

@@ -80 +80 @@
   class Object : public Value {
   public:
-    Object();
+    Object() { }
     explicit Object(ObjectImp *v);
-    Object(const Object &v);
-    virtual ~Object();
-
-    Object& operator=(const Object &v);
-
-    virtual const ClassInfo *classInfo() const;
+    
+    ObjectImp *imp() const;
+
+    const ClassInfo *classInfo() const;
     bool inherits(const ClassInfo *cinfo) const;
 
@@ -133 +131 @@
      */
     Value get(ExecState *exec, const UString &propertyName) const;
+    Value get(ExecState *exec, unsigned propertyName) const;
 
     /**
@@ -145 +144 @@
     void put(ExecState *exec, const UString &propertyName,
              const Value &value, int attr = None);
+    void put(ExecState *exec, unsigned propertyName,
+             const Value &value, int attr = None);
 
     /**
@@ -169 +170 @@
      */
     bool hasProperty(ExecState *exec, const UString &propertyName) const;
+    bool hasProperty(ExecState *exec, unsigned propertyName) const;
 
     /**
@@ -182 +184 @@
      */
     bool deleteProperty(ExecState *exec, const UString &propertyName);
+    bool deleteProperty(ExecState *exec, unsigned propertyName);
 
     /**
@@ -350 +353 @@
   };
 
+  inline Object Value::toObject(ExecState *exec) const { return rep->toObject(exec); }
+  
   class ObjectImp : public ValueImp {
   public:
@@ -467 +472 @@
     // [[Get]] - must be implemented by all Objects
     virtual Value get(ExecState *exec, const UString &propertyName) const;
+    virtual Value get(ExecState *exec, unsigned propertyName) const;
 
     /**
@@ -476 +482 @@
     virtual void put(ExecState *exec, const UString &propertyName,
                      const Value &value, int attr = None);
+    virtual void put(ExecState *exec, unsigned propertyName,
+                     const Value &value, int attr = None);
 
     /**
@@ -493 +501 @@
     virtual bool hasProperty(ExecState *exec,
                              const UString &propertyName) const;
+    virtual bool hasProperty(ExecState *exec, unsigned propertyName) const;
 
     /**
@@ -502 +511 @@
     virtual bool deleteProperty(ExecState *exec,
                                 const UString &propertyName);
+    virtual bool deleteProperty(ExecState *exec, unsigned propertyName);
 
     /**
@@ -560 +570 @@
     bool toBoolean(ExecState *exec) const;
     double toNumber(ExecState *exec) const;
-    int toInteger(ExecState *exec) const;
-    int toInt32(ExecState *exec) const;
-    unsigned int toUInt32(ExecState *exec) const;
-    unsigned short toUInt16(ExecState *exec) const;
     UString toString(ExecState *exec) const;
     Object toObject(ExecState *exec) const;
@@ -613 +619 @@
   };
 
+  inline Object::Object(ObjectImp *v) : Value(v) { }
+
+  inline ObjectImp *Object::imp() const { return static_cast<ObjectImp*>(rep); }
+
+  inline const ClassInfo *Object::classInfo() const
+    { return imp()->classInfo(); }
+
+  inline bool Object::inherits(const ClassInfo *cinfo) const
+    { return imp()->inherits(cinfo); }
+
+  inline Value Object::prototype() const
+    { return Value(imp()->prototype()); }
+
+  inline UString Object::className() const
+    { return imp()->className(); }
+
+  inline Value Object::get(ExecState *exec, const UString &propertyName) const
+    { return imp()->get(exec,propertyName); }
+
+  inline Value Object::get(ExecState *exec, unsigned propertyName) const
+    { return imp()->get(exec,propertyName); }
+
+  inline void Object::put(ExecState *exec, const UString &propertyName, const Value &value, int attr)
+    { imp()->put(exec,propertyName,value,attr); }
+
+  inline void Object::put(ExecState *exec, unsigned propertyName, const Value &value, int attr)
+    { imp()->put(exec,propertyName,value,attr); }
+
+  inline bool Object::canPut(ExecState *exec, const UString &propertyName) const
+    { return imp()->canPut(exec,propertyName); }
+
+  inline bool Object::hasProperty(ExecState *exec, const UString &propertyName) const
+    { return imp()->hasProperty(exec, propertyName); }
+
+  inline bool Object::hasProperty(ExecState *exec, unsigned propertyName) const
+    { return imp()->hasProperty(exec, propertyName); }
+
+  inline bool Object::deleteProperty(ExecState *exec, const UString &propertyName)
+    { return imp()->deleteProperty(exec,propertyName); }
+
+  inline bool Object::deleteProperty(ExecState *exec, unsigned propertyName)
+    { return imp()->deleteProperty(exec,propertyName); }
+
+  inline Value Object::defaultValue(ExecState *exec, Type hint) const
+    { return imp()->defaultValue(exec,hint); }
+
+  inline bool Object::implementsConstruct() const
+    { return imp()->implementsConstruct(); }
+
+  inline Object Object::construct(ExecState *exec, const List &args)
+    { return imp()->construct(exec,args); }
+
+  inline bool Object::implementsCall() const
+    { return imp()->implementsCall(); }
+
+  inline Value Object::call(ExecState *exec, Object &thisObj, const List &args)
+    { return imp()->call(exec,thisObj,args); }
+
+  inline bool Object::implementsHasInstance() const
+    { return imp()->implementsHasInstance(); }
+
+  inline Boolean Object::hasInstance(ExecState *exec, const Value &value)
+    { return imp()->hasInstance(exec,value); }
+
+  inline const List Object::scope() const
+    { return imp()->scope(); }
+
+  inline void Object::setScope(const List &s)
+    { imp()->setScope(s); }
+
+  inline List Object::propList(ExecState *exec, bool recursive)
+    { return imp()->propList(exec,recursive); }
+
+  inline Value Object::internalValue() const
+    { return imp()->internalValue(); }
+
+  inline void Object::setInternalValue(const Value &v)
+    { imp()->setInternalValue(v); }
+
+  extern const UString lengthPropertyName;
+  extern const UString prototypePropertyName;
+  extern const UString toStringPropertyName;
+  extern const UString valueOfPropertyName;
+
 }; // namespace
 

trunk/JavaScriptCore/kjs/object_object.cpp

@@ -39 +39 @@
 {
   Value protect(this);
-  put(exec,"toString", Object(new ObjectProtoFuncImp(exec,funcProto,ObjectProtoFuncImp::ToString, 0)), DontEnum);
-  put(exec,"valueOf",  Object(new ObjectProtoFuncImp(exec,funcProto,ObjectProtoFuncImp::ValueOf,  0)), DontEnum);
+  put(exec,toStringPropertyName, Object(new ObjectProtoFuncImp(exec,funcProto,ObjectProtoFuncImp::ToString, 0)), DontEnum);
+  put(exec,valueOfPropertyName,  Object(new ObjectProtoFuncImp(exec,funcProto,ObjectProtoFuncImp::ValueOf,  0)), DontEnum);
 }
 
@@ -52 +52 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -80 +80 @@
   Value protect(this);
   // ECMA 15.2.3.1
-  put(exec,"prototype", Object(objProto), DontEnum|DontDelete|ReadOnly);
+  put(exec,prototypePropertyName, Object(objProto), DontEnum|DontDelete|ReadOnly);
 
   // no. of arguments for constructor
-  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(1), ReadOnly|DontDelete|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/regexp_object.cpp

@@ -50 +50 @@
   put(exec, "exec",     Object(new RegExpProtoFuncImp(exec,funcProto,RegExpProtoFuncImp::Exec,     0)), DontEnum);
   put(exec, "test",     Object(new RegExpProtoFuncImp(exec,funcProto,RegExpProtoFuncImp::Test,     0)), DontEnum);
-  put(exec, "toString", Object(new RegExpProtoFuncImp(exec,funcProto,RegExpProtoFuncImp::ToString, 0)), DontEnum);
+  put(exec, toStringPropertyName, Object(new RegExpProtoFuncImp(exec,funcProto,RegExpProtoFuncImp::ToString, 0)), DontEnum);
 }
 
@@ -60 +60 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -157 +157 @@
   Value protect(this);
   // ECMA 15.10.5.1 RegExp.prototype
-  put(exec,"prototype", Object(regProto), DontEnum|DontDelete|ReadOnly);
+  put(exec,prototypePropertyName, Object(regProto), DontEnum|DontDelete|ReadOnly);
 
   // no. of arguments for constructor
-  put(exec,"length", Number(2), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(2), ReadOnly|DontDelete|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/string_object.cpp

@@ -90 +90 @@
   Value protect(this);
   // The constructor will be added later, after StringObjectImp has been built
-  put(exec,"length",Number(0),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(0),DontDelete|ReadOnly|DontEnum);
 
 }
@@ -107 +107 @@
 {
   Value protect(this);
-  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
@@ -343 +343 @@
       if (u.isEmpty() && !reg.match(u, 0).isNull()) {
         // empty string matched by regexp -> empty array
-        res.put(exec,"length", Number(0));
+        res.put(exec,lengthPropertyName, Number(0));
         break;
       }
@@ -357 +357 @@
         pos = mpos + (mstr.isEmpty() ? 1 : mstr.size());
         if (mpos != p0 || !mstr.isEmpty()) {
-          res.put(exec,UString::from(i), String(u.substr(p0, mpos-p0)));
+          res.put(exec,i, String(u.substr(p0, mpos-p0)));
           p0 = mpos + mstr.size();
           i++;
@@ -367 +367 @@
         if (u.isEmpty()) {
           // empty separator matches empty string -> empty array
-          put(exec,"length", Number(0));
+          put(exec,lengthPropertyName, Number(0));
           break;
         } else {
           while (i != d && i < u.size()-1)
-            res.put(exec,UString::from(i++), String(u.substr(p0++, 1)));
+            res.put(exec, i++, String(u.substr(p0++, 1)));
         }
       } else {
         while (i != d && (pos = u.find(u2, p0)) >= 0) {
-          res.put(exec,UString::from(i), String(u.substr(p0, pos-p0)));
+          res.put(exec, i, String(u.substr(p0, pos-p0)));
           p0 = pos + u2.size();
           i++;
@@ -383 +383 @@
     // add remaining string, if any
     if (i != d)
-      res.put(exec,UString::from(i++), String(u.substr(p0)));
-    res.put(exec,"length", Number(i));
+      res.put(exec, i++, String(u.substr(p0)));
+    res.put(exec,lengthPropertyName, Number(i));
     }
     break;
@@ -498 +498 @@
   Value protect(this);
   // ECMA 15.5.3.1 String.prototype
-  put(exec,"prototype", Object(stringProto), DontEnum|DontDelete|ReadOnly);
-
-  put(exec,"fromCharCode", Object(new StringObjectFuncImp(exec,funcProto)), DontEnum);
+  put(exec,prototypePropertyName, Object(stringProto), DontEnum|DontDelete|ReadOnly);
+
+  static UString fromCharCode("fromCharCode");
+  put(exec,fromCharCode, Object(new StringObjectFuncImp(exec,funcProto)), DontEnum);
 
   // no. of arguments for constructor
-  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+  put(exec,lengthPropertyName, Number(1), ReadOnly|DontDelete|DontEnum);
 }
 
@@ -525 +526 @@
 
   obj.setInternalValue(String(s));
-  obj.put(exec, "length", Number(s.size()), ReadOnly|DontEnum|DontDelete);
+  obj.put(exec, lengthPropertyName, Number(s.size()), ReadOnly|DontEnum|DontDelete);
 
   return obj;
@@ -553 +554 @@
 {
   Value protect(this);
-  put(exec,"length",Number(1),DontDelete|ReadOnly|DontEnum);
+  put(exec,lengthPropertyName,Number(1),DontDelete|ReadOnly|DontEnum);
 }
 

trunk/JavaScriptCore/kjs/types.cpp

@@ -46 +46 @@
 }
 
+Reference::Reference(const Object& b, unsigned p)
+  : Value(new ReferenceImp(b,p))
+{
+}
+
 Reference::Reference(const Null& b, const UString& p)
   : Value(new ReferenceImp(b,p))
@@ -51 +56 @@
 }
 
-Reference::Reference(ReferenceImp *v) : Value(v)
-{
-}
-
-Reference::Reference(const Reference &v) : Value(v)
-{
-}
-
-Reference::~Reference()
-{
-}
-
-Reference& Reference::operator=(const Reference &v)
-{
-  Value::operator=(v);
-  return *this;
+Reference::Reference(const Null& b, unsigned p)
+  : Value(new ReferenceImp(b,p))
+{
 }
 
@@ -87 +79 @@
 ListIterator::ListIterator(const List &l)
   : node(static_cast<ListImp*>(l.imp())->hook->next)
-{
-}
-
-ListIterator& ListIterator::operator=(const ListIterator &iterator)
-{
-  node=iterator.node;
-  return *this;
-}
-
-ListIterator::ListIterator(const ListIterator &i) : node(i.node)
-{
-}
-
-ListIterator::~ListIterator()
 {
 }
@@ -160 +138 @@
 }
 
-List::List(ListImp *v) : Value(v)
-{
-  //fprintf(stderr,"List::List(imp) this=%p imp=%p refcount=%d\n",this,v,v?v->refcount:0);
-}
-
-List::List(const List &v) : Value(v)
-{
-  //fprintf(stderr,"List::List(List) this=%p imp=%p refcount=%d\n",this,rep,rep?rep->refcount:0);
-}
-
-List::~List()
-{
-  //fprintf(stderr,"List::~List() this=%p imp=%p refcount=%d\n",this,rep,rep->refcount-1);
-}
-
-List& List::operator=(const List &v)
-{
-  //fprintf(stderr,"List::operator=() this=%p\n",this);
-  Value::operator=(v);
-  return *this;
-}
-
 List List::dynamicCast(const Value &v)
 {
@@ -286 +242 @@
 }
 
-Completion::Completion(CompletionImp *v) : Value(v)
-{
-}
-
-Completion::Completion(const Completion &v) : Value(v)
-{
-}
-
-Completion::~Completion()
-{
-}
-
-Completion& Completion::operator=(const Completion &v)
-{
-  Value::operator=(v);
-  return *this;
-}
-
 Completion Completion::dynamicCast(const Value &v)
 {

trunk/JavaScriptCore/kjs/types.h

@@ -34 +34 @@
   public:
     Reference(const Object& b, const UString& p);
+    Reference(const Object& b, unsigned p);
     Reference(const Null& b, const UString& p);
+    Reference(const Null& b, unsigned p);
     Reference(ReferenceImp *v);
-    Reference(const Reference &v);
-    virtual ~Reference();
-
-    Reference& operator=(const Reference &v);
 
     /**
@@ -72 +70 @@
     ListIterator(const List &l);
     /**
-     * Assignment constructor.
-     */
-    ListIterator& operator=(const ListIterator &iterator);
-    /**
-     * Copy constructor.
-     */
-    ListIterator(const ListIterator &i);
-    ~ListIterator();
-    /**
      * Dereference the iterator.
      * @return A pointer to the element the iterator operates on.
@@ -139 +128 @@
     List();
     List(ListImp *v);
-    List(const List &v);
-    virtual ~List();
-
-    List& operator=(const List &v);
 
     /**
@@ -255 +240 @@
                const UString &t = UString::null);
     Completion(CompletionImp *v);
-    Completion(const Completion &v);
-    virtual ~Completion();
-
-    Completion& operator=(const Completion &v);
 
     /**

trunk/JavaScriptCore/kjs/ustring.cpp

@@ -116 +116 @@
 UChar UChar::null;
 UString::Rep UString::Rep::null = { 0, 0, 0, 1 };
+UString::Rep UString::Rep::empty = { 0, 0, 0, 1 };
 UString UString::null;
 const int normalStatBufferSize = 4096;
@@ -191 +192 @@
   }
   int length = strlen(c);
+  if (length == 0) {
+    attach(&Rep::empty);
+    return;
+  }
   UChar *d = new UChar[length];
   for (int i = 0; i < length; i++)
@@ -199 +204 @@
 UString::UString(const UChar *c, int length)
 {
+  if (length == 0) {
+    attach(&Rep::empty);
+    return;
+  }
   UChar *d = new UChar[length];
   memcpy(d, c, length * sizeof(UChar));
@@ -206 +215 @@
 UString::UString(UChar *c, int length, bool copy)
 {
+  if (length == 0) {
+    attach(&Rep::empty);
+    return;
+  }
   UChar *d;
   if (copy) {
@@ -224 +237 @@
   int aSize = a.size();
   int bSize = b.size();
-  UChar *d = new UChar[aSize + bSize];
+  int length = aSize + bSize;
+  if (length == 0) {
+    attach(&Rep::empty);
+    return;
+  }
+  UChar *d = new UChar[length];
   memcpy(d, a.data(), aSize * sizeof(UChar));
   memcpy(d + aSize, b.data(), bSize * sizeof(UChar));
-  rep = Rep::create(d, aSize + bSize);
+  rep = Rep::create(d, length);
 }
 
@@ -467 +485 @@
 int UString::find(const UString &f, int pos) const
 {
-  if (isNull())
+  if (size() < f.size())
     return -1;
-  long fsize = f.size() * sizeof(UChar);
   if (pos < 0)
     pos = 0;
   const UChar *end = data() + size() - f.size();
+  long fsize = f.size() * sizeof(UChar);
+  const void *fdata = f.data();
   for (const UChar *c = data() + pos; c <= end; c++)
-    if (!memcmp((void*)c, (void*)f.data(), fsize))
+    if (!memcmp(c, fdata, fsize))
       return (c-data());
 
@@ -480 +499 @@
 }
 
+int UString::find(UChar ch, int pos) const
+{
+  if (pos < 0)
+    pos = 0;
+  const UChar *end = data() + size();
+  for (const UChar *c = data() + pos; c < end; c++)
+    if (*c == ch)
+      return (c-data());
+
+  return -1;
+}
+
 int UString::rfind(const UString &f, int pos) const
 {
-  if (isNull())
+  if (size() < f.size())
     return -1;
   if (pos + f.size() >= size())
     pos = size() - f.size();
   long fsize = f.size() * sizeof(UChar);
+  const void *fdata = f.data();
   for (const UChar *c = data() + pos; c >= data(); c--) {
-    if (!memcmp((void*)c, (void*)f.data(), fsize))
+    if (!memcmp(c, fdata, fsize))
       return (c-data());
   }
@@ -495 +527 @@
 }
 
+int UString::rfind(UChar ch, int pos) const
+{
+  if (isEmpty())
+    return -1;
+  if (pos + 1 >= size())
+    pos = size() - 1;
+  for (const UChar *c = data() + pos; c >= data(); c--) {
+    if (*c == ch)
+      return (c-data());
+  }
+
+  return -1;
+}
+
 UString UString::substr(int pos, int len) const
 {
-  if (isNull())
-    return UString();
   if (pos < 0)
     pos = 0;
@@ -552 +596 @@
 bool KJS::operator==(const UString& s1, const char *s2)
 {
-  if (s2 == 0L && s1.isNull())
-    return true;
-
-  if (s1.size() != (int) strlen(s2))
+  if (s2 == 0) {
+    return s1.isEmpty();
+  }
+
+  if (s1.size() != (int)strlen(s2))
     return false;
 
   const UChar *u = s1.data();
   while (*s2) {
-    if (u->uc != *s2 )
+    if (u->uc != (unsigned char)*s2)
       return false;
     s2++;
@@ -583 +628 @@
   }
   if (l < lmin)
-    return (c1->unicode() < c2->unicode());
+    return (c1->uc < c2->uc);
 
   return (l1 < l2);

trunk/JavaScriptCore/kjs/ustring.h

@@ -216 +216 @@
       int rc;
       static Rep null;
+      static Rep empty;
     };
 
@@ -226 +227 @@
      * Constructs a string from the single character c.
      */
-    UString(char c);
+    explicit UString(char c);
     /**
      * Constructs a string from a classical zero determined char string.
@@ -316 +317 @@
      */
     UString &operator=(const char *c);
-    /**
-     * Assignment operator.
-     */
     UString &operator=(const UString &);
     /**
@@ -376 +374 @@
      */
     int find(const UString &f, int pos = 0) const;
+    int find(UChar, int pos = 0) const;
     /**
      * @return Position of first occurence of f searching backwards from
@@ -382 +381 @@
      */
     int rfind(const UString &f, int pos) const;
+    int rfind(UChar, int pos) const;
     /**
      * @return The sub string starting at position pos and length len.

trunk/JavaScriptCore/kjs/value.cpp

@@ -83 +83 @@
 }
 
+bool ValueImp::toUInt32(unsigned&) const
+{
+  return false;
+}
+
 // ECMA 9.4
 int ValueImp::toInteger(ExecState *exec) const
 {
+  unsigned i;
+  if (toUInt32(i))
+    return (int)i;
   return int(roundValue(exec, Value(const_cast<ValueImp*>(this))));
 }
@@ -91 +99 @@
 int ValueImp::toInt32(ExecState *exec) const
 {
+  unsigned i;
+  if (toUInt32(i))
+    return (int)i;
+
   double d = roundValue(exec, Value(const_cast<ValueImp*>(this)));
   double d32 = fmod(d, D32);
@@ -102 +114 @@
 unsigned int ValueImp::toUInt32(ExecState *exec) const
 {
+  unsigned i;
+  if (toUInt32(i))
+    return i;
+
   double d = roundValue(exec, Value(const_cast<ValueImp*>(this)));
   double d32 = fmod(d, D32);
@@ -110 +126 @@
 unsigned short ValueImp::toUInt16(ExecState *exec) const
 {
+  unsigned i;
+  if (toUInt32(i))
+    return (unsigned short)i;
+
   double d = roundValue(exec, Value(const_cast<ValueImp*>(this)));
   double d16 = fmod(d, D16);
@@ -119 +139 @@
 Value ValueImp::getBase(ExecState *exec) const
 {
-  if (type() != ReferenceType) {
-    Object err = Error::create(exec, ReferenceError, I18N_NOOP("Invalid reference base"));
-    exec->setException(err);
-    return err;
-  }
-
-  return (static_cast<const ReferenceImp*>(this))->getBase();
+  Object err = Error::create(exec, ReferenceError, I18N_NOOP("Invalid reference base"));
+  exec->setException(err);
+  return err;
 }
 
@@ -131 +147 @@
 UString ValueImp::getPropertyName(ExecState * /*exec*/) const
 {
-  if (type() != ReferenceType)
-    // the spec wants a runtime error here. But getValue() and putValue()
-    // will catch this case on their own earlier. When returning a Null
-    // string we should be on the safe side.
-    return UString();
-
-  return (static_cast<const ReferenceImp*>(this))->getPropertyName();
+  // the spec wants a runtime error here. But getValue() and putValue()
+  // will catch this case on their own earlier. When returning a Null
+  // string we should be on the safe side.
+  return UString();
 }
 
@@ -143 +156 @@
 Value ValueImp::getValue(ExecState *exec) const
 {
-  if (type() != ReferenceType)
-    return Value(const_cast<ValueImp*>(this));
-
-  Value o = getBase(exec);
-
-  if (o.isNull() || o.type() == NullType) {
-    UString m = I18N_NOOP("Can't find variable: ") + getPropertyName(exec);
-    Object err = Error::create(exec, ReferenceError, m.ascii());
-    exec->setException(err);
-    return err;
-  }
-
-  if (o.type() != ObjectType) {
-    UString m = I18N_NOOP("Base is not an object");
-    Object err = Error::create(exec, ReferenceError, m.ascii());
-    exec->setException(err);
-    return err;
-  }
-
-  return static_cast<ObjectImp*>(o.imp())->get(exec,getPropertyName(exec));
-}
-
-void ValueImp::putValue(ExecState *exec, const Value w)
-{
-  if (type() != ReferenceType) {
-    Object err = Error::create(exec,ReferenceError);
-    exec->setException(err);
-    return;
-  }
-
-#ifdef KJS_VERBOSE
-  printInfo(exec,(UString("setting property ")+getPropertyName(exec)).cstring().c_str(),w);
-#endif
-  Value o = getBase(exec);
-  if (o.type() == NullType)
-    exec->interpreter()->globalObject().put(exec,getPropertyName(exec), w);
-  else {
-    static_cast<ObjectImp*>(o.imp())->put(exec,getPropertyName(exec), w);
-  }
-
-  return;
-}
-
-bool KJS::operator==(const Value &v1, const Value &v2)
-{
-  return (v1.imp() == v2.imp());
-}
-
-bool KJS::operator!=(const Value &v1, const Value &v2)
-{
-  return (v1.imp() != v2.imp());
-}
-
-
-
+  return Value(const_cast<ValueImp*>(this));
+}
+
+void ValueImp::putValue(ExecState *exec, const Value& w)
+{
+  Object err = Error::create(exec,ReferenceError);
+  exec->setException(err);
+}
+
+bool ValueImp::deleteValue(ExecState *exec)
+{
+  Object err = Error::create(exec,ReferenceError);
+  exec->setException(err);
+  return false;
+}
 
 // ------------------------------ Value ----------------------------------------
-
-Value::Value()
-{
-  rep = 0;
-}
 
 Value::Value(ValueImp *v)
@@ -251 +219 @@
 }
 
-bool Value::isNull() const
-{
-  return (rep == 0);
-}
-
-ValueImp *Value::imp() const
-{
-  return rep;
-}
-
-Type Value::type() const
-{
-  return rep->type();
-}
-
-bool Value::isA(Type t) const
-{
-  return (type() == t);
-}
-
-Value Value::toPrimitive(ExecState *exec, Type preferredType) const
-{
-  return rep->toPrimitive(exec,preferredType);
-}
-
-bool Value::toBoolean(ExecState *exec) const
-{
-  return rep->toBoolean(exec);
-}
-
-double Value::toNumber(ExecState *exec) const
-{
-  return rep->toNumber(exec);
-}
-
-int Value::toInteger(ExecState *exec) const
-{
-  return rep->toInteger(exec);
-}
-
-int Value::toInt32(ExecState *exec) const
-{
-  return rep->toInt32(exec);
-}
-
-unsigned int Value::toUInt32(ExecState *exec) const
-{
-  return rep->toUInt32(exec);
-}
-
-unsigned short Value::toUInt16(ExecState *exec) const
-{
-  return rep->toUInt16(exec);
-}
-
-UString Value::toString(ExecState *exec) const
-{
-  return rep->toString(exec);
-}
-
-Object Value::toObject(ExecState *exec) const
-{
-  return rep->toObject(exec);
-}
-
-Value Value::getBase(ExecState *exec) const
-{
-  return rep->getBase(exec);
-}
-
-UString Value::getPropertyName(ExecState *exec) const
-{
-  return rep->getPropertyName(exec);
-}
-
-Value Value::getValue(ExecState *exec) const
-{
-  return rep->getValue(exec);
-}
-
-void Value::putValue(ExecState *exec, const Value w)
-{
-  rep->putValue(exec,w);
-}
-
 // ------------------------------ Undefined ------------------------------------
 
 Undefined::Undefined() : Value(UndefinedImp::staticUndefined)
 {
-}
-
-Undefined::~Undefined() {
-}
-
-Undefined::Undefined(UndefinedImp *v) : Value(v)
-{
-}
-
-Undefined::Undefined(const Undefined &v) : Value(v)
-{
-}
-
-Undefined& Undefined::operator=(const Undefined &v)
-{
-  Value::operator=(v);
-  return *this;
 }
 
@@ -373 +239 @@
 }
 
-Null::~Null() {
-}
-
-
-Null::Null(NullImp *v) : Value(v)
-{
-}
-
-Null::Null(const Null &v) : Value(v)
-{
-}
-
-Null& Null::operator=(const Null &v)
-{
-  Value::operator=(v);
-  return *this;
-}
-
 Null Null::dynamicCast(const Value &v)
 {
@@ -406 +254 @@
 }
 
-Boolean::~Boolean() { }
-
-
-
-Boolean::Boolean(BooleanImp *v) : Value(v)
-{
-}
-
-Boolean::Boolean(const Boolean &v) : Value(v)
-{
-}
-
-Boolean& Boolean::operator=(const Boolean &v)
-{
-  Value::operator=(v);
-  return *this;
-}
-
-
 bool Boolean::value() const
 {
@@ -445 +274 @@
 }
 
-String::~String() { }
-
-String::String(StringImp *v) : Value(v)
-{
-}
-
-String::String(const String &v) : Value(v)
-{
-}
-
-String& String::operator=(const String &v)
-{
-  Value::operator=(v);
-  return *this;
-}
-
 UString String::value() const
 {
@@ -492 +305 @@
   : Value(new NumberImp(static_cast<double>(l))) { }
 
-Number::~Number() { }
-
-Number::Number(NumberImp *v) : Value(v)
-{
-}
-
-Number::Number(const Number &v) : Value(v)
-{
-}
-
-Number& Number::operator=(const Number &v)
-{
-  Value::operator=(v);
-  return *this;
-}
-
 Number Number::dynamicCast(const Value &v)
 {
@@ -536 +333 @@
   return KJS::isInf(value());
 }
-

trunk/JavaScriptCore/kjs/value.h

@@ -115 +115 @@
     // The conversion operations
 
-    virtual Value toPrimitive(ExecState *exec,
-                              Type preferredType = UnspecifiedType) const = 0;
+    virtual Value toPrimitive(ExecState *exec, Type preferredType = UnspecifiedType) const = 0;
     virtual bool toBoolean(ExecState *exec) const = 0;
     virtual double toNumber(ExecState *exec) const = 0;
-    virtual int toInteger(ExecState *exec) const;
-    virtual int toInt32(ExecState *exec) const;
-    virtual unsigned int toUInt32(ExecState *exec) const;
-    virtual unsigned short toUInt16(ExecState *exec) const;
     virtual UString toString(ExecState *exec) const = 0;
     virtual Object toObject(ExecState *exec) const = 0;
+
+    virtual bool toUInt32(unsigned&) const;
+    
+    int toInteger(ExecState *exec) const;
+    int toInt32(ExecState *exec) const;
+    unsigned int toUInt32(ExecState *exec) const;
+    unsigned short toUInt16(ExecState *exec) const;
 
     // Reference operations
@@ -131 +133 @@
     virtual UString getPropertyName(ExecState *exec) const;
     virtual Value getValue(ExecState *exec) const;
-    virtual void putValue(ExecState *exec, const Value w);
+    virtual void putValue(ExecState *exec, const Value& w);
+    virtual bool deleteValue(ExecState *exec);
 
   private:
@@ -143 +146 @@
     ValueImpPrivate *_vd;
     unsigned int _flags;
+    
+    // Give a compile time error if we try to copy one of these.
+    ValueImp(const ValueImp&);
+    ValueImp& operator=(const ValueImp&);
   };
 
@@ -162 +169 @@
   class Value {
   public:
-    Value();
+    Value() : rep(0) { }
     explicit Value(ValueImp *v);
     Value(const Value &v);
-    virtual ~Value();
+    ~Value();
 
     Value& operator=(const Value &v);
-    bool isNull() const;
-    ValueImp *imp() const;
+    bool isNull() const { return rep == 0; }
+    ValueImp *imp() const { return rep; }
 
     /**
@@ -178 +185 @@
      * @return The type of value
      */
-    Type type() const;
+    Type type() const { return rep->type(); }
 
     /**
@@ -186 +193 @@
      * @return true if the value is of the specified type, otherwise false
      */
-    bool isA(Type t) const;
+    bool isA(Type t) const { return rep->type() == t; }
 
     /**
@@ -193 +200 @@
      */
     Value toPrimitive(ExecState *exec,
-                      Type preferredType = UnspecifiedType) const;
+                      Type preferredType = UnspecifiedType) const
+      { return rep->toPrimitive(exec, preferredType); }
 
     /**
      * Performs the ToBoolean type conversion operation on this value (ECMA 9.2)
      */
-    bool toBoolean(ExecState *exec) const;
+    bool toBoolean(ExecState *exec) const { return rep->toBoolean(exec); }
 
     /**
      * Performs the ToNumber type conversion operation on this value (ECMA 9.3)
      */
-    double toNumber(ExecState *exec) const;
+    double toNumber(ExecState *exec) const { return rep->toNumber(exec); }
 
     /**
      * Performs the ToInteger type conversion operation on this value (ECMA 9.4)
      */
-    int toInteger(ExecState *exec) const;
+    int toInteger(ExecState *exec) const { return rep->toInteger(exec); }
 
     /**
      * Performs the ToInt32 type conversion operation on this value (ECMA 9.5)
      */
-    int toInt32(ExecState *exec) const;
+    int toInt32(ExecState *exec) const { return rep->toInt32(exec); }
 
     /**
      * Performs the ToUint32 type conversion operation on this value (ECMA 9.6)
      */
-    unsigned int toUInt32(ExecState *exec) const;
+    unsigned int toUInt32(ExecState *exec) const { return rep->toUInt32(exec); }
 
     /**
      * Performs the ToUint16 type conversion operation on this value (ECMA 9.7)
      */
-    unsigned short toUInt16(ExecState *exec) const;
+    unsigned short toUInt16(ExecState *exec) const { return rep->toUInt16(exec); }
 
     /**
      * Performs the ToString type conversion operation on this value (ECMA 9.8)
      */
-    UString toString(ExecState *exec) const;
+    UString toString(ExecState *exec) const { return rep->toString(exec); }
 
     /**
@@ -241 +249 @@
      * this method is guaranteed to return either Null() or an Object value.
      */
-    Value getBase(ExecState *exec) const;
+    Value getBase(ExecState *exec) const { return rep->getBase(exec); }
 
     /**
@@ -247 +255 @@
      * (ECMA 8.7)
      */
-    UString getPropertyName(ExecState *exec) const;
+    UString getPropertyName(ExecState *exec) const { return rep->getPropertyName(exec); }
 
     /**
@@ -253 +261 @@
      * (ECMA 8.7.1)
      */
-    Value getValue(ExecState *exec) const;
+    Value getValue(ExecState *exec) const { return rep->getValue(exec); }
 
     /**
@@ -259 +267 @@
      * (ECMA 8.7.1)
      */
-    void putValue(ExecState *exec, const Value w);
+    void putValue(ExecState *exec, const Value &w) { rep->putValue(exec, w); }
+    bool deleteValue(ExecState *exec) { return rep->deleteValue(exec); }
+
+    /**
+     * Checks if we can do a lossless conversion to UInt32.
+     */
+    bool toUInt32(unsigned& i) const { return rep->toUInt32(i); }
 
   protected:
     ValueImp *rep;
   };
-
-  bool operator==(const Value &v1, const Value &v2);
-  bool operator!=(const Value &v1, const Value &v2);
 
   // Primitive types
@@ -278 +289 @@
   public:
     Undefined();
-    Undefined(const Undefined &v);
-    virtual ~Undefined();
-
-    Undefined& operator=(const Undefined &v);
 
     /**
@@ -307 +314 @@
   public:
     Null();
-    Null(const Null &v);
-    virtual ~Null();
-
-    Null& operator=(const Null &v);
 
     /**
@@ -333 +336 @@
   public:
     Boolean(bool b = false);
-    Boolean(const Boolean &v);
-    virtual ~Boolean();
-
-    Boolean& operator=(const Boolean &v);
 
     /**
@@ -361 +360 @@
   public:
     String(const UString &s = "");
-    String(const String &v);
-    virtual ~String();
-
-    String& operator=(const String &v);
 
     /**
@@ -396 +391 @@
     Number(long int l);
     Number(long unsigned int l);
-    Number(const Number &v);
-    virtual ~Number();
-
-    Number& operator=(const Number &v);
 
     double value() const;