v8::Utf8LengthHelper Class Reference

Inheritance diagram for v8::Utf8LengthHelper:

Collaboration diagram for v8::Utf8LengthHelper:

Classes
class	Visitor

Public Types
enum	State {   kEndsWithLeadingSurrogate = 1 << 0 , kStartsWithTrailingSurrogate = 1 << 1 , kLeftmostEdgeIsCalculated = 1 << 2 , kRightmostEdgeIsCalculated = 1 << 3 ,   kLeftmostEdgeIsSurrogate = 1 << 4 , kRightmostEdgeIsSurrogate = 1 << 5 }

Static Public Member Functions
static bool	EndsWithSurrogate (uint8_t state)
static bool	StartsWithSurrogate (uint8_t state)
static void	MergeLeafLeft (int *length, uint8_t *state, uint8_t leaf_state)
static void	MergeLeafRight (int *length, uint8_t *state, uint8_t leaf_state)
static void	MergeTerminal (int *length, uint8_t state, uint8_t *state_out)
static int	Calculate (i::ConsString *current, uint8_t *state_out)
static int	Calculate (i::ConsString *current)

Static Public Attributes
static const uint8_t	kInitialState = 0

Private Member Functions
	DISALLOW_IMPLICIT_CONSTRUCTORS (Utf8LengthHelper)

Detailed Description

Definition at line 4368 of file api.cc.

Member Enumeration Documentation

State

enum v8::Utf8LengthHelper::State

Enumerator
kEndsWithLeadingSurrogate
kStartsWithTrailingSurrogate
kLeftmostEdgeIsCalculated
kRightmostEdgeIsCalculated
kLeftmostEdgeIsSurrogate
kRightmostEdgeIsSurrogate

Definition at line 4370 of file api.cc.

             {
    kEndsWithLeadingSurrogate = 1 << 0,
    kStartsWithTrailingSurrogate = 1 << 1,
    kLeftmostEdgeIsCalculated = 1 << 2,
    kRightmostEdgeIsCalculated = 1 << 3,
    kLeftmostEdgeIsSurrogate = 1 << 4,
    kRightmostEdgeIsSurrogate = 1 << 5
  };

Member Function Documentation

Calculate() [1/2]

static int v8::Utf8LengthHelper::Calculate ( i::ConsString *  current )

inlinestatic

Definition at line 4539 of file api.cc.

                                                    {
    uint8_t state = kInitialState;
    return Calculate(current, &state);
  }

References Calculate(), and kInitialState.

Here is the call graph for this function:

Calculate() [2/2]

static int v8::Utf8LengthHelper::Calculate ( i::ConsString *  current, uint8_t *  state_out  )

inlinestatic

Definition at line 4488 of file api.cc.

                                                                 {
    using namespace internal;
    int total_length = 0;
    uint8_t state = kInitialState;
    while (true) {
      i::String* left = current->first();
      i::String* right = current->second();
      uint8_t right_leaf_state;
      uint8_t left_leaf_state;
      int leaf_length;
      ConsString* left_as_cons =
          Visitor::VisitFlat(left, &leaf_length, &left_leaf_state);
      if (left_as_cons == NULL) {
        total_length += leaf_length;
        MergeLeafLeft(&total_length, &state, left_leaf_state);
      }
      ConsString* right_as_cons =
          Visitor::VisitFlat(right, &leaf_length, &right_leaf_state);
      if (right_as_cons == NULL) {
        total_length += leaf_length;
        MergeLeafRight(&total_length, &state, right_leaf_state);
        if (left_as_cons != NULL) {
          // 1 Leaf node. Descend in place.
          current = left_as_cons;
          continue;
        } else {
          // Terminal node.
          MergeTerminal(&total_length, state, state_out);
          return total_length;
        }
      } else if (left_as_cons == NULL) {
        // 1 Leaf node. Descend in place.
        current = right_as_cons;
        continue;
      }
      // Both strings are ConsStrings.
      // Recurse on smallest.
      if (left->length() < right->length()) {
        total_length += Calculate(left_as_cons, &left_leaf_state);
        MergeLeafLeft(&total_length, &state, left_leaf_state);
        current = right_as_cons;
      } else {
        total_length += Calculate(right_as_cons, &right_leaf_state);
        MergeLeafRight(&total_length, &state, right_leaf_state);
        current = left_as_cons;
      }
    }
    UNREACHABLE();
    return 0;
  }

References v8::internal::ConsString::first(), kInitialState, v8::internal::String::length(), MergeLeafLeft(), MergeLeafRight(), MergeTerminal(), NULL, v8::internal::ConsString::second(), UNREACHABLE, and v8::Utf8LengthHelper::Visitor::VisitFlat().

Referenced by Calculate(), and v8::Utf8Length().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::Utf8LengthHelper::DISALLOW_IMPLICIT_CONSTRUCTORS ( Utf8LengthHelper  )

private

EndsWithSurrogate()

static bool v8::Utf8LengthHelper::EndsWithSurrogate ( uint8_t  state )

inlinestatic

Definition at line 4381 of file api.cc.

                                                      {
    return state & kEndsWithLeadingSurrogate;
  }

References kEndsWithLeadingSurrogate.

Referenced by MergeLeafLeft(), MergeLeafRight(), and MergeTerminal().

Here is the caller graph for this function:

MergeLeafLeft()

static void v8::Utf8LengthHelper::MergeLeafLeft ( int *  length, uint8_t *  state, uint8_t  leaf_state  )

inlinestatic

Definition at line 4439 of file api.cc.

                                                       {
    bool edge_surrogate = StartsWithSurrogate(leaf_state);
    if (!(*state & kLeftmostEdgeIsCalculated)) {
      DCHECK(!(*state & kLeftmostEdgeIsSurrogate));
      *state |= kLeftmostEdgeIsCalculated
          | (edge_surrogate ? kLeftmostEdgeIsSurrogate : 0);
    } else if (EndsWithSurrogate(*state) && edge_surrogate) {
      *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
    }
    if (EndsWithSurrogate(leaf_state)) {
      *state |= kEndsWithLeadingSurrogate;
    } else {
      *state &= ~kEndsWithLeadingSurrogate;
    }
  }

References DCHECK, EndsWithSurrogate(), unibrow::Utf8::kBytesSavedByCombiningSurrogates, kEndsWithLeadingSurrogate, kLeftmostEdgeIsCalculated, kLeftmostEdgeIsSurrogate, and StartsWithSurrogate().

Referenced by Calculate().

Here is the call graph for this function:

Here is the caller graph for this function:

MergeLeafRight()

static void v8::Utf8LengthHelper::MergeLeafRight ( int *  length, uint8_t *  state, uint8_t  leaf_state  )

inlinestatic

Definition at line 4457 of file api.cc.

                                                        {
    bool edge_surrogate = EndsWithSurrogate(leaf_state);
    if (!(*state & kRightmostEdgeIsCalculated)) {
      DCHECK(!(*state & kRightmostEdgeIsSurrogate));
      *state |= (kRightmostEdgeIsCalculated
                 | (edge_surrogate ? kRightmostEdgeIsSurrogate : 0));
    } else if (edge_surrogate && StartsWithSurrogate(*state)) {
      *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
    }
    if (StartsWithSurrogate(leaf_state)) {
      *state |= kStartsWithTrailingSurrogate;
    } else {
      *state &= ~kStartsWithTrailingSurrogate;
    }
  }

References DCHECK, EndsWithSurrogate(), unibrow::Utf8::kBytesSavedByCombiningSurrogates, kRightmostEdgeIsCalculated, kRightmostEdgeIsSurrogate, kStartsWithTrailingSurrogate, and StartsWithSurrogate().

Referenced by Calculate().

Here is the call graph for this function:

Here is the caller graph for this function:

MergeTerminal()

static void v8::Utf8LengthHelper::MergeTerminal ( int *  length, uint8_t  state, uint8_t *  state_out  )

inlinestatic

Definition at line 4475 of file api.cc.

                                                       {
    DCHECK((state & kLeftmostEdgeIsCalculated) &&
           (state & kRightmostEdgeIsCalculated));
    if (EndsWithSurrogate(state) && StartsWithSurrogate(state)) {
      *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
    }
    *state_out = kInitialState |
        (state & kLeftmostEdgeIsSurrogate ? kStartsWithTrailingSurrogate : 0) |
        (state & kRightmostEdgeIsSurrogate ? kEndsWithLeadingSurrogate : 0);
  }

References DCHECK, EndsWithSurrogate(), unibrow::Utf8::kBytesSavedByCombiningSurrogates, kEndsWithLeadingSurrogate, kInitialState, kLeftmostEdgeIsCalculated, kLeftmostEdgeIsSurrogate, kRightmostEdgeIsCalculated, kRightmostEdgeIsSurrogate, kStartsWithTrailingSurrogate, and StartsWithSurrogate().

Referenced by Calculate().

Here is the call graph for this function:

Here is the caller graph for this function:

StartsWithSurrogate()

static bool v8::Utf8LengthHelper::StartsWithSurrogate ( uint8_t  state )

inlinestatic

Definition at line 4385 of file api.cc.

                                                        {
    return state & kStartsWithTrailingSurrogate;
  }

References kStartsWithTrailingSurrogate.

Referenced by MergeLeafLeft(), MergeLeafRight(), and MergeTerminal().

Here is the caller graph for this function:

Member Data Documentation

kInitialState

const uint8_t v8::Utf8LengthHelper::kInitialState = 0

static

Definition at line 4379 of file api.cc.

Referenced by Calculate(), MergeTerminal(), and v8::Utf8LengthHelper::Visitor::VisitOneByteString().

---

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

• /mnt/V8SourceCode/src/api.cc