template<class Derived, class Iterator, int entrysize>
-int OrderedHashTable<Derived, Iterator, entrysize>::FindEntry(Object* key) {
+int OrderedHashTable<Derived, Iterator, entrysize>::FindEntry(
+ Handle<Object> key) {
+ DisallowHeapAllocation no_gc;
ASSERT(!key->IsTheHole());
Object* hash = key->GetHash();
if (hash->IsUndefined()) return kNotFound;
entry != kNotFound;
entry = ChainAt(entry)) {
Object* candidate = KeyAt(entry);
- if (candidate->SameValue(key))
+ if (candidate->SameValue(*key))
return entry;
}
return kNotFound;
Handle<OrderedHashSet> table);
template int
-OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::FindEntry(Object* key);
+OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::FindEntry(
+ Handle<Object> key);
template int
OrderedHashTable<OrderedHashSet, JSSetIterator, 1>::AddEntry(int hash);
Handle<OrderedHashMap> table);
template int
-OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::FindEntry(Object* key);
+OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::FindEntry(
+ Handle<Object> key);
template int
OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::AddEntry(int hash);
OrderedHashTable<OrderedHashMap, JSMapIterator, 2>::RemoveEntry(int entry);
-bool OrderedHashSet::Contains(Object* key) {
+bool OrderedHashSet::Contains(Handle<Object> key) {
return FindEntry(key) != kNotFound;
}
Handle<OrderedHashSet> OrderedHashSet::Add(Handle<OrderedHashSet> table,
Handle<Object> key) {
- if (table->FindEntry(*key) != kNotFound) return table;
+ if (table->FindEntry(key) != kNotFound) return table;
table = EnsureGrowable(table);
Handle<OrderedHashSet> OrderedHashSet::Remove(Handle<OrderedHashSet> table,
Handle<Object> key) {
- int entry = table->FindEntry(*key);
+ int entry = table->FindEntry(key);
if (entry == kNotFound) return table;
table->RemoveEntry(entry);
return Shrink(table);
Object* OrderedHashMap::Lookup(Handle<Object> key) {
DisallowHeapAllocation no_gc;
- int entry = FindEntry(*key);
+ int entry = FindEntry(key);
if (entry == kNotFound) return GetHeap()->the_hole_value();
return ValueAt(entry);
}
Handle<OrderedHashMap> OrderedHashMap::Put(Handle<OrderedHashMap> table,
Handle<Object> key,
Handle<Object> value) {
- int entry = table->FindEntry(*key);
+ int entry = table->FindEntry(key);
if (value->IsTheHole()) {
if (entry == kNotFound) return table;
static Handle<Derived> Clear(Handle<Derived> table);
// Returns kNotFound if the key isn't present.
- int FindEntry(Object* key);
+ int FindEntry(Handle<Object> key);
int NumberOfElements() {
return Smi::cast(get(kNumberOfElementsIndex))->value();
return reinterpret_cast<OrderedHashSet*>(obj);
}
- bool Contains(Object* key);
+ bool Contains(Handle<Object> key);
static Handle<OrderedHashSet> Add(
Handle<OrderedHashSet> table, Handle<Object> key);
static Handle<OrderedHashSet> Remove(
CONVERT_ARG_HANDLE_CHECKED(JSSet, holder, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<OrderedHashSet> table(OrderedHashSet::cast(holder->table()));
- return isolate->heap()->ToBoolean(table->Contains(*key));
+ return isolate->heap()->ToBoolean(table->Contains(key));
}
Handle<JSObject> value = factory->NewJSArray(11);
table = HashMap::Put(table, key, value);
CHECK_EQ(table->NumberOfElements(), i + 1);
- CHECK_NE(table->FindEntry(*key), HashMap::kNotFound);
+ CHECK_NE(table->FindEntry(key), HashMap::kNotFound);
CHECK_EQ(table->Lookup(key), *value);
CHECK(key->GetIdentityHash()->IsSmi());
}
for (int i = 0; i < 100; i++) {
Handle<JSReceiver> key = factory->NewJSArray(7);
CHECK(JSReceiver::GetOrCreateIdentityHash(key)->IsSmi());
- CHECK_EQ(table->FindEntry(*key), HashMap::kNotFound);
+ CHECK_EQ(table->FindEntry(key), HashMap::kNotFound);
CHECK_EQ(table->Lookup(key), CcTest::heap()->the_hole_value());
CHECK(key->GetIdentityHash()->IsSmi());
}
// Calling Contains() should not cause GC ever.
int gc_count = isolate->heap()->gc_count();
- CHECK(!table->Contains(*key));
+ CHECK(!table->Contains(key));
CHECK(gc_count == isolate->heap()->gc_count());
// Calling Remove() will not cause GC in this case.
Handle<Map> map = factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
Handle<JSObject> obj = factory->NewJSObjectFromMap(map);
- CHECK(!ordered_set->Contains(*obj));
+ CHECK(!ordered_set->Contains(obj));
ordered_set = OrderedHashSet::Add(ordered_set, obj);
CHECK_EQ(1, ordered_set->NumberOfElements());
- CHECK(ordered_set->Contains(*obj));
+ CHECK(ordered_set->Contains(obj));
ordered_set = OrderedHashSet::Remove(ordered_set, obj);
CHECK_EQ(0, ordered_set->NumberOfElements());
- CHECK(!ordered_set->Contains(*obj));
+ CHECK(!ordered_set->Contains(obj));
// Test for collisions/chaining
Handle<JSObject> obj1 = factory->NewJSObjectFromMap(map);
Handle<JSObject> obj3 = factory->NewJSObjectFromMap(map);
ordered_set = OrderedHashSet::Add(ordered_set, obj3);
CHECK_EQ(3, ordered_set->NumberOfElements());
- CHECK(ordered_set->Contains(*obj1));
- CHECK(ordered_set->Contains(*obj2));
- CHECK(ordered_set->Contains(*obj3));
+ CHECK(ordered_set->Contains(obj1));
+ CHECK(ordered_set->Contains(obj2));
+ CHECK(ordered_set->Contains(obj3));
// Test iteration
CheckIterResultObject(
ordered_set = OrderedHashSet::Add(ordered_set, obj);
Handle<JSObject> obj4 = factory->NewJSObjectFromMap(map);
ordered_set = OrderedHashSet::Add(ordered_set, obj4);
- CHECK(ordered_set->Contains(*obj));
- CHECK(ordered_set->Contains(*obj1));
- CHECK(ordered_set->Contains(*obj2));
- CHECK(ordered_set->Contains(*obj3));
- CHECK(ordered_set->Contains(*obj4));
+ CHECK(ordered_set->Contains(obj));
+ CHECK(ordered_set->Contains(obj1));
+ CHECK(ordered_set->Contains(obj2));
+ CHECK(ordered_set->Contains(obj3));
+ CHECK(ordered_set->Contains(obj4));
CHECK_EQ(5, ordered_set->NumberOfElements());
CHECK_EQ(0, ordered_set->NumberOfDeletedElements());
CHECK_EQ(4, ordered_set->NumberOfBuckets());