v8::ContainsOnlyOneByteHelper Class Reference

Collaboration diagram for v8::ContainsOnlyOneByteHelper:

Public Member Functions
	ContainsOnlyOneByteHelper ()
bool	Check (i::String *string)
void	VisitOneByteString (const uint8_t *chars, int length)
void	VisitTwoByteString (const uint16_t *chars, int length)

Private Member Functions
bool	CheckCons (i::ConsString *cons_string)
	DISALLOW_COPY_AND_ASSIGN (ContainsOnlyOneByteHelper)

Private Attributes
bool	is_one_byte_

Detailed Description

Definition at line 4271 of file api.cc.

Constructor & Destructor Documentation

ContainsOnlyOneByteHelper()

v8::ContainsOnlyOneByteHelper::ContainsOnlyOneByteHelper ( )

inline

Definition at line 4273 of file api.cc.

: is_one_byte_(true) {}

Member Function Documentation

Check()

bool v8::ContainsOnlyOneByteHelper::Check ( i::String *  string )

inline

Definition at line 4274 of file api.cc.

                              {
    i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
    if (cons_string == NULL) return is_one_byte_;
    return CheckCons(cons_string);
  }

References CheckCons(), is_one_byte_, NULL, and v8::internal::String::VisitFlat().

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

Here is the call graph for this function:

Here is the caller graph for this function:

CheckCons()

bool v8::ContainsOnlyOneByteHelper::CheckCons ( i::ConsString *  cons_string )

inlineprivate

Definition at line 4315 of file api.cc.

                                           {
    while (true) {
      // Check left side if flat.
      i::String* left = cons_string->first();
      i::ConsString* left_as_cons =
          i::String::VisitFlat(this, left, 0);
      if (!is_one_byte_) return false;
      // Check right side if flat.
      i::String* right = cons_string->second();
      i::ConsString* right_as_cons =
          i::String::VisitFlat(this, right, 0);
      if (!is_one_byte_) return false;
      // Standard recurse/iterate trick.
      if (left_as_cons != NULL && right_as_cons != NULL) {
        if (left->length() < right->length()) {
          CheckCons(left_as_cons);
          cons_string = right_as_cons;
        } else {
          CheckCons(right_as_cons);
          cons_string = left_as_cons;
        }
        // Check fast return.
        if (!is_one_byte_) return false;
        continue;
      }
      // Descend left in place.
      if (left_as_cons != NULL) {
        cons_string = left_as_cons;
        continue;
      }
      // Descend right in place.
      if (right_as_cons != NULL) {
        cons_string = right_as_cons;
        continue;
      }
      // Terminate.
      break;
    }
    return is_one_byte_;
  }

References v8::internal::ConsString::first(), is_one_byte_, v8::internal::String::length(), NULL, v8::internal::ConsString::second(), and v8::internal::String::VisitFlat().

Referenced by Check().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::ContainsOnlyOneByteHelper::DISALLOW_COPY_AND_ASSIGN ( ContainsOnlyOneByteHelper  )

private

VisitOneByteString()

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

inline

Definition at line 4279 of file api.cc.

                                                            {
    // Nothing to do.
  }

VisitTwoByteString()

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

inline

Definition at line 4282 of file api.cc.

                                                             {
    // Accumulated bits.
    uintptr_t acc = 0;
    // Align to uintptr_t.
    const uint16_t* end = chars + length;
    while (Unaligned(chars) && chars != end) {
      acc |= *chars++;
    }
    // Read word aligned in blocks,
    // checking the return value at the end of each block.
    const uint16_t* aligned_end = Align(end);
    const int increment = sizeof(uintptr_t)/sizeof(uint16_t);
    const int inner_loops = 16;
    while (chars + inner_loops*increment < aligned_end) {
      for (int i = 0; i < inner_loops; i++) {
        acc |= *reinterpret_cast<const uintptr_t*>(chars);
        chars += increment;
      }
      // Check for early return.
      if ((acc & kOneByteMask) != 0) {
        is_one_byte_ = false;
        return;
      }
    }
    // Read the rest.
    while (chars != end) {
      acc |= *chars++;
    }
    // Check result.
    if ((acc & kOneByteMask) != 0) is_one_byte_ = false;
  }

References v8::Align(), is_one_byte_, v8::kOneByteMask, and v8::Unaligned().

Here is the call graph for this function:

Member Data Documentation

is_one_byte_

bool v8::ContainsOnlyOneByteHelper::is_one_byte_

private

Definition at line 4355 of file api.cc.

Referenced by Check(), CheckCons(), and VisitTwoByteString().

---

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

• /mnt/V8SourceCode/src/api.cc