OLD | NEW |
1 // Copyright 2013 the V8 project authors. All rights reserved. | 1 // Copyright 2013 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/v8.h" | 5 #include "src/v8.h" |
6 | 6 |
7 #include "src/accessors.h" | 7 #include "src/accessors.h" |
8 #include "src/allocation-site-scopes.h" | 8 #include "src/allocation-site-scopes.h" |
9 #include "src/api.h" | 9 #include "src/api.h" |
10 #include "src/arguments.h" | 10 #include "src/arguments.h" |
(...skipping 16211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
16222 | 16222 |
16223 Handle<Smi> hash = GetOrCreateHash(table->GetIsolate(), key); | 16223 Handle<Smi> hash = GetOrCreateHash(table->GetIsolate(), key); |
16224 int index = table->AddEntry(hash->value()); | 16224 int index = table->AddEntry(hash->value()); |
16225 table->set(index, *key); | 16225 table->set(index, *key); |
16226 table->set(index + kValueOffset, *value); | 16226 table->set(index + kValueOffset, *value); |
16227 return table; | 16227 return table; |
16228 } | 16228 } |
16229 | 16229 |
16230 | 16230 |
16231 template<class Derived, class TableType> | 16231 template<class Derived, class TableType> |
16232 Handle<JSObject> OrderedHashTableIterator<Derived, TableType>::Next( | |
16233 Handle<Derived> iterator) { | |
16234 Isolate* isolate = iterator->GetIsolate(); | |
16235 Factory* factory = isolate->factory(); | |
16236 | |
16237 Handle<Object> maybe_table(iterator->table(), isolate); | |
16238 if (!maybe_table->IsUndefined()) { | |
16239 iterator->Transition(); | |
16240 | |
16241 Handle<TableType> table(TableType::cast(iterator->table()), isolate); | |
16242 int index = Smi::cast(iterator->index())->value(); | |
16243 int used_capacity = table->UsedCapacity(); | |
16244 | |
16245 while (index < used_capacity && table->KeyAt(index)->IsTheHole()) { | |
16246 index++; | |
16247 } | |
16248 | |
16249 if (index < used_capacity) { | |
16250 int entry_index = table->EntryToIndex(index); | |
16251 Handle<Object> value = | |
16252 Derived::ValueForKind(iterator, entry_index); | |
16253 iterator->set_index(Smi::FromInt(index + 1)); | |
16254 return factory->NewIteratorResultObject(value, false); | |
16255 } | |
16256 | |
16257 iterator->set_table(iterator->GetHeap()->undefined_value()); | |
16258 } | |
16259 | |
16260 return factory->NewIteratorResultObject(factory->undefined_value(), true); | |
16261 } | |
16262 | |
16263 | |
16264 template<class Derived, class TableType> | |
16265 void OrderedHashTableIterator<Derived, TableType>::Transition() { | 16232 void OrderedHashTableIterator<Derived, TableType>::Transition() { |
16266 Isolate* isolate = GetIsolate(); | 16233 DisallowHeapAllocation no_allocation; |
16267 Handle<TableType> table(TableType::cast(this->table()), isolate); | 16234 TableType* table = TableType::cast(this->table()); |
16268 if (!table->IsObsolete()) return; | 16235 if (!table->IsObsolete()) return; |
16269 | 16236 |
16270 int index = Smi::cast(this->index())->value(); | 16237 int index = Smi::cast(this->index())->value(); |
16271 while (table->IsObsolete()) { | 16238 while (table->IsObsolete()) { |
16272 Handle<TableType> next_table(table->NextTable(), isolate); | 16239 TableType* next_table = table->NextTable(); |
16273 | 16240 |
16274 if (index > 0) { | 16241 if (index > 0) { |
16275 int nod = table->NumberOfDeletedElements(); | 16242 int nod = table->NumberOfDeletedElements(); |
16276 | 16243 |
16277 // When we clear the table we set the number of deleted elements to -1. | 16244 // When we clear the table we set the number of deleted elements to -1. |
16278 if (nod == -1) { | 16245 if (nod == -1) { |
16279 index = 0; | 16246 index = 0; |
16280 } else { | 16247 } else { |
16281 int old_index = index; | 16248 int old_index = index; |
16282 for (int i = 0; i < nod; ++i) { | 16249 for (int i = 0; i < nod; ++i) { |
16283 int removed_index = table->RemovedIndexAt(i); | 16250 int removed_index = table->RemovedIndexAt(i); |
16284 if (removed_index >= old_index) break; | 16251 if (removed_index >= old_index) break; |
16285 --index; | 16252 --index; |
16286 } | 16253 } |
16287 } | 16254 } |
16288 } | 16255 } |
16289 | 16256 |
16290 table = next_table; | 16257 table = next_table; |
16291 } | 16258 } |
16292 | 16259 |
16293 set_table(*table); | 16260 set_table(table); |
16294 set_index(Smi::FromInt(index)); | 16261 set_index(Smi::FromInt(index)); |
16295 } | 16262 } |
16296 | 16263 |
16297 | 16264 |
16298 template Handle<JSObject> | 16265 template<class Derived, class TableType> |
| 16266 bool OrderedHashTableIterator<Derived, TableType>::HasMore() { |
| 16267 DisallowHeapAllocation no_allocation; |
| 16268 if (this->table()->IsUndefined()) return false; |
| 16269 |
| 16270 Transition(); |
| 16271 |
| 16272 TableType* table = TableType::cast(this->table()); |
| 16273 int index = Smi::cast(this->index())->value(); |
| 16274 int used_capacity = table->UsedCapacity(); |
| 16275 |
| 16276 while (index < used_capacity && table->KeyAt(index)->IsTheHole()) { |
| 16277 index++; |
| 16278 } |
| 16279 |
| 16280 set_index(Smi::FromInt(index)); |
| 16281 |
| 16282 if (index < used_capacity) return true; |
| 16283 |
| 16284 set_table(GetHeap()->undefined_value()); |
| 16285 return false; |
| 16286 } |
| 16287 |
| 16288 |
| 16289 template<class Derived, class TableType> |
| 16290 Smi* OrderedHashTableIterator<Derived, TableType>::Next(JSArray* value_array) { |
| 16291 DisallowHeapAllocation no_allocation; |
| 16292 if (HasMore()) { |
| 16293 FixedArray* array = FixedArray::cast(value_array->elements()); |
| 16294 static_cast<Derived*>(this)->PopulateValueArray(array); |
| 16295 MoveNext(); |
| 16296 return kind(); |
| 16297 } |
| 16298 return Smi::FromInt(0); |
| 16299 } |
| 16300 |
| 16301 |
| 16302 template Smi* |
16299 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Next( | 16303 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Next( |
16300 Handle<JSSetIterator> iterator); | 16304 JSArray* value_array); |
| 16305 |
| 16306 template bool |
| 16307 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::HasMore(); |
| 16308 |
| 16309 template void |
| 16310 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::MoveNext(); |
| 16311 |
| 16312 template Object* |
| 16313 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::CurrentKey(); |
16301 | 16314 |
16302 template void | 16315 template void |
16303 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Transition(); | 16316 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Transition(); |
16304 | 16317 |
16305 | 16318 |
16306 template Handle<JSObject> | 16319 template Smi* |
16307 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Next( | 16320 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Next( |
16308 Handle<JSMapIterator> iterator); | 16321 JSArray* value_array); |
| 16322 |
| 16323 template bool |
| 16324 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::HasMore(); |
| 16325 |
| 16326 template void |
| 16327 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::MoveNext(); |
| 16328 |
| 16329 template Object* |
| 16330 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::CurrentKey(); |
16309 | 16331 |
16310 template void | 16332 template void |
16311 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Transition(); | 16333 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Transition(); |
16312 | 16334 |
16313 | 16335 |
16314 Handle<Object> JSSetIterator::ValueForKind( | |
16315 Handle<JSSetIterator> iterator, int entry_index) { | |
16316 int kind = iterator->kind()->value(); | |
16317 // Set.prototype only has values and entries. | |
16318 ASSERT(kind == kKindValues || kind == kKindEntries); | |
16319 | |
16320 Isolate* isolate = iterator->GetIsolate(); | |
16321 Factory* factory = isolate->factory(); | |
16322 | |
16323 Handle<OrderedHashSet> table( | |
16324 OrderedHashSet::cast(iterator->table()), isolate); | |
16325 Handle<Object> value = Handle<Object>(table->get(entry_index), isolate); | |
16326 | |
16327 if (kind == kKindEntries) { | |
16328 Handle<FixedArray> array = factory->NewFixedArray(2); | |
16329 array->set(0, *value); | |
16330 array->set(1, *value); | |
16331 return factory->NewJSArrayWithElements(array); | |
16332 } | |
16333 | |
16334 return value; | |
16335 } | |
16336 | |
16337 | |
16338 Handle<Object> JSMapIterator::ValueForKind( | |
16339 Handle<JSMapIterator> iterator, int entry_index) { | |
16340 int kind = iterator->kind()->value(); | |
16341 ASSERT(kind == kKindKeys || kind == kKindValues || kind == kKindEntries); | |
16342 | |
16343 Isolate* isolate = iterator->GetIsolate(); | |
16344 Factory* factory = isolate->factory(); | |
16345 | |
16346 Handle<OrderedHashMap> table( | |
16347 OrderedHashMap::cast(iterator->table()), isolate); | |
16348 | |
16349 switch (kind) { | |
16350 case kKindKeys: | |
16351 return Handle<Object>(table->get(entry_index), isolate); | |
16352 | |
16353 case kKindValues: | |
16354 return Handle<Object>(table->get(entry_index + 1), isolate); | |
16355 | |
16356 case kKindEntries: { | |
16357 Handle<Object> key(table->get(entry_index), isolate); | |
16358 Handle<Object> value(table->get(entry_index + 1), isolate); | |
16359 Handle<FixedArray> array = factory->NewFixedArray(2); | |
16360 array->set(0, *key); | |
16361 array->set(1, *value); | |
16362 return factory->NewJSArrayWithElements(array); | |
16363 } | |
16364 } | |
16365 | |
16366 UNREACHABLE(); | |
16367 return factory->undefined_value(); | |
16368 } | |
16369 | |
16370 | |
16371 DeclaredAccessorDescriptorIterator::DeclaredAccessorDescriptorIterator( | 16336 DeclaredAccessorDescriptorIterator::DeclaredAccessorDescriptorIterator( |
16372 DeclaredAccessorDescriptor* descriptor) | 16337 DeclaredAccessorDescriptor* descriptor) |
16373 : array_(descriptor->serialized_data()->GetDataStartAddress()), | 16338 : array_(descriptor->serialized_data()->GetDataStartAddress()), |
16374 length_(descriptor->serialized_data()->length()), | 16339 length_(descriptor->serialized_data()->length()), |
16375 offset_(0) { | 16340 offset_(0) { |
16376 } | 16341 } |
16377 | 16342 |
16378 | 16343 |
16379 const DeclaredAccessorDescriptorData* | 16344 const DeclaredAccessorDescriptorData* |
16380 DeclaredAccessorDescriptorIterator::Next() { | 16345 DeclaredAccessorDescriptorIterator::Next() { |
(...skipping 572 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
16953 #define ERROR_MESSAGES_TEXTS(C, T) T, | 16918 #define ERROR_MESSAGES_TEXTS(C, T) T, |
16954 static const char* error_messages_[] = { | 16919 static const char* error_messages_[] = { |
16955 ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS) | 16920 ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS) |
16956 }; | 16921 }; |
16957 #undef ERROR_MESSAGES_TEXTS | 16922 #undef ERROR_MESSAGES_TEXTS |
16958 return error_messages_[reason]; | 16923 return error_messages_[reason]; |
16959 } | 16924 } |
16960 | 16925 |
16961 | 16926 |
16962 } } // namespace v8::internal | 16927 } } // namespace v8::internal |
OLD | NEW |