dart::Symbols Class Reference

#include <symbols.h>

Inheritance diagram for dart::Symbols:

Public Types
enum	{ kMaxOneCharCodeSymbol = 0xFF }
enum	SymbolId { kIllegal = 0 , kTokenTableStart , DART_TOKEN_LIST , kMaxPredefinedId = kNullCharId + kMaxOneCharCodeSymbol + 1 }

Static Public Member Functions
static const String &	Symbol (intptr_t index)
static const String &	Dot ()
static const String &	Equals ()
static const String &	Plus ()
static const String &	Minus ()
static const String &	BitOr ()
static const String &	BitAnd ()
static const String &	LAngleBracket ()
static const String &	RAngleBracket ()
static const String &	LParen ()
static const String &	RParen ()
static const String &	LBracket ()
static const String &	RBracket ()
static const String &	LBrace ()
static const String &	RBrace ()
static const String &	Blank ()
static const String &	Dollar ()
static const String &	NewLine ()
static const String &	DoubleQuote ()
static const String &	SingleQuote ()
static const String &	LowercaseR ()
static const String &	Dash ()
static const String &	Ampersand ()
static const String &	Backtick ()
static const String &	Slash ()
static const String &	At ()
static const String &	HashMark ()
static const String &	Semicolon ()
static const String &	Star ()
static const String &	Percent ()
static const String &	QuestionMark ()
static const String &	Caret ()
static const String &	Tilde ()
static const String &	Empty ()
static const String &	False ()
static const String &	Library ()
static const String &	Super ()
static const String &	This ()
static const String &	True ()
static const String &	Void ()
static const String &	Token (Token::Kind token)
static void	Init (IsolateGroup *isolate_group)
static void	InitFromSnapshot (IsolateGroup *isolate_group)
static void	SetupSymbolTable (IsolateGroup *isolate_group)
static StringPtr	New (Thread *thread, const char *cstr)
static StringPtr	New (Thread *thread, const char *cstr, intptr_t length)
static StringPtr	FromUTF8 (Thread *thread, const uint8_t *utf8_array, intptr_t len)
static StringPtr	FromLatin1 (Thread *thread, const uint8_t *latin1_array, intptr_t len)
static StringPtr	FromUTF16 (Thread *thread, const uint16_t *utf16_array, intptr_t len)
static StringPtr	New (Thread *thread, const String &str)
static StringPtr	New (Thread *thread, const String &str, intptr_t begin_index, intptr_t length)
static StringPtr	NewFormatted (Thread *thread, const char *format,...) PRINTF_ATTRIBUTE(2
static StringPtr static StringPtr	NewFormattedV (Thread *thread, const char *format, va_list args)
static StringPtr	FromConcat (Thread *thread, const String &str1, const String &str2)
static StringPtr	FromConcatAll (Thread *thread, const GrowableHandlePtrArray< const String > &strs)
static StringPtr	FromGet (Thread *thread, const String &str)
static StringPtr	FromSet (Thread *thread, const String &str)
static StringPtr	FromDot (Thread *thread, const String &str)
static const char *	Name (SymbolId symbol)
static StringPtr	FromCharCode (Thread *thread, uint16_t char_code)
static StringPtr *	PredefinedAddress ()
static void	DumpStats (IsolateGroup *isolate_group)
static void	DumpTable (IsolateGroup *isolate_group)
template<typename StringType >
static StringPtr	Lookup (Thread *thread, const StringType &str)
static StringPtr	LookupFromConcat (Thread *thread, const String &str1, const String &str2)
static StringPtr	LookupFromGet (Thread *thread, const String &str)
static StringPtr	LookupFromSet (Thread *thread, const String &str)
static StringPtr	LookupFromDot (Thread *thread, const String &str)
static void	GetStats (IsolateGroup *isolate_group, intptr_t *size, intptr_t *capacity)

Static Public Attributes
static constexpr int	kNumberOfOneCharCodeSymbols
static constexpr int	kNullCharCodeSymbolOffset = 0

Friends
class	Dart
class	String
class	Serializer
class	Deserializer

Detailed Description

Definition at line 575 of file symbols.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
kMaxOneCharCodeSymbol

Definition at line 577 of file symbols.h.

{ kMaxOneCharCodeSymbol = 0xFF };

SymbolId

enum dart::Symbols::SymbolId

Enumerator
kIllegal
kTokenTableStart
DART_TOKEN_LIST
kMaxPredefinedId

Definition at line 580 of file symbols.h.

                {
    // clang-format off
    kIllegal = 0,
 
#define DEFINE_SYMBOL_INDEX(symbol, literal) k##symbol##Id,
    PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_INDEX)
#undef DEFINE_SYMBOL_INDEX
 
    kTokenTableStart,  // First token at kTokenTableStart + 1.
 
#define DEFINE_TOKEN_SYMBOL_INDEX(t, s, p, a) t##Id,
    DART_TOKEN_LIST(DEFINE_TOKEN_SYMBOL_INDEX) DART_KEYWORD_LIST(
        DEFINE_TOKEN_SYMBOL_INDEX)
#undef DEFINE_TOKEN_SYMBOL_INDEX
 
    kNullCharId,  // One char code symbol starts here and takes up 256 entries.
    kMaxPredefinedId = kNullCharId + kMaxOneCharCodeSymbol + 1,
    // clang-format on
  };

Member Function Documentation

Ampersand()

static const String & dart::Symbols::Ampersand ( )

inlinestatic

Definition at line 664 of file symbols.h.

                                   {
    return *(symbol_handles_[kNullCharId + '&']);
  }

At()

static const String & dart::Symbols::At ( )

inlinestatic

Definition at line 671 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '@']); }

Backtick()

static const String & dart::Symbols::Backtick ( )

inlinestatic

Definition at line 667 of file symbols.h.

                                  {
    return *(symbol_handles_[kNullCharId + '`']);
  }

BitAnd()

static const String & dart::Symbols::BitAnd ( )

inlinestatic

Definition at line 620 of file symbols.h.

                                {
    return *(symbol_handles_[kNullCharId + '&']);
  }

BitOr()

static const String & dart::Symbols::BitOr ( )

inlinestatic

Definition at line 619 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '|']); }

Blank()

static const String & dart::Symbols::Blank ( )

inlinestatic

Definition at line 647 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + ' ']); }

Caret()

static const String & dart::Symbols::Caret ( )

inlinestatic

Definition at line 685 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '^']); }

Dash()

static const String & dart::Symbols::Dash ( )

inlinestatic

Definition at line 663 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '-']); }

Dollar()

static const String & dart::Symbols::Dollar ( )

inlinestatic

Definition at line 648 of file symbols.h.

                                {
    return *(symbol_handles_[kNullCharId + '$']);
  }

Dot()

static const String & dart::Symbols::Dot ( )

inlinestatic

Definition at line 613 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '.']); }

DoubleQuote()

static const String & dart::Symbols::DoubleQuote ( )

inlinestatic

Definition at line 654 of file symbols.h.

                                     {
    return *(symbol_handles_[kNullCharId + '"']);
  }

DumpStats()

void dart::Symbols::DumpStats ( IsolateGroup *  isolate_group )

static

Definition at line 481 of file symbols.cc.

                                                   {
  intptr_t size = -1;
  intptr_t capacity = -1;
  // First dump VM symbol table stats.
  GetStats(Dart::vm_isolate_group(), &size, &capacity);
  OS::PrintErr("VM Isolate: Number of symbols : %" Pd "\n", size);
  OS::PrintErr("VM Isolate: Symbol table capacity : %" Pd "\n", capacity);
  // Now dump regular isolate symbol table stats.
  GetStats(isolate_group, &size, &capacity);
  OS::PrintErr("Isolate: Number of symbols : %" Pd "\n", size);
  OS::PrintErr("Isolate: Symbol table capacity : %" Pd "\n", capacity);
  // TODO(koda): Consider recording growth and collision stats in HashTable,
  // in DEBUG mode.
}

DumpTable()

void dart::Symbols::DumpTable ( IsolateGroup *  isolate_group )

static

Definition at line 496 of file symbols.cc.

                                                   {
  OS::PrintErr("symbols:\n");
  CanonicalStringSet table(isolate_group->object_store()->symbol_table());
  table.Dump();
  table.Release();
}

Empty()

static const String & dart::Symbols::Empty ( )

inlinestatic

Definition at line 688 of file symbols.h.

{ return *(symbol_handles_[kTokenTableStart]); }

Equals()

static const String & dart::Symbols::Equals ( )

inlinestatic

Definition at line 614 of file symbols.h.

                                {
    return *(symbol_handles_[kNullCharId + '=']);
  }

False()

static const String & dart::Symbols::False ( )

inlinestatic

Definition at line 689 of file symbols.h.

{ return *(symbol_handles_[kFALSEId]); }

FromCharCode()

StringPtr dart::Symbols::FromCharCode ( Thread *  thread, uint16_t  char_code  )

static

Definition at line 474 of file symbols.cc.

                                                                  {
  if (char_code > kMaxOneCharCodeSymbol) {
    return FromUTF16(thread, &char_code, 1);
  }
  return predefined_[char_code];
}

FromConcat()

StringPtr dart::Symbols::FromConcat ( Thread *  thread, const String &  str1, const String &  str2  )

static

Definition at line 235 of file symbols.cc.

                                                  {
  if (str1.Length() == 0) {
    return New(thread, str2);
  } else if (str2.Length() == 0) {
    return New(thread, str1);
  } else {
    return NewSymbol(thread, ConcatString(str1, str2));
  }
}

FromConcatAll()

StringPtr dart::Symbols::FromConcatAll ( Thread *  thread, const GrowableHandlePtrArray< const String > &  strs  )

static

Definition at line 262 of file symbols.cc.

                                                      {
  const intptr_t strs_length = strs.length();
  GrowableArray<intptr_t> lengths(strs_length);
 
  intptr_t len_sum = 0;
  const intptr_t kOneByteChar = 1;
  intptr_t char_size = kOneByteChar;
 
  for (intptr_t i = 0; i < strs_length; i++) {
    const String& str = strs[i];
    const intptr_t str_len = str.Length();
    if ((String::kMaxElements - len_sum) < str_len) {
      Exceptions::ThrowOOM();
      UNREACHABLE();
    }
    len_sum += str_len;
    lengths.Add(str_len);
    char_size = Utils::Maximum(char_size, str.CharSize());
  }
  const bool is_one_byte_string = char_size == kOneByteChar;
 
  Zone* zone = thread->zone();
  if (is_one_byte_string) {
    uint8_t* buffer = zone->Alloc<uint8_t>(len_sum);
    const uint8_t* const orig_buffer = buffer;
    for (intptr_t i = 0; i < strs_length; i++) {
      NoSafepointScope no_safepoint;
      intptr_t str_len = lengths[i];
      if (str_len > 0) {
        const String& str = strs[i];
        ASSERT(str.IsOneByteString());
        const uint8_t* src_p = OneByteString::DataStart(str);
        memmove(buffer, src_p, str_len);
        buffer += str_len;
      }
    }
    ASSERT(len_sum == buffer - orig_buffer);
    return Symbols::FromLatin1(thread, orig_buffer, len_sum);
  } else {
    uint16_t* buffer = zone->Alloc<uint16_t>(len_sum);
    const uint16_t* const orig_buffer = buffer;
    for (intptr_t i = 0; i < strs_length; i++) {
      NoSafepointScope no_safepoint;
      intptr_t str_len = lengths[i];
      if (str_len > 0) {
        const String& str = strs[i];
        if (str.IsTwoByteString()) {
          memmove(buffer, TwoByteString::DataStart(str), str_len * 2);
        } else {
          // One-byte to two-byte string copy.
          ASSERT(str.IsOneByteString());
          const uint8_t* src_p = OneByteString::DataStart(str);
          for (int n = 0; n < str_len; n++) {
            buffer[n] = src_p[n];
          }
        }
        buffer += str_len;
      }
    }
    ASSERT(len_sum == buffer - orig_buffer);
    return Symbols::FromUTF16(thread, orig_buffer, len_sum);
  }
}

FromDot()

StringPtr dart::Symbols::FromDot ( Thread *  thread, const String &  str  )

static

Definition at line 255 of file symbols.cc.

                                                            {
  return FromConcat(thread, str, Dot());
}

FromGet()

StringPtr dart::Symbols::FromGet ( Thread *  thread, const String &  str  )

static

Definition at line 247 of file symbols.cc.

                                                            {
  return FromConcat(thread, GetterPrefix(), str);
}

FromLatin1()

StringPtr dart::Symbols::FromLatin1 ( Thread *  thread, const uint8_t *  latin1_array, intptr_t  len  )

static

Definition at line 223 of file symbols.cc.

                                            {
  return NewSymbol(thread, Latin1Array(latin1_array, len));
}

FromSet()

StringPtr dart::Symbols::FromSet ( Thread *  thread, const String &  str  )

static

Definition at line 251 of file symbols.cc.

                                                            {
  return FromConcat(thread, SetterPrefix(), str);
}

FromUTF16()

StringPtr dart::Symbols::FromUTF16 ( Thread *  thread, const uint16_t *  utf16_array, intptr_t  len  )

static

Definition at line 229 of file symbols.cc.

                                           {
  return NewSymbol(thread, UTF16Array(utf16_array, len));
}

FromUTF8()

StringPtr dart::Symbols::FromUTF8 ( Thread *  thread, const uint8_t *  utf8_array, intptr_t  len  )

static

Definition at line 196 of file symbols.cc.

                                                {
  if (array_len == 0 || utf8_array == nullptr) {
    return FromLatin1(thread, static_cast<uint8_t*>(nullptr), 0);
  }
  Utf8::Type type;
  intptr_t len = Utf8::CodeUnitCount(utf8_array, array_len, &type);
  ASSERT(len != 0);
  Zone* zone = thread->zone();
  if (type == Utf8::kLatin1) {
    uint8_t* characters = zone->Alloc<uint8_t>(len);
    if (!Utf8::DecodeToLatin1(utf8_array, array_len, characters, len)) {
      Utf8::ReportInvalidByte(utf8_array, array_len, len);
      return String::null();
    }
    return FromLatin1(thread, characters, len);
  }
  ASSERT((type == Utf8::kBMP) || (type == Utf8::kSupplementary));
  uint16_t* characters = zone->Alloc<uint16_t>(len);
  if (!Utf8::DecodeToUTF16(utf8_array, array_len, characters, len)) {
    Utf8::ReportInvalidByte(utf8_array, array_len, len);
    return String::null();
  }
  return FromUTF16(thread, characters, len);
}

GetStats()

void dart::Symbols::GetStats ( IsolateGroup *  isolate_group, intptr_t *  size, intptr_t *  capacity  )

static

Definition at line 180 of file symbols.cc.

                                           {
  ASSERT(isolate_group != nullptr);
  CanonicalStringSet table(isolate_group->object_store()->symbol_table());
  *size = table.NumOccupied();
  *capacity = table.NumEntries();
  table.Release();
}

HashMark()

static const String & dart::Symbols::HashMark ( )

inlinestatic

Definition at line 672 of file symbols.h.

                                  {
    return *(symbol_handles_[kNullCharId + '#']);
  }

Init()

void dart::Symbols::Init ( IsolateGroup *  isolate_group )

static

Definition at line 80 of file symbols.cc.

                                                 {
  // Should only be run by the vm isolate.
  ASSERT(IsolateGroup::Current() == Dart::vm_isolate_group());
  ASSERT(vm_isolate_group == Dart::vm_isolate_group());
  Zone* zone = Thread::Current()->zone();
 
  // Create and setup a symbol table in the vm isolate.
  SetupSymbolTable(vm_isolate_group);
 
  // Create all predefined symbols.
  ASSERT((sizeof(names) / sizeof(const char*)) == Symbols::kNullCharId);
 
  CanonicalStringSet table(zone,
                           vm_isolate_group->object_store()->symbol_table());
 
  // First set up all the predefined string symbols.
  // Create symbols for language keywords. Some keywords are equal to
  // symbols we already created, so use New() instead of Add() to ensure
  // that the symbols are canonicalized.
  for (intptr_t i = 1; i < Symbols::kNullCharId; i++) {
    String* str = String::ReadOnlyHandle();
    *str = OneByteString::New(names[i], Heap::kOld);
    str->Hash();
    *str ^= table.InsertOrGet(*str);
    str->SetCanonical();  // Make canonical once entered.
    symbol_handles_[i] = str;
  }
 
  // Add Latin1 characters as Symbols, so that Symbols::FromCharCode is fast.
  for (intptr_t c = 0; c < kNumberOfOneCharCodeSymbols; c++) {
    intptr_t idx = (kNullCharId + c);
    ASSERT(idx < kMaxPredefinedId);
    ASSERT(Utf::IsLatin1(c));
    uint8_t ch = static_cast<uint8_t>(c);
    String* str = String::ReadOnlyHandle();
    *str = OneByteString::New(&ch, 1, Heap::kOld);
    str->Hash();
    *str ^= table.InsertOrGet(*str);
    ASSERT(predefined_[c] == nullptr);
    str->SetCanonical();  // Make canonical once entered.
    predefined_[c] = str->ptr();
    symbol_handles_[idx] = str;
  }
 
  vm_isolate_group->object_store()->set_symbol_table(table.Release());
}

InitFromSnapshot()

void dart::Symbols::InitFromSnapshot ( IsolateGroup *  isolate_group )

static

Definition at line 127 of file symbols.cc.

                                                             {
  // Should only be run by the vm isolate.
  ASSERT(IsolateGroup::Current() == Dart::vm_isolate_group());
  ASSERT(vm_isolate_group == Dart::vm_isolate_group());
  Zone* zone = Thread::Current()->zone();
 
  CanonicalStringSet table(zone,
                           vm_isolate_group->object_store()->symbol_table());
 
  // Lookup all the predefined string symbols and language keyword symbols
  // and cache them in the read only handles for fast access.
  for (intptr_t i = 1; i < Symbols::kNullCharId; i++) {
    String* str = String::ReadOnlyHandle();
    const unsigned char* name =
        reinterpret_cast<const unsigned char*>(names[i]);
    *str ^= table.GetOrNull(Latin1Array(name, strlen(names[i])));
    ASSERT(!str->IsNull());
    ASSERT(str->HasHash());
    ASSERT(str->IsCanonical());
    symbol_handles_[i] = str;
  }
 
  // Lookup Latin1 character Symbols and cache them in read only handles,
  // so that Symbols::FromCharCode is fast.
  for (intptr_t c = 0; c < kNumberOfOneCharCodeSymbols; c++) {
    intptr_t idx = (kNullCharId + c);
    ASSERT(idx < kMaxPredefinedId);
    ASSERT(Utf::IsLatin1(c));
    uint8_t ch = static_cast<uint8_t>(c);
    String* str = String::ReadOnlyHandle();
    *str ^= table.GetOrNull(Latin1Array(&ch, 1));
    ASSERT(!str->IsNull());
    ASSERT(str->HasHash());
    ASSERT(str->IsCanonical());
    predefined_[c] = str->ptr();
    symbol_handles_[idx] = str;
  }
 
  vm_isolate_group->object_store()->set_symbol_table(table.Release());
}

LAngleBracket()

static const String & dart::Symbols::LAngleBracket ( )

inlinestatic

Definition at line 623 of file symbols.h.

                                       {
    return *(symbol_handles_[kNullCharId + '<']);
  }

LBrace()

static const String & dart::Symbols::LBrace ( )

inlinestatic

Definition at line 641 of file symbols.h.

                                {
    return *(symbol_handles_[kNullCharId + '{']);
  }

LBracket()

static const String & dart::Symbols::LBracket ( )

inlinestatic

Definition at line 635 of file symbols.h.

                                  {
    return *(symbol_handles_[kNullCharId + '[']);
  }

Library()

static const String & dart::Symbols::Library ( )

inlinestatic

Definition at line 690 of file symbols.h.

{ return *(symbol_handles_[kLIBRARYId]); }

Lookup()

template<typename StringType >

StringPtr dart::Symbols::Lookup ( Thread *  thread, const StringType &  str  )

static

Definition at line 375 of file symbols.cc.

                                                               {
  REUSABLE_OBJECT_HANDLESCOPE(thread);
  REUSABLE_SMI_HANDLESCOPE(thread);
  REUSABLE_ARRAY_HANDLESCOPE(thread);
  String& symbol = String::Handle(thread->zone());
  dart::Object& key = thread->ObjectHandle();
  Smi& value = thread->SmiHandle();
  class WeakArray& data = thread->WeakArrayHandle();
  {
    auto vm_isolate_group = Dart::vm_isolate_group();
    data = vm_isolate_group->object_store()->symbol_table();
    CanonicalStringSet table(&key, &value, &data);
    symbol ^= table.GetOrNull(str);
    table.Release();
  }
  if (symbol.IsNull()) {
    IsolateGroup* group = thread->isolate_group();
    ObjectStore* object_store = group->object_store();
    // See `Symbols::NewSymbol` for more information why we separate the two
    // cases.
    if (thread->OwnsSafepoint()) {
      data = object_store->symbol_table();
      CanonicalStringSet table(&key, &value, &data);
      symbol ^= table.GetOrNull(str);
      table.Release();
    } else {
      data = object_store->symbol_table();
      CanonicalStringSet table(&key, &value, &data);
      symbol ^= table.GetOrNull(str);
      table.Release();
    }
  }
  ASSERT(symbol.IsNull() || symbol.IsSymbol());
  ASSERT(symbol.IsNull() || symbol.HasHash());
  return symbol.ptr();
}

LookupFromConcat()

StringPtr dart::Symbols::LookupFromConcat ( Thread *  thread, const String &  str1, const String &  str2  )

static

Definition at line 412 of file symbols.cc.

                                                        {
  if (str1.Length() == 0) {
    return Lookup(thread, str2);
  } else if (str2.Length() == 0) {
    return Lookup(thread, str1);
  } else {
    return Lookup(thread, ConcatString(str1, str2));
  }
}

LookupFromDot()

StringPtr dart::Symbols::LookupFromDot ( Thread *  thread, const String &  str  )

static

Definition at line 432 of file symbols.cc.

                                                                  {
  return LookupFromConcat(thread, str, Dot());
}

LookupFromGet()

StringPtr dart::Symbols::LookupFromGet ( Thread *  thread, const String &  str  )

static

Definition at line 424 of file symbols.cc.

                                                                  {
  return LookupFromConcat(thread, GetterPrefix(), str);
}

LookupFromSet()

StringPtr dart::Symbols::LookupFromSet ( Thread *  thread, const String &  str  )

static

Definition at line 428 of file symbols.cc.

                                                                  {
  return LookupFromConcat(thread, SetterPrefix(), str);
}

LowercaseR()

static const String & dart::Symbols::LowercaseR ( )

inlinestatic

Definition at line 660 of file symbols.h.

                                    {
    return *(symbol_handles_[kNullCharId + 'r']);
  }

LParen()

static const String & dart::Symbols::LParen ( )

inlinestatic

Definition at line 629 of file symbols.h.

                                {
    return *(symbol_handles_[kNullCharId + '(']);
  }

Minus()

static const String & dart::Symbols::Minus ( )

inlinestatic

Definition at line 618 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '-']); }

Name()

const char * dart::Symbols::Name ( SymbolId  symbol )

static

Definition at line 66 of file symbols.cc.

                                         {
  ASSERT((symbol > kIllegal) && (symbol < kNullCharId));
  return names[symbol];
}

New() [1/4]

static StringPtr dart::Symbols::New ( Thread *  thread, const char *  cstr  )

inlinestatic

Definition at line 723 of file symbols.h.

                                                         {
    return New(thread, cstr, strlen(cstr));
  }

New() [2/4]

StringPtr dart::Symbols::New ( Thread *  thread, const char *  cstr, intptr_t  length  )

static

Definition at line 190 of file symbols.cc.

                                                                     {
  ASSERT((cstr != nullptr) && (len >= 0));
  const uint8_t* utf8_array = reinterpret_cast<const uint8_t*>(cstr);
  return Symbols::FromUTF8(thread, utf8_array, len);
}

New() [3/4]

StringPtr dart::Symbols::New ( Thread *  thread, const String &  str  )

static

Definition at line 436 of file symbols.cc.

                                                        {
  if (str.IsSymbol()) {
    return str.ptr();
  }
  return New(thread, str, 0, str.Length());
}

New() [4/4]

StringPtr dart::Symbols::New ( Thread *  thread, const String &  str, intptr_t  begin_index, intptr_t  length  )

static

Definition at line 443 of file symbols.cc.

                                     {
  return NewSymbol(thread, StringSlice(str, begin_index, len));
}

NewFormatted()

StringPtr dart::Symbols::NewFormatted ( Thread *  thread, const char *  format,   ...  )

static

Definition at line 450 of file symbols.cc.

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

NewFormattedV()

StringPtr dart::Symbols::NewFormattedV ( Thread *  thread, const char *  format, va_list  args  )

static

Definition at line 459 of file symbols.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 Symbols::New(thread, buffer);
}

NewLine()

static const String & dart::Symbols::NewLine ( )

inlinestatic

Definition at line 651 of file symbols.h.

                                 {
    return *(symbol_handles_[kNullCharId + '\n']);
  }

Percent()

static const String & dart::Symbols::Percent ( )

inlinestatic

Definition at line 679 of file symbols.h.

                                 {
    return *(symbol_handles_[kNullCharId + '%']);
  }

Plus()

static const String & dart::Symbols::Plus ( )

inlinestatic

Definition at line 617 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '+']); }

PredefinedAddress()

static StringPtr * dart::Symbols::PredefinedAddress ( )

inlinestatic

Definition at line 772 of file symbols.h.

                                        {
    return reinterpret_cast<StringPtr*>(&predefined_);
  }

QuestionMark()

static const String & dart::Symbols::QuestionMark ( )

inlinestatic

Definition at line 682 of file symbols.h.

                                      {
    return *(symbol_handles_[kNullCharId + '?']);
  }

RAngleBracket()

static const String & dart::Symbols::RAngleBracket ( )

inlinestatic

Definition at line 626 of file symbols.h.

                                       {
    return *(symbol_handles_[kNullCharId + '>']);
  }

RBrace()

static const String & dart::Symbols::RBrace ( )

inlinestatic

Definition at line 644 of file symbols.h.

                                {
    return *(symbol_handles_[kNullCharId + '}']);
  }

RBracket()

static const String & dart::Symbols::RBracket ( )

inlinestatic

Definition at line 638 of file symbols.h.

                                  {
    return *(symbol_handles_[kNullCharId + ']']);
  }

RParen()

static const String & dart::Symbols::RParen ( )

inlinestatic

Definition at line 632 of file symbols.h.

                                {
    return *(symbol_handles_[kNullCharId + ')']);
  }

Semicolon()

static const String & dart::Symbols::Semicolon ( )

inlinestatic

Definition at line 675 of file symbols.h.

                                   {
    return *(symbol_handles_[kNullCharId + ';']);
  }

SetupSymbolTable()

void dart::Symbols::SetupSymbolTable ( IsolateGroup *  isolate_group )

static

Definition at line 168 of file symbols.cc.

                                                          {
  ASSERT(isolate_group != nullptr);
 
  // Setup the symbol table used within the String class.
  const intptr_t initial_size = (isolate_group == Dart::vm_isolate_group())
                                    ? kInitialVMIsolateSymtabSize
                                    : kInitialSymtabSize;
  class WeakArray& array = WeakArray::Handle(
      HashTables::New<CanonicalStringSet>(initial_size, Heap::kOld));
  isolate_group->object_store()->set_symbol_table(array);
}

SingleQuote()

static const String & dart::Symbols::SingleQuote ( )

inlinestatic

Definition at line 657 of file symbols.h.

                                     {
    return *(symbol_handles_[kNullCharId + '\'']);
  }

Slash()

static const String & dart::Symbols::Slash ( )

inlinestatic

Definition at line 670 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '/']); }

Star()

static const String & dart::Symbols::Star ( )

inlinestatic

Definition at line 678 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '*']); }

Super()

static const String & dart::Symbols::Super ( )

inlinestatic

Definition at line 691 of file symbols.h.

{ return *(symbol_handles_[kSUPERId]); }

Symbol()

static const String & dart::Symbols::Symbol ( intptr_t  index )

inlinestatic

Definition at line 607 of file symbols.h.

                                              {
    ASSERT((index > kIllegal) && (index < kMaxPredefinedId));
    return *(symbol_handles_[index]);
  }

This()

static const String & dart::Symbols::This ( )

inlinestatic

Definition at line 692 of file symbols.h.

{ return *(symbol_handles_[kTHISId]); }

Tilde()

static const String & dart::Symbols::Tilde ( )

inlinestatic

Definition at line 686 of file symbols.h.

{ return *(symbol_handles_[kNullCharId + '~']); }

Token()

const String & dart::Symbols::Token ( Token::Kind  token )

static

Definition at line 71 of file symbols.cc.

                                            {
  const int tok_index = token;
  ASSERT((0 <= tok_index) && (tok_index < Token::kNumTokens));
  // First keyword symbol is in symbol_handles_[kTokenTableStart + 1].
  const intptr_t token_id = Symbols::kTokenTableStart + 1 + tok_index;
  ASSERT(symbol_handles_[token_id] != nullptr);
  return *symbol_handles_[token_id];
}

True()

static const String & dart::Symbols::True ( )

inlinestatic

Definition at line 693 of file symbols.h.

{ return *(symbol_handles_[kTRUEId]); }

Void()

static const String & dart::Symbols::Void ( )

inlinestatic

Definition at line 694 of file symbols.h.

{ return *(symbol_handles_[kVOIDId]); }

Friends And Related Function Documentation

Dart

friend class Dart

friend

Definition at line 810 of file symbols.h.

Deserializer

friend class Deserializer

friend

Definition at line 813 of file symbols.h.

Serializer

friend class Serializer

friend

Definition at line 812 of file symbols.h.

String

friend class String

friend

Definition at line 811 of file symbols.h.

Member Data Documentation

kNullCharCodeSymbolOffset

constexpr int dart::Symbols::kNullCharCodeSymbolOffset = 0

staticconstexpr

Definition at line 605 of file symbols.h.

kNumberOfOneCharCodeSymbols

constexpr int dart::Symbols::kNumberOfOneCharCodeSymbols

staticconstexpr

Initial value:

=
      (kMaxPredefinedId - kNullCharId)

Definition at line 601 of file symbols.h.

---

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

• third_party/dart-lang/sdk/runtime/vm/symbols.h
• third_party/dart-lang/sdk/runtime/vm/symbols.cc