#include <object.h>

Inheritance diagram for dart::String:

Classes
class	CodePointIterator

Public Member Functions
intptr_t	Length () const

uword	Hash () const

bool	HasHash () const

virtual ObjectPtr	HashCode () const

uint16_t	CharAt (intptr_t index) const

intptr_t	CharSize () const

bool	Equals (const String &str) const

bool	Equals (const String &str, intptr_t begin_index, intptr_t len) const

bool	Equals (const char *cstr) const

bool	EqualsLatin1 (const uint8_t *characters, intptr_t len) const

bool	Equals (const uint16_t *characters, intptr_t len) const

bool	Equals (const int32_t *characters, intptr_t len) const

bool	EqualsConcat (const String &str1, const String &str2) const

virtual bool	OperatorEquals (const Instance &other) const

virtual bool	CanonicalizeEquals (const Instance &other) const

virtual uint32_t	CanonicalizeHash () const

virtual bool	Equals (const Instance &other) const

intptr_t	CompareTo (const String &other) const

bool	StartsWith (const String &other) const

bool	EndsWith (const String &other) const

virtual InstancePtr	CanonicalizeLocked (Thread *thread) const

bool	IsSymbol () const

bool	IsOneByteString () const

bool	IsTwoByteString () const

char *	ToMallocCString () const

void	ToUTF8 (uint8_t *utf8_array, intptr_t array_len) const

Public Member Functions inherited from dart::Instance
bool	IsIdenticalTo (const Instance &other) const

intptr_t	SizeFromClass () const

InstancePtr	Canonicalize (Thread *thread) const

virtual void	CanonicalizeFieldsLocked (Thread *thread) const

InstancePtr	CopyShallowToOldSpace (Thread *thread) const

ObjectPtr	GetField (const Field &field) const

void	SetField (const Field &field, const Object &value) const

AbstractTypePtr	GetType (Heap::Space space) const

virtual TypeArgumentsPtr	GetTypeArguments () const

virtual void	SetTypeArguments (const TypeArguments &value) const

bool	IsInstanceOf (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments) const

bool	IsAssignableTo (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments) const

bool	IsValidNativeIndex (int index) const

intptr_t *	NativeFieldsDataAddr () const

intptr_t	GetNativeField (int index) const

void	GetNativeFields (uint16_t num_fields, intptr_t *field_values) const

void	SetNativeFields (uint16_t num_fields, const intptr_t *field_values) const

uint16_t	NumNativeFields () const

void	SetNativeField (int index, intptr_t value) const

bool	IsCallable (Function *function) const

ObjectPtr	Invoke (const String &selector, const Array &arguments, const Array &argument_names, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	InvokeGetter (const String &selector, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	InvokeSetter (const String &selector, const Instance &argument, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	EvaluateCompiledExpression (const Class &klass, const ExternalTypedData &kernel_buffer, const Array &type_definitions, const Array &arguments, const TypeArguments &type_arguments) const

IntegerPtr	IdentityHashCode (Thread *thread) const

virtual bool	IsPointer () const

Public Member Functions inherited from dart::Object
virtual	~Object ()

ObjectPtr	ptr () const

void	operator= (ObjectPtr value)

bool	IsCanonical () const

void	SetCanonical () const

void	ClearCanonical () const

bool	IsImmutable () const

void	SetImmutable () const

void	ClearImmutable () const

intptr_t	GetClassId () const

ClassPtr	clazz () const

	CLASS_LIST_FOR_HANDLES (DEFINE_CLASS_TESTER)

bool	IsNull () const

virtual const char *	ToCString () const

void	PrintJSON (JSONStream *stream, bool ref=true) const

virtual void	PrintJSONImpl (JSONStream *stream, bool ref) const

void	PrintImplementationFields (JSONStream *stream) const

virtual void	PrintImplementationFieldsImpl (const JSONArray &jsarr_fields) const

virtual const char *	JSONType () const

virtual StringPtr	DictionaryName () const

bool	IsNew () const

bool	IsOld () const

bool	InVMIsolateHeap () const

void	Print () const

Static Public Member Functions
static intptr_t	HeaderSize ()

static intptr_t	InstanceSize ()

static intptr_t	LengthOf (StringPtr obj)

static intptr_t	length_offset ()

static uword	Hash (StringPtr raw)

static intptr_t	hash_offset ()

static uword	Hash (const String &str, intptr_t begin_index, intptr_t len)

static uword	Hash (const char *characters, intptr_t len)

static uword	Hash (const uint16_t *characters, intptr_t len)

static uword	Hash (const int32_t *characters, intptr_t len)

static uword	HashRawSymbol (const StringPtr symbol)

static uword	HashConcat (const String &str1, const String &str2)

static uint16_t	CharAt (StringPtr str, intptr_t index)

static bool	StartsWith (StringPtr str, StringPtr prefix)

static const char *	ToCString (Thread *thread, StringPtr ptr)

static StringPtr	New (const char *cstr, Heap::Space space=Heap::kNew)

static StringPtr	FromUTF8 (const uint8_t *utf8_array, intptr_t array_len, Heap::Space space=Heap::kNew)

static StringPtr	FromLatin1 (const uint8_t *latin1_array, intptr_t array_len, Heap::Space space=Heap::kNew)

static StringPtr	FromUTF16 (const uint16_t *utf16_array, intptr_t array_len, Heap::Space space=Heap::kNew)

static StringPtr	FromUTF32 (const int32_t *utf32_array, intptr_t array_len, Heap::Space space=Heap::kNew)

static StringPtr	New (const String &str, Heap::Space space=Heap::kNew)

static StringPtr	NewExternal (const uint8_t utf8_array, intptr_t array_len, void peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, Heap::Space=Heap::kNew)

static StringPtr	NewExternal (const uint16_t utf16_array, intptr_t array_len, void peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback, Heap::Space=Heap::kNew)

static void	Copy (const String &dst, intptr_t dst_offset, const uint8_t *characters, intptr_t len)

static void	Copy (const String &dst, intptr_t dst_offset, const uint16_t *characters, intptr_t len)

static void	Copy (const String &dst, intptr_t dst_offset, const String &src, intptr_t src_offset, intptr_t len)

static StringPtr	EscapeSpecialCharacters (const String &str)

static const char *	EncodeIRI (const String &str)

static StringPtr	DecodeIRI (const String &str)

static StringPtr	Concat (const String &str1, const String &str2, Heap::Space space=Heap::kNew)

static StringPtr	ConcatAll (const Array &strings, Heap::Space space=Heap::kNew)

static StringPtr	ConcatAllRange (const Array &strings, intptr_t start, intptr_t end, Heap::Space space=Heap::kNew)

static StringPtr	SubString (const String &str, intptr_t begin_index, Heap::Space space=Heap::kNew)

static StringPtr	SubString (const String &str, intptr_t begin_index, intptr_t length, Heap::Space space=Heap::kNew)

static StringPtr	SubString (Thread *thread, const String &str, intptr_t begin_index, intptr_t length, Heap::Space space=Heap::kNew)

static StringPtr	Transform (int32_t(*mapping)(int32_t ch), const String &str, Heap::Space space=Heap::kNew)

static StringPtr	ToUpperCase (const String &str, Heap::Space space=Heap::kNew)

static StringPtr	ToLowerCase (const String &str, Heap::Space space=Heap::kNew)

static StringPtr	RemovePrivateKey (const String &name)

static const char *	ScrubName (const String &name, bool is_extension=false)

static StringPtr	ScrubNameRetainPrivate (const String &name, bool is_extension=false)

static bool	EqualsIgnoringPrivateKey (const String &str1, const String &str2)

static StringPtr	NewFormatted (const char *format,...) PRINTF_ATTRIBUTE(1

static StringPtr static StringPtr	NewFormatted (Heap::Space space, const char *format,...) PRINTF_ATTRIBUTE(2

static StringPtr static StringPtr static StringPtr	NewFormattedV (const char *format, va_list args, Heap::Space space=Heap::kNew)

static bool	ParseDouble (const String &str, intptr_t start, intptr_t end, double *result)

static uint32_t	GetCachedHash (const StringPtr obj)

static uint32_t	SetCachedHashIfNotSet (StringPtr obj, uint32_t hash)

static uint32_t	SetCachedHash (StringPtr obj, uint32_t hash)

Static Public Member Functions inherited from dart::Instance
static bool	NullIsAssignableTo (const AbstractType &other)

static bool	NullIsAssignableTo (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments)

static ObjectPtr	EvaluateCompiledExpression (Thread *thread, const Object &receiver, const Library &library, const Class &klass, const ExternalTypedData &kernel_buffer, const Array &type_definitions, const Array &param_values, const TypeArguments &type_param_values)

static intptr_t	UnroundedSize ()

static intptr_t	InstanceSize ()

static InstancePtr	New (const Class &cls, Heap::Space space=Heap::kNew)

static InstancePtr	NewAlreadyFinalized (const Class &cls, Heap::Space space=Heap::kNew)

static intptr_t	DataOffsetFor (intptr_t cid)

static intptr_t	ElementSizeFor (intptr_t cid)

static intptr_t	NextFieldOffset ()

static intptr_t	NativeFieldsOffset ()

Static Public Member Functions inherited from dart::Object
static ObjectPtr	RawCast (ObjectPtr obj)

static constexpr bool	ContainsCompressedPointers ()

static intptr_t	tags_offset ()

static Object &	Handle ()

static Object &	Handle (Zone *zone)

static Object &	Handle (ObjectPtr ptr)

static Object &	Handle (Zone *zone, ObjectPtr ptr)

static Object &	ZoneHandle ()

static Object &	ZoneHandle (Zone *zone)

static Object &	ZoneHandle (ObjectPtr ptr)

static Object &	ZoneHandle (Zone *zone, ObjectPtr ptr)

static Object *	ReadOnlyHandle ()

static ObjectPtr	null ()

static void	set_vm_isolate_snapshot_object_table (const Array &table)

static ClassPtr	class_class ()

static ClassPtr	dynamic_class ()

static ClassPtr	void_class ()

static ClassPtr	type_parameters_class ()

static ClassPtr	type_arguments_class ()

static ClassPtr	patch_class_class ()

static ClassPtr	function_class ()

static ClassPtr	closure_data_class ()

static ClassPtr	ffi_trampoline_data_class ()

static ClassPtr	field_class ()

static ClassPtr	script_class ()

static ClassPtr	library_class ()

static ClassPtr	namespace_class ()

static ClassPtr	kernel_program_info_class ()

static ClassPtr	code_class ()

static ClassPtr	instructions_class ()

static ClassPtr	instructions_section_class ()

static ClassPtr	instructions_table_class ()

static ClassPtr	object_pool_class ()

static ClassPtr	pc_descriptors_class ()

static ClassPtr	code_source_map_class ()

static ClassPtr	compressed_stackmaps_class ()

static ClassPtr	var_descriptors_class ()

static ClassPtr	exception_handlers_class ()

static ClassPtr	context_class ()

static ClassPtr	context_scope_class ()

static ClassPtr	sentinel_class ()

static ClassPtr	api_error_class ()

static ClassPtr	language_error_class ()

static ClassPtr	unhandled_exception_class ()

static ClassPtr	unwind_error_class ()

static ClassPtr	singletargetcache_class ()

static ClassPtr	unlinkedcall_class ()

static ClassPtr	monomorphicsmiablecall_class ()

static ClassPtr	icdata_class ()

static ClassPtr	megamorphic_cache_class ()

static ClassPtr	subtypetestcache_class ()

static ClassPtr	loadingunit_class ()

static ClassPtr	weak_serialization_reference_class ()

static ClassPtr	weak_array_class ()

static void	InitNullAndBool (IsolateGroup *isolate_group)

static void	Init (IsolateGroup *isolate_group)

static void	InitVtables ()

static void	FinishInit (IsolateGroup *isolate_group)

static void	FinalizeVMIsolate (IsolateGroup *isolate_group)

static void	FinalizeReadOnlyObject (ObjectPtr object)

static void	Cleanup ()

static ErrorPtr	Init (IsolateGroup isolate_group, const uint8_t kernel_buffer, intptr_t kernel_buffer_size)

static void	MakeUnusedSpaceTraversable (const Object &obj, intptr_t original_size, intptr_t used_size)

static intptr_t	InstanceSize ()

template<class FakeObject >
static void	VerifyBuiltinVtable (intptr_t cid)

static void	VerifyBuiltinVtables ()

static bool	ShouldHaveImmutabilityBitSet (classid_t class_id)

Static Public Attributes
static constexpr intptr_t	kOneByteChar = 1

static constexpr intptr_t	kTwoByteChar = 2

static constexpr intptr_t	kSizeofRawString

static constexpr intptr_t	kMaxElements = kSmiMax / kTwoByteChar

Static Public Attributes inherited from dart::Object
static constexpr intptr_t	kHashBits = 30

static const ClassId	kClassId = kObjectCid

Protected Member Functions
bool	Equals (const uint8_t *characters, intptr_t len) const

void	SetLength (intptr_t value) const

void	SetHash (intptr_t value) const

	FINAL_HEAP_OBJECT_IMPLEMENTATION (String, Instance)

Protected Member Functions inherited from dart::Instance
virtual void	PrintSharedInstanceJSON (JSONObject *jsobj, bool ref, bool include_id=true) const

Protected Member Functions inherited from dart::Object
	Object ()

uword	raw_value () const

void	setPtr (ObjectPtr value, intptr_t default_cid)

void	CheckHandle () const

cpp_vtable	vtable () const

void	set_vtable (cpp_vtable value)

bool	Contains (uword addr) const

template<typename type , std::memory_order order = std::memory_order_relaxed>
type	LoadPointer (type const *addr) const

template<typename type , std::memory_order order = std::memory_order_relaxed>
void	StorePointer (type const *addr, type value) const

template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>
void	StoreCompressedPointer (compressed_type const *addr, type value) const

template<typename type >
void	StorePointerUnaligned (type const addr, type value, Thread thread) const

void	StoreSmi (SmiPtr const *addr, SmiPtr value) const

template<typename FieldType >
void	StoreSimd128 (const FieldType *addr, simd128_value_t value) const

template<typename FieldType >
FieldType	LoadNonPointer (const FieldType *addr) const

template<typename FieldType , std::memory_order order>
FieldType	LoadNonPointer (const FieldType *addr) const

template<typename FieldType , typename ValueType >
void	StoreNonPointer (const FieldType *addr, ValueType value) const

template<typename FieldType , typename ValueType , std::memory_order order>
void	StoreNonPointer (const FieldType *addr, ValueType value) const

template<typename FieldType >
FieldType *	UnsafeMutableNonPointer (const FieldType *addr) const

	CLASS_LIST (STORE_NON_POINTER_ILLEGAL_TYPE)

void	UnimplementedMethod () const

void	AddCommonObjectProperties (JSONObject jsobj, const char protocol_type, bool ref) const

Static Protected Member Functions
static uword	Hash (const uint8_t *characters, intptr_t len)

Static Protected Member Functions inherited from dart::Object
static DART_NOINLINE Object &	HandleImpl (Zone *zone, ObjectPtr ptr, intptr_t default_cid)

static DART_NOINLINE Object &	ZoneHandleImpl (Zone *zone, ObjectPtr ptr, intptr_t default_cid)

static DART_NOINLINE Object *	ReadOnlyHandleImpl (intptr_t cid)

static ObjectPtr	Allocate (intptr_t cls_id, intptr_t size, Heap::Space space, bool compressed, uword ptr_field_start_offset, uword ptr_field_end_offset)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	Allocate (Heap::Space space)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	Allocate (Heap::Space space, intptr_t elements)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	AllocateVariant (intptr_t class_id, Heap::Space space)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	AllocateVariant (intptr_t class_id, Heap::Space space, intptr_t elements)

static constexpr intptr_t	RoundedAllocationSize (intptr_t size)

static ObjectPtr	Clone (const Object &orig, Heap::Space space, bool load_with_relaxed_atomics=false)

template<typename T >
static DART_FORCE_INLINE uword	from_offset ()

template<typename T >
static DART_FORCE_INLINE uword	to_offset (intptr_t length=0)

Friends
class	Class

class	Symbols

class	StringSlice

template<typename CharType >
class	CharArray

class	ConcatString

class	OneByteString

class	TwoByteString

class	UntaggedOneByteString

class	RODataSerializationCluster

class	Pass2Visitor

Additional Inherited Members
Public Types inherited from dart::Object
enum	NameVisibility { kInternalName = 0 , kScrubbedName , kUserVisibleName }

enum class	NameDisambiguation { kYes , kNo }

using	UntaggedObjectType = UntaggedObject

using	ObjectPtrType = ObjectPtr

Protected Attributes inherited from dart::Object
ObjectPtr	ptr_

Detailed Description

Definition at line 10137 of file object.h.

Member Function Documentation

◆ CanonicalizeEquals()

virtual bool dart::String::CanonicalizeEquals ( const Instance & other ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 10269 of file object.h.

                                                               {
    return Equals(other);
  }

◆ CanonicalizeHash()

virtual uint32_t dart::String::CanonicalizeHash ( ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 10272 of file object.h.

10272{ return Hash(); }

dart::String::Hash

uword Hash() const

Definition object.h:10195

◆ CanonicalizeLocked()

InstancePtr dart::String::CanonicalizeLocked ( Thread * thread ) const

virtual

Reimplemented from dart::Instance.

Definition at line 23770 of file object.cc.

                                                           {
  if (IsCanonical()) {
    return this->ptr();
  }
  return Symbols::New(Thread::Current(), *this);
}

◆ CharAt() [1/2]

uint16_t dart::String::CharAt ( intptr_t index ) const

inline

Definition at line 10238 of file object.h.

10238{ return CharAt(ptr(), index); }

dart::String::CharAt

uint16_t CharAt(intptr_t index) const

Definition object.h:10238

◆ CharAt() [2/2]

uint16_t dart::String::CharAt	(	StringPtr	str,
		intptr_t	index
	)

inlinestatic

Definition at line 13385 of file object.h.

                                                            {
  switch (str->GetClassId()) {
    case kOneByteStringCid:
      return OneByteString::CharAt(static_cast<OneByteStringPtr>(str), index);
    case kTwoByteStringCid:
      return TwoByteString::CharAt(static_cast<TwoByteStringPtr>(str), index);
  }
  UNREACHABLE();
  return 0;
}

◆ CharSize()

intptr_t dart::String::CharSize ( ) const

Definition at line 23601 of file object.cc.

                                {
  intptr_t class_id = ptr()->GetClassId();
  if (class_id == kOneByteStringCid) {
    return kOneByteChar;
  }
  ASSERT(class_id == kTwoByteStringCid);
  return kTwoByteChar;
}

◆ CompareTo()

intptr_t dart::String::CompareTo ( const String & other ) const

Definition at line 23717 of file object.cc.

                                                    {
  const intptr_t this_len = this->Length();
  const intptr_t other_len = other.IsNull() ? 0 : other.Length();
  const intptr_t len = (this_len < other_len) ? this_len : other_len;
  for (intptr_t i = 0; i < len; i++) {
    uint16_t this_code_unit = this->CharAt(i);
    uint16_t other_code_unit = other.CharAt(i);
    if (this_code_unit < other_code_unit) {
      return -1;
    }
    if (this_code_unit > other_code_unit) {
      return 1;
    }
  }
  if (this_len < other_len) return -1;
  if (this_len > other_len) return 1;
  return 0;
}

◆ Concat()

StringPtr dart::String::Concat	(	const String &	str1,
		const String &	str2,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24116 of file object.cc.

                                          {
  ASSERT(!str1.IsNull() && !str2.IsNull());
  intptr_t char_size = Utils::Maximum(str1.CharSize(), str2.CharSize());
  if (char_size == kTwoByteChar) {
    return TwoByteString::Concat(str1, str2, space);
  }
  return OneByteString::Concat(str1, str2, space);
}

◆ ConcatAll()

StringPtr dart::String::ConcatAll	(	const Array &	strings,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24127 of file object.cc.

                                                                 {
  return ConcatAllRange(strings, 0, strings.Length(), space);
}

◆ ConcatAllRange()

StringPtr dart::String::ConcatAllRange	(	const Array &	strings,
		intptr_t	start,
		intptr_t	end,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24131 of file object.cc.

                                                  {
  ASSERT(!strings.IsNull());
  ASSERT(start >= 0);
  ASSERT(end <= strings.Length());
  intptr_t result_len = 0;
  String& str = String::Handle();
  intptr_t char_size = kOneByteChar;
  // Compute 'char_size' and 'result_len'.
  for (intptr_t i = start; i < end; i++) {
    str ^= strings.At(i);
    const intptr_t str_len = str.Length();
    if ((kMaxElements - result_len) < str_len) {
      Exceptions::ThrowOOM();
      UNREACHABLE();
    }
    result_len += str_len;
    char_size = Utils::Maximum(char_size, str.CharSize());
  }
  if (char_size == kOneByteChar) {
    return OneByteString::ConcatAll(strings, start, end, result_len, space);
  }
  ASSERT(char_size == kTwoByteChar);
  return TwoByteString::ConcatAll(strings, start, end, result_len, space);
}

◆ Copy() [1/3]

void dart::String::Copy	(	const String &	dst,
		intptr_t	dst_offset,
		const String &	src,
		intptr_t	src_offset,
		intptr_t	len
	)

static

Definition at line 23913 of file object.cc.

                                {
  ASSERT(dst_offset >= 0);
  ASSERT(src_offset >= 0);
  ASSERT(len >= 0);
  ASSERT(len <= (dst.Length() - dst_offset));
  ASSERT(len <= (src.Length() - src_offset));
  if (len > 0) {
    intptr_t char_size = src.CharSize();
    if (char_size == kOneByteChar) {
      ASSERT(src.IsOneByteString());
      NoSafepointScope no_safepoint;
      String::Copy(dst, dst_offset, OneByteString::CharAddr(src, src_offset),
                   len);
    } else {
      ASSERT(char_size == kTwoByteChar);
      ASSERT(src.IsTwoByteString());
      NoSafepointScope no_safepoint;
      String::Copy(dst, dst_offset, TwoByteString::CharAddr(src, src_offset),
                   len);
    }
  }
}

◆ Copy() [2/3]

void dart::String::Copy	(	const String &	dst,
		intptr_t	dst_offset,
		const uint16_t *	characters,
		intptr_t	len
	)

static

Definition at line 23890 of file object.cc.

                                      {
  ASSERT(dst_offset >= 0);
  ASSERT(array_len >= 0);
  ASSERT(array_len <= (dst.Length() - dst_offset));
  if (dst.IsOneByteString()) {
    NoSafepointScope no_safepoint;
    for (intptr_t i = 0; i < array_len; ++i) {
      ASSERT(Utf::IsLatin1(LoadUnaligned(&utf16_array[i])));
      *OneByteString::CharAddr(dst, i + dst_offset) = utf16_array[i];
    }
  } else {
    ASSERT(dst.IsTwoByteString());
    NoSafepointScope no_safepoint;
    if (array_len > 0) {
      memmove(TwoByteString::CharAddr(dst, dst_offset), utf16_array,
              array_len * 2);
    }
  }
}

◆ Copy() [3/3]

void dart::String::Copy	(	const String &	dst,
		intptr_t	dst_offset,
		const uint8_t *	characters,
		intptr_t	len
	)

static

Definition at line 23871 of file object.cc.

                                {
  ASSERT(dst_offset >= 0);
  ASSERT(len >= 0);
  ASSERT(len <= (dst.Length() - dst_offset));
  if (dst.IsOneByteString()) {
    NoSafepointScope no_safepoint;
    if (len > 0) {
      memmove(OneByteString::CharAddr(dst, dst_offset), characters, len);
    }
  } else if (dst.IsTwoByteString()) {
    for (intptr_t i = 0; i < len; ++i) {
      *TwoByteString::CharAddr(dst, i + dst_offset) = characters[i];
    }
  }
}

◆ DecodeIRI()

StringPtr dart::String::DecodeIRI ( const String & str )

static

Definition at line 24027 of file object.cc.

                                             {
  CodePointIterator cpi(str);
  intptr_t num_escapes = 0;
  intptr_t len = str.Length();
  {
    CodePointIterator cpi(str);
    while (cpi.Next()) {
      int32_t code_point = cpi.Current();
      if (IsPercent(code_point)) {
        // Verify that the two characters following the % are hex digits.
        if (!cpi.Next()) {
          return String::null();
        }
        int32_t code_point = cpi.Current();
        if (!IsHexCharacter(code_point)) {
          return String::null();
        }
        if (!cpi.Next()) {
          return String::null();
        }
        code_point = cpi.Current();
        if (!IsHexCharacter(code_point)) {
          return String::null();
        }
        num_escapes += 2;
      }
    }
  }
  intptr_t utf8_len = len - num_escapes;
  ASSERT(utf8_len >= 0);
  Zone* zone = Thread::Current()->zone();
  uint8_t* utf8 = zone->Alloc<uint8_t>(utf8_len);
  {
    intptr_t index = 0;
    CodePointIterator cpi(str);
    while (cpi.Next()) {
      ASSERT(index < utf8_len);
      int32_t code_point = cpi.Current();
      if (IsPercent(code_point)) {
        cpi.Next();
        int32_t ch1 = cpi.Current();
        cpi.Next();
        int32_t ch2 = cpi.Current();
        int32_t merged = MergeHexCharacters(ch1, ch2);
        ASSERT(merged >= 0 && merged < 256);
        utf8[index] = static_cast<uint8_t>(merged);
      } else {
        ASSERT(code_point >= 0 && code_point < 256);
        utf8[index] = static_cast<uint8_t>(code_point);
      }
      index++;
    }
  }
  return FromUTF8(utf8, utf8_len);
}

◆ EncodeIRI()

const char * dart::String::EncodeIRI ( const String & str )

static

Definition at line 23997 of file object.cc.

                                               {
  const intptr_t len = Utf8::Length(str);
  Zone* zone = Thread::Current()->zone();
  uint8_t* utf8 = zone->Alloc<uint8_t>(len);
  str.ToUTF8(utf8, len);
  intptr_t num_escapes = 0;
  for (int i = 0; i < len; ++i) {
    uint8_t byte = utf8[i];
    if (!IsURISafeCharacter(byte)) {
      num_escapes += 2;
    }
  }
  intptr_t cstr_len = len + num_escapes + 1;
  char* cstr = zone->Alloc<char>(cstr_len);
  intptr_t index = 0;
  for (int i = 0; i < len; ++i) {
    uint8_t byte = utf8[i];
    if (!IsURISafeCharacter(byte)) {
      cstr[index++] = '%';
      cstr[index++] = GetHexCharacter(byte >> 4);
      cstr[index++] = GetHexCharacter(byte & 0xF);
    } else {
      ASSERT(byte <= 127);
      cstr[index++] = byte;
    }
  }
  cstr[index] = '\0';
  return cstr;
}

◆ EndsWith()

bool dart::String::EndsWith ( const String & other ) const

Definition at line 23751 of file object.cc.

                                               {
  if (other.IsNull()) {
    return false;
  }
  const intptr_t len = this->Length();
  const intptr_t other_len = other.Length();
  const intptr_t offset = len - other_len;
 
  if ((other_len == 0) || (other_len > len)) {
    return false;
  }
  for (int i = offset; i < len; i++) {
    if (this->CharAt(i) != other.CharAt(i - offset)) {
      return false;
    }
  }
  return true;
}

◆ Equals() [1/7]

bool dart::String::Equals ( const char * cstr ) const

Definition at line 23644 of file object.cc.

                                          {
  ASSERT(cstr != nullptr);
  CodePointIterator it(*this);
  intptr_t len = strlen(cstr);
  while (it.Next()) {
    if (*cstr == '\0') {
      // Lengths don't match.
      return false;
    }
    int32_t ch;
    intptr_t consumed =
        Utf8::Decode(reinterpret_cast<const uint8_t*>(cstr), len, &ch);
    if (consumed == 0 || it.Current() != ch) {
      return false;
    }
    cstr += consumed;
    len -= consumed;
  }
  return *cstr == '\0';
}

◆ Equals() [2/7]

bool dart::String::Equals ( const Instance & other ) const

virtual

Definition at line 23610 of file object.cc.

                                               {
  if (this->ptr() == other.ptr()) {
    // Both handles point to the same raw instance.
    return true;
  }
 
  if (!other.IsString()) {
    return false;
  }
 
  const String& other_string = String::Cast(other);
  return Equals(other_string);
}

◆ Equals() [3/7]

bool dart::String::Equals	(	const int32_t *	characters,
		intptr_t	len
	)		const

Definition at line 23693 of file object.cc.

                                                                  {
  if (len < 0) return false;
  intptr_t j = 0;
  for (intptr_t i = 0; i < len; ++i) {
    if (Utf::IsSupplementary(utf32_array[i])) {
      uint16_t encoded[2];
      Utf16::Encode(utf32_array[i], &encoded[0]);
      if (j + 1 >= Length()) return false;
      if (CharAt(j++) != encoded[0]) return false;
      if (CharAt(j++) != encoded[1]) return false;
    } else {
      if (j >= Length()) return false;
      if (CharAt(j++) != utf32_array[i]) return false;
    }
  }
  return j == Length();
}

◆ Equals() [4/7]

bool dart::String::Equals ( const String & str ) const

inline

Definition at line 13311 of file object.h.

                                           {
  if (ptr() == str.ptr()) {
    return true;  // Both handles point to the same raw instance.
  }
  if (str.IsNull()) {
    return false;
  }
  if (IsCanonical() && str.IsCanonical()) {
    return false;  // Two symbols that aren't identical aren't equal.
  }
  if (HasHash() && str.HasHash() && (Hash() != str.Hash())) {
    return false;  // Both sides have hash codes and they do not match.
  }
  return Equals(str, 0, str.Length());
}

◆ Equals() [5/7]

bool dart::String::Equals	(	const String &	str,
		intptr_t	begin_index,
		intptr_t	len
	)		const

Definition at line 23624 of file object.cc.

                                        {
  ASSERT(begin_index >= 0);
  ASSERT((begin_index == 0) || (begin_index < str.Length()));
  ASSERT(len >= 0);
  ASSERT(len <= str.Length());
  if (len != this->Length()) {
    return false;  // Lengths don't match.
  }
 
  for (intptr_t i = 0; i < len; i++) {
    if (CharAt(i) != str.CharAt(begin_index + i)) {
      return false;
    }
  }
 
  return true;
}

◆ Equals() [6/7]

bool dart::String::Equals	(	const uint16_t *	characters,
		intptr_t	len
	)		const

Definition at line 23679 of file object.cc.

                                                                   {
  if (len != this->Length()) {
    // Lengths don't match.
    return false;
  }
 
  for (intptr_t i = 0; i < len; i++) {
    if (this->CharAt(i) != LoadUnaligned(&utf16_array[i])) {
      return false;
    }
  }
  return true;
}

◆ Equals() [7/7]

bool dart::String::Equals	(	const uint8_t *	characters,
		intptr_t	len
	)		const

protected

Definition at line 23665 of file object.cc.

                                                                   {
  if (len != this->Length()) {
    // Lengths don't match.
    return false;
  }
 
  for (intptr_t i = 0; i < len; i++) {
    if (this->CharAt(i) != latin1_array[i]) {
      return false;
    }
  }
  return true;
}

◆ EqualsConcat()

bool dart::String::EqualsConcat	(	const String &	str1,
		const String &	str2
	)		const

Definition at line 23711 of file object.cc.

                                                                      {
  return (Length() == str1.Length() + str2.Length()) &&
         str1.Equals(*this, 0, str1.Length()) &&
         str2.Equals(*this, str1.Length(), str2.Length());
}

◆ EqualsIgnoringPrivateKey()

bool dart::String::EqualsIgnoringPrivateKey	(	const String &	str1,
		const String &	str2
	)

static

Definition at line 24378 of file object.cc.

                                                                            {
  if (str1.ptr() == str2.ptr()) {
    return true;  // Both handles point to the same raw instance.
  }
  NoSafepointScope no_safepoint;
  intptr_t str1_class_id = str1.ptr()->GetClassId();
  intptr_t str2_class_id = str2.ptr()->GetClassId();
  switch (str1_class_id) {
    case kOneByteStringCid:
      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, OneByteString, str1, str2);
      break;
    case kTwoByteStringCid:
      EQUALS_IGNORING_PRIVATE_KEY(str2_class_id, TwoByteString, str1, str2);
      break;
  }
  UNREACHABLE();
  return false;
}

◆ EqualsLatin1()

bool dart::String::EqualsLatin1	(	const uint8_t *	characters,
		intptr_t	len
	)		const

inline

Definition at line 10253 of file object.h.

                                                                   {
    return Equals(characters, len);
  }

◆ EscapeSpecialCharacters()

StringPtr dart::String::EscapeSpecialCharacters ( const String & str )

static

Definition at line 23940 of file object.cc.

                                                           {
  if (str.IsOneByteString()) {
    return OneByteString::EscapeSpecialCharacters(str);
  }
  ASSERT(str.IsTwoByteString());
  return TwoByteString::EscapeSpecialCharacters(str);
}

◆ FINAL_HEAP_OBJECT_IMPLEMENTATION()

dart::String::FINAL_HEAP_OBJECT_IMPLEMENTATION	(	String	,
		Instance
	)

protected

◆ FromLatin1()

StringPtr dart::String::FromLatin1	(	const uint8_t *	latin1_array,
		intptr_t	array_len,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 23812 of file object.cc.

                                              {
  return OneByteString::New(latin1_array, array_len, space);
}

◆ FromUTF16()

StringPtr dart::String::FromUTF16	(	const uint16_t *	utf16_array,
		intptr_t	array_len,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 23818 of file object.cc.

                                             {
  bool is_one_byte_string = true;
  for (intptr_t i = 0; i < array_len; ++i) {
    if (!Utf::IsLatin1(LoadUnaligned(&utf16_array[i]))) {
      is_one_byte_string = false;
      break;
    }
  }
  if (is_one_byte_string) {
    return OneByteString::New(utf16_array, array_len, space);
  }
  return TwoByteString::New(utf16_array, array_len, space);
}

◆ FromUTF32()

StringPtr dart::String::FromUTF32	(	const int32_t *	utf32_array,
		intptr_t	array_len,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 23834 of file object.cc.

                                             {
  bool is_one_byte_string = true;
  intptr_t utf16_len = array_len;
  for (intptr_t i = 0; i < array_len; ++i) {
    if (!Utf::IsLatin1(utf32_array[i])) {
      is_one_byte_string = false;
      if (Utf::IsSupplementary(utf32_array[i])) {
        utf16_len += 1;
      }
    }
  }
  if (is_one_byte_string) {
    return OneByteString::New(utf32_array, array_len, space);
  }
  return TwoByteString::New(utf16_len, utf32_array, array_len, space);
}

◆ FromUTF8()

StringPtr dart::String::FromUTF8	(	const uint8_t *	utf8_array,
		intptr_t	array_len,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 23784 of file object.cc.

                                            {
  Utf8::Type type;
  intptr_t len = Utf8::CodeUnitCount(utf8_array, array_len, &type);
  if (type == Utf8::kLatin1) {
    const String& strobj = String::Handle(OneByteString::New(len, space));
    if (len > 0) {
      NoSafepointScope no_safepoint;
      if (!Utf8::DecodeToLatin1(utf8_array, array_len,
                                OneByteString::DataStart(strobj), len)) {
        Utf8::ReportInvalidByte(utf8_array, array_len, len);
        return String::null();
      }
    }
    return strobj.ptr();
  }
  ASSERT((type == Utf8::kBMP) || (type == Utf8::kSupplementary));
  const String& strobj = String::Handle(TwoByteString::New(len, space));
  NoSafepointScope no_safepoint;
  if (!Utf8::DecodeToUTF16(utf8_array, array_len,
                           TwoByteString::DataStart(strobj), len)) {
    Utf8::ReportInvalidByte(utf8_array, array_len, len);
    return String::null();
  }
  return strobj.ptr();
}

◆ GetCachedHash()

static uint32_t dart::String::GetCachedHash ( const StringPtr obj )

inlinestatic

Definition at line 10424 of file object.h.

                                                     {
    return Smi::Value(obj->untag()->hash_);
  }

◆ Hash() [1/7]

uword dart::String::Hash ( ) const

inline

Definition at line 10195 of file object.h.

                     {
    uword result = GetCachedHash(ptr());
    if (result != 0) {
      return result;
    }
    result = String::Hash(*this, 0, this->Length());
    uword set_hash = SetCachedHashIfNotSet(ptr(), result);
    ASSERT(set_hash == result);
    return result;
  }

◆ Hash() [2/7]

uword dart::String::Hash	(	const char *	characters,
		intptr_t	len
	)

static

Definition at line 23583 of file object.cc.

                                                       {
  StringHasher hasher;
  hasher.Add(reinterpret_cast<const uint8_t*>(characters), len);
  return hasher.Finalize();
}

◆ Hash() [3/7]

static uword dart::String::Hash	(	const int32_t *	characters,
		intptr_t	len
	)

static

◆ Hash() [4/7]

uword dart::String::Hash	(	const String &	str,
		intptr_t	begin_index,
		intptr_t	len
	)

static

Definition at line 23558 of file object.cc.

                                                                        {
  StringHasher hasher;
  hasher.Add(str, begin_index, len);
  return hasher.Finalize();
}

◆ Hash() [5/7]

uword dart::String::Hash	(	const uint16_t *	characters,
		intptr_t	len
	)

static

Definition at line 23595 of file object.cc.

                                                           {
  StringHasher hasher;
  hasher.Add(characters, len);
  return hasher.Finalize();
}

◆ Hash() [6/7]

uword dart::String::Hash	(	const uint8_t *	characters,
		intptr_t	len
	)

staticprotected

Definition at line 23589 of file object.cc.

                                                          {
  StringHasher hasher;
  hasher.Add(characters, len);
  return hasher.Finalize();
}

◆ Hash() [7/7]

uword dart::String::Hash ( StringPtr raw )

static

Definition at line 23571 of file object.cc.

                                {
  StringHasher hasher;
  uword length = Smi::Value(raw->untag()->length());
  if (raw->IsOneByteString()) {
    const uint8_t* data = static_cast<OneByteStringPtr>(raw)->untag()->data();
    return String::Hash(data, length);
  } else {
    const uint16_t* data = static_cast<TwoByteStringPtr>(raw)->untag()->data();
    return String::Hash(data, length);
  }
}

◆ hash_offset()

static intptr_t dart::String::hash_offset ( )

inlinestatic

Definition at line 10213 of file object.h.

                                {
#if defined(HASH_IN_OBJECT_HEADER)
    COMPILE_ASSERT(UntaggedObject::kHashTagPos % kBitsPerByte == 0);
    return OFFSET_OF(UntaggedObject, tags_) +
           UntaggedObject::kHashTagPos / kBitsPerByte;
#else
    return OFFSET_OF(UntaggedString, hash_);
#endif
  }

◆ HasHash()

bool dart::String::HasHash ( ) const

inline

Definition at line 10208 of file object.h.

                       {
    ASSERT(Smi::New(0) == nullptr);
    return GetCachedHash(ptr()) != 0;
  }

◆ HashCode()

virtual ObjectPtr dart::String::HashCode ( ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 10236 of file object.h.

10236{ return Integer::New(Hash()); }

dart::Integer::New

static IntegerPtr New(const String &str, Heap::Space space=Heap::kNew)

Definition object.cc:23063

◆ HashConcat()

uword dart::String::HashConcat	(	const String &	str1,
		const String &	str2
	)

static

Definition at line 23564 of file object.cc.

                                                               {
  StringHasher hasher;
  hasher.Add(str1, 0, str1.Length());
  hasher.Add(str2, 0, str2.Length());
  return hasher.Finalize();
}

◆ HashRawSymbol()

static uword dart::String::HashRawSymbol ( const StringPtr symbol )

inlinestatic

Definition at line 10226 of file object.h.

                                                     {
    ASSERT(symbol->untag()->IsCanonical());
    const uword result = GetCachedHash(symbol);
    ASSERT(result != 0);
    return result;
  }

◆ HeaderSize()

static intptr_t dart::String::HeaderSize ( )

inlinestatic

Definition at line 10154 of file object.h.

10154{ return String::kSizeofRawString; }

dart::String::kSizeofRawString

static constexpr intptr_t kSizeofRawString

Definition object.h:10149

◆ InstanceSize()

static intptr_t dart::String::InstanceSize ( )

inlinestatic

Definition at line 10156 of file object.h.

                                 {
    return RoundedAllocationSize(sizeof(UntaggedString));
  }

◆ IsOneByteString()

bool dart::String::IsOneByteString ( ) const

inline

Definition at line 10290 of file object.h.

                               {
    return ptr()->GetClassId() == kOneByteStringCid;
  }

◆ IsSymbol()

bool dart::String::IsSymbol ( ) const

inline

Definition at line 10288 of file object.h.

10288{ return ptr()->untag()->IsCanonical(); }

dart::ObjectPtr::untag

UntaggedObject * untag() const

Definition tagged_pointer.h:105

dart::UntaggedObject::IsCanonical

bool IsCanonical() const

Definition raw_object.h:329

◆ IsTwoByteString()

bool dart::String::IsTwoByteString ( ) const

inline

Definition at line 10294 of file object.h.

                               {
    return ptr()->GetClassId() == kTwoByteStringCid;
  }

◆ Length()

intptr_t dart::String::Length ( ) const

inline

Definition at line 10189 of file object.h.

10189{ return LengthOf(ptr()); }

dart::String::LengthOf

static intptr_t LengthOf(StringPtr obj)

Definition object.h:10190

◆ length_offset()

static intptr_t dart::String::length_offset ( )

inlinestatic

Definition at line 10193 of file object.h.

10193{ return OFFSET_OF(UntaggedString, length_); }

◆ LengthOf()

static intptr_t dart::String::LengthOf ( StringPtr obj )

inlinestatic

Definition at line 10190 of file object.h.

                                          {
    return Smi::Value(obj->untag()->length());
  }

◆ New() [1/2]

StringPtr dart::String::New	(	const char *	cstr,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 23777 of file object.cc.

                                                       {
  ASSERT(cstr != nullptr);
  intptr_t array_len = strlen(cstr);
  const uint8_t* utf8_array = reinterpret_cast<const uint8_t*>(cstr);
  return String::FromUTF8(utf8_array, array_len, space);
}

◆ New() [2/2]

StringPtr dart::String::New	(	const String &	str,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 23853 of file object.cc.

                                                        {
  // Currently this just creates a copy of the string in the correct space.
  // Once we have external string support, this will also create a heap copy of
  // the string if necessary. Some optimizations are possible, such as not
  // copying internal strings into the same space.
  intptr_t len = str.Length();
  String& result = String::Handle();
  intptr_t char_size = str.CharSize();
  if (char_size == kOneByteChar) {
    result = OneByteString::New(len, space);
  } else {
    ASSERT(char_size == kTwoByteChar);
    result = TwoByteString::New(len, space);
  }
  String::Copy(result, 0, str, 0, len);
  return result.ptr();
}

◆ NewExternal() [1/2]

static StringPtr dart::String::NewExternal	(	const uint16_t *	utf16_array,
		intptr_t	array_len,
		void *	peer,
		intptr_t	external_allocation_size,
		Dart_HandleFinalizer	callback,
		Heap::Space	= `Heap::kNew`
	)

static

◆ NewExternal() [2/2]

static StringPtr dart::String::NewExternal	(	const uint8_t *	utf8_array,
		intptr_t	array_len,
		void *	peer,
		intptr_t	external_allocation_size,
		Dart_HandleFinalizer	callback,
		Heap::Space	= `Heap::kNew`
	)

static

◆ NewFormatted() [1/2]

StringPtr dart::String::NewFormatted	(	const char *	format,
			...
	)

static

Definition at line 24083 of file object.cc.

                                                      {
  va_list args;
  va_start(args, format);
  StringPtr result = NewFormattedV(format, args);
  NoSafepointScope no_safepoint;
  va_end(args);
  return result;
}

◆ NewFormatted() [2/2]

StringPtr dart::String::NewFormatted	(	Heap::Space	space,
		const char *	format,
			...
	)

static

Definition at line 24092 of file object.cc.

                                                                       {
  va_list args;
  va_start(args, format);
  StringPtr result = NewFormattedV(format, args, space);
  NoSafepointScope no_safepoint;
  va_end(args);
  return result;
}

◆ NewFormattedV()

StringPtr dart::String::NewFormattedV	(	const char *	format,
		va_list	args,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24101 of file object.cc.

                                                 {
  va_list args_copy;
  va_copy(args_copy, args);
  intptr_t len = Utils::VSNPrint(nullptr, 0, format, args_copy);
  va_end(args_copy);
 
  Zone* zone = Thread::Current()->zone();
  char* buffer = zone->Alloc<char>(len + 1);
  Utils::VSNPrint(buffer, (len + 1), format, args);
 
  return String::New(buffer, space);
}

◆ OperatorEquals()

virtual bool dart::String::OperatorEquals ( const Instance & other ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 10266 of file object.h.

                                                           {
    return Equals(other);
  }

◆ ParseDouble()

bool dart::String::ParseDouble	(	const String &	str,
		intptr_t	start,
		intptr_t	end,
		double *	result
	)

static

Definition at line 24286 of file object.cc.

                                         {
  ASSERT(0 <= start);
  ASSERT(start <= end);
  ASSERT(end <= str.Length());
  intptr_t length = end - start;
  NoSafepointScope no_safepoint;
  const uint8_t* startChar;
  if (str.IsOneByteString()) {
    startChar = OneByteString::CharAddr(str, start);
  } else {
    uint8_t* chars = Thread::Current()->zone()->Alloc<uint8_t>(length);
    for (intptr_t i = 0; i < length; i++) {
      int32_t ch = str.CharAt(start + i);
      if (ch < 128) {
        chars[i] = ch;
      } else {
        return false;  // Not ASCII, so definitely not valid double numeral.
      }
    }
    startChar = chars;
  }
  return CStringToDouble(reinterpret_cast<const char*>(startChar), length,
                         result);
}

◆ RemovePrivateKey()

StringPtr dart::String::RemovePrivateKey ( const String & name )

static

Definition at line 233 of file object.cc.

                                                     {
  ASSERT(name.IsOneByteString());
  GrowableArray<uint8_t> without_key(name.Length());
  intptr_t i = 0;
  while (i < name.Length()) {
    while (i < name.Length()) {
      uint8_t c = name.CharAt(i++);
      if (c == '@') break;
      without_key.Add(c);
    }
    while (i < name.Length()) {
      uint8_t c = name.CharAt(i);
      if ((c < '0') || (c > '9')) break;
      i++;
    }
  }
 
  return String::FromLatin1(without_key.data(), without_key.length());
}

◆ ScrubName()

const char * dart::String::ScrubName	(	const String &	name,
		bool	is_extension = `false`
	)

static

Definition at line 287 of file object.cc.

                                                                   {
  Thread* thread = Thread::Current();
  NoSafepointScope no_safepoint(thread);
  Zone* zone = thread->zone();
  ZoneTextBuffer printer(zone);
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  if (name.Equals(Symbols::TopLevel())) {
    // Name of invisible top-level class.
    return "";
  }
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
  const char* cname = name.ToCString();
  ASSERT(strlen(cname) == static_cast<size_t>(name.Length()));
  const intptr_t name_len = name.Length();
  // First remove all private name mangling and if 'is_extension' is true
  // substitute the first '|' character with '.'.
  intptr_t start_pos = 0;
  intptr_t sum_segment_len = 0;
  for (intptr_t i = 0; i < name_len; i++) {
    if ((cname[i] == '@') && ((i + 1) < name_len) && (cname[i + 1] >= '0') &&
        (cname[i + 1] <= '9')) {
      // Append the current segment to the unmangled name.
      const intptr_t segment_len = i - start_pos;
      sum_segment_len += segment_len;
      AppendSubString(&printer, cname, start_pos, segment_len);
      // Advance until past the name mangling. The private keys are only
      // numbers so we skip until the first non-number.
      i++;  // Skip the '@'.
      while ((i < name.Length()) && (name.CharAt(i) >= '0') &&
             (name.CharAt(i) <= '9')) {
        i++;
      }
      start_pos = i;
      i--;  // Account for for-loop increment.
    } else if (is_extension && cname[i] == '|') {
      // Append the current segment to the unmangled name.
      const intptr_t segment_len = i - start_pos;
      AppendSubString(&printer, cname, start_pos, segment_len);
      // Append the '.' character (replaces '|' with '.').
      AppendSubString(&printer, ".", 0, 1);
      start_pos = i + 1;
      // Account for length of segments added so far.
      sum_segment_len += (segment_len + 1);
    }
  }
 
  const char* unmangled_name = nullptr;
  if (start_pos == 0) {
    // No name unmangling needed, reuse the name that was passed in.
    unmangled_name = cname;
    sum_segment_len = name_len;
  } else if (name.Length() != start_pos) {
    // Append the last segment.
    const intptr_t segment_len = name.Length() - start_pos;
    sum_segment_len += segment_len;
    AppendSubString(&printer, cname, start_pos, segment_len);
  }
  if (unmangled_name == nullptr) {
    // Merge unmangled_segments.
    unmangled_name = printer.buffer();
  }
 
  printer.Clear();
  intptr_t start = 0;
  intptr_t len = sum_segment_len;
  bool is_setter = false;
  if (is_extension) {
    // First scan till we see the '.' character.
    for (intptr_t i = 0; i < len; i++) {
      if (unmangled_name[i] == '.') {
        intptr_t slen = i + 1;
        intptr_t plen = slen - start;
        AppendSubString(&printer, unmangled_name, start, plen);
        unmangled_name += slen;
        len -= slen;
        break;
      } else if (unmangled_name[i] == ':') {
        if (start != 0) {
          // Reset and break.
          start = 0;
          is_setter = false;
          break;
        }
        if (unmangled_name[0] == 's') {
          is_setter = true;
        }
        start = i + 1;
      }
    }
  }
  intptr_t dot_pos = -1;  // Position of '.' in the name, if any.
  start = 0;
  for (intptr_t i = start; i < len; i++) {
    if (unmangled_name[i] == ':' ||
        (is_extension && unmangled_name[i] == '#')) {
      if (start != 0) {
        // Reset and break.
        start = 0;
        dot_pos = -1;
        break;
      }
      ASSERT(start == 0);  // Only one : is possible in getters or setters.
      if (unmangled_name[0] == 's') {
        ASSERT(!is_setter);
        is_setter = true;
      }
      start = i + 1;
    } else if (unmangled_name[i] == '.') {
      if (dot_pos != -1) {
        // Reset and break.
        start = 0;
        dot_pos = -1;
        break;
      }
      ASSERT(dot_pos == -1);  // Only one dot is supported.
      dot_pos = i;
    }
  }
 
  if (!is_extension && (start == 0) && (dot_pos == -1)) {
    // This unmangled_name is fine as it is.
    return unmangled_name;
  }
 
  // Drop the trailing dot if needed.
  intptr_t end = ((dot_pos + 1) == len) ? dot_pos : len;
 
  intptr_t substr_len = end - start;
  AppendSubString(&printer, unmangled_name, start, substr_len);
  if (is_setter) {
    const char* equals = Symbols::Equals().ToCString();
    const intptr_t equals_len = strlen(equals);
    AppendSubString(&printer, equals, 0, equals_len);
  }
 
  return printer.buffer();
}

◆ ScrubNameRetainPrivate()

StringPtr dart::String::ScrubNameRetainPrivate	(	const String &	name,
		bool	is_extension = `false`
	)

static

Definition at line 427 of file object.cc.

                                                            {
#if !defined(DART_PRECOMPILED_RUNTIME)
  intptr_t len = name.Length();
  intptr_t start = 0;
  intptr_t at_pos = -1;  // Position of '@' in the name, if any.
  bool is_setter = false;
 
  String& result = String::Handle();
 
  // If extension strip out the leading prefix e.g" ext|func would strip out
  // 'ext|'.
  if (is_extension) {
    // First scan till we see the '|' character.
    for (intptr_t i = 0; i < len; i++) {
      if (name.CharAt(i) == '|') {
        result = String::SubString(name, start, (i - start));
        result = String::Concat(result, Symbols::Dot());
        start = i + 1;
        break;
      } else if (name.CharAt(i) == ':') {
        if (start != 0) {
          // Reset and break.
          start = 0;
          is_setter = false;
          break;
        }
        if (name.CharAt(0) == 's') {
          is_setter = true;
        }
        start = i + 1;
      }
    }
  }
 
  for (intptr_t i = start; i < len; i++) {
    if (name.CharAt(i) == ':' || (is_extension && name.CharAt(i) == '#')) {
      // Only one : is possible in getters or setters.
      ASSERT(is_extension || start == 0);
      if (name.CharAt(start) == 's') {
        is_setter = true;
      }
      start = i + 1;
    } else if (name.CharAt(i) == '@') {
      // Setters should have only one @ so we know where to put the =.
      ASSERT(!is_setter || (at_pos == -1));
      at_pos = i;
    }
  }
 
  if (start == 0) {
    // This unmangled_name is fine as it is.
    return name.ptr();
  }
 
  if (is_extension) {
    const String& fname =
        String::Handle(String::SubString(name, start, (len - start)));
    result = String::Concat(result, fname);
  } else {
    result = String::SubString(name, start, (len - start));
  }
 
  if (is_setter) {
    // Setters need to end with '='.
    if (at_pos == -1) {
      return String::Concat(result, Symbols::Equals());
    } else {
      const String& pre_at =
          String::Handle(String::SubString(result, 0, at_pos - 4));
      const String& post_at =
          String::Handle(String::SubString(name, at_pos, len - at_pos));
      result = String::Concat(pre_at, Symbols::Equals());
      result = String::Concat(result, post_at);
    }
  }
 
  return result.ptr();
#endif                // !defined(DART_PRECOMPILED_RUNTIME)
  return name.ptr();  // In AOT, return argument unchanged.
}

◆ SetCachedHash()

static uint32_t dart::String::SetCachedHash	(	StringPtr	obj,
		uint32_t	hash
	)

inlinestatic

Definition at line 10433 of file object.h.

                                                              {
    obj->untag()->hash_ = Smi::New(hash);
    return hash;
  }

◆ SetCachedHashIfNotSet()

static uint32_t dart::String::SetCachedHashIfNotSet	(	StringPtr	obj,
		uint32_t	hash
	)

inlinestatic

Definition at line 10428 of file object.h.

                                                                      {
    ASSERT(Smi::Value(obj->untag()->hash_) == 0 ||
           Smi::Value(obj->untag()->hash_) == static_cast<intptr_t>(hash));
    return SetCachedHash(obj, hash);
  }

◆ SetHash()

void dart::String::SetHash ( intptr_t value ) const

inlineprotected

Definition at line 10456 of file object.h.

                                     {
    const intptr_t hash_set = SetCachedHashIfNotSet(ptr(), value);
    ASSERT(hash_set == value);
  }

◆ SetLength()

void dart::String::SetLength ( intptr_t value ) const

inlineprotected

Definition at line 10450 of file object.h.

                                       {
    // This is only safe because we create a new Smi, which does not cause
    // heap allocation.
    untag()->set_length(Smi::New(value));
  }

◆ StartsWith() [1/2]

bool dart::String::StartsWith ( const String & other ) const

inline

Definition at line 10277 of file object.h.

                                             {
    NoSafepointScope no_safepoint;
    return StartsWith(ptr(), other.ptr());
  }

◆ StartsWith() [2/2]

bool dart::String::StartsWith	(	StringPtr	str,
		StringPtr	prefix
	)

static

Definition at line 23736 of file object.cc.

                                                       {
  if (prefix == String::null()) return false;
 
  const intptr_t length = String::LengthOf(str);
  const intptr_t prefix_length = String::LengthOf(prefix);
  if (prefix_length > length) return false;
 
  for (intptr_t i = 0; i < prefix_length; i++) {
    if (String::CharAt(str, i) != String::CharAt(prefix, i)) {
      return false;
    }
  }
  return true;
}

◆ SubString() [1/3]

StringPtr dart::String::SubString	(	const String &	str,
		intptr_t	begin_index,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24159 of file object.cc.

                                             {
  ASSERT(!str.IsNull());
  if (begin_index >= str.Length()) {
    return String::null();
  }
  return String::SubString(str, begin_index, (str.Length() - begin_index),
                           space);
}

◆ SubString() [2/3]

static StringPtr dart::String::SubString	(	const String &	str,
		intptr_t	begin_index,
		intptr_t	length,
		Heap::Space	space = `Heap::kNew`
	)

inlinestatic

Definition at line 10382 of file object.h.

                                                         {
    return SubString(Thread::Current(), str, begin_index, length, space);
  }

◆ SubString() [3/3]

StringPtr dart::String::SubString	(	Thread *	thread,
		const String &	str,
		intptr_t	begin_index,
		intptr_t	length,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24170 of file object.cc.

                                             {
  ASSERT(!str.IsNull());
  ASSERT(begin_index >= 0);
  ASSERT(length >= 0);
  if (begin_index <= str.Length() && length == 0) {
    return Symbols::Empty().ptr();
  }
  if (begin_index > str.Length()) {
    return String::null();
  }
  bool is_one_byte_string = true;
  intptr_t char_size = str.CharSize();
  if (char_size == kTwoByteChar) {
    for (intptr_t i = begin_index; i < begin_index + length; ++i) {
      if (!Utf::IsLatin1(str.CharAt(i))) {
        is_one_byte_string = false;
        break;
      }
    }
  }
  REUSABLE_STRING_HANDLESCOPE(thread);
  String& result = thread->StringHandle();
  if (is_one_byte_string) {
    result = OneByteString::New(length, space);
  } else {
    result = TwoByteString::New(length, space);
  }
  String::Copy(result, 0, str, begin_index, length);
  return result.ptr();
}

◆ ToCString()

const char * dart::String::ToCString	(	Thread *	thread,
		StringPtr	ptr
	)

static

Definition at line 24205 of file object.cc.

                                    {
  if (IsNull()) {
    return "String: null";
  }
  const intptr_t len = Utf8::Length(*this);
  Zone* zone = Thread::Current()->zone();
  uint8_t* result = zone->Alloc<uint8_t>(len + 1);
  ToUTF8(result, len);
  result[len] = 0;
  return reinterpret_cast<const char*>(result);
}

◆ ToLowerCase()

StringPtr dart::String::ToLowerCase	(	const String &	str,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24281 of file object.cc.

                                                                {
  // TODO(cshapiro): create a fast-path for OneByteString instances.
  return Transform(CaseMapping::ToLower, str, space);
}

◆ ToMallocCString()

char * dart::String::ToMallocCString ( ) const

Definition at line 24217 of file object.cc.

                                    {
  const intptr_t len = Utf8::Length(*this);
  uint8_t* result = reinterpret_cast<uint8_t*>(malloc(len + 1));
  ToUTF8(result, len);
  result[len] = 0;
  return reinterpret_cast<char*>(result);
}

◆ ToUpperCase()

StringPtr dart::String::ToUpperCase	(	const String &	str,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24276 of file object.cc.

                                                                {
  // TODO(cshapiro): create a fast-path for OneByteString instances.
  return Transform(CaseMapping::ToUpper, str, space);
}

◆ ToUTF8()

void dart::String::ToUTF8	(	uint8_t *	utf8_array,
		intptr_t	array_len
	)		const

Definition at line 24225 of file object.cc.

                                                                 {
  ASSERT(array_len >= Utf8::Length(*this));
  Utf8::Encode(*this, reinterpret_cast<char*>(utf8_array), array_len);
}

◆ Transform()

StringPtr dart::String::Transform	(	int32_t(*)(int32_t ch)	mapping,
		const String &	str,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24251 of file object.cc.

                                             {
  ASSERT(!str.IsNull());
  bool has_mapping = false;
  int32_t dst_max = 0;
  CodePointIterator it(str);
  while (it.Next()) {
    int32_t src = it.Current();
    int32_t dst = mapping(src);
    if (src != dst) {
      has_mapping = true;
    }
    dst_max = Utils::Maximum(dst_max, dst);
  }
  if (!has_mapping) {
    return str.ptr();
  }
  if (Utf::IsLatin1(dst_max)) {
    return OneByteString::Transform(mapping, str, space);
  }
  ASSERT(Utf::IsBmp(dst_max) || Utf::IsSupplementary(dst_max));
  return TwoByteString::Transform(mapping, str, space);
}

Friends And Related Symbol Documentation

◆ CharArray

template<typename CharType >

friend class CharArray

friend

Definition at line 10467 of file object.h.

◆ Class

friend class Class

friend

Definition at line 10463 of file object.h.

◆ ConcatString

friend class ConcatString

friend

Definition at line 10468 of file object.h.

◆ OneByteString

friend class OneByteString

friend

Definition at line 10469 of file object.h.

◆ Pass2Visitor

friend class Pass2Visitor

friend

Definition at line 10473 of file object.h.

◆ RODataSerializationCluster

friend class RODataSerializationCluster

friend

Definition at line 10472 of file object.h.

◆ StringSlice

friend class StringSlice

friend

Definition at line 10465 of file object.h.

◆ Symbols

friend class Symbols

friend

Definition at line 10464 of file object.h.

◆ TwoByteString

friend class TwoByteString

friend

Definition at line 10470 of file object.h.

◆ UntaggedOneByteString

friend class UntaggedOneByteString

friend

Definition at line 10471 of file object.h.

Member Data Documentation

◆ kMaxElements

constexpr intptr_t dart::String::kMaxElements = kSmiMax / kTwoByteChar

staticconstexpr

Definition at line 10152 of file object.h.

◆ kOneByteChar

constexpr intptr_t dart::String::kOneByteChar = 1

staticconstexpr

Definition at line 10139 of file object.h.

◆ kSizeofRawString

constexpr intptr_t dart::String::kSizeofRawString

staticconstexpr

Initial value:

=

sizeof(UntaggedInstance) + 2 * kWordSize

dart::kWordSize

constexpr intptr_t kWordSize

Definition globals.h:509

Definition at line 10149 of file object.h.

◆ kTwoByteChar

constexpr intptr_t dart::String::kTwoByteChar = 2

staticconstexpr

Definition at line 10140 of file object.h.

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

third_party/dart-lang/sdk/runtime/vm/object.h
third_party/dart-lang/sdk/runtime/vm/object.cc

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ CanonicalizeEquals()

◆ CanonicalizeHash()

◆ CanonicalizeLocked()

◆ CharAt() [1/2]

◆ CharAt() [2/2]

◆ CharSize()

◆ CompareTo()

◆ Concat()

◆ ConcatAll()

◆ ConcatAllRange()

◆ Copy() [1/3]

◆ Copy() [2/3]

◆ Copy() [3/3]

◆ DecodeIRI()

◆ EncodeIRI()

◆ EndsWith()

◆ Equals() [1/7]

◆ Equals() [2/7]

◆ Equals() [3/7]

◆ Equals() [4/7]

◆ Equals() [5/7]

◆ Equals() [6/7]

◆ Equals() [7/7]

◆ EqualsConcat()

◆ EqualsIgnoringPrivateKey()

◆ EqualsLatin1()

◆ EscapeSpecialCharacters()

◆ FINAL_HEAP_OBJECT_IMPLEMENTATION()

◆ FromLatin1()

◆ FromUTF16()

◆ FromUTF32()

◆ FromUTF8()

◆ GetCachedHash()

◆ Hash() [1/7]

◆ Hash() [2/7]

◆ Hash() [3/7]

◆ Hash() [4/7]

◆ Hash() [5/7]

◆ Hash() [6/7]

◆ Hash() [7/7]

◆ hash_offset()

◆ HasHash()

◆ HashCode()

◆ HashConcat()

◆ HashRawSymbol()

◆ HeaderSize()

◆ InstanceSize()

◆ IsOneByteString()

◆ IsSymbol()

◆ IsTwoByteString()

◆ Length()

◆ length_offset()

◆ LengthOf()

◆ New() [1/2]

◆ New() [2/2]

◆ NewExternal() [1/2]

◆ NewExternal() [2/2]

◆ NewFormatted() [1/2]

◆ NewFormatted() [2/2]

◆ NewFormattedV()

◆ OperatorEquals()

◆ ParseDouble()

◆ RemovePrivateKey()

◆ ScrubName()

◆ ScrubNameRetainPrivate()

◆ SetCachedHash()

◆ SetCachedHashIfNotSet()

◆ SetHash()

◆ SetLength()

◆ StartsWith() [1/2]