v8::Utf8WriterVisitor Class Reference

Collaboration diagram for v8::Utf8WriterVisitor:

Public Member Functions
	Utf8WriterVisitor (char *buffer, int capacity, bool skip_capacity_check, bool replace_invalid_utf8)
template<typename Char >
void	Visit (const Char *chars, const int length)
bool	IsDone ()
void	VisitOneByteString (const uint8_t *chars, int length)
void	VisitTwoByteString (const uint16_t *chars, int length)
int	CompleteWrite (bool write_null, int *utf16_chars_read_out)

Static Public Member Functions
static int	WriteEndCharacter (uint16_t character, int last_character, int remaining, char *const buffer, bool replace_invalid_utf8)

Private Member Functions
	DISALLOW_IMPLICIT_CONSTRUCTORS (Utf8WriterVisitor)

Private Attributes
bool	early_termination_
int	last_character_
char *	buffer_
char *const	start_
int	capacity_
bool const	skip_capacity_check_
bool const	replace_invalid_utf8_
int	utf16_chars_read_

Detailed Description

Definition at line 4567 of file api.cc.

Constructor & Destructor Documentation

Utf8WriterVisitor()

v8::Utf8WriterVisitor::Utf8WriterVisitor ( char *  buffer, int  capacity, bool  skip_capacity_check, bool  replace_invalid_utf8  )

inline

Definition at line 4569 of file api.cc.

    : early_termination_(false),
      last_character_(unibrow::Utf16::kNoPreviousCharacter),
      buffer_(buffer),
      start_(buffer),
      capacity_(capacity),
      skip_capacity_check_(capacity == -1 || skip_capacity_check),
      replace_invalid_utf8_(replace_invalid_utf8),
      utf16_chars_read_(0) {
  }

Member Function Documentation

CompleteWrite()

int v8::Utf8WriterVisitor::CompleteWrite ( bool  write_null, int *  utf16_chars_read_out  )

inline

Definition at line 4725 of file api.cc.

                                                                {
    // Write out number of utf16 characters written to the stream.
    if (utf16_chars_read_out != NULL) {
      *utf16_chars_read_out = utf16_chars_read_;
    }
    // Only null terminate if all of the string was written and there's space.
    if (write_null &&
        !early_termination_ &&
        (capacity_ == -1 || (buffer_ - start_) < capacity_)) {
      *buffer_++ = '\0';
    }
    return static_cast<int>(buffer_ - start_);
  }

References NULL.

Referenced by v8::String::WriteUtf8().

Here is the caller graph for this function:

DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::Utf8WriterVisitor::DISALLOW_IMPLICIT_CONSTRUCTORS ( Utf8WriterVisitor  )

private

IsDone()

bool v8::Utf8WriterVisitor::IsDone ( )

inline

Definition at line 4713 of file api.cc.

                       {
    return early_termination_;
  }

Referenced by v8::RecursivelySerializeToUtf8().

Here is the caller graph for this function:

Visit()

template<typename Char >

void v8::Utf8WriterVisitor::Visit ( const Char *  chars, const int  length  )

inline

Definition at line 4629 of file api.cc.

                                                  {
    using namespace unibrow;
    DCHECK(!early_termination_);
    if (length == 0) return;
    // Copy state to stack.
    char* buffer = buffer_;
    int last_character =
        sizeof(Char) == 1 ? Utf16::kNoPreviousCharacter : last_character_;
    int i = 0;
    // Do a fast loop where there is no exit capacity check.
    while (true) {
      int fast_length;
      if (skip_capacity_check_) {
        fast_length = length;
      } else {
        int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
        // Need enough space to write everything but one character.
        STATIC_ASSERT(Utf16::kMaxExtraUtf8BytesForOneUtf16CodeUnit == 3);
        int max_size_per_char =  sizeof(Char) == 1 ? 2 : 3;
        int writable_length =
            (remaining_capacity - max_size_per_char)/max_size_per_char;
        // Need to drop into slow loop.
        if (writable_length <= 0) break;
        fast_length = i + writable_length;
        if (fast_length > length) fast_length = length;
      }
      // Write the characters to the stream.
      if (sizeof(Char) == 1) {
        for (; i < fast_length; i++) {
          buffer +=
              Utf8::EncodeOneByte(buffer, static_cast<uint8_t>(*chars++));
          DCHECK(capacity_ == -1 || (buffer - start_) <= capacity_);
        }
      } else {
        for (; i < fast_length; i++) {
          uint16_t character = *chars++;
          buffer += Utf8::Encode(buffer,
                                 character,
                                 last_character,
                                 replace_invalid_utf8_);
          last_character = character;
          DCHECK(capacity_ == -1 || (buffer - start_) <= capacity_);
        }
      }
      // Array is fully written. Exit.
      if (fast_length == length) {
        // Write state back out to object.
        last_character_ = last_character;
        buffer_ = buffer;
        utf16_chars_read_ += length;
        return;
      }
    }
    DCHECK(!skip_capacity_check_);
    // Slow loop. Must check capacity on each iteration.
    int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
    DCHECK(remaining_capacity >= 0);
    for (; i < length && remaining_capacity > 0; i++) {
      uint16_t character = *chars++;
      // remaining_capacity is <= 3 bytes at this point, so we do not write out
      // an umatched lead surrogate.
      if (replace_invalid_utf8_ && Utf16::IsLeadSurrogate(character)) {
        early_termination_ = true;
        break;
      }
      int written = WriteEndCharacter(character,
                                      last_character,
                                      remaining_capacity,
                                      buffer,
                                      replace_invalid_utf8_);
      if (written == 0) {
        early_termination_ = true;
        break;
      }
      buffer += written;
      remaining_capacity -= written;
      last_character = character;
    }
    // Write state back out to object.
    last_character_ = last_character;
    buffer_ = buffer;
    utf16_chars_read_ += i;
  }

References DCHECK, and STATIC_ASSERT.

VisitOneByteString()

void v8::Utf8WriterVisitor::VisitOneByteString ( const uint8_t *  chars, int  length  )

inline

Definition at line 4717 of file api.cc.

                                                                   {
    Visit(chars, length);
  }

VisitTwoByteString()

void v8::Utf8WriterVisitor::VisitTwoByteString ( const uint16_t *  chars, int  length  )

inline

Definition at line 4721 of file api.cc.

                                                                    {
    Visit(chars, length);
  }

WriteEndCharacter()

static int v8::Utf8WriterVisitor::WriteEndCharacter ( uint16_t  character, int  last_character, int  remaining, char *const  buffer, bool  replace_invalid_utf8  )

inlinestatic

Definition at line 4584 of file api.cc.

                                                          {
    using namespace unibrow;
    DCHECK(remaining > 0);
    // We can't use a local buffer here because Encode needs to modify
    // previous characters in the stream.  We know, however, that
    // exactly one character will be advanced.
    if (Utf16::IsSurrogatePair(last_character, character)) {
      int written = Utf8::Encode(buffer,
                                 character,
                                 last_character,
                                 replace_invalid_utf8);
      DCHECK(written == 1);
      return written;
    }
    // Use a scratch buffer to check the required characters.
    char temp_buffer[Utf8::kMaxEncodedSize];
    // Can't encode using last_character as gcc has array bounds issues.
    int written = Utf8::Encode(temp_buffer,
                               character,
                               Utf16::kNoPreviousCharacter,
                               replace_invalid_utf8);
    // Won't fit.
    if (written > remaining) return 0;
    // Copy over the character from temp_buffer.
    for (int j = 0; j < written; j++) {
      buffer[j] = temp_buffer[j];
    }
    return written;
  }

References DCHECK.

Member Data Documentation

buffer_

char* v8::Utf8WriterVisitor::buffer_

private

Definition at line 4742 of file api.cc.

capacity_

int v8::Utf8WriterVisitor::capacity_

private

Definition at line 4744 of file api.cc.

early_termination_

bool v8::Utf8WriterVisitor::early_termination_

private

Definition at line 4740 of file api.cc.

last_character_

int v8::Utf8WriterVisitor::last_character_

private

Definition at line 4741 of file api.cc.

replace_invalid_utf8_

bool const v8::Utf8WriterVisitor::replace_invalid_utf8_

private

Definition at line 4746 of file api.cc.

skip_capacity_check_

bool const v8::Utf8WriterVisitor::skip_capacity_check_

private

Definition at line 4745 of file api.cc.

start_

char* const v8::Utf8WriterVisitor::start_

private

Definition at line 4743 of file api.cc.

utf16_chars_read_

int v8::Utf8WriterVisitor::utf16_chars_read_

private

Definition at line 4747 of file api.cc.

---

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

• /mnt/V8SourceCode/src/api.cc