Changeset 12523 in webkit for trunk/JavaScriptCore/kjs/property_map.cpp

Timestamp:

Feb 2, 2006, 12:22:43 AM (19 years ago)

Author:

darin

Message:

Reviewed by Maciej.

• ​http://bugzilla.opendarwin.org/show_bug.cgi?id=7005 add Noncopyable, OwnPtr, OwnArrayPtr to KXMLCore

• kxmlcore/Noncopyable.h: Added.
• kxmlcore/OwnArrayPtr.h: Added.
• kxmlcore/OwnPtr.h: Added.

• JavaScriptCore.xcodeproj/project.pbxproj: Added new files.

• kjs/function.h:
• kjs/function.cpp: Use OwnPtr for Parameter pointers.

• kjs/internal.h: Use Noncopyable for LabelStack.

• kjs/list.cpp: Use OwnArrayPtr for overflow.

• kjs/property_map.h:
• kjs/property_map.cpp: Use OwnArrayPtr for SavedProperties. Use Vector for some stack buffers.

• kjs/regexp_object.h:
• kjs/regexp_object.cpp: Use OwnArrayPtr for lastOvector.

File:

• trunk/JavaScriptCore/kjs/property_map.cpp (modified) (8 diffs)

trunk/JavaScriptCore/kjs/property_map.cpp

@@ -1 +1 @@
 /*
  *  This file is part of the KDE libraries
- *  Copyright (C) 2004 Apple Computer, Inc.
+ *  Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
  *
  *  This library is free software; you can redistribute it and/or
@@ -23 +23 @@
 #include "property_map.h"
 
-#include <kxmlcore/FastMalloc.h>
 #include "object.h"
 #include "protect.h"
 #include "reference_list.h"
-
 #include <algorithm>
+#include <kxmlcore/FastMalloc.h>
+#include <kxmlcore/Vector.h>
 
 using std::max;
@@ -95 +95 @@
 };
 
-SavedProperties::SavedProperties() : _count(0), _properties(0) { }
-
-SavedProperties::~SavedProperties()
-{
-    delete [] _properties;
-}
+SavedProperties::SavedProperties() : _count(0) { }
+SavedProperties::~SavedProperties() { }
 
 // Algorithm concepts from Algorithms in C++, Sedgewick.
@@ -598 +594 @@
 
     // Allocate a buffer to use to sort the keys.
-    Entry *fixedSizeBuffer[smallMapThreshold];
-    Entry **sortedEnumerables;
-    if (_table->keyCount <= smallMapThreshold)
-        sortedEnumerables = fixedSizeBuffer;
-    else
-        sortedEnumerables = new Entry *[_table->keyCount];
+    Vector<Entry*, smallMapThreshold> sortedEnumerables(_table->keyCount);
 
     // Get pointers to the enumerable entries in the buffer.
-    Entry **p = sortedEnumerables;
+    Entry** p = sortedEnumerables.data();
     int size = _table->size;
-    Entry *entries = _table->entries;
+    Entry* entries = _table->entries;
     for (int i = 0; i != size; ++i) {
-        Entry *e = &entries[i];
+        Entry* e = &entries[i];
         if (e->key && !(e->attributes & DontEnum))
             *p++ = e;
@@ -616 +607 @@
 
     // Sort the entries by index.
-    qsort(sortedEnumerables, p - sortedEnumerables, sizeof(sortedEnumerables[0]), comparePropertyMapEntryIndices);
+    qsort(sortedEnumerables.data(), p - sortedEnumerables.data(), sizeof(Entry*), comparePropertyMapEntryIndices);
 
     // Put the keys of the sorted entries into the reference list.
-    Entry **q = sortedEnumerables;
-    while (q != p)
-        list.append(Reference(base, Identifier((*q++)->key)));
-
-    // Deallocate the buffer.
-    if (sortedEnumerables != fixedSizeBuffer)
-        delete [] sortedEnumerables;
+    for (Entry** q = sortedEnumerables.data(); q != p; ++q)
+        list.append(Reference(base, Identifier((*q)->key)));
 }
 
@@ -675 +661 @@
     }
 
-    delete [] p._properties;
-
+    p._properties.clear();
     p._count = count;
 
-    if (count == 0) {
-        p._properties = 0;
-        return;
-    }
-    
-    p._properties = new SavedProperty [count];
-    
-    SavedProperty *prop = p._properties;
+    if (count == 0)
+        return;
+    
+    p._properties.set(new SavedProperty [count]);
+    
+    SavedProperty *prop = p._properties.get();
     
     if (!_table) {
@@ -702 +685 @@
 
         // Allocate a buffer to use to sort the keys.
-        Entry *fixedSizeBuffer[smallMapThreshold];
-        Entry **sortedEntries;
-        if (count <= smallMapThreshold)
-            sortedEntries = fixedSizeBuffer;
-        else
-            sortedEntries = new Entry *[count];
+        Vector<Entry*, smallMapThreshold> sortedEntries(count);
 
         // Get pointers to the entries in the buffer.
-        Entry **p = sortedEntries;
+        Entry** p = sortedEntries.data();
         int size = _table->size;
-        Entry *entries = _table->entries;
+        Entry* entries = _table->entries;
         for (int i = 0; i != size; ++i) {
             Entry *e = &entries[i];
@@ -718 +696 @@
                 *p++ = e;
         }
-        assert(p - sortedEntries == count);
+        assert(p - sortedEntries.data() == count);
 
         // Sort the entries by index.
-        qsort(sortedEntries, p - sortedEntries, sizeof(sortedEntries[0]), comparePropertyMapEntryIndices);
+        qsort(sortedEntries.data(), p - sortedEntries.data(), sizeof(Entry*), comparePropertyMapEntryIndices);
 
         // Put the sorted entries into the saved properties list.
-        Entry **q = sortedEntries;
-        while (q != p) {
-            Entry *e = *q++;
+        for (Entry** q = sortedEntries.data(); q != p; ++q, ++prop) {
+            Entry* e = *q;
             prop->key = Identifier(e->key);
             prop->value = e->value;
             prop->attributes = e->attributes;
-            ++prop;
-        }
-
-        // Deallocate the buffer.
-        if (sortedEntries != fixedSizeBuffer)
-            delete [] sortedEntries;
+        }
     }
 }