unibrow::Utf8DecoderBase Class Reference

#include <unicode.h>

Inheritance diagram for unibrow::Utf8DecoderBase:

Collaboration diagram for unibrow::Utf8DecoderBase:

Public Member Functions
	Utf8DecoderBase ()
	Utf8DecoderBase (uint16_t *buffer, unsigned buffer_length, const uint8_t *stream, unsigned stream_length)
unsigned	Utf16Length () const

Protected Member Functions
void	Reset (uint16_t *buffer, unsigned buffer_length, const uint8_t *stream, unsigned stream_length)

Static Protected Member Functions
static void	WriteUtf16Slow (const uint8_t *stream, uint16_t *data, unsigned length)

Protected Attributes
const uint8_t *	unbuffered_start_
unsigned	utf16_length_
bool	last_byte_of_buffer_unused_

Private Member Functions
	DISALLOW_COPY_AND_ASSIGN (Utf8DecoderBase)

Detailed Description

Definition at line 159 of file unicode.h.

Constructor & Destructor Documentation

Utf8DecoderBase() [1/2]

unibrow::Utf8DecoderBase::Utf8DecoderBase ( )

inline

Definition at line 156 of file unicode-inl.h.

  : unbuffered_start_(NULL),
    utf16_length_(0),
    last_byte_of_buffer_unused_(false) {}

Utf8DecoderBase() [2/2]

unibrow::Utf8DecoderBase::Utf8DecoderBase ( uint16_t *  buffer, unsigned  buffer_length, const uint8_t *  stream, unsigned  stream_length  )

inline

Definition at line 161 of file unicode-inl.h.

                                                         {
  Reset(buffer, buffer_length, stream, stream_length);
}

References Reset().

Here is the call graph for this function:

Member Function Documentation

DISALLOW_COPY_AND_ASSIGN()

unibrow::Utf8DecoderBase::DISALLOW_COPY_AND_ASSIGN ( Utf8DecoderBase  )

private

Reset()

void unibrow::Utf8DecoderBase::Reset ( uint16_t *  buffer, unsigned  buffer_length, const uint8_t *  stream, unsigned  stream_length  )

protected

Definition at line 261 of file unicode.cc.

                                                    {
  // Assume everything will fit in the buffer and stream won't be needed.
  last_byte_of_buffer_unused_ = false;
  unbuffered_start_ = NULL;
  bool writing_to_buffer = true;
  // Loop until stream is read, writing to buffer as long as buffer has space.
  unsigned utf16_length = 0;
  while (stream_length != 0) {
    unsigned cursor = 0;
    uint32_t character = Utf8::ValueOf(stream, stream_length, &cursor);
    DCHECK(cursor > 0 && cursor <= stream_length);
    stream += cursor;
    stream_length -= cursor;
    bool is_two_characters = character > Utf16::kMaxNonSurrogateCharCode;
    utf16_length += is_two_characters ? 2 : 1;
    // Don't need to write to the buffer, but still need utf16_length.
    if (!writing_to_buffer) continue;
    // Write out the characters to the buffer.
    // Must check for equality with buffer_length as we've already updated it.
    if (utf16_length <= buffer_length) {
      if (is_two_characters) {
        *buffer++ = Utf16::LeadSurrogate(character);
        *buffer++ = Utf16::TrailSurrogate(character);
      } else {
        *buffer++ = character;
      }
      if (utf16_length == buffer_length) {
        // Just wrote last character of buffer
        writing_to_buffer = false;
        unbuffered_start_ = stream;
      }
      continue;
    }
    // Have gone over buffer.
    // Last char of buffer is unused, set cursor back.
    DCHECK(is_two_characters);
    writing_to_buffer = false;
    last_byte_of_buffer_unused_ = true;
    unbuffered_start_ = stream - cursor;
  }
  utf16_length_ = utf16_length;
}

References DCHECK, unibrow::Utf16::kMaxNonSurrogateCharCode, last_byte_of_buffer_unused_, unibrow::Utf16::LeadSurrogate(), NULL, unibrow::Utf16::TrailSurrogate(), unbuffered_start_, utf16_length_, and unibrow::Utf8::ValueOf().

Referenced by unibrow::Utf8Decoder< kBufferSize >::Reset(), and Utf8DecoderBase().

Here is the call graph for this function:

Here is the caller graph for this function:

Utf16Length()

unsigned unibrow::Utf8DecoderBase::Utf16Length ( ) const

inline

Definition at line 167 of file unicode.h.

{ return utf16_length_; }

References utf16_length_.

WriteUtf16Slow()

void unibrow::Utf8DecoderBase::WriteUtf16Slow ( const uint8_t *  stream, uint16_t *  data, unsigned  length  )

staticprotected

Definition at line 308 of file unicode.cc.

                                                           {
  while (data_length != 0) {
    unsigned cursor = 0;
    uint32_t character = Utf8::ValueOf(stream, Utf8::kMaxEncodedSize, &cursor);
    // There's a total lack of bounds checking for stream
    // as it was already done in Reset.
    stream += cursor;
    if (character > unibrow::Utf16::kMaxNonSurrogateCharCode) {
      *data++ = Utf16::LeadSurrogate(character);
      *data++ = Utf16::TrailSurrogate(character);
      DCHECK(data_length > 1);
      data_length -= 2;
    } else {
      *data++ = character;
      data_length -= 1;
    }
  }
}

References DCHECK, unibrow::Utf8::kMaxEncodedSize, unibrow::Utf16::kMaxNonSurrogateCharCode, unibrow::Utf16::LeadSurrogate(), unibrow::Utf16::TrailSurrogate(), and unibrow::Utf8::ValueOf().

Here is the call graph for this function:

Member Data Documentation

last_byte_of_buffer_unused_

bool unibrow::Utf8DecoderBase::last_byte_of_buffer_unused_

protected

Definition at line 180 of file unicode.h.

Referenced by Reset().

unbuffered_start_

const uint8_t* unibrow::Utf8DecoderBase::unbuffered_start_

protected

Definition at line 178 of file unicode.h.

Referenced by Reset().

utf16_length_

unsigned unibrow::Utf8DecoderBase::utf16_length_

protected

Definition at line 179 of file unicode.h.

Referenced by Reset(), and Utf16Length().

---

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

• /mnt/V8SourceCode/src/unicode.h
• /mnt/V8SourceCode/src/unicode-inl.h
• /mnt/V8SourceCode/src/unicode.cc