Lines Matching defs:array
58 #include "src/objects/embedder-data-array-inl.h"
67 #include "src/objects/js-array-buffer-inl.h"
68 #include "src/objects/js-array-inl.h"
1025 Handle<JSArray> array = Handle<JSArray>::cast(object);
1027 if (!array->HasArrayPrototype(isolate) ||
1028 !array->length().ToUint32(&length) || !array->HasFastElements() ||
1029 !JSObject::PrototypeHasNoElements(isolate, *array)) {
1032 return array->GetElementsAccessor()->CreateListFromArrayLike(
1033 isolate, array, length);
1035 Handle<JSTypedArray> array = Handle<JSTypedArray>::cast(object);
1036 size_t length = array->length();
1037 if (array->WasDetached() ||
1043 return array->GetElementsAccessor()->CreateListFromArrayLike(
1044 isolate, array, static_cast<uint32_t>(length));
1767 // Check that this object is an array.
1769 JSArray array = JSArray::cast(*this);
1770 Isolate* isolate = array.GetIsolate();
1775 if (!array.GetCreationContext().ToHandle(&context)) return false;
1776 if (!array.map().prototype().IsJSObject()) return true;
1777 JSObject array_proto = JSObject::cast(array.map().prototype());
1788 ElementsKind array_kind = array.GetElementsKind();
2904 Handle<JSArray> array = Handle<JSArray>::cast(receiver);
2905 if (JSArray::WouldChangeReadOnlyLength(array, it->array_index())) {
2909 Object::TypeOf(isolate, array), array));
2976 Handle<typename T::Array> array,
2988 if (!T::Contains(key, entry, valid_descriptors, array)) {
2989 T::Insert(key, entry, valid_descriptors, array);
3000 int valid_descriptors, Handle<FixedArray> array) {
3002 if (*key == AccessorInfo::cast(array->get(i)).name()) return true;
3007 int valid_descriptors, Handle<FixedArray> array) {
3009 array->set(valid_descriptors, *entry);
3014 Handle<FixedArray> array,
3017 DCHECK_GE(array->length(), callbacks->length() + valid_descriptors);
3018 return AppendUniqueCallbacks<FixedArrayAppender>(isolate, callbacks, array,
3298 // 3. Else if P is an array index, then:
3918 // Create a new descriptor array with only enumerable, configurable, writeable
3988 Handle<FixedArray> array, int index,
3990 if (index < array->length()) {
3991 array->set(index, *value);
3992 return array;
3994 int capacity = array->length();
3999 array->CopyTo(0, *new_array, 0, array->length());
4000 new_array->FillWithHoles(array->length(), new_array->length());
4006 Handle<FixedArray> array,
4009 return array->GetReadOnlyRoots().empty_fixed_array_handle();
4011 array->Shrink(isolate, new_length);
4012 return array;
4026 // a canonical read-only empty fixed array.
4035 Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
4037 int length = array->Length();
4038 array = EnsureSpace(isolate, array, length + 1);
4039 // Check that GC didn't remove elements from the array.
4040 DCHECK_EQ(array->Length(), length);
4043 ArrayList raw_array = *array;
4047 return array;
4051 Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
4053 int length = array->Length();
4054 array = EnsureSpace(isolate, array, length + 2);
4055 // Check that GC didn't remove elements from the array.
4056 DCHECK_EQ(array->Length(), length);
4059 ArrayList raw_array = *array;
4064 return array;
4067 Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
4070 int length = array->Length();
4071 array = EnsureSpace(isolate, array, length + 4);
4072 // Check that GC didn't remove elements from the array.
4073 DCHECK_EQ(array->Length(), length);
4076 ArrayList raw_array = *array;
4083 return array;
4092 Handle<ArrayList> array) {
4093 int length = array->Length();
4096 array->CopyTo(kFirstIndex, *result, 0, length);
4103 Handle<FixedArray> array,
4105 int capacity = array->length();
4110 array = isolate->factory()->CopyFixedArrayAndGrow(array, grow_by);
4112 return array;
4119 Handle<ArrayList> array, int length) {
4122 EnsureSpaceInFixedArray(isolate, array, kFirstIndex + length));
4123 DCHECK_EQ(array->Length(), new_array->Length());
4129 Handle<WeakArrayList> array,
4131 int length = array->length();
4132 array = EnsureSpace(isolate, array, length + 1);
4135 WeakArrayList raw = *array;
4136 // Reload length; GC might have removed elements from the array.
4141 return array;
4145 Handle<WeakArrayList> array,
4148 int length = array->length();
4149 array = EnsureSpace(isolate, array, length + 2);
4152 WeakArrayList raw = *array;
4153 // Reload length; GC might have removed elements from the array.
4154 length = array->length();
4159 return array;
4164 Handle<WeakArrayList> array,
4171 WeakArrayList raw = *array;
4177 return array;
4180 // Not enough space in the array left, either grow, shrink or
4181 // compact the array.
4189 // Grow or shrink array and compact out-of-place.
4191 array = isolate->factory()->CompactWeakArrayList(array, new_capacity,
4195 // Perform compaction in the current array.
4196 array->Compact(isolate);
4199 // Now append value to the array, there should always be enough space now.
4200 DCHECK_LT(array->length(), array->capacity());
4204 WeakArrayList raw = *array;
4210 return array;
4236 Handle<WeakArrayList> array,
4239 int capacity = array->capacity();
4242 array = isolate->factory()->CopyWeakArrayListAndGrow(array, grow_by,
4245 return array;
4289 Handle<WeakArrayList> array,
4292 int length = array->length();
4295 array = WeakArrayList::EnsureSpace(isolate, array, kFirstIndex + 1);
4296 set_empty_slot_index(*array, kNoEmptySlotsMarker);
4297 array->Set(kFirstIndex, HeapObjectReference::Weak(*value));
4298 array->set_length(kFirstIndex + 1);
4300 return array;
4303 // If the array has unfilled space at the end, use it.
4304 if (!array->IsFull()) {
4305 array->Set(length, HeapObjectReference::Weak(*value));
4306 array->set_length(length + 1);
4308 return array;
4312 int empty_slot = Smi::ToInt(empty_slot_index(*array));
4315 // GCs might have cleared some references, rescan the array for empty slots.
4316 PrototypeUsers::ScanForEmptySlots(*array);
4317 empty_slot = Smi::ToInt(empty_slot_index(*array));
4322 CHECK_LT(empty_slot, array->length());
4323 int next_empty_slot = array->Get(empty_slot).ToSmi().value();
4325 array->Set(empty_slot, HeapObjectReference::Weak(*value));
4328 set_empty_slot_index(*array, next_empty_slot);
4329 return array;
4334 // Array full and no empty slots. Grow the array.
4335 array = WeakArrayList::EnsureSpace(isolate, array, length + 1);
4336 array->Set(length, HeapObjectReference::Weak(*value));
4337 array->set_length(length + 1);
4339 return array;
4343 void PrototypeUsers::ScanForEmptySlots(WeakArrayList array) {
4344 for (int i = kFirstIndex; i < array.length(); i++) {
4345 if (array.Get(i)->IsCleared()) {
4346 PrototypeUsers::MarkSlotEmpty(array, i);
4351 WeakArrayList PrototypeUsers::Compact(Handle<WeakArrayList> array, Heap* heap,
4354 if (array->length() == 0) {
4355 return *array;
4357 int new_length = kFirstIndex + array->CountLiveWeakReferences();
4358 if (new_length == array->length()) {
4359 return *array;
4369 for (int i = kFirstIndex; i < array->length(); i++) {
4370 MaybeObject element = array->Get(i);
4466 // Reset sorting since the descriptor array might contain invalid pointers.
4491 // Extract elements and create sorted array.
4493 // Put max element at the back of the array.
4761 // For array indexes mix the length into the hash as an array index could
4837 Handle<FixedArray> array = String::CalculateLineEnds(isolate, src, true);
4838 script->set_line_ends(*array);
4853 // For wasm, we do not create an artificial line_ends array, but do the
4965 // Determine line number by doing a binary search on the line ends array.
5158 void JSArray::Initialize(Handle<JSArray> array, int capacity, int length) {
5160 array->GetIsolate()->factory()->NewJSArrayStorage(
5161 array, length, capacity, INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
5164 Maybe<bool> JSArray::SetLength(Handle<JSArray> array, uint32_t new_length) {
5165 if (array->SetLengthWouldNormalize(new_length)) {
5166 JSObject::NormalizeElements(array);
5168 return array->GetElementsAccessor()->SetLength(array, new_length);
5306 // the first in the descriptor array.
5313 bool JSArray::HasReadOnlyLength(Handle<JSArray> array) {
5314 Map map = array->map();
5320 Isolate* isolate = array->GetIsolate();
5321 LookupIterator it(isolate, array, isolate->factory()->length_string(), array,
5327 bool JSArray::WouldChangeReadOnlyLength(Handle<JSArray> array, uint32_t index) {
5329 CHECK(array->length().ToArrayLength(&length));
5330 if (length <= index) return HasReadOnlyLength(array);
5723 Handle<FixedArray> array = factory->NewFixedArrayWithMap(
5725 Handle<Derived> table = Handle<Derived>::cast(array);
5741 // Copy prefix to new array.
6232 Handle<FixedArray> array =
6242 array->set(array_size++, Smi::FromInt(i.as_int()));
6256 AtomicSlot start(array->GetFirstElementAddress());
6259 return FixedArray::ShrinkOrEmpty(isolate, array, array_size);
6389 // TODO(verwaest): Consider to shrink the fixed array in place.