Lines Matching refs:Index
943 static Handle<Object> GetElement(Handle<Object> object, uint32_t index);
944 MUST_USE_RESULT inline MaybeObject* GetElement(uint32_t index);
946 inline Object* GetElementNoExceptionThrown(uint32_t index);
948 uint32_t index);
963 // Tries to convert an object to an array index. Returns true and sets
965 inline bool ToArrayIndex(uint32_t* index);
967 // Returns true if this is a JSValue containing a string and the index is
969 inline bool IsStringObjectWithCharacterAt(uint32_t index);
1411 MUST_USE_RESULT MaybeObject* DeleteElement(uint32_t index, DeleteMode mode);
1413 // Set the index'th array element.
1415 MUST_USE_RESULT MaybeObject* SetElement(uint32_t index,
1439 inline bool HasElement(uint32_t index);
1537 // Collects elements starting at index 0.
1704 static Handle<Object> DeleteElement(Handle<JSObject> obj, uint32_t index);
1705 MUST_USE_RESULT MaybeObject* DeleteElement(uint32_t index, DeleteMode mode);
1739 // Tells whether the index'th element is present.
1740 bool HasElementWithReceiver(JSReceiver* receiver, uint32_t index);
1748 // Tells whether the index'th element is present and how it is stored.
1750 // There is no element with given index.
1753 // Element with given index is handled by interceptor.
1756 // Element with given index is character in string.
1759 // Element with given index is stored in fast backing store.
1762 // Element with given index is stored in slow backing store.
1766 LocalElementType HasLocalElement(uint32_t index);
1768 bool HasElementWithInterceptor(JSReceiver* receiver, uint32_t index);
1770 MUST_USE_RESULT MaybeObject* SetFastElement(uint32_t index,
1776 uint32_t index,
1784 uint32_t index,
1790 uint32_t index,
1797 uint32_t index,
1805 uint32_t index,
1812 // Returns the index'th element.
1813 // The undefined object if index is out of bounds.
1815 uint32_t index);
1841 bool HasRealElementProperty(uint32_t index);
1844 // Get the header size for a JSObject. Used to compute the index of
1849 inline int GetInternalFieldOffset(int index);
1850 inline Object* GetInternalField(int index);
1851 inline void SetInternalField(int index, Object* value);
1852 inline void SetInternalField(int index, Smi* value);
1860 uint32_t index, Object* value, bool* found, StrictModeFlag strict_mode);
1867 // index.
1868 void GetLocalPropertyNames(FixedArray* storage, int index);
1989 // Access fast-case object properties at index.
1990 inline Object* FastPropertyAt(int index);
1991 inline Object* FastPropertyAtPut(int index, Object* value);
1994 inline int GetInObjectPropertyOffset(int index);
1995 inline Object* InObjectPropertyAt(int index);
1996 inline Object* InObjectPropertyAtPut(int index,
2120 uint32_t index,
2124 uint32_t index,
2129 uint32_t index,
2136 uint32_t index,
2159 MUST_USE_RESULT MaybeObject* DeleteElementWithInterceptor(uint32_t index);
2161 MUST_USE_RESULT MaybeObject* DeleteFastElement(uint32_t index);
2162 MUST_USE_RESULT MaybeObject* DeleteDictionaryElement(uint32_t index,
2177 uint32_t index,
2185 uint32_t index,
2234 inline Object* get(int index);
2236 inline void set(int index, Object* value);
2237 inline bool is_the_hole(int index);
2240 inline void set(int index, Smi* value);
2242 inline void set(int index, Object* value, WriteBarrierMode mode);
2245 inline void set_undefined(int index);
2247 inline void set_undefined(Heap* heap, int index);
2248 inline void set_null(int index);
2250 inline void set_null(Heap* heap, int index);
2251 inline void set_the_hole(int index);
2254 inline void set_unchecked(int index, Smi* value);
2255 inline void set_null_unchecked(Heap* heap, int index);
2256 inline void set_unchecked(Heap* heap, int index, Object* value,
2282 static int OffsetOfElementAt(int index) { return SizeFor(index); }
2328 int index,
2335 int index,
2347 inline double get_scalar(int index);
2348 inline int64_t get_representation(int index);
2349 MUST_USE_RESULT inline MaybeObject* get(int index);
2350 inline void set(int index, double value);
2351 inline void set_the_hole(int index);
2354 inline bool is_the_hole(int index);
2365 static int OffsetOfElementAt(int index) { return SizeFor(index); }
2408 // [2]: next enumeration index (Smi), or pointer to small fixed array:
2409 // [0]: next enumeration index (Smi)
2434 Object* index = FixedArray::cast(obj)->get(kEnumCacheBridgeEnumIndex);
2435 return Smi::cast(index)->value();
2439 // Set next enumeration index and flush any enum cache.
2514 // or null), its enumeration index is kept as is.
2606 // An entry in a DescriptorArray, represented as an (array, index) pair.
2609 inline explicit Entry(DescriptorArray* descs, int index) :
2610 descs_(descs), index_(index) { }
2813 // Returns the index for an entry (of the key)
3029 void CopyKeysTo(FixedArray* storage, int index, SortMode sort_mode);
3031 // Accessors for next enumeration index.
3032 void SetNextEnumerationIndex(int index) {
3033 this->set(kNextEnumerationIndexIndex, Smi::FromInt(index));
3078 // Generate new enumeration indices to avoid enumeration index overflow.
3169 uint32_t index,
3181 // elements if an element has been added at an index larger than
3215 uint32_t index,
3277 // Returns the index to the value of an entry.
3287 // [1]: finger index
3397 // the stack slot index for a given slot name if the slot is
3403 // context slot index for a given slot name if the slot is present; otherwise
3412 // parameter index for a given parameter name if the parameter is present;
3417 // function context slot index if the function name is present (named
3476 // in increasing order of the stack slot index. One slot is used per stack
3482 // index starting with Context::MIN_CONTEXT_SLOTS. One slot is used per
3494 // b. The context or stack slot index for the variable.
3551 inline byte get(int index);
3552 inline void set(int index, byte value);
3555 inline int get_int(int index);
3654 inline bool is_the_hole(int index) { return false; }
3690 inline uint8_t get_scalar(int index);
3691 MUST_USE_RESULT inline MaybeObject* get(int index);
3692 inline void set(int index, uint8_t value);
3696 Object* SetValue(uint32_t index, Object* value);
3719 inline int8_t get_scalar(int index);
3720 MUST_USE_RESULT inline MaybeObject* get(int index);
3721 inline void set(int index, int8_t value);
3725 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3748 inline uint8_t get_scalar(int index);
3749 MUST_USE_RESULT inline MaybeObject* get(int index);
3750 inline void set(int index, uint8_t value);
3754 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3777 inline int16_t get_scalar(int index);
3778 MUST_USE_RESULT inline MaybeObject* get(int index);
3779 inline void set(int index, int16_t value);
3783 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3806 inline uint16_t get_scalar(int index);
3807 MUST_USE_RESULT inline MaybeObject* get(int index);
3808 inline void set(int index, uint16_t value);
3812 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3835 inline int32_t get_scalar(int index);
3836 MUST_USE_RESULT inline MaybeObject* get(int index);
3837 inline void set(int index, int32_t value);
3841 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3864 inline uint32_t get_scalar(int index);
3865 MUST_USE_RESULT inline MaybeObject* get(int index);
3866 inline void set(int index, uint32_t value);
3870 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3893 inline float get_scalar(int index);
3894 MUST_USE_RESULT inline MaybeObject* get(int index);
3895 inline void set(int index, float value);
3899 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3922 inline double get_scalar(int index);
3923 MUST_USE_RESULT inline MaybeObject* get(int index);
3924 inline void set(int index, double value);
3928 MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);
3975 return type::cast(get(k##name##Index)); \
3978 set(k##name##Index, value); \
4039 Smi* AstId(int index) { return Smi::cast(get(index * 2)); }
4040 void SetAstId(int index, Smi* id) { set(index * 2, id); }
4041 Smi* PcAndState(int index) { return Smi::cast(get(1 + index * 2)); }
4042 void SetPcAndState(int index, Smi* offset) { set(1 + index * 2, offset); }
4075 inline Smi* AstId(int index);
4076 inline void SetAstId(int index, Smi* id);
4079 inline JSGlobalPropertyCell* Cell(int index);
4080 inline void SetCell(int index, JSGlobalPropertyCell* cell);
4713 // 0: finger - index of the first free cell in the cache
4756 // Returns the property index for name (only valid for FAST MODE).
4759 // Returns the next free property index (only valid for FAST MODE).
4786 // Returns the non-negative index of the code object if it is in the
4790 // Removes a code object from the code cache at the given index.
4791 void RemoveFromCodeCache(String* name, Code* code, int index);
5456 String* GetThisPropertyAssignmentName(int index);
5457 bool IsThisPropertyAssignmentArgument(int index);
5458 int GetThisPropertyAssignmentArgument(int index);
5459 Object* GetThisPropertyAssignmentConstant(int index);
6096 // Returns the date field with the specified index.
6098 static MaybeObject* GetField(Object* date, Smi* index);
6155 inline Object* DoGetField(FieldIndex index);
6157 Object* GetUTCField(FieldIndex index, double value, DateCache* date_cache);
6271 inline Object* DataAt(int index);
6273 inline void SetDataAt(int index, Object* value);
6276 inline Object* DataAtUnchecked(int index);
6277 inline void SetDataAtUnchecked(int index, Object* value, Heap* heap);
6368 // code index to the saved code index we mask it of to be in the [0:255]
6438 // Get the internal index of a code object in the cache. Returns -1 if the
6439 // code object is not in that cache. This index can be used to later call
6444 // Remove an object from the cache with the provided internal index.
6445 void RemoveByIndex(Object* name, Code* code, int index);
6510 void RemoveByIndex(int index);
6611 // - the parameter map contains an index into the context
6615 // - this struct (in the slow backing store) contains an index into the context
6654 // Add a character to the hash and update the array index calculation.
6657 // Adds a character to the hash but does not update the array index
6659 // that the input is not an array index.
6672 // index.
6844 inline void Set(int index, uint16_t value);
6847 inline uint16_t Get(int index);
6935 uint32_t* index,
6943 inline bool AsArrayIndex(uint32_t* index);
6974 // value into an array index.
6983 // and if it is an array index. The least significant bit indicates
6986 // array index.
6998 // Array index strings this short can keep their index in the hash
7004 // the case for the string '0'. 24 bits are used for the array index value.
7137 bool SlowAsArrayIndex(uint32_t* index);
7167 inline uint16_t SeqAsciiStringGet(int index);
7168 inline void SeqAsciiStringSet(int index, uint16_t value);
7214 inline uint16_t SeqTwoByteStringGet(int index);
7215 inline void SeqTwoByteStringSet(int index, uint16_t value);
7281 uint16_t ConsStringGet(int index);
7334 uint16_t SlicedStringGet(int index);
7418 inline uint16_t ExternalAsciiStringGet(int index);
7463 inline uint16_t ExternalTwoByteStringGet(int index);
7519 inline uc32 Get(int index);
7664 bool HasElementWithHandler(uint32_t index);
7671 uint32_t index);
7679 uint32_t index,
7696 uint32_t index,
7704 uint32_t index);
7932 MUST_USE_RESULT MaybeObject* JSArrayUpdateLengthFromIndex(uint32_t index,
7982 // This initial map adds in-object properties for "index" and "input"
8417 // Lookup the index in the break_points array for a code position.
