Lines Matching refs:Array
57 #include "smart-array-pointer.h"
189 // an array.
285 // Check that there are only symbols and array indices among keys.
302 // If we only have symbols and array indices among keys then we can
307 // Create the fixed array with the key.
342 // Get the global context from the literals array. This is the
384 // simple object or array literal.
385 Handle<FixedArray> array = Handle<FixedArray>::cast(value);
386 value = CreateLiteralBoilerplate(isolate, literals, array);
393 // Array index as string (uint32).
403 // Array index (uint32).
512 // simple object or array literal.
541 Handle<FixedArray> array) {
542 Handle<FixedArray> elements = CompileTimeValue::GetElements(array);
544 switch (CompileTimeValue::GetType(array)) {
987 // Enumerator used as indices into the array returned from GetOwnProperty
1140 // Returns an array with the property description:
1774 JSArray* array = JSArray::cast(new_object);
1775 array->set_properties(isolate->heap()->empty_fixed_array());
1776 array->set_elements(elements);
1777 array->set_length(Smi::FromInt(elements_count));
1778 // Write in-object properties after the length of the array.
1779 array->InObjectPropertyAtPut(JSRegExpResult::kIndexIndex, args[1]);
1780 array->InObjectPropertyAtPut(JSRegExpResult::kInputIndex, args[2]);
1781 return array;
1859 // on Array.prototype and below.
1935 // Get the RegExp function from the context in the literals array.
2109 // Construct a new field descriptors array containing the new descriptor.
2119 // Create a new map featuring the new field descriptors array.
2192 // Array, and Object, and some web code
2207 // Insert the object, regexp and array functions in the literals
2208 // array prefix. These are the functions that will be used when
2209 // creating object, regexp and array literals.
2300 // extend the array will work.
2309 // extend the array will work.
2349 Handle<FixedArray> array() {
2409 // extend the array will work.
2466 *array_builder_.array(),
2476 *array_builder_.array(),
2591 // tag == REPLACEMENT_STRING: data is index into array of substrings
3891 // Arguments array to replace function is match, captures, index and
4045 // Character array used for conversion.
4196 // Check if the given key is an array index.
4460 // Check if the given key is an array index.
4517 // Check if the given key is an array index.
4568 // Check if the given key is an array index.
4768 // an array index and there are no interceptors or hidden
4965 // Allocate an array with storage for all the property names.
5046 v8::Handle<v8::Array> result = GetKeysForNamedInterceptor(obj, obj);
5061 v8::Handle<v8::Array> result = GetKeysForIndexedInterceptor(obj, obj);
5084 // If proxy is detached we simply return an empty array.
5095 // property array and since the result is mutable we have to create
5143 // Try to convert the string key into an array index.
5820 FixedArray* array,
5822 int length = array->length();
5846 String* str = String::cast(array->get(i));
5874 CONVERT_ARG_CHECKED(JSArray, array, 0);
5876 if (!array->HasFastElements()) return isolate->heap()->undefined_value();
5877 FixedArray* elements = FixedArray::cast(array->elements());
6351 // Copies ASCII characters to the given fixed array looking up
6409 // to prevent GC from seeing partially initialized array.
6680 CONVERT_ARG_CHECKED(JSArray, array, 0);
6691 MaybeObject* maybe_result = array->EnsureCanContainHeapObjectElements();
6695 if (!array->HasFastElements()) {
6698 FixedArray* fixed_array = FixedArray::cast(array->elements());
6797 CONVERT_ARG_CHECKED(JSArray, array, 0);
6805 if (!array->HasFastElements()) {
6808 FixedArray* fixed_array = FixedArray::cast(array->elements());
6903 // Array length must be representable as a signed 32-bit number,
6928 // array_length is length of original array (used to add separators);
6981 V8::FatalProcessOutOfMemory("Array join result too large.");
7617 // Store the context and the arguments array at the beginning of the
7628 // These go directly in the arguments array and have no
7648 // This goes directly in the arguments array with a hole in the
7654 // arguments array.
7700 // Allocate the fixed array.
7707 FixedArray* array = reinterpret_cast<FixedArray*>(obj);
7708 array->set_map_no_write_barrier(isolate->heap()->fixed_array_map());
7709 array->set_length(length);
7711 WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
7713 array->set(i, *--parameters, mode);
7740 // into C++ code. Collect these in a newly allocated array of handles (possibly
7808 // Initialize array of bindings (function, this, and any existing arguments
8831 // Context is a fixed array and set cannot fail.
9270 // Push an object unto an array of objects if it is not already in the
9271 // array. Returns true if the element was pushed on the stack and
9275 CONVERT_ARG_CHECKED(JSArray, array, 0);
9277 RUNTIME_ASSERT(array->HasFastElements() || array->HasFastSmiOnlyElements());
9278 int length = Smi::cast(array->length())->value();
9279 FixedArray* elements = FixedArray::cast(array->elements());
9284 // Strict not needed. Used for cycle detection in Array join implementation.
9286 array->SetFastElement(length, element, kNonStrictMode, true);
9294 * A simple visitor visits every element of Array's.
9295 * The backend storage can be a fixed array for fast elements case,
9296 * or a dictionary for sparse array. Since Dictionary is a subtype
9301 * An index limit is used to deal with the situation that a result array
9356 Handle<JSArray> array = isolate_->factory()->NewJSArray(0);
9361 map = isolate_->factory()->GetElementsTransitionMap(array,
9364 map = isolate_->factory()->GetElementsTransitionMap(array,
9367 array->set_map(*map);
9368 array->set_length(*length);
9369 array->set_elements(*storage_);
9370 return array;
9417 static uint32_t EstimateElementCount(Handle<JSArray> array) {
9418 uint32_t length = static_cast<uint32_t>(array->length()->Number());
9420 switch (array->GetElementsKind()) {
9427 Handle<FixedArray> elements(FixedArray::cast(array->elements()));
9439 SeededNumberDictionary::cast(array->elements()));
9475 Handle<ExternalArrayClass> array(
9477 uint32_t len = static_cast<uint32_t>(array->length());
9484 Handle<Smi> e(Smi::FromInt(static_cast<int>(array->get_scalar(j))));
9490 int64_t val = static_cast<int64_t>(array->get_scalar(j));
9504 Handle<Object> e = isolate->factory()->NewNumber(array->get_scalar(j));
9639 * The visitor argument called for each existing element in the array
9641 * Afterwards it increments the base-index of the visitor by the array
9758 * Array::concat implementation.
9786 Handle<JSArray> array(Handle<JSArray>::cast(obj));
9790 if (array->HasFastDoubleElements()) {
9791 array = Handle<JSArray>::cast(
9792 JSObject::TransitionElementsKind(array, FAST_ELEMENTS));
9795 static_cast<uint32_t>(array->length()->Number());
9797 EstimateElementCount(array);
9819 // fixed array (fast case) is more time and space-efficient than a
9825 // The backing storage array must have non-existing elements to
9842 Handle<JSArray> array = Handle<JSArray>::cast(obj);
9843 if (!IterateElements(isolate, array, &visitor)) {
9884 // Move contents of argument 0 (an array) to argument 1 (an array)
9916 // How many elements does this object/array have?
9932 // Returns an array that tells you where in the [0, length) interval an array
9940 CONVERT_ARG_HANDLE_CHECKED(JSObject, array, 0);
9942 if (array->elements()->IsDictionary()) {
9943 // Create an array and get all the keys into it, then remove all the
9947 GetKeysInFixedArrayFor(array, INCLUDE_PROTOS, &threw);
9961 ASSERT(array->HasFastElements() ||
9962 array->HasFastSmiOnlyElements() ||
9963 array->HasFastDoubleElements());
9965 // -1 means start of array.
9967 FixedArrayBase* elements = FixedArrayBase::cast(array->elements());
10094 // The array returned contains the following information:
10175 // If the callback object is a fixed array then it contains JavaScript
10414 // Return an array with frame details
10418 // The array returned contains the following information:
10487 // Get the locals names and values into a temporary array.
11231 // Return an array with scope details
11237 // The array returned contains the following information:
11330 // Return an array with thread details
11334 // The array returned contains the following information:
11349 // Allocate array for result.
11380 // Convert to JS array and return.
11405 // Return array as JS array
11749 Handle<FixedArray> array = isolate->factory()->NewFixedArray(length);
11752 WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
11754 array
11756 arguments->set_elements(*array);
12008 // Return result as a JS array.
12061 // Valid reference found add to instance array if supplied an update
12110 // Get the constructor function for context extension and arguments array.
12123 // Allocate an array to hold the result.
12138 // Return result as JS array.
12164 // Valid reference found add to instance array if supplied an update
12203 // Allocate an array to hold the result.
12219 // Return result as JS array.
12347 Handle<FixedArray> array;
12348 array = isolate->factory()->NewFixedArray(kBufferSize);
12355 FixedArray* arr = *array;
12359 array = isolate->factory()->NewFixedArray(number);
12364 FixedArray* arr = *array;
12368 Handle<JSArray> result = isolate->factory()->NewJSArrayWithElements(array);
12380 // Returns a JSArray of compilation infos. The array is ordered so that
12487 // array of groups of 3 numbers:
12500 // For array of SharedFunctionInfo's (each wrapped in JSValue)
12502 // Returns array of the same length with corresponding results of
12927 // Collect the raw data for a stack trace. Returns an array of 4
