#include <objects.h>

Inheritance diagram for v8::internal::String:

Collaboration diagram for v8::internal::String:

Classes
class	ArrayIndexLengthBits

class	ArrayIndexValueBits

class	FlatContent

Public Types
enum	Encoding { ONE_BYTE_ENCODING , TWO_BYTE_ENCODING }

Public Types inherited from v8::internal::Object
enum	StoreFromKeyed { MAY_BE_STORE_FROM_KEYED , CERTAINLY_NOT_STORE_FROM_KEYED }

enum	StorePropertyMode { NORMAL_PROPERTY , SUPER_PROPERTY }

Public Member Functions
	STATIC_ASSERT ((kArrayIndexLengthBits > 0))

	STATIC_ASSERT (IS_POWER_OF_TWO(kMaxCachedArrayIndexLength+1))

int	length () const

void	set_length (int value)

int	synchronized_length () const

void	synchronized_set_length (int value)

bool	IsOneByteRepresentation () const

bool	IsTwoByteRepresentation () const

bool	IsOneByteRepresentationUnderneath ()

bool	IsTwoByteRepresentationUnderneath ()

bool	HasOnlyOneByteChars ()

void	Set (int index, uint16_t value)

	INLINE (uint16_t Get(int index))

FlatContent	GetFlatContent ()

String *	GetUnderlying ()

bool	MarkAsUndetectable ()

bool	Equals (String *other)

bool	IsUtf8EqualTo (Vector< const char > str, bool allow_prefix_match=false)

bool	IsOneByteEqualTo (Vector< const uint8_t > str)

bool	IsTwoByteEqualTo (Vector< const uc16 > str)

SmartArrayPointer< char >	ToCString (AllowNullsFlag allow_nulls, RobustnessFlag robustness_flag, int offset, int length, int *length_output=0)

SmartArrayPointer< char >	ToCString (AllowNullsFlag allow_nulls=DISALLOW_NULLS, RobustnessFlag robustness_flag=FAST_STRING_TRAVERSAL, int *length_output=0)

SmartArrayPointer< uc16 >	ToWideCString (RobustnessFlag robustness_flag=FAST_STRING_TRAVERSAL)

bool	ComputeArrayIndex (uint32_t *index)

bool	MakeExternal (v8::String::ExternalStringResource *resource)

bool	MakeExternal (v8::String::ExternalOneByteStringResource *resource)

bool	AsArrayIndex (uint32_t *index)

void	PrintOn (FILE *out)

bool	LooksValid ()

void	StringShortPrint (StringStream *accumulator)

void	PrintUC16 (OStream &os, int start=0, int end=-1)

bool	IsFlat ()

	STATIC_ASSERT (kMaxArrayIndexSize<(1<< kArrayIndexLengthBits))

const uc16 *	GetTwoByteData (unsigned start)

void	SetForwardedInternalizedString (String *string)

String *	GetForwardedInternalizedString ()

Public Member Functions inherited from v8::internal::Name
uint32_t	hash_field ()

void	set_hash_field (uint32_t value)

bool	HasHashCode ()

uint32_t	Hash ()

bool	Equals (Name *other)

bool	AsArrayIndex (uint32_t *index)

bool	IsOwn ()

	STATIC_ASSERT ((kArrayIndexLengthBits > 0))

	STATIC_ASSERT (IS_POWER_OF_TWO(kMaxCachedArrayIndexLength+1))

Public Member Functions inherited from v8::internal::HeapObject
Map *	map () const

void	set_map (Map *value)

void	set_map_no_write_barrier (Map *value)

Map *	synchronized_map ()

MapWord	synchronized_map_word () const

void	synchronized_set_map (Map *value)

void	synchronized_set_map_no_write_barrier (Map *value)

void	synchronized_set_map_word (MapWord map_word)

MapWord	map_word () const

void	set_map_word (MapWord map_word)

Heap *	GetHeap () const

Isolate *	GetIsolate () const

Address	address ()

void	Iterate (ObjectVisitor *v)

void	IterateBody (InstanceType type, int object_size, ObjectVisitor *v)

int	Size ()

bool	MayContainRawValues ()

int	SizeFromMap (Map *map)

WriteBarrierMode	GetWriteBarrierMode (const DisallowHeapAllocation &promise)

void	HeapObjectShortPrint (OStream &os)

	STATIC_ASSERT (kMapOffset==Internals::kHeapObjectMapOffset)

Public Member Functions inherited from v8::internal::Object
bool	IsObject () const

	INLINE (bool IsFixedArrayBase() const)

	INLINE (bool IsExternal() const)

	INLINE (bool IsAccessorInfo() const)

	INLINE (bool IsStruct() const)

	INLINE (bool IsSpecObject()) const

	INLINE (bool IsSpecFunction()) const

	INLINE (bool IsTemplateInfo()) const

	INLINE (bool IsNameDictionary() const)

	INLINE (bool IsSeededNumberDictionary() const)

	INLINE (bool IsUnseededNumberDictionary() const)

	INLINE (bool IsOrderedHashSet() const)

	INLINE (bool IsOrderedHashMap() const)

bool	IsCallable () const

	INLINE (bool IsUndefined() const)

	INLINE (bool IsNull() const)

	INLINE (bool IsTheHole() const)

	INLINE (bool IsException() const)

	INLINE (bool IsUninitialized() const)

	INLINE (bool IsTrue() const)

	INLINE (bool IsFalse() const)

	INLINE (bool IsArgumentsMarker() const)

	INLINE (bool IsFiller() const)

double	Number ()

	INLINE (bool IsNaN() const)

	INLINE (bool IsMinusZero() const)

bool	ToInt32 (int32_t *value)

bool	ToUint32 (uint32_t *value)

Representation	OptimalRepresentation ()

bool	FitsRepresentation (Representation representation)

Handle< HeapType >	OptimalType (Isolate *isolate, Representation representation)

bool	HasValidElements ()

bool	HasSpecificClassOf (String *name)

bool	BooleanValue ()

Object *	GetHash ()

bool	SameValue (Object *other)

bool	SameValueZero (Object *other)

bool	ToArrayIndex (uint32_t *index)

bool	IsStringObjectWithCharacterAt (uint32_t index)

void	VerifyApiCallResultType ()

void	ShortPrint (FILE *out=stdout)

void	ShortPrint (StringStream *accumulator)

Static Public Member Functions
static Handle< String >	Flatten (Handle< String > string, PretenureFlag pretenure=NOT_TENURED)

static bool	Equals (Handle< String > one, Handle< String > two)

template<typename sinkchar >
static void	WriteToFlat (String source, sinkchar sink, int from, int to)

static int	NonAsciiStart (const char *chars, int length)

static bool	IsAscii (const char *chars, int length)

static bool	IsAscii (const uint8_t *chars, int length)

static int	NonOneByteStart (const uc16 *chars, int length)

static bool	IsOneByte (const uc16 *chars, int length)

template<class Visitor >
static ConsString *	VisitFlat (Visitor visitor, String string, int offset=0)

static Handle< FixedArray >	CalculateLineEnds (Handle< String > string, bool include_ending_line)

Static Public Member Functions inherited from v8::internal::Name
static bool	Equals (Handle< Name > one, Handle< Name > two)

Static Public Member Functions inherited from v8::internal::HeapObject
static HeapObject *	FromAddress (Address address)

static Object **	RawField (HeapObject *obj, int offset)

static void	UpdateMapCodeCache (Handle< HeapObject > object, Handle< Name > name, Handle< Code > code)

Static Public Member Functions inherited from v8::internal::Object
static Handle< Object >	NewStorageFor (Isolate *isolate, Handle< Object > object, Representation representation)

static Handle< Object >	WrapForRead (Isolate *isolate, Handle< Object > object, Representation representation)

static MaybeHandle< JSReceiver >	ToObject (Isolate *isolate, Handle< Object > object)

static MaybeHandle< JSReceiver >	ToObject (Isolate *isolate, Handle< Object > object, Handle< Context > context)

static MUST_USE_RESULT MaybeHandle< Smi >	ToSmi (Isolate *isolate, Handle< Object > object)

static MUST_USE_RESULT MaybeHandle< Object >	GetProperty (LookupIterator *it)

static MUST_USE_RESULT MaybeHandle< Object >	SetProperty (Handle< Object > object, Handle< Name > key, Handle< Object > value, StrictMode strict_mode, StoreFromKeyed store_mode=MAY_BE_STORE_FROM_KEYED)

static MUST_USE_RESULT MaybeHandle< Object >	SetProperty (LookupIterator *it, Handle< Object > value, StrictMode strict_mode, StoreFromKeyed store_mode, StorePropertyMode data_store_mode=NORMAL_PROPERTY)

static MUST_USE_RESULT MaybeHandle< Object >	WriteToReadOnlyProperty (LookupIterator *it, Handle< Object > value, StrictMode strict_mode)

static Handle< Object >	SetDataProperty (LookupIterator *it, Handle< Object > value)

static MUST_USE_RESULT MaybeHandle< Object >	AddDataProperty (LookupIterator *it, Handle< Object > value, PropertyAttributes attributes, StrictMode strict_mode, StoreFromKeyed store_mode)

static MUST_USE_RESULT MaybeHandle< Object >	GetPropertyOrElement (Handle< Object > object, Handle< Name > key)

static MUST_USE_RESULT MaybeHandle< Object >	GetProperty (Isolate isolate, Handle< Object > object, const char key)

static MUST_USE_RESULT MaybeHandle< Object >	GetProperty (Handle< Object > object, Handle< Name > key)

static MUST_USE_RESULT MaybeHandle< Object >	GetPropertyWithAccessor (Handle< Object > receiver, Handle< Name > name, Handle< JSObject > holder, Handle< Object > structure)

static MUST_USE_RESULT MaybeHandle< Object >	SetPropertyWithAccessor (Handle< Object > receiver, Handle< Name > name, Handle< Object > value, Handle< JSObject > holder, Handle< Object > structure, StrictMode strict_mode)

static MUST_USE_RESULT MaybeHandle< Object >	GetPropertyWithDefinedGetter (Handle< Object > receiver, Handle< JSReceiver > getter)

static MUST_USE_RESULT MaybeHandle< Object >	SetPropertyWithDefinedSetter (Handle< Object > receiver, Handle< JSReceiver > setter, Handle< Object > value)

static MUST_USE_RESULT MaybeHandle< Object >	GetElement (Isolate *isolate, Handle< Object > object, uint32_t index)

static MUST_USE_RESULT MaybeHandle< Object >	GetElementWithReceiver (Isolate *isolate, Handle< Object > object, Handle< Object > receiver, uint32_t index)

static Handle< Smi >	GetOrCreateHash (Isolate *isolate, Handle< Object > object)

Static Public Attributes
static const int	kMaxCachedArrayIndexLength = 7

static const int	kArrayIndexValueBits = 24

static const int	kArrayIndexLengthBits

static const unsigned int	kContainsCachedArrayIndexMask

static const int	kLengthOffset = Name::kSize

static const int	kSize = kLengthOffset + kPointerSize

static const int	kMaxArrayIndexSize = 10

static const int32_t	kMaxOneByteCharCode = unibrow::Latin1::kMaxChar

static const uint32_t	kMaxOneByteCharCodeU = unibrow::Latin1::kMaxChar

static const int	kMaxUtf16CodeUnit = 0xffff

static const uint32_t	kMaxUtf16CodeUnitU = kMaxUtf16CodeUnit

static const int	kEmptyStringHash = kIsNotArrayIndexMask

static const int	kMaxLength = (1 << 28) - 16

static const int	kMaxHashCalcLength = 16383

static const int	kMaxShortPrintLength = 1024

Static Public Attributes inherited from v8::internal::Name
static const int	kHashFieldOffset = HeapObject::kHeaderSize

static const int	kSize = kHashFieldOffset + kPointerSize

static const int	kHashNotComputedMask = 1

static const int	kIsNotArrayIndexMask = 1 << 1

static const int	kNofHashBitFields = 2

static const int	kHashShift = kNofHashBitFields

static const uint32_t	kHashBitMask = 0xffffffffu >> kHashShift

static const int	kMaxCachedArrayIndexLength = 7

static const int	kArrayIndexValueBits = 24

static const int	kArrayIndexLengthBits

static const unsigned int	kContainsCachedArrayIndexMask

static const int	kEmptyHashField

Static Public Attributes inherited from v8::internal::HeapObject
static const int	kMapOffset = Object::kHeaderSize

static const int	kHeaderSize = kMapOffset + kPointerSize

Static Public Attributes inherited from v8::internal::Object
static const int	kHeaderSize = 0

Private Member Functions
bool	SlowEquals (String *other)

bool	SlowAsArrayIndex (uint32_t *index)

uint32_t	ComputeAndSetHash ()

	DISALLOW_IMPLICIT_CONSTRUCTORS (String)

Static Private Member Functions
static Handle< String >	SlowFlatten (Handle< ConsString > cons, PretenureFlag tenure)

static bool	SlowEquals (Handle< String > one, Handle< String > two)

Friends
class	Name

class	StringTableInsertionKey

Additional Inherited Members
Protected Member Functions inherited from v8::internal::HeapObject
void	IteratePointers (ObjectVisitor *v, int start, int end)

void	IteratePointer (ObjectVisitor *v, int offset)

void	IterateNextCodeLink (ObjectVisitor *v, int offset)

Static Protected Member Functions inherited from v8::internal::Name
static bool	IsHashFieldComputed (uint32_t field)

Detailed Description

Definition at line 8591 of file objects.h.

Member Enumeration Documentation

◆ Encoding

enum v8::internal::String::Encoding

Enumerator
ONE_BYTE_ENCODING
TWO_BYTE_ENCODING

Definition at line 8593 of file objects.h.

8593 { ONE_BYTE_ENCODING, TWO_BYTE_ENCODING };

v8::internal::String::ONE_BYTE_ENCODING

@ ONE_BYTE_ENCODING

Definition: objects.h:8593

v8::internal::String::TWO_BYTE_ENCODING

@ TWO_BYTE_ENCODING

Definition: objects.h:8593

Member Function Documentation

◆ AsArrayIndex()

bool v8::internal::String::AsArrayIndex ( uint32_t * index )

inline

Definition at line 6606 of file objects-inl.h.

                                          {
   uint32_t field = hash_field();
   if (IsHashFieldComputed(field) && (field & kIsNotArrayIndexMask)) {
     return false;
   }
   return SlowAsArrayIndex(index);
 }

References v8::internal::Name::hash_field(), v8::internal::Name::IsHashFieldComputed(), v8::internal::Name::kIsNotArrayIndexMask, and SlowAsArrayIndex().

Here is the call graph for this function:

◆ CalculateLineEnds()

Handle< FixedArray > v8::internal::String::CalculateLineEnds	(	Handle< String >	string,
		bool	include_ending_line
	)

static

Definition at line 8483 of file objects.cc.

                                                                        {
   src = Flatten(src);
   // Rough estimate of line count based on a roughly estimated average
   // length of (unpacked) code.
   int line_count_estimate = src->length() >> 4;
   List<int> line_ends(line_count_estimate);
   Isolate* isolate = src->GetIsolate();
   { DisallowHeapAllocation no_allocation;  // ensure vectors stay valid.
     // Dispatch on type of strings.
     String::FlatContent content = src->GetFlatContent();
     DCHECK(content.IsFlat());
     if (content.IsOneByte()) {
       CalculateLineEndsImpl(isolate,
                             &line_ends,
                             content.ToOneByteVector(),
                             include_ending_line);
     } else {
       CalculateLineEndsImpl(isolate,
                             &line_ends,
                             content.ToUC16Vector(),
                             include_ending_line);
     }
   }
   int line_count = line_ends.length();
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(line_count);
   for (int i = 0; i < line_count; i++) {
     array->set(i, Smi::FromInt(line_ends[i]));
   }
   return array;
 }

References v8::internal::CalculateLineEndsImpl(), DCHECK, v8::internal::Isolate::factory(), Flatten(), v8::internal::Smi::FromInt(), v8::internal::String::FlatContent::IsFlat(), v8::internal::String::FlatContent::IsOneByte(), v8::internal::String::FlatContent::ToOneByteVector(), and v8::internal::String::FlatContent::ToUC16Vector().

Referenced by v8::internal::Script::InitLineEnds().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeAndSetHash()

uint32_t v8::internal::String::ComputeAndSetHash ( )

private

Definition at line 8844 of file objects.cc.

                                    {
   // Should only be called if hash code has not yet been computed.
   DCHECK(!HasHashCode());
  
   // Store the hash code in the object.
   uint32_t field = IteratingStringHasher::Hash(this, GetHeap()->HashSeed());
   set_hash_field(field);
  
   // Check the hash code is there.
   DCHECK(HasHashCode());
   uint32_t result = field >> kHashShift;
   DCHECK(result != 0);  // Ensure that the hash value of 0 is never computed.
   return result;
 }

References DCHECK, v8::internal::HeapObject::GetHeap(), v8::internal::IteratingStringHasher::Hash(), v8::internal::Name::HasHashCode(), v8::internal::Name::kHashShift, and v8::internal::Name::set_hash_field().

Here is the call graph for this function:

◆ ComputeArrayIndex()

bool v8::internal::String::ComputeArrayIndex ( uint32_t * index )

Definition at line 8860 of file objects.cc.

                                               {
   int length = this->length();
   if (length == 0 || length > kMaxArrayIndexSize) return false;
   ConsStringIteratorOp op;
   StringCharacterStream stream(this, &op);
   return StringToArrayIndex(&stream, index);
 }

References kMaxArrayIndexSize, length(), and v8::internal::StringToArrayIndex().

Referenced by SlowAsArrayIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::String::DISALLOW_IMPLICIT_CONSTRUCTORS ( String )

private

◆ Equals() [1/2]

bool v8::internal::String::Equals	(	Handle< String >	one,
		Handle< String >	two
	)

inlinestatic

Definition at line 3345 of file objects-inl.h.

                                                           {
   if (one.is_identical_to(two)) return true;
   if (one->IsInternalizedString() && two->IsInternalizedString()) {
     return false;
   }
   return SlowEquals(one, two);
 }

◆ Equals() [2/2]

bool v8::internal::String::Equals ( String * other )

inline

Definition at line 3336 of file objects-inl.h.

                                  {
   if (other == this) return true;
   if (this->IsInternalizedString() && other->IsInternalizedString()) {
     return false;
   }
   return SlowEquals(other);
 }

Referenced by v8::internal::LCodeGen::EmitClassOfTest(), v8::internal::LCodeGen::EmitTypeofIs(), v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::GetJSObjectFieldAccess(), v8::internal::CompilationCacheScript::HasOrigin(), v8::internal::StringSharedKey::IsMatch(), v8::internal::Context::Lookup(), v8::internal::ContextSlotCache::Lookup(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::Match(), v8::Object::ObjectProtoToString(), v8::internal::RUNTIME_FUNCTION(), v8::internal::SetCatchVariableValue(), v8::internal::SetContextLocalValue(), v8::internal::SetLocalVariableValue(), v8::Value::StrictEquals(), and v8::internal::HOptimizedGraphBuilder::TryArgumentsAccess().

Here is the caller graph for this function:

◆ Flatten()

Handle< String > v8::internal::String::Flatten	(	Handle< String >	string,
		PretenureFlag	pretenure = `NOT_TENURED`
	)

inlinestatic

Definition at line 3354 of file objects-inl.h.

                                                                              {
   if (!string->IsConsString()) return string;
   Handle<ConsString> cons = Handle<ConsString>::cast(string);
   if (cons->IsFlat()) return handle(cons->first());
   return SlowFlatten(cons, pretenure);
 }

References v8::internal::Handle< T >::cast(), and v8::internal::handle().

Referenced by v8::internal::RegExpImpl::AtomExecRaw(), CalculateLineEnds(), v8::internal::LiveEdit::CompareStrings(), v8::internal::RegExpImpl::Compile(), v8::internal::RegExpEngine::Compile(), v8::internal::RegExpImpl::CompileIrregexp(), v8::internal::ConvertCase(), v8::internal::JSObject::DefineAccessor(), v8::internal::Runtime::DefineObjectProperty(), v8::internal::Runtime::DeleteObjectProperty(), v8::internal::GetCharAt(), v8::internal::MessageHandler::GetMessage(), v8::internal::RegExpImpl::IrregexpPrepare(), v8::internal::BASE_EMBEDDED< Visitor >::JsonParser(), v8::JSON::Parse(), v8::internal::Parser::ParseLazy(), v8::internal::Parser::ParseProgram(), v8::internal::RUNTIME_FUNCTION(), v8::internal::JSObject::SetAccessor(), v8::internal::Runtime::SetObjectProperty(), SlowEquals(), v8::internal::Runtime::StringMatch(), v8::WriteHelper(), and v8::String::WriteUtf8().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetFlatContent()

String::FlatContent v8::internal::String::GetFlatContent ( )

Definition at line 7961 of file objects.cc.

                                          {
   DCHECK(!AllowHeapAllocation::IsAllowed());
   int length = this->length();
   StringShape shape(this);
   String* string = this;
   int offset = 0;
   if (shape.representation_tag() == kConsStringTag) {
     ConsString* cons = ConsString::cast(string);
     if (cons->second()->length() != 0) {
       return FlatContent();
     }
     string = cons->first();
     shape = StringShape(string);
   }
   if (shape.representation_tag() == kSlicedStringTag) {
     SlicedString* slice = SlicedString::cast(string);
     offset = slice->offset();
     string = slice->parent();
     shape = StringShape(string);
     DCHECK(shape.representation_tag() != kConsStringTag &&
            shape.representation_tag() != kSlicedStringTag);
   }
   if (shape.encoding_tag() == kOneByteStringTag) {
     const uint8_t* start;
     if (shape.representation_tag() == kSeqStringTag) {
       start = SeqOneByteString::cast(string)->GetChars();
     } else {
       start = ExternalOneByteString::cast(string)->GetChars();
     }
     return FlatContent(start + offset, length);
   } else {
     DCHECK(shape.encoding_tag() == kTwoByteStringTag);
     const uc16* start;
     if (shape.representation_tag() == kSeqStringTag) {
       start = SeqTwoByteString::cast(string)->GetChars();
     } else {
       start = ExternalTwoByteString::cast(string)->GetChars();
     }
     return FlatContent(start + offset, length);
   }
 }

References DCHECK, v8::internal::ConsString::first(), v8::internal::kConsStringTag, v8::internal::kOneByteStringTag, v8::internal::kSeqStringTag, v8::internal::kSlicedStringTag, v8::internal::kTwoByteStringTag, length(), v8::internal::SlicedString::offset(), v8::internal::SlicedString::parent(), and v8::internal::ConsString::second().

Referenced by v8::internal::RegExpImpl::AtomExecRaw(), v8::internal::FindStringIndicesDispatch(), IsOneByteEqualTo(), and IsTwoByteEqualTo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetForwardedInternalizedString()

String * v8::internal::String::GetForwardedInternalizedString ( )

inline

Definition at line 6630 of file objects-inl.h.

                                                {
   DCHECK(IsInternalizedString());
   if (HasHashCode()) return this;
   String* canonical = String::cast(READ_FIELD(this, kHashFieldOffset));
   DCHECK(canonical->IsInternalizedString());
   DCHECK(SlowEquals(canonical));
   DCHECK(canonical->HasHashCode());
   return canonical;
 }

References DCHECK, v8::internal::Name::HasHashCode(), v8::internal::Name::kHashFieldOffset, READ_FIELD, and SlowEquals().

Here is the call graph for this function:

◆ GetTwoByteData()

const uc16 * v8::internal::String::GetTwoByteData ( unsigned start )

Definition at line 8062 of file objects.cc.

                                                  {
   DCHECK(!IsOneByteRepresentationUnderneath());
   switch (StringShape(this).representation_tag()) {
     case kSeqStringTag:
       return SeqTwoByteString::cast(this)->SeqTwoByteStringGetData(start);
     case kExternalStringTag:
       return ExternalTwoByteString::cast(this)->
         ExternalTwoByteStringGetData(start);
     case kSlicedStringTag: {
       SlicedString* slice = SlicedString::cast(this);
       return slice->parent()->GetTwoByteData(start + slice->offset());
     }
     case kConsStringTag:
       UNREACHABLE();
       return NULL;
   }
   UNREACHABLE();
   return NULL;
 }

References DCHECK, GetTwoByteData(), v8::internal::kConsStringTag, v8::internal::kExternalStringTag, v8::internal::kSeqStringTag, v8::internal::kSlicedStringTag, NULL, v8::internal::SlicedString::offset(), v8::internal::SlicedString::parent(), and UNREACHABLE.

Referenced by GetTwoByteData().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetUnderlying()

String * v8::internal::String::GetUnderlying ( )

inline

Definition at line 3404 of file objects-inl.h.

                               {
   // Giving direct access to underlying string only makes sense if the
   // wrapping string is already flattened.
   DCHECK(this->IsFlat());
   DCHECK(StringShape(this).IsIndirect());
   STATIC_ASSERT(ConsString::kFirstOffset == SlicedString::kParentOffset);
   const int kUnderlyingOffset = SlicedString::kParentOffset;
   return String::cast(READ_FIELD(this, kUnderlyingOffset));
 }

References DCHECK, v8::internal::ConsString::kFirstOffset, v8::internal::SlicedString::kParentOffset, READ_FIELD, and v8::internal::FixedArray::STATIC_ASSERT().

Referenced by IsOneByteRepresentationUnderneath(), and IsTwoByteRepresentationUnderneath().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasOnlyOneByteChars()

bool v8::internal::String::HasOnlyOneByteChars ( )

inline

Definition at line 381 of file objects-inl.h.

                                  {
   uint32_t type = map()->instance_type();
   return (type & kOneByteDataHintMask) == kOneByteDataHintTag ||
          IsOneByteRepresentation();
 }

References v8::internal::Map::instance_type(), IsOneByteRepresentation(), v8::internal::kOneByteDataHintMask, v8::internal::kOneByteDataHintTag, and v8::internal::HeapObject::map().

Referenced by v8::internal::StringBuilderConcatLength().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ INLINE()

v8::internal::String::INLINE ( uint16_t Getint index )

◆ IsAscii() [1/2]

static bool v8::internal::String::IsAscii	(	const char *	chars,
		int	length
	)

inlinestatic

Definition at line 8876 of file objects.h.

                                                             {
     return NonAsciiStart(chars, length) >= length;
   }

◆ IsAscii() [2/2]

static bool v8::internal::String::IsAscii	(	const uint8_t *	chars,
		int	length
	)

inlinestatic

Definition at line 8880 of file objects.h.

                                                                {
     return
         NonAsciiStart(reinterpret_cast<const char*>(chars), length) >= length;
   }

◆ IsFlat()

bool v8::internal::String::IsFlat ( )

inline

Definition at line 3398 of file objects-inl.h.

                     {
   if (!StringShape(this).IsCons()) return true;
   return ConsString::cast(this)->second()->length() == 0;
 }

Referenced by v8::internal::RegExpImpl::AtomExecRaw(), IsOneByteRepresentationUnderneath(), and IsTwoByteRepresentationUnderneath().

Here is the caller graph for this function:

◆ IsOneByte()

static bool v8::internal::String::IsOneByte	(	const uc16 *	chars,
		int	length
	)

inlinestatic

Definition at line 8895 of file objects.h.

                                                               {
     return NonOneByteStart(chars, length) >= length;
   }

Referenced by v8::internal::StringSearchBase::IsOneByteString(), and MakeExternal().

Here is the caller graph for this function:

◆ IsOneByteEqualTo()

bool v8::internal::String::IsOneByteEqualTo ( Vector< const uint8_t > str )

Definition at line 8813 of file objects.cc.

                                                        {
   int slen = length();
   if (str.length() != slen) return false;
   DisallowHeapAllocation no_gc;
   FlatContent content = GetFlatContent();
   if (content.IsOneByte()) {
     return CompareChars(content.ToOneByteVector().start(),
                         str.start(), slen) == 0;
   }
   for (int i = 0; i < slen; i++) {
     if (Get(i) != static_cast<uint16_t>(str[i])) return false;
   }
   return true;
 }

References v8::internal::CompareChars(), GetFlatContent(), v8::internal::String::FlatContent::IsOneByte(), length(), v8::internal::Vector< T >::length(), v8::internal::Vector< T >::start(), and v8::internal::String::FlatContent::ToOneByteVector().

Here is the call graph for this function:

◆ IsOneByteRepresentation()

bool v8::internal::String::IsOneByteRepresentation ( ) const

inline

Definition at line 337 of file objects-inl.h.

                                            {
   uint32_t type = map()->instance_type();
   return (type & kStringEncodingMask) == kOneByteStringTag;
 }

References v8::internal::Map::instance_type(), v8::internal::kOneByteStringTag, v8::internal::kStringEncodingMask, and v8::internal::HeapObject::map().

Referenced by v8::internal::BOOL_ACCESSORS(), HasOnlyOneByteChars(), v8::internal::Heap::IsOneByte(), IsOneByteRepresentationUnderneath(), MakeExternal(), v8::internal::NativeRegExpMacroAssembler::Match(), v8::internal::RUNTIME_FUNCTION(), and v8::internal::NativeRegExpMacroAssembler::StringCharacterPosition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsOneByteRepresentationUnderneath()

bool v8::internal::String::IsOneByteRepresentationUnderneath ( )

inline

Definition at line 349 of file objects-inl.h.

                                                {
   uint32_t type = map()->instance_type();
   STATIC_ASSERT(kIsIndirectStringTag != 0);
   STATIC_ASSERT((kIsIndirectStringMask & kStringEncodingMask) == 0);
   DCHECK(IsFlat());
   switch (type & (kIsIndirectStringMask | kStringEncodingMask)) {
     case kOneByteStringTag:
       return true;
     case kTwoByteStringTag:
       return false;
     default:  // Cons or sliced string.  Need to go deeper.
       return GetUnderlying()->IsOneByteRepresentation();
   }
 }

References DCHECK, GetUnderlying(), v8::internal::Map::instance_type(), IsFlat(), IsOneByteRepresentation(), v8::internal::kIsIndirectStringMask, v8::internal::kIsIndirectStringTag, v8::internal::kOneByteStringTag, v8::internal::kStringEncodingMask, v8::internal::kTwoByteStringTag, v8::internal::HeapObject::map(), and STATIC_ASSERT().

Here is the call graph for this function:

◆ IsTwoByteEqualTo()

bool v8::internal::String::IsTwoByteEqualTo ( Vector< const uc16 > str )

Definition at line 8829 of file objects.cc.

                                                     {
   int slen = length();
   if (str.length() != slen) return false;
   DisallowHeapAllocation no_gc;
   FlatContent content = GetFlatContent();
   if (content.IsTwoByte()) {
     return CompareChars(content.ToUC16Vector().start(), str.start(), slen) == 0;
   }
   for (int i = 0; i < slen; i++) {
     if (Get(i) != str[i]) return false;
   }
   return true;
 }

References v8::internal::CompareChars(), GetFlatContent(), v8::internal::String::FlatContent::IsTwoByte(), length(), v8::internal::Vector< T >::length(), v8::internal::Vector< T >::start(), and v8::internal::String::FlatContent::ToUC16Vector().

Here is the call graph for this function:

◆ IsTwoByteRepresentation()

bool v8::internal::String::IsTwoByteRepresentation ( ) const

inline

Definition at line 343 of file objects-inl.h.

                                            {
   uint32_t type = map()->instance_type();
   return (type & kStringEncodingMask) == kTwoByteStringTag;
 }

References v8::internal::Map::instance_type(), v8::internal::kStringEncodingMask, v8::internal::kTwoByteStringTag, and v8::internal::HeapObject::map().

Referenced by v8::internal::BOOL_ACCESSORS(), IsTwoByteRepresentationUnderneath(), and MakeExternal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsTwoByteRepresentationUnderneath()

bool v8::internal::String::IsTwoByteRepresentationUnderneath ( )

inline

Definition at line 365 of file objects-inl.h.

                                                {
   uint32_t type = map()->instance_type();
   STATIC_ASSERT(kIsIndirectStringTag != 0);
   STATIC_ASSERT((kIsIndirectStringMask & kStringEncodingMask) == 0);
   DCHECK(IsFlat());
   switch (type & (kIsIndirectStringMask | kStringEncodingMask)) {
     case kOneByteStringTag:
       return false;
     case kTwoByteStringTag:
       return true;
     default:  // Cons or sliced string.  Need to go deeper.
       return GetUnderlying()->IsTwoByteRepresentation();
   }
 }

References DCHECK, GetUnderlying(), v8::internal::Map::instance_type(), IsFlat(), IsTwoByteRepresentation(), v8::internal::kIsIndirectStringMask, v8::internal::kIsIndirectStringTag, v8::internal::kOneByteStringTag, v8::internal::kStringEncodingMask, v8::internal::kTwoByteStringTag, v8::internal::HeapObject::map(), and STATIC_ASSERT().

Here is the call graph for this function:

◆ IsUtf8EqualTo()

bool v8::internal::String::IsUtf8EqualTo	(	Vector< const char >	str,
		bool	allow_prefix_match = `false`
	)

Definition at line 8783 of file objects.cc.

                                                                           {
   int slen = length();
   // Can't check exact length equality, but we can check bounds.
   int str_len = str.length();
   if (!allow_prefix_match &&
       (str_len < slen ||
           str_len > slen*static_cast<int>(unibrow::Utf8::kMaxEncodedSize))) {
     return false;
   }
   int i;
   unsigned remaining_in_str = static_cast<unsigned>(str_len);
   const uint8_t* utf8_data = reinterpret_cast<const uint8_t*>(str.start());
   for (i = 0; i < slen && remaining_in_str > 0; i++) {
     unsigned cursor = 0;
     uint32_t r = unibrow::Utf8::ValueOf(utf8_data, remaining_in_str, &cursor);
     DCHECK(cursor > 0 && cursor <= remaining_in_str);
     if (r > unibrow::Utf16::kMaxNonSurrogateCharCode) {
       if (i > slen - 1) return false;
       if (Get(i++) != unibrow::Utf16::LeadSurrogate(r)) return false;
       if (Get(i) != unibrow::Utf16::TrailSurrogate(r)) return false;
     } else {
       if (Get(i) != r) return false;
     }
     utf8_data += cursor;
     remaining_in_str -= cursor;
   }
   return (allow_prefix_match || i == slen) && remaining_in_str == 0;
 }

References DCHECK, unibrow::Utf8::kMaxEncodedSize, unibrow::Utf16::kMaxNonSurrogateCharCode, unibrow::Utf16::LeadSurrogate(), length(), v8::internal::Vector< T >::length(), v8::internal::Vector< T >::start(), unibrow::Utf16::TrailSurrogate(), and unibrow::Utf8::ValueOf().

Referenced by v8::internal::BASE_EMBEDDED< Visitor >::Lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ length()

int v8::internal::String::length ( ) const

inline

Referenced by v8::internal::AnWord(), v8::internal::CodeEventLogger::NameBuffer::AppendString(), v8::internal::RegExpImpl::AtomExecRaw(), v8::Utf8LengthHelper::Calculate(), v8::ContainsOnlyOneByteHelper::CheckCons(), ComputeArrayIndex(), v8::internal::ConsString::ConsStringGet(), v8::internal::ConvertCaseHelper(), v8::internal::StringComparator::Equals(), GetFlatContent(), v8::internal::Script::GetLineNumber(), v8::internal::StringsStorage::GetName(), v8::internal::JSObject::GetOwnElementKeys(), v8::internal::IteratingStringHasher::Hash(), v8::internal::TwoCharHashTableKey::IsMatch(), IsOneByteEqualTo(), v8::internal::Object::IsStringObjectWithCharacterAt(), IsTwoByteEqualTo(), IsUtf8EqualTo(), v8::internal::JoinSparseArrayWithSeparator(), v8::internal::JSObject::JSObjectShortPrint(), MakeExternal(), v8::internal::NativeRegExpMacroAssembler::Match(), PrintOn(), PrintUC16(), v8::internal::RUNTIME_FUNCTION(), v8::internal::ConsStringIteratorOp::Search(), SlowAsArrayIndex(), SlowEquals(), SlowFlatten(), v8::internal::StringBuilderConcatLength(), v8::internal::StringReplaceGlobalAtomRegExpWithString(), StringShortPrint(), v8::Utf8Length(), v8::internal::WriteOneByteData(), WriteToFlat(), and v8::internal::WriteTwoByteData().

Here is the caller graph for this function:

◆ LooksValid()

bool v8::internal::String::LooksValid ( )

Definition at line 7955 of file objects.cc.

                         {
   if (!GetIsolate()->heap()->Contains(this)) return false;
   return true;
 }

References v8::internal::HeapObject::GetIsolate().

Referenced by v8::internal::operator<<(), and StringShortPrint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeExternal() [1/2]

bool v8::internal::String::MakeExternal ( v8::String::ExternalOneByteStringResource * resource )

Definition at line 1051 of file objects.cc.

                                                                          {
   // Externalizing twice leaks the external resource, so it's
   // prohibited by the API.
   DCHECK(!this->IsExternalString());
 #ifdef ENABLE_SLOW_DCHECKS
   if (FLAG_enable_slow_asserts) {
     // Assert that the resource and the string are equivalent.
     DCHECK(static_cast<size_t>(this->length()) == resource->length());
     if (this->IsTwoByteRepresentation()) {
       ScopedVector<uint16_t> smart_chars(this->length());
       String::WriteToFlat(this, smart_chars.start(), 0, this->length());
       DCHECK(String::IsOneByte(smart_chars.start(), this->length()));
     }
     ScopedVector<char> smart_chars(this->length());
     String::WriteToFlat(this, smart_chars.start(), 0, this->length());
     DCHECK(memcmp(smart_chars.start(),
                   resource->data(),
                   resource->length() * sizeof(smart_chars[0])) == 0);
   }
 #endif  // DEBUG
   int size = this->Size();  // Byte size of the original string.
   // Abort if size does not allow in-place conversion.
   if (size < ExternalString::kShortSize) return false;
   Heap* heap = GetHeap();
   bool is_internalized = this->IsInternalizedString();
  
   // Morph the string to an external string by replacing the map and
   // reinitializing the fields.  This won't work if the space the existing
   // string occupies is too small for a regular  external string.
   // Instead, we resort to a short external string instead, omitting
   // the field caching the address of the backing store.  When we encounter
   // short external strings in generated code, we need to bailout to runtime.
   Map* new_map;
   if (size < ExternalString::kSize) {
     new_map = is_internalized
                   ? heap->short_external_one_byte_internalized_string_map()
                   : heap->short_external_one_byte_string_map();
   } else {
     new_map = is_internalized
                   ? heap->external_one_byte_internalized_string_map()
                   : heap->external_one_byte_string_map();
   }
  
   // Byte size of the external String object.
   int new_size = this->SizeFromMap(new_map);
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
  
   // We are storing the new map using release store after creating a filler for
   // the left-over space to avoid races with the sweeper thread.
   this->synchronized_set_map(new_map);
  
   ExternalOneByteString* self = ExternalOneByteString::cast(this);
   self->set_resource(resource);
   if (is_internalized) self->Hash();  // Force regeneration of the hash value.
  
   heap->AdjustLiveBytes(this->address(), new_size - size, Heap::FROM_MUTATOR);
   return true;
 }

References v8::internal::HeapObject::address(), v8::internal::Heap::AdjustLiveBytes(), v8::internal::Heap::CreateFillerObjectAt(), v8::String::ExternalOneByteStringResource::data(), DCHECK, v8::internal::FLAG_enable_slow_asserts, v8::internal::Heap::FROM_MUTATOR, v8::internal::HeapObject::GetHeap(), IsOneByte(), IsTwoByteRepresentation(), v8::internal::ExternalString::kShortSize, v8::internal::ExternalString::kSize, length(), v8::String::ExternalOneByteStringResource::length(), size, v8::internal::HeapObject::Size(), v8::internal::HeapObject::SizeFromMap(), v8::internal::Vector< T >::start(), v8::internal::HeapObject::synchronized_set_map(), and WriteToFlat().

Here is the call graph for this function:

◆ MakeExternal() [2/2]

bool v8::internal::String::MakeExternal ( v8::String::ExternalStringResource * resource )

Definition at line 989 of file objects.cc.

                                                                   {
   // Externalizing twice leaks the external resource, so it's
   // prohibited by the API.
   DCHECK(!this->IsExternalString());
 #ifdef ENABLE_SLOW_DCHECKS
   if (FLAG_enable_slow_asserts) {
     // Assert that the resource and the string are equivalent.
     DCHECK(static_cast<size_t>(this->length()) == resource->length());
     ScopedVector<uc16> smart_chars(this->length());
     String::WriteToFlat(this, smart_chars.start(), 0, this->length());
     DCHECK(memcmp(smart_chars.start(),
                   resource->data(),
                   resource->length() * sizeof(smart_chars[0])) == 0);
   }
 #endif  // DEBUG
   int size = this->Size();  // Byte size of the original string.
   // Abort if size does not allow in-place conversion.
   if (size < ExternalString::kShortSize) return false;
   Heap* heap = GetHeap();
   bool is_one_byte = this->IsOneByteRepresentation();
   bool is_internalized = this->IsInternalizedString();
  
   // Morph the string to an external string by replacing the map and
   // reinitializing the fields.  This won't work if the space the existing
   // string occupies is too small for a regular  external string.
   // Instead, we resort to a short external string instead, omitting
   // the field caching the address of the backing store.  When we encounter
   // short external strings in generated code, we need to bailout to runtime.
   Map* new_map;
   if (size < ExternalString::kSize) {
     new_map = is_internalized
         ? (is_one_byte
            ? heap->short_external_internalized_string_with_one_byte_data_map()
            : heap->short_external_internalized_string_map())
         : (is_one_byte ? heap->short_external_string_with_one_byte_data_map()
                        : heap->short_external_string_map());
   } else {
     new_map = is_internalized
         ? (is_one_byte
            ? heap->external_internalized_string_with_one_byte_data_map()
            : heap->external_internalized_string_map())
         : (is_one_byte ? heap->external_string_with_one_byte_data_map()
                        : heap->external_string_map());
   }
  
   // Byte size of the external String object.
   int new_size = this->SizeFromMap(new_map);
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
  
   // We are storing the new map using release store after creating a filler for
   // the left-over space to avoid races with the sweeper thread.
   this->synchronized_set_map(new_map);
  
   ExternalTwoByteString* self = ExternalTwoByteString::cast(this);
   self->set_resource(resource);
   if (is_internalized) self->Hash();  // Force regeneration of the hash value.
  
   heap->AdjustLiveBytes(this->address(), new_size - size, Heap::FROM_MUTATOR);
   return true;
 }

References v8::internal::HeapObject::address(), v8::internal::Heap::AdjustLiveBytes(), v8::internal::Heap::CreateFillerObjectAt(), v8::String::ExternalStringResource::data(), DCHECK, v8::internal::FLAG_enable_slow_asserts, v8::internal::Heap::FROM_MUTATOR, v8::internal::HeapObject::GetHeap(), IsOneByteRepresentation(), v8::internal::ExternalString::kShortSize, v8::internal::ExternalString::kSize, length(), v8::String::ExternalStringResource::length(), size, v8::internal::HeapObject::Size(), v8::internal::HeapObject::SizeFromMap(), v8::internal::Vector< T >::start(), v8::internal::HeapObject::synchronized_set_map(), and WriteToFlat().

Here is the call graph for this function:

◆ MarkAsUndetectable()

bool v8::internal::String::MarkAsUndetectable ( )

Definition at line 8766 of file objects.cc.

                                 {
   if (StringShape(this).IsInternalized()) return false;
  
   Map* map = this->map();
   Heap* heap = GetHeap();
   if (map == heap->string_map()) {
     this->set_map(heap->undetectable_string_map());
     return true;
   } else if (map == heap->one_byte_string_map()) {
     this->set_map(heap->undetectable_one_byte_string_map());
     return true;
   }
   // Rest cannot be marked as undetectable
   return false;
 }

References v8::internal::HeapObject::GetHeap(), v8::internal::HeapObject::map(), and v8::internal::HeapObject::set_map().

Here is the call graph for this function:

◆ NonAsciiStart()

static int v8::internal::String::NonAsciiStart	(	const char *	chars,
		int	length
	)

inlinestatic

Definition at line 8843 of file objects.h.

                                                                  {
     const char* start = chars;
     const char* limit = chars + length;
  
     if (length >= kIntptrSize) {
       // Check unaligned bytes.
       while (!IsAligned(reinterpret_cast<intptr_t>(chars), sizeof(uintptr_t))) {
         if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
           return static_cast<int>(chars - start);
         }
         ++chars;
       }
       // Check aligned words.
       DCHECK(unibrow::Utf8::kMaxOneByteChar == 0x7F);
       const uintptr_t non_one_byte_mask = kUintptrAllBitsSet / 0xFF * 0x80;
       while (chars + sizeof(uintptr_t) <= limit) {
         if (*reinterpret_cast<const uintptr_t*>(chars) & non_one_byte_mask) {
           return static_cast<int>(chars - start);
         }
         chars += sizeof(uintptr_t);
       }
     }
     // Check remaining unaligned bytes.
     while (chars < limit) {
       if (static_cast<uint8_t>(*chars) > unibrow::Utf8::kMaxOneByteChar) {
         return static_cast<int>(chars - start);
       }
       ++chars;
     }
  
     return static_cast<int>(chars - start);
   }

References DCHECK, v8::internal::IsAligned(), v8::internal::kIntptrSize, unibrow::Utf8::kMaxOneByteChar, and v8::internal::kUintptrAllBitsSet.

Here is the call graph for this function:

◆ NonOneByteStart()

static int v8::internal::String::NonOneByteStart	(	const uc16 *	chars,
		int	length
	)

inlinestatic

Definition at line 8885 of file objects.h.

                                                                    {
     const uc16* limit = chars + length;
     const uc16* start = chars;
     while (chars < limit) {
       if (*chars > kMaxOneByteCharCodeU) return static_cast<int>(chars - start);
       ++chars;
     }
     return static_cast<int>(chars - start);
   }

◆ PrintOn()

void v8::internal::String::PrintOn ( FILE * out )

Definition at line 9005 of file objects.cc.

                                {
   int length = this->length();
   for (int i = 0; i < length; i++) {
     PrintF(file, "%c", Get(i));
   }
 }

References length(), and v8::internal::PrintF().

Referenced by v8::internal::Map::PrintGeneralization(), and v8::internal::JSObject::PrintInstanceMigration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintUC16()

void v8::internal::String::PrintUC16	(	OStream &	os,
		int	start = `0`,
		int	end = `-1`
	)

Definition at line 1175 of file objects.cc.

                                                       {  // NOLINT
   if (end < 0) end = length();
   ConsStringIteratorOp op;
   StringCharacterStream stream(this, &op, start);
   for (int i = start; i < end && stream.HasMore(); i++) {
     os << AsUC16(stream.GetNext());
   }
 }

References v8::internal::StringCharacterStream::GetNext(), v8::internal::StringCharacterStream::HasMore(), and length().

Referenced by v8::internal::operator<<().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Set()

void v8::internal::String::Set	(	int	index,
		uint16_t	value
	)

inline

Definition at line 3388 of file objects-inl.h.

                                           {
   DCHECK(index >= 0 && index < length());
   DCHECK(StringShape(this).IsSequential());
  
   return this->IsOneByteRepresentation()
       ? SeqOneByteString::cast(this)->SeqOneByteStringSet(index, value)
       : SeqTwoByteString::cast(this)->SeqTwoByteStringSet(index, value);
 }

References DCHECK, and v8::internal::FixedArrayBase::length().

Referenced by v8::internal::ConvertCaseHelper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_length()

void v8::internal::String::set_length ( int value )

inline

Referenced by v8::internal::Heap::AllocateInternalizedStringImpl(), v8::internal::Heap::AllocateOneByteInternalizedString(), and v8::internal::Heap::AllocateTwoByteInternalizedString().

Here is the caller graph for this function:

◆ SetForwardedInternalizedString()

void v8::internal::String::SetForwardedInternalizedString ( String * string )

inline

Definition at line 6615 of file objects-inl.h.

                                                              {
   DCHECK(IsInternalizedString());
   DCHECK(HasHashCode());
   if (canonical == this) return;  // No need to forward.
   DCHECK(SlowEquals(canonical));
   DCHECK(canonical->IsInternalizedString());
   DCHECK(canonical->HasHashCode());
   WRITE_FIELD(this, kHashFieldOffset, canonical);
   // Setting the hash field to a tagged value sets the LSB, causing the hash
   // code to be interpreted as uninitialized.  We use this fact to recognize
   // that we have a forwarded string.
   DCHECK(!HasHashCode());
 }

References DCHECK, v8::internal::Name::HasHashCode(), v8::internal::Name::kHashFieldOffset, SlowEquals(), and WRITE_FIELD.

Here is the call graph for this function:

◆ SlowAsArrayIndex()

bool v8::internal::String::SlowAsArrayIndex ( uint32_t * index )

private

Definition at line 8869 of file objects.cc.

                                              {
   if (length() <= kMaxCachedArrayIndexLength) {
     Hash();  // force computation of hash code
     uint32_t field = hash_field();
     if ((field & kIsNotArrayIndexMask) != 0) return false;
     // Isolate the array index form the full hash field.
     *index = ArrayIndexValueBits::decode(field);
     return true;
   } else {
     return ComputeArrayIndex(index);
   }
 }

References ComputeArrayIndex(), v8::internal::BitFieldBase< T, shift, size, U >::decode(), v8::internal::Name::Hash(), v8::internal::Name::hash_field(), v8::internal::Name::kIsNotArrayIndexMask, kMaxCachedArrayIndexLength, and length().

Referenced by AsArrayIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SlowEquals() [1/2]

bool v8::internal::String::SlowEquals	(	Handle< String >	one,
		Handle< String >	two
	)

staticprivate

Definition at line 8716 of file objects.cc.

                                                               {
   // Fast check: negative check with lengths.
   int one_length = one->length();
   if (one_length != two->length()) return false;
   if (one_length == 0) return true;
  
   // Fast check: if hash code is computed for both strings
   // a fast negative check can be performed.
   if (one->HasHashCode() && two->HasHashCode()) {
 #ifdef ENABLE_SLOW_DCHECKS
     if (FLAG_enable_slow_asserts) {
       if (one->Hash() != two->Hash()) {
         bool found_difference = false;
         for (int i = 0; i < one_length; i++) {
           if (one->Get(i) != two->Get(i)) {
             found_difference = true;
             break;
           }
         }
         DCHECK(found_difference);
       }
     }
 #endif
     if (one->Hash() != two->Hash()) return false;
   }
  
   // We know the strings are both non-empty. Compare the first chars
   // before we try to flatten the strings.
   if (one->Get(0) != two->Get(0)) return false;
  
   one = String::Flatten(one);
   two = String::Flatten(two);
  
   DisallowHeapAllocation no_gc;
   String::FlatContent flat1 = one->GetFlatContent();
   String::FlatContent flat2 = two->GetFlatContent();
  
   if (flat1.IsOneByte() && flat2.IsOneByte()) {
       return CompareRawStringContents(flat1.ToOneByteVector().start(),
                                       flat2.ToOneByteVector().start(),
                                       one_length);
   } else {
     for (int i = 0; i < one_length; i++) {
       if (flat1.Get(i) != flat2.Get(i)) return false;
     }
     return true;
   }
 }

References v8::internal::CompareRawStringContents(), DCHECK, v8::internal::FLAG_enable_slow_asserts, Flatten(), v8::internal::String::FlatContent::Get(), v8::internal::String::FlatContent::IsOneByte(), and v8::internal::String::FlatContent::ToOneByteVector().

Here is the call graph for this function:

◆ SlowEquals() [2/2]

bool v8::internal::String::SlowEquals ( String * other )

private

Definition at line 8671 of file objects.cc.

                                      {
   DisallowHeapAllocation no_gc;
   // Fast check: negative check with lengths.
   int len = length();
   if (len != other->length()) return false;
   if (len == 0) return true;
  
   // Fast check: if hash code is computed for both strings
   // a fast negative check can be performed.
   if (HasHashCode() && other->HasHashCode()) {
 #ifdef ENABLE_SLOW_DCHECKS
     if (FLAG_enable_slow_asserts) {
       if (Hash() != other->Hash()) {
         bool found_difference = false;
         for (int i = 0; i < len; i++) {
           if (Get(i) != other->Get(i)) {
             found_difference = true;
             break;
           }
         }
         DCHECK(found_difference);
       }
     }
 #endif
     if (Hash() != other->Hash()) return false;
   }
  
   // We know the strings are both non-empty. Compare the first chars
   // before we try to flatten the strings.
   if (this->Get(0) != other->Get(0)) return false;
  
   if (IsSeqOneByteString() && other->IsSeqOneByteString()) {
     const uint8_t* str1 = SeqOneByteString::cast(this)->GetChars();
     const uint8_t* str2 = SeqOneByteString::cast(other)->GetChars();
     return CompareRawStringContents(str1, str2, len);
   }
  
   Isolate* isolate = GetIsolate();
   StringComparator comparator(isolate->objects_string_compare_iterator_a(),
                               isolate->objects_string_compare_iterator_b());
  
   return comparator.Equals(this, other);
 }

References v8::internal::anonymous_namespace{heap-snapshot-generator.cc}::comparator(), v8::internal::CompareRawStringContents(), DCHECK, v8::internal::FLAG_enable_slow_asserts, v8::internal::HeapObject::GetIsolate(), v8::internal::Name::Hash(), v8::internal::Name::HasHashCode(), length(), v8::internal::Isolate::objects_string_compare_iterator_a(), and v8::internal::Isolate::objects_string_compare_iterator_b().

Referenced by v8::internal::Name::Equals(), GetForwardedInternalizedString(), v8::internal::StringTableInsertionKey::IsMatch(), and SetForwardedInternalizedString().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SlowFlatten()

Handle< String > v8::internal::String::SlowFlatten	(	Handle< ConsString >	cons,
		PretenureFlag	tenure
	)

staticprivate

Definition at line 959 of file objects.cc.

                                                             {
   DCHECK(AllowHeapAllocation::IsAllowed());
   DCHECK(cons->second()->length() != 0);
   Isolate* isolate = cons->GetIsolate();
   int length = cons->length();
   PretenureFlag tenure = isolate->heap()->InNewSpace(*cons) ? pretenure
                                                             : TENURED;
   Handle<SeqString> result;
   if (cons->IsOneByteRepresentation()) {
     Handle<SeqOneByteString> flat = isolate->factory()->NewRawOneByteString(
         length, tenure).ToHandleChecked();
     DisallowHeapAllocation no_gc;
     WriteToFlat(*cons, flat->GetChars(), 0, length);
     result = flat;
   } else {
     Handle<SeqTwoByteString> flat = isolate->factory()->NewRawTwoByteString(
         length, tenure).ToHandleChecked();
     DisallowHeapAllocation no_gc;
     WriteToFlat(*cons, flat->GetChars(), 0, length);
     result = flat;
   }
   cons->set_first(*result);
   cons->set_second(isolate->heap()->empty_string());
   DCHECK(result->IsFlat());
   return result;
 }

References DCHECK, v8::internal::Isolate::factory(), v8::internal::Isolate::heap(), v8::internal::Heap::InNewSpace(), length(), v8::internal::TENURED, and WriteToFlat().

Here is the call graph for this function:

◆ STATIC_ASSERT() [1/3]

v8::internal::String::STATIC_ASSERT ( (kArrayIndexLengthBits > 0) )

◆ STATIC_ASSERT() [2/3]

v8::internal::String::STATIC_ASSERT ( IS_POWER_OF_TWO(kMaxCachedArrayIndexLength+1) )

◆ STATIC_ASSERT() [3/3]

v8::internal::String::STATIC_ASSERT ( )

Referenced by IsOneByteRepresentationUnderneath(), and IsTwoByteRepresentationUnderneath().

Here is the caller graph for this function:

◆ StringShortPrint()

void v8::internal::String::StringShortPrint ( StringStream * accumulator )

Definition at line 1111 of file objects.cc.

                                                        {
   int len = length();
   if (len > kMaxShortPrintLength) {
     accumulator->Add("<Very long string[%u]>", len);
     return;
   }
  
   if (!LooksValid()) {
     accumulator->Add("<Invalid String>");
     return;
   }
  
   ConsStringIteratorOp op;
   StringCharacterStream stream(this, &op);
  
   bool truncated = false;
   if (len > kMaxShortPrintLength) {
     len = kMaxShortPrintLength;
     truncated = true;
   }
   bool one_byte = true;
   for (int i = 0; i < len; i++) {
     uint16_t c = stream.GetNext();
  
     if (c < 32 || c >= 127) {
       one_byte = false;
     }
   }
   stream.Reset(this);
   if (one_byte) {
     accumulator->Add("<String[%u]: ", length());
     for (int i = 0; i < len; i++) {
       accumulator->Put(static_cast<char>(stream.GetNext()));
     }
     accumulator->Put('>');
   } else {
     // Backslash indicates that the string contains control
     // characters and that backslashes are therefore escaped.
     accumulator->Add("<String[%u]\\: ", length());
     for (int i = 0; i < len; i++) {
       uint16_t c = stream.GetNext();
       if (c == '\n') {
         accumulator->Add("\\n");
       } else if (c == '\r') {
         accumulator->Add("\\r");
       } else if (c == '\\') {
         accumulator->Add("\\\\");
       } else if (c < 32 || c > 126) {
         accumulator->Add("\\x%02x", c);
       } else {
         accumulator->Put(static_cast<char>(c));
       }
     }
     if (truncated) {
       accumulator->Put('.');
       accumulator->Put('.');
       accumulator->Put('.');
     }
     accumulator->Put('>');
   }
   return;
 }

References v8::internal::StringCharacterStream::GetNext(), kMaxShortPrintLength, length(), LooksValid(), and v8::internal::StringCharacterStream::Reset().

Here is the call graph for this function:

◆ synchronized_length()

int v8::internal::String::synchronized_length ( ) const

inline

◆ synchronized_set_length()

void v8::internal::String::synchronized_set_length ( int value )

inline

◆ ToCString() [1/2]

SmartArrayPointer< char > v8::internal::String::ToCString	(	AllowNullsFlag	allow_nulls,
		RobustnessFlag	robustness_flag,
		int	offset,
		int	length,
		int *	length_output = `0`
	)

Definition at line 8004 of file objects.cc.

                                                               {
   if (robust_flag == ROBUST_STRING_TRAVERSAL && !LooksValid()) {
     return SmartArrayPointer<char>(NULL);
   }
   Heap* heap = GetHeap();
  
   // Negative length means the to the end of the string.
   if (length < 0) length = kMaxInt - offset;
  
   // Compute the size of the UTF-8 string. Start at the specified offset.
   Access<ConsStringIteratorOp> op(
       heap->isolate()->objects_string_iterator());
   StringCharacterStream stream(this, op.value(), offset);
   int character_position = offset;
   int utf8_bytes = 0;
   int last = unibrow::Utf16::kNoPreviousCharacter;
   while (stream.HasMore() && character_position++ < offset + length) {
     uint16_t character = stream.GetNext();
     utf8_bytes += unibrow::Utf8::Length(character, last);
     last = character;
   }
  
   if (length_return) {
     *length_return = utf8_bytes;
   }
  
   char* result = NewArray<char>(utf8_bytes + 1);
  
   // Convert the UTF-16 string to a UTF-8 buffer. Start at the specified offset.
   stream.Reset(this, offset);
   character_position = offset;
   int utf8_byte_position = 0;
   last = unibrow::Utf16::kNoPreviousCharacter;
   while (stream.HasMore() && character_position++ < offset + length) {
     uint16_t character = stream.GetNext();
     if (allow_nulls == DISALLOW_NULLS && character == 0) {
       character = ' ';
     }
     utf8_byte_position +=
         unibrow::Utf8::Encode(result + utf8_byte_position, character, last);
     last = character;
   }
   result[utf8_byte_position] = 0;
   return SmartArrayPointer<char>(result);
 }

References v8::internal::DISALLOW_NULLS, unibrow::Utf8::Encode(), v8::internal::HeapObject::GetHeap(), v8::internal::StringCharacterStream::GetNext(), v8::internal::StringCharacterStream::HasMore(), v8::internal::Heap::isolate(), v8::internal::kMaxInt, unibrow::Utf16::kNoPreviousCharacter, unibrow::Utf8::Length(), NULL, v8::internal::Isolate::objects_string_iterator(), v8::internal::StringCharacterStream::Reset(), v8::internal::ROBUST_STRING_TRAVERSAL, and v8::internal::Access< T >::value().

Referenced by v8::internal::Logger::ApiIndexedPropertyAccess(), v8::internal::Logger::ApiNamedPropertyAccess(), v8::internal::Logger::ApiObjectAccess(), v8::internal::Logger::CodeCreateEvent(), v8::internal::Logger::CodeDisableOptEvent(), v8::internal::StringsStorage::GetName(), v8::internal::Deoptimizer::GetOutputInfo(), v8::internal::HeapObject::HeapObjectShortPrint(), v8::internal::RegExpImpl::IrregexpExec(), and v8::internal::JavaScriptFrame::PrintFunctionAndOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToCString() [2/2]

SmartArrayPointer< char > v8::internal::String::ToCString	(	AllowNullsFlag	allow_nulls = `DISALLOW_NULLS`,
		RobustnessFlag	robustness_flag = `FAST_STRING_TRAVERSAL`,
		int *	length_output = `0`
	)

Definition at line 8055 of file objects.cc.

                                                               {
   return ToCString(allow_nulls, robust_flag, 0, -1, length_return);
 }

◆ ToWideCString()

SmartArrayPointer< uc16 > v8::internal::String::ToWideCString ( RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL )

Definition at line 8083 of file objects.cc.

                                                                         {
   if (robust_flag == ROBUST_STRING_TRAVERSAL && !LooksValid()) {
     return SmartArrayPointer<uc16>();
   }
   Heap* heap = GetHeap();
  
   Access<ConsStringIteratorOp> op(
       heap->isolate()->objects_string_iterator());
   StringCharacterStream stream(this, op.value());
  
   uc16* result = NewArray<uc16>(length() + 1);
  
   int i = 0;
   while (stream.HasMore()) {
     uint16_t character = stream.GetNext();
     result[i++] = character;
   }
   result[i] = 0;
   return SmartArrayPointer<uc16>(result);
 }

References v8::internal::HeapObject::GetHeap(), v8::internal::StringCharacterStream::GetNext(), v8::internal::StringCharacterStream::HasMore(), v8::internal::Heap::isolate(), v8::internal::Isolate::objects_string_iterator(), v8::internal::ROBUST_STRING_TRAVERSAL, and v8::internal::Access< T >::value().

Here is the call graph for this function:

◆ VisitFlat()

template<class Visitor >

ConsString * v8::internal::String::VisitFlat	(	Visitor *	visitor,
		String *	string,
		int	offset = `0`
	)

inlinestatic

Definition at line 3416 of file objects-inl.h.

                                                 {
   int slice_offset = offset;
   const int length = string->length();
   DCHECK(offset <= length);
   while (true) {
     int32_t type = string->map()->instance_type();
     switch (type & (kStringRepresentationMask | kStringEncodingMask)) {
       case kSeqStringTag | kOneByteStringTag:
         visitor->VisitOneByteString(
             SeqOneByteString::cast(string)->GetChars() + slice_offset,
             length - offset);
         return NULL;
  
       case kSeqStringTag | kTwoByteStringTag:
         visitor->VisitTwoByteString(
             SeqTwoByteString::cast(string)->GetChars() + slice_offset,
             length - offset);
         return NULL;
  
       case kExternalStringTag | kOneByteStringTag:
         visitor->VisitOneByteString(
             ExternalOneByteString::cast(string)->GetChars() + slice_offset,
             length - offset);
         return NULL;
  
       case kExternalStringTag | kTwoByteStringTag:
         visitor->VisitTwoByteString(
             ExternalTwoByteString::cast(string)->GetChars() + slice_offset,
             length - offset);
         return NULL;
  
       case kSlicedStringTag | kOneByteStringTag:
       case kSlicedStringTag | kTwoByteStringTag: {
         SlicedString* slicedString = SlicedString::cast(string);
         slice_offset += slicedString->offset();
         string = slicedString->parent();
         continue;
       }
  
       case kConsStringTag | kOneByteStringTag:
       case kConsStringTag | kTwoByteStringTag:
         return ConsString::cast(string);
  
       default:
         UNREACHABLE();
         return NULL;
     }
   }
 }

References DCHECK, v8::internal::kConsStringTag, v8::internal::kExternalStringTag, v8::internal::kOneByteStringTag, v8::internal::kSeqStringTag, v8::internal::kSlicedStringTag, v8::internal::kStringEncodingMask, v8::internal::kStringRepresentationMask, v8::internal::kTwoByteStringTag, v8::internal::FixedArrayBase::length(), NULL, v8::internal::SlicedString::offset(), v8::internal::SlicedString::parent(), and UNREACHABLE.

Referenced by v8::internal::StringComparator::State::Advance(), v8::ContainsOnlyOneByteHelper::Check(), v8::ContainsOnlyOneByteHelper::CheckCons(), v8::internal::IteratingStringHasher::Hash(), v8::internal::StringCharacterStream::HasMore(), v8::internal::StringComparator::State::Init(), v8::RecursivelySerializeToUtf8(), v8::internal::StringCharacterStream::Reset(), v8::Utf8LengthHelper::Visitor::VisitFlat(), and v8::String::WriteUtf8().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WriteToFlat()

template<typename sinkchar >

void v8::internal::String::WriteToFlat	(	String *	source,
		sinkchar *	sink,
		int	from,
		int	to
	)

static

Definition at line 8370 of file objects.cc.

                                 {
   String* source = src;
   int from = f;
   int to = t;
   while (true) {
     DCHECK(0 <= from && from <= to && to <= source->length());
     switch (StringShape(source).full_representation_tag()) {
       case kOneByteStringTag | kExternalStringTag: {
         CopyChars(sink, ExternalOneByteString::cast(source)->GetChars() + from,
                   to - from);
         return;
       }
       case kTwoByteStringTag | kExternalStringTag: {
         const uc16* data =
             ExternalTwoByteString::cast(source)->GetChars();
         CopyChars(sink,
                   data + from,
                   to - from);
         return;
       }
       case kOneByteStringTag | kSeqStringTag: {
         CopyChars(sink,
                   SeqOneByteString::cast(source)->GetChars() + from,
                   to - from);
         return;
       }
       case kTwoByteStringTag | kSeqStringTag: {
         CopyChars(sink,
                   SeqTwoByteString::cast(source)->GetChars() + from,
                   to - from);
         return;
       }
       case kOneByteStringTag | kConsStringTag:
       case kTwoByteStringTag | kConsStringTag: {
         ConsString* cons_string = ConsString::cast(source);
         String* first = cons_string->first();
         int boundary = first->length();
         if (to - boundary >= boundary - from) {
           // Right hand side is longer.  Recurse over left.
           if (from < boundary) {
             WriteToFlat(first, sink, from, boundary);
             sink += boundary - from;
             from = 0;
           } else {
             from -= boundary;
           }
           to -= boundary;
           source = cons_string->second();
         } else {
           // Left hand side is longer.  Recurse over right.
           if (to > boundary) {
             String* second = cons_string->second();
             // When repeatedly appending to a string, we get a cons string that
             // is unbalanced to the left, a list, essentially.  We inline the
             // common case of sequential one-byte right child.
             if (to - boundary == 1) {
               sink[boundary - from] = static_cast<sinkchar>(second->Get(0));
             } else if (second->IsSeqOneByteString()) {
               CopyChars(sink + boundary - from,
                         SeqOneByteString::cast(second)->GetChars(),
                         to - boundary);
             } else {
               WriteToFlat(second,
                           sink + boundary - from,
                           0,
                           to - boundary);
             }
             to = boundary;
           }
           source = first;
         }
         break;
       }
       case kOneByteStringTag | kSlicedStringTag:
       case kTwoByteStringTag | kSlicedStringTag: {
         SlicedString* slice = SlicedString::cast(source);
         unsigned offset = slice->offset();
         WriteToFlat(slice->parent(), sink, from + offset, to + offset);
         return;
       }
     }
   }
 }

References v8::internal::CopyChars(), DCHECK, v8::internal::ConsString::first(), v8::internal::kConsStringTag, v8::internal::kExternalStringTag, v8::internal::kOneByteStringTag, v8::internal::kSeqStringTag, v8::internal::kSlicedStringTag, v8::internal::kTwoByteStringTag, length(), v8::internal::SlicedString::offset(), v8::internal::SlicedString::parent(), v8::internal::ConsString::second(), and to().

Referenced by v8::internal::CodeEventLogger::NameBuffer::AppendString(), v8::internal::ConcatStringContent(), v8::internal::ExternalizeStringExtension::Externalize(), MakeExternal(), v8::internal::RUNTIME_FUNCTION(), SlowFlatten(), v8::internal::StringBuilderConcatHelper(), v8::internal::StringReplaceGlobalAtomRegExpWithString(), v8::internal::StringReplaceGlobalRegExpWithEmptyString(), v8::WriteHelper(), v8::internal::WriteOneByteData(), and v8::internal::WriteTwoByteData().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ Name

friend class Name

friend

Definition at line 8913 of file objects.h.

◆ StringTableInsertionKey

friend class StringTableInsertionKey

friend

Definition at line 8914 of file objects.h.

Member Data Documentation

◆ kArrayIndexLengthBits

const int v8::internal::String::kArrayIndexLengthBits

static

Initial value:

=

kBitsPerInt - kArrayIndexValueBits - kNofHashBitFields

v8::internal::Name::kNofHashBitFields

static const int kNofHashBitFields

Definition: objects.h:8496

v8::internal::String::kArrayIndexValueBits

static const int kArrayIndexValueBits

Definition: objects.h:8601

v8::internal::kBitsPerInt

const int kBitsPerInt

Definition: globals.h:165

Definition at line 8602 of file objects.h.

◆ kArrayIndexValueBits

const int v8::internal::String::kArrayIndexValueBits = 24

static

Definition at line 8601 of file objects.h.

Referenced by v8::internal::StringHasher::MakeArrayIndexHash().

◆ kContainsCachedArrayIndexMask

const unsigned int v8::internal::String::kContainsCachedArrayIndexMask

static

Initial value:

=
      (~static_cast<unsigned>(kMaxCachedArrayIndexLength)
       << ArrayIndexLengthBits::kShift) |
      kIsNotArrayIndexMask

Definition at line 8618 of file objects.h.

Referenced by v8::internal::StringHasher::MakeArrayIndexHash().

◆ kEmptyStringHash

const int v8::internal::String::kEmptyStringHash = kIsNotArrayIndexMask

static

Definition at line 8817 of file objects.h.

Referenced by v8::internal::Heap::CreateInitialObjects().

◆ kLengthOffset

const int v8::internal::String::kLengthOffset = Name::kSize

static

Definition at line 8802 of file objects.h.

Referenced by v8::internal::CodeStubGraphBuilder< Stub >::BuildCodeStub(), v8::internal::LoadIC::CompileHandler(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForStringLength(), and v8::internal::Accessors::IsJSObjectFieldAccessor().

◆ kMaxArrayIndexSize

const int v8::internal::String::kMaxArrayIndexSize = 10

static

Definition at line 8807 of file objects.h.

Referenced by v8::internal::AstRawString::AsArrayIndex(), ComputeArrayIndex(), v8::internal::StringHasher::ComputeUtf8Hash(), v8::internal::StringHasher::MakeArrayIndexHash(), and v8::internal::RUNTIME_FUNCTION().

◆ kMaxCachedArrayIndexLength

const int v8::internal::String::kMaxCachedArrayIndexLength = 7

static

Definition at line 8596 of file objects.h.

Referenced by v8::internal::StringHasher::MakeArrayIndexHash(), and SlowAsArrayIndex().

◆ kMaxHashCalcLength

const int v8::internal::String::kMaxHashCalcLength = 16383

static

Definition at line 8824 of file objects.h.

Referenced by v8::internal::StringHasher::ComputeUtf8Hash(), v8::internal::StringHasher::GetHashField(), and v8::internal::StringHasher::has_trivial_hash().

◆ kMaxLength

const int v8::internal::String::kMaxLength = (1 << 28) - 16

static

Definition at line 8820 of file objects.h.

Referenced by v8::internal::Heap::AllocateInternalizedStringImpl(), v8::internal::Heap::AllocateOneByteInternalizedString(), v8::internal::Heap::AllocateRawOneByteString(), v8::internal::Heap::AllocateRawTwoByteString(), v8::internal::Heap::AllocateTwoByteInternalizedString(), v8::internal::ConvertCaseHelper(), v8::internal::URIEscape::Escape(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForStringLength(), v8::internal::ReplacementStringBuilder::IncrementCharacterCount(), v8::internal::FuncNameInferrer::MakeNameFromStackHelper(), v8::internal::RUNTIME_FUNCTION(), v8::internal::StringBuilderConcatLength(), v8::internal::StringReplaceGlobalAtomRegExpWithString(), and v8::internal::URIUnescape::UnescapeSlow().

◆ kMaxOneByteCharCode

const int32_t v8::internal::String::kMaxOneByteCharCode = unibrow::Latin1::kMaxChar

static

Definition at line 8811 of file objects.h.

Referenced by v8::internal::CharacterRange::AddCaseEquivalents(), v8::internal::BoyerMooreLookahead::BoyerMooreLookahead(), v8::internal::Heap::CreateInitialObjects(), v8::internal::EmitCharClass(), v8::internal::RegExpNode::EmitQuickCheck(), v8::internal::TextNode::FillInBMInfo(), v8::internal::TextNode::FilterOneByte(), v8::internal::GetCaseIndependentLetters(), v8::internal::TextNode::GetQuickCheckDetails(), v8::internal::TextNode::GetSuccessorOfOmnivorousTextNode(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::InferRange(), v8::internal::QuickCheckDetails::Rationalize(), v8::internal::ShortCutEmitCharacterPair(), v8::internal::SplitSearchSpace(), v8::internal::StringMatchBackwards(), v8::internal::TextNode::TextEmitPass(), and v8::internal::URIUnescape::UnescapeSlow().

◆ kMaxOneByteCharCodeU

const uint32_t v8::internal::String::kMaxOneByteCharCodeU = unibrow::Latin1::kMaxChar

static

Definition at line 8812 of file objects.h.

Referenced by v8::internal::EmitAtomNonLetter(), v8::internal::StringSearch< PatternChar, SubjectChar >::exceedsOneByte(), and v8::internal::MakeOrFindTwoCharacterString().

◆ kMaxShortPrintLength

const int v8::internal::String::kMaxShortPrintLength = 1024

static

Definition at line 8827 of file objects.h.

Referenced by StringShortPrint().

◆ kMaxUtf16CodeUnit

const int v8::internal::String::kMaxUtf16CodeUnit = 0xffff

static

Definition at line 8813 of file objects.h.

Referenced by v8::internal::AddClassNegated(), v8::internal::DispatchTableConstructor::AddInverse(), v8::internal::DispatchTable::AddRange(), v8::internal::AddRange(), v8::internal::BoyerMooreLookahead::BoyerMooreLookahead(), v8::internal::EmitCharClass(), v8::internal::RegExpNode::EmitQuickCheck(), v8::internal::TextNode::GetQuickCheckDetails(), v8::internal::TextNode::GetSuccessorOfOmnivorousTextNode(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::InferRange(), v8::internal::CharacterRange::Negate(), v8::internal::QuickCheckDetails::Rationalize(), and v8::internal::ShortCutEmitCharacterPair().

◆ kMaxUtf16CodeUnitU

const uint32_t v8::internal::String::kMaxUtf16CodeUnitU = kMaxUtf16CodeUnit

static

Definition at line 8814 of file objects.h.

◆ kSize

const int v8::internal::String::kSize = kLengthOffset + kPointerSize

static

Definition at line 8803 of file objects.h.

The documentation for this class was generated from the following files:

/mnt/V8SourceCode/src/objects.h
/mnt/V8SourceCode/src/objects-inl.h
/mnt/V8SourceCode/src/objects.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Encoding

Member Function Documentation

◆ AsArrayIndex()

◆ CalculateLineEnds()

◆ ComputeAndSetHash()

◆ ComputeArrayIndex()

◆ DISALLOW_IMPLICIT_CONSTRUCTORS()

◆ Equals() [1/2]

◆ Equals() [2/2]

◆ Flatten()

◆ GetFlatContent()

◆ GetForwardedInternalizedString()

◆ GetTwoByteData()

◆ GetUnderlying()

◆ HasOnlyOneByteChars()

◆ INLINE()

◆ IsAscii() [1/2]

◆ IsAscii() [2/2]

◆ IsFlat()

◆ IsOneByte()

◆ IsOneByteEqualTo()

◆ IsOneByteRepresentation()

◆ IsOneByteRepresentationUnderneath()

◆ IsTwoByteEqualTo()

◆ IsTwoByteRepresentation()

◆ IsTwoByteRepresentationUnderneath()

◆ IsUtf8EqualTo()

◆ length()

◆ LooksValid()

◆ MakeExternal() [1/2]

◆ MakeExternal() [2/2]

◆ MarkAsUndetectable()

◆ NonAsciiStart()

◆ NonOneByteStart()

◆ PrintOn()

◆ PrintUC16()

◆ Set()

◆ set_length()

◆ SetForwardedInternalizedString()

◆ SlowAsArrayIndex()

◆ SlowEquals() [1/2]

◆ SlowEquals() [2/2]

◆ SlowFlatten()

◆ STATIC_ASSERT() [1/3]

◆ STATIC_ASSERT() [2/3]

◆ STATIC_ASSERT() [3/3]

◆ StringShortPrint()

◆ synchronized_length()

◆ synchronized_set_length()

◆ ToCString() [1/2]

◆ ToCString() [2/2]

◆ ToWideCString()

◆ VisitFlat()

◆ WriteToFlat()

Friends And Related Function Documentation

◆ Name

◆ StringTableInsertionKey

Member Data Documentation

◆ kArrayIndexLengthBits

◆ kArrayIndexValueBits

◆ kContainsCachedArrayIndexMask

◆ kEmptyStringHash

◆ kLengthOffset

◆ kMaxArrayIndexSize

◆ kMaxCachedArrayIndexLength

◆ kMaxHashCalcLength

◆ kMaxLength

◆ kMaxOneByteCharCode

◆ kMaxOneByteCharCodeU