v8::internal::DuplicateFinder Class Reference

#include <scanner.h>

Collaboration diagram for v8::internal::DuplicateFinder:

Public Member Functions
	DuplicateFinder (UnicodeCache *constants)
int	AddOneByteSymbol (Vector< const uint8_t > key, int value)
int	AddTwoByteSymbol (Vector< const uint16_t > key, int value)
int	AddNumber (Vector< const uint8_t > key, int value)

Private Member Functions
int	AddSymbol (Vector< const uint8_t > key, bool is_one_byte, int value)
uint8_t *	BackupKey (Vector< const uint8_t > key, bool is_one_byte)

Static Private Member Functions
static bool	Match (void *first, void *second)
static uint32_t	Hash (Vector< const uint8_t > key, bool is_one_byte)
static bool	IsNumberCanonical (Vector< const uint8_t > key)

Private Attributes
UnicodeCache *	unicode_constants_
SequenceCollector< unsigned char >	backing_store_
HashMap	map_
char	number_buffer_ [kBufferSize]

Static Private Attributes
static const int	kBufferSize = 100

Detailed Description

Definition at line 144 of file scanner.h.

Constructor & Destructor Documentation

DuplicateFinder()

v8::internal::DuplicateFinder::DuplicateFinder ( UnicodeCache *  constants )

inlineexplicit

Definition at line 146 of file scanner.h.

      : unicode_constants_(constants),
        backing_store_(16),
        map_(&Match) { }

Member Function Documentation

AddNumber()

int v8::internal::DuplicateFinder::AddNumber	(	Vector< const uint8_t >	key,
		int	value
	)

Definition at line 1256 of file scanner.cc.

                                                                   {
  DCHECK(key.length() > 0);
  // Quick check for already being in canonical form.
  if (IsNumberCanonical(key)) {
    return AddOneByteSymbol(key, value);
  }
 
  int flags = ALLOW_HEX | ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL | ALLOW_BINARY;
  double double_value = StringToDouble(
      unicode_constants_, key, flags, 0.0);
  int length;
  const char* string;
  if (!std::isfinite(double_value)) {
    string = "Infinity";
    length = 8;  // strlen("Infinity");
  } else {
    string = DoubleToCString(double_value,
                             Vector<char>(number_buffer_, kBufferSize));
    length = StrLength(string);
  }
  return AddSymbol(Vector<const byte>(reinterpret_cast<const byte*>(string),
                                      length), true, value);
}

References AddOneByteSymbol(), AddSymbol(), v8::internal::ALLOW_BINARY, v8::internal::ALLOW_HEX, v8::internal::ALLOW_IMPLICIT_OCTAL, v8::internal::ALLOW_OCTAL, DCHECK, v8::internal::DoubleToCString(), v8::internal::anonymous_namespace{flags.cc}::flags, IsNumberCanonical(), kBufferSize, v8::internal::Vector< T >::length(), number_buffer_, v8::internal::StringToDouble(), v8::internal::StrLength(), and unicode_constants_.

Referenced by v8::internal::Scanner::FindNumber().

Here is the call graph for this function:

Here is the caller graph for this function:

AddOneByteSymbol()

int v8::internal::DuplicateFinder::AddOneByteSymbol	(	Vector< const uint8_t >	key,
		int	value
	)

Definition at line 1233 of file scanner.cc.

                                                                          {
  return AddSymbol(key, true, value);
}

References AddSymbol().

Referenced by AddNumber(), and v8::internal::Scanner::FindSymbol().

Here is the call graph for this function:

Here is the caller graph for this function:

AddSymbol()

int v8::internal::DuplicateFinder::AddSymbol ( Vector< const uint8_t >  key, bool  is_one_byte, int  value  )

private

Definition at line 1243 of file scanner.cc.

                                          {
  uint32_t hash = Hash(key, is_one_byte);
  byte* encoding = BackupKey(key, is_one_byte);
  HashMap::Entry* entry = map_.Lookup(encoding, hash, true);
  int old_value = static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
  entry->value =
    reinterpret_cast<void*>(static_cast<intptr_t>(value | old_value));
  return old_value;
}

References BackupKey(), Hash(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), and map_.

Referenced by AddNumber(), AddOneByteSymbol(), and AddTwoByteSymbol().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTwoByteSymbol()

int v8::internal::DuplicateFinder::AddTwoByteSymbol	(	Vector< const uint16_t >	key,
		int	value
	)

Definition at line 1238 of file scanner.cc.

                                                                           {
  return AddSymbol(Vector<const uint8_t>::cast(key), false, value);
}

References AddSymbol().

Referenced by v8::internal::Scanner::FindSymbol().

Here is the call graph for this function:

Here is the caller graph for this function:

BackupKey()

byte * v8::internal::DuplicateFinder::BackupKey ( Vector< const uint8_t >  key, bool  is_one_byte  )

private

Definition at line 1345 of file scanner.cc.

                                                   {
  uint32_t one_byte_length = (bytes.length() << 1) | (is_one_byte ? 1 : 0);
  backing_store_.StartSequence();
  // Emit one_byte_length as base-128 encoded number, with the 7th bit set
  // on the byte of every heptet except the last, least significant, one.
  if (one_byte_length >= (1 << 7)) {
    if (one_byte_length >= (1 << 14)) {
      if (one_byte_length >= (1 << 21)) {
        if (one_byte_length >= (1 << 28)) {
          backing_store_.Add(
              static_cast<uint8_t>((one_byte_length >> 28) | 0x80));
        }
        backing_store_.Add(
            static_cast<uint8_t>((one_byte_length >> 21) | 0x80u));
      }
      backing_store_.Add(
          static_cast<uint8_t>((one_byte_length >> 14) | 0x80u));
    }
    backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
  }
  backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
  backing_store_.AddBlock(bytes);
  return backing_store_.EndSequence().start();
}

References v8::internal::Collector< T, growth_factor, max_growth >::Add(), v8::internal::Collector< T, growth_factor, max_growth >::AddBlock(), backing_store_, v8::internal::SequenceCollector< T, growth_factor, max_growth >::EndSequence(), v8::internal::Vector< T >::length(), and v8::internal::SequenceCollector< T, growth_factor, max_growth >::StartSequence().

Referenced by AddSymbol().

Here is the call graph for this function:

Here is the caller graph for this function:

Hash()

uint32_t v8::internal::DuplicateFinder::Hash ( Vector< const uint8_t >  key, bool  is_one_byte  )

staticprivate

Definition at line 1309 of file scanner.cc.

                                                                          {
  // Primitive hash function, almost identical to the one used
  // for strings (except that it's seeded by the length and representation).
  int length = key.length();
  uint32_t hash = (length << 1) | (is_one_byte ? 1 : 0) ;
  for (int i = 0; i < length; i++) {
    uint32_t c = key[i];
    hash = (hash + c) * 1025;
    hash ^= (hash >> 6);
  }
  return hash;
}

References v8::internal::Vector< T >::length().

Referenced by AddSymbol().

Here is the call graph for this function:

Here is the caller graph for this function:

IsNumberCanonical()

bool v8::internal::DuplicateFinder::IsNumberCanonical ( Vector< const uint8_t >  key )

staticprivate

Definition at line 1281 of file scanner.cc.

                                                                    {
  // Test for a safe approximation of number literals that are already
  // in canonical form: max 15 digits, no leading zeroes, except an
  // integer part that is a single zero, and no trailing zeros below
  // the decimal point.
  int pos = 0;
  int length = number.length();
  if (number.length() > 15) return false;
  if (number[pos] == '0') {
    pos++;
  } else {
    while (pos < length &&
           static_cast<unsigned>(number[pos] - '0') <= ('9' - '0')) pos++;
  }
  if (length == pos) return true;
  if (number[pos] != '.') return false;
  pos++;
  bool invalid_last_digit = true;
  while (pos < length) {
    uint8_t digit = number[pos] - '0';
    if (digit > '9' - '0') return false;
    invalid_last_digit = (digit == 0);
    pos++;
  }
  return !invalid_last_digit;
}

References v8::internal::Vector< T >::length().

Referenced by AddNumber().

Here is the call graph for this function:

Here is the caller graph for this function:

Match()

bool v8::internal::DuplicateFinder::Match ( void *  first, void *  second  )

staticprivate

Definition at line 1323 of file scanner.cc.

                                                     {
  // Decode lengths.
  // Length + representation is encoded as base 128, most significant heptet
  // first, with a 8th bit being non-zero while there are more heptets.
  // The value encodes the number of bytes following, and whether the original
  // was Latin1.
  byte* s1 = reinterpret_cast<byte*>(first);
  byte* s2 = reinterpret_cast<byte*>(second);
  uint32_t length_one_byte_field = 0;
  byte c1;
  do {
    c1 = *s1;
    if (c1 != *s2) return false;
    length_one_byte_field = (length_one_byte_field << 7) | (c1 & 0x7f);
    s1++;
    s2++;
  } while ((c1 & 0x80) != 0);
  int length = static_cast<int>(length_one_byte_field >> 1);
  return memcmp(s1, s2, length) == 0;
}

References v8::internal::s1, and v8::internal::s2.

Member Data Documentation

backing_store_

SequenceCollector<unsigned char> v8::internal::DuplicateFinder::backing_store_

private

Definition at line 184 of file scanner.h.

Referenced by BackupKey().

kBufferSize

const int v8::internal::DuplicateFinder::kBufferSize = 100

staticprivate

Definition at line 180 of file scanner.h.

Referenced by AddNumber().

map_

HashMap v8::internal::DuplicateFinder::map_

private

Definition at line 185 of file scanner.h.

Referenced by AddSymbol().

number_buffer_

char v8::internal::DuplicateFinder::number_buffer_[kBufferSize]

private

Definition at line 187 of file scanner.h.

Referenced by AddNumber().

unicode_constants_

UnicodeCache* v8::internal::DuplicateFinder::unicode_constants_

private

Definition at line 182 of file scanner.h.

Referenced by AddNumber().

---

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

• /mnt/V8SourceCode/src/scanner.h
• /mnt/V8SourceCode/src/scanner.cc