Lines Matching refs:Array
141 // an array.
226 // Create the fixed array with the key.
250 // Get the global context from the literals array. This is the
276 Handle<FixedArray> array = Handle<FixedArray>::cast(value);
277 value = CreateLiteralBoilerplate(literals, array);
283 // If key is a symbol it is not an array element.
287 } else if (Array::IndexFromObject(*key, &element_index)) {
288 // Array index (uint32).
343 Handle<FixedArray> array) {
344 Handle<FixedArray> elements = CompileTimeValue::GetElements(array);
345 switch (CompileTimeValue::GetType(array)) {
379 // the array literal and produces JSArray with those elements.
380 // Additionally takes the literals array of the surrounding function
381 // which contains the context from which to get the Array function
382 // to use for creating the array literal.
575 // Returns an array with the property description:
1241 // Get the RegExp function from the context in the literals array.
1408 // Array, and Object, and some web code
1422 // Insert the object, regexp and array functions in the literals
1423 // array prefix. These are the functions that will be used when
1424 // creating object, regexp and array literals.
1440 if (!Array::IndexFromObject(index, &i)) return Heap::nan_value();
1456 if (Array::IndexFromObject(char_code, &code)) {
1517 // extend the array will work.
1697 // tag == REPLACEMENT_STRING: data is index into array of substrings
2464 if (!Array::IndexFromObject(index, &start_index)) return Smi::FromInt(-1);
2514 if (!Array::IndexFromObject(index, &start_index)) return Smi::FromInt(-1);
2718 // Character array used for conversion.
2864 // Check if the given key is an array index.
2866 if (Array::IndexFromObject(*key, &index)) {
3050 // Check if the given key is an array index.
3052 if (Array::IndexFromObject(*key, &index)) {
3102 // Check if the given key is an array index.
3104 if (Array::IndexFromObject(*key, &index)) {
3149 // Check if the given key is an array index.
3151 if (Array::IndexFromObject(*key, &index)) {
3420 // Allocate an array with storage for all the property names.
3500 v8::Handle<v8::Array> result = GetKeysForNamedInterceptor(obj, obj);
3515 v8::Handle<v8::Array> result = GetKeysForIndexedInterceptor(obj, obj);
3530 // property array and since the result is mutable we have to create
3565 if (Array::IndexFromObject(args[0], &index) && index < n) {
3577 // Try to convert the string key into an array index.
4319 CONVERT_CHECKED(JSArray, array, args[0]);
4331 if (!array->HasFastElements()) {
4334 FixedArray* fixed_array = FixedArray::cast(array->elements());
4589 // If one array is a suffix of the other array, the longest array is
4877 // Allocate the fixed array.
4882 reinterpret_cast<Array*>(obj)->set_map(Heap::fixed_array_map());
4883 FixedArray* array = FixedArray::cast(obj);
4884 array->set_length(length);
4886 WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
4888 array->set(i, *--parameters, mode);
5700 // Push an array unto an array of arrays if it is not already in the
5701 // array. Returns true if the element was pushed on the stack and
5705 CONVERT_CHECKED(JSArray, array, args[0]);
5707 RUNTIME_ASSERT(array->HasFastElements());
5708 int length = Smi::cast(array->length())->value();
5709 FixedArray* elements = FixedArray::cast(array->elements());
5713 Object* obj = array->SetFastElement(length, element);
5720 * A simple visitor visits every element of Array's.
5721 * The backend storage can be a fixed array for fast elements case,
5722 * or a dictionary for sparse array. Since Dictionary is a subtype
5727 * An index limit is used to deal with the situation that a result array
5782 Handle<ExternalArrayClass> array(
5784 uint32_t len = Min(static_cast<uint32_t>(array->length()), range);
5790 Handle<Smi> e(Smi::FromInt(static_cast<int>(array->get(j))));
5795 int64_t val = static_cast<int64_t>(array->get(j));
5808 Handle<Object> e(Heap::AllocateHeapNumber(array->get(j)));
5936 * A helper function that visits elements of an Array object, and elements
5940 * less than Array length are visited.
5947 * in the array's prototype chain, it will be counted more than once, but
5950 static uint32_t IterateArrayAndPrototypeElements(Handle<JSArray> array,
5952 uint32_t range = static_cast<uint32_t>(array->length()->Number());
5953 Handle<Object> obj = array;
5962 // the same index. This follows Array::concat semantics.
5988 * The first argument is an Array of arrays and objects. It is the
5989 * same as the arguments array of Array::concat JS function.
5991 * If an argument is an Array object, the function visits array
5992 * elements. If an argument is not an Array object, the function
5993 * visits the object as if it is an one-element array.
5995 * If the result array index overflows 32-bit unsigned integer, the rounded
5997 * array length is 2^32 - 1, second array length is 1, the
5998 * concatenated array length is 0.
6000 * is one more than the last array index to get a value assigned).
6010 Handle<JSArray> array = Handle<JSArray>::cast(obj);
6011 uint32_t len = static_cast<uint32_t>(array->length()->Number());
6013 IterateArrayAndPrototypeElements(array, visitor);
6014 // Total elements of array and its prototype chain can be more than
6015 // the array length, but ArrayConcat can only concatenate at most
6016 // the array length number of elements. We use the length as an estimate
6040 * Array::concat implementation.
6075 // Allocate an empty array, will set length and content later.
6080 // fixed array (fast case) is more time and space-efficient than a
6086 // The backing storage array must have non-existing elements to
6140 // Move contents of argument 0 (an array) to argument 1 (an array)
6153 // How many elements does this array have?
6156 CONVERT_CHECKED(JSArray, array, args[0]);
6157 HeapObject* elements = array->elements();
6161 return array->length();
6166 // Returns an array that tells you where in the [0, length) interval an array
6172 CONVERT_ARG_CHECKED(JSObject, array, 0);
6174 if (array->elements()->IsDictionary()) {
6175 // Create an array and get all the keys into it, then remove all the
6177 Handle<FixedArray> keys = GetKeysInFixedArrayFor(array, INCLUDE_PROTOS);
6182 if (!Array::IndexFromObject(key, &index) || index >= length) {
6190 // -1 means start of array.
6192 uint32_t actual_length = static_cast<uint32_t>(array->elements()->length());
6334 // The array returned contains the following information:
6404 // If the callback object is a fixed array then it contains JavaScript
6549 // Return an array with frame details
6553 // The array returned contains the following information:
6611 // Get the locals names and values into a temporary array.
7093 // Return an array with scope details
7098 // The array returned contains the following information:
7226 // Return an array with thread details
7230 // The array returned contains the following information:
7242 // Allocate array for result.
7268 // Convert to JS array and return.
7282 // Return array as JS array
7563 Handle<FixedArray> array = Factory::NewFixedArray(length);
7566 WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
7568 array->set(i, frame->GetParameter(i), mode);
7570 arguments->set_elements(*array);
7766 // Return result as a JS array.
7818 // Valid reference found add to instance array if supplied an update
7861 // Get the constructor function for context extension and arguments array.
7872 // Allocate an array to hold the result.
7881 // Return result as JS array.
7905 // Valid reference found add to instance array if supplied an update
7938 // Allocate an array to hold the result.
7946 // Return result as JS array.
8118 // Collect the raw data for a stack trace. Returns an array of three
