v8::internal::CompiledReplacement Class Reference

Collaboration diagram for v8::internal::CompiledReplacement:

Classes
struct	ReplacementPart

Public Member Functions
	CompiledReplacement (Zone *zone)
bool	Compile (Handle< String > replacement, int capture_count, int subject_length)
void	Apply (ReplacementStringBuilder *builder, int match_from, int match_to, int32_t *match)
int	parts ()
Zone *	zone () const

Private Types
enum	PartType {   SUBJECT_PREFIX = 1 , SUBJECT_SUFFIX , SUBJECT_CAPTURE , REPLACEMENT_SUBSTRING ,   REPLACEMENT_STRING , NUMBER_OF_PART_TYPES }

Private Member Functions
template<typename Char >
bool	ParseReplacementPattern (ZoneList< ReplacementPart > *parts, Vector< Char > characters, int capture_count, int subject_length, Zone *zone)

Private Attributes
ZoneList< ReplacementPart >	parts_
ZoneList< Handle< String > >	replacement_substrings_
Zone *	zone_

Detailed Description

Definition at line 18 of file runtime-regexp.cc.

Member Enumeration Documentation

PartType

enum v8::internal::CompiledReplacement::PartType

private

Enumerator
SUBJECT_PREFIX
SUBJECT_SUFFIX
SUBJECT_CAPTURE
REPLACEMENT_SUBSTRING
REPLACEMENT_STRING
NUMBER_OF_PART_TYPES

Definition at line 37 of file runtime-regexp.cc.

                {
    SUBJECT_PREFIX = 1,
    SUBJECT_SUFFIX,
    SUBJECT_CAPTURE,
    REPLACEMENT_SUBSTRING,
    REPLACEMENT_STRING,
    NUMBER_OF_PART_TYPES
  };

Constructor & Destructor Documentation

CompiledReplacement()

v8::internal::CompiledReplacement::CompiledReplacement ( Zone *  zone )

inlineexplicit

Definition at line 20 of file runtime-regexp.cc.

      : parts_(1, zone), replacement_substrings_(0, zone), zone_(zone) {}

Member Function Documentation

Apply()

void v8::internal::CompiledReplacement::Apply	(	ReplacementStringBuilder *	builder,
		int	match_from,
		int	match_to,
		int32_t *	match
	)

Definition at line 246 of file runtime-regexp.cc.

                                                                              {
  DCHECK_LT(0, parts_.length());
  for (int i = 0, n = parts_.length(); i < n; i++) {
    ReplacementPart part = parts_[i];
    switch (part.tag) {
      case SUBJECT_PREFIX:
        if (match_from > 0) builder->AddSubjectSlice(0, match_from);
        break;
      case SUBJECT_SUFFIX: {
        int subject_length = part.data;
        if (match_to < subject_length) {
          builder->AddSubjectSlice(match_to, subject_length);
        }
        break;
      }
      case SUBJECT_CAPTURE: {
        int capture = part.data;
        int from = match[capture * 2];
        int to = match[capture * 2 + 1];
        if (from >= 0 && to > from) {
          builder->AddSubjectSlice(from, to);
        }
        break;
      }
      case REPLACEMENT_SUBSTRING:
      case REPLACEMENT_STRING:
        builder->AddString(replacement_substrings_[part.data]);
        break;
      default:
        UNREACHABLE();
    }
  }
}

References v8::internal::ReplacementStringBuilder::AddString(), v8::internal::ReplacementStringBuilder::AddSubjectSlice(), v8::internal::CompiledReplacement::ReplacementPart::data, DCHECK_LT, parts_, REPLACEMENT_STRING, REPLACEMENT_SUBSTRING, replacement_substrings_, SUBJECT_CAPTURE, SUBJECT_PREFIX, SUBJECT_SUFFIX, v8::internal::CompiledReplacement::ReplacementPart::tag, to(), and UNREACHABLE.

Referenced by v8::internal::StringReplaceGlobalRegExpWithString().

Here is the call graph for this function:

Here is the caller graph for this function:

Compile()

bool v8::internal::CompiledReplacement::Compile	(	Handle< String >	replacement,
		int	capture_count,
		int	subject_length
	)

Definition at line 205 of file runtime-regexp.cc.

                                                      {
  {
    DisallowHeapAllocation no_gc;
    String::FlatContent content = replacement->GetFlatContent();
    DCHECK(content.IsFlat());
    bool simple = false;
    if (content.IsOneByte()) {
      simple = ParseReplacementPattern(&parts_, content.ToOneByteVector(),
                                       capture_count, subject_length, zone());
    } else {
      DCHECK(content.IsTwoByte());
      simple = ParseReplacementPattern(&parts_, content.ToUC16Vector(),
                                       capture_count, subject_length, zone());
    }
    if (simple) return true;
  }
 
  Isolate* isolate = replacement->GetIsolate();
  // Find substrings of replacement string and create them as String objects.
  int substring_index = 0;
  for (int i = 0, n = parts_.length(); i < n; i++) {
    int tag = parts_[i].tag;
    if (tag <= 0) {  // A replacement string slice.
      int from = -tag;
      int to = parts_[i].data;
      replacement_substrings_.Add(
          isolate->factory()->NewSubString(replacement, from, to), zone());
      parts_[i].tag = REPLACEMENT_SUBSTRING;
      parts_[i].data = substring_index;
      substring_index++;
    } else if (tag == REPLACEMENT_STRING) {
      replacement_substrings_.Add(replacement, zone());
      parts_[i].data = substring_index;
      substring_index++;
    }
  }
  return false;
}

References DCHECK, v8::internal::Isolate::factory(), v8::internal::String::FlatContent::IsFlat(), v8::internal::String::FlatContent::IsOneByte(), v8::internal::String::FlatContent::IsTwoByte(), ParseReplacementPattern(), parts_, REPLACEMENT_STRING, REPLACEMENT_SUBSTRING, replacement_substrings_, to(), v8::internal::String::FlatContent::ToOneByteVector(), v8::internal::String::FlatContent::ToUC16Vector(), and zone().

Referenced by v8::internal::StringReplaceGlobalRegExpWithString().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseReplacementPattern()

template<typename Char >

bool v8::internal::CompiledReplacement::ParseReplacementPattern ( ZoneList< ReplacementPart > *  parts, Vector< Char >  characters, int  capture_count, int  subject_length, Zone *  zone  )

inlineprivate

Definition at line 92 of file runtime-regexp.cc.

                                                               {
    int length = characters.length();
    int last = 0;
    for (int i = 0; i < length; i++) {
      Char c = characters[i];
      if (c == '$') {
        int next_index = i + 1;
        if (next_index == length) {  // No next character!
          break;
        }
        Char c2 = characters[next_index];
        switch (c2) {
          case '$':
            if (i > last) {
              // There is a substring before. Include the first "$".
              parts->Add(
                  ReplacementPart::ReplacementSubString(last, next_index),
                  zone);
              last = next_index + 1;  // Continue after the second "$".
            } else {
              // Let the next substring start with the second "$".
              last = next_index;
            }
            i = next_index;
            break;
          case '`':
            if (i > last) {
              parts->Add(ReplacementPart::ReplacementSubString(last, i), zone);
            }
            parts->Add(ReplacementPart::SubjectPrefix(), zone);
            i = next_index;
            last = i + 1;
            break;
          case '\'':
            if (i > last) {
              parts->Add(ReplacementPart::ReplacementSubString(last, i), zone);
            }
            parts->Add(ReplacementPart::SubjectSuffix(subject_length), zone);
            i = next_index;
            last = i + 1;
            break;
          case '&':
            if (i > last) {
              parts->Add(ReplacementPart::ReplacementSubString(last, i), zone);
            }
            parts->Add(ReplacementPart::SubjectMatch(), zone);
            i = next_index;
            last = i + 1;
            break;
          case '0':
          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7':
          case '8':
          case '9': {
            int capture_ref = c2 - '0';
            if (capture_ref > capture_count) {
              i = next_index;
              continue;
            }
            int second_digit_index = next_index + 1;
            if (second_digit_index < length) {
              // Peek ahead to see if we have two digits.
              Char c3 = characters[second_digit_index];
              if ('0' <= c3 && c3 <= '9') {  // Double digits.
                int double_digit_ref = capture_ref * 10 + c3 - '0';
                if (double_digit_ref <= capture_count) {
                  next_index = second_digit_index;
                  capture_ref = double_digit_ref;
                }
              }
            }
            if (capture_ref > 0) {
              if (i > last) {
                parts->Add(ReplacementPart::ReplacementSubString(last, i),
                           zone);
              }
              DCHECK(capture_ref <= capture_count);
              parts->Add(ReplacementPart::SubjectCapture(capture_ref), zone);
              last = next_index + 1;
            }
            i = next_index;
            break;
          }
          default:
            i = next_index;
            break;
        }
      }
    }
    if (length > last) {
      if (last == 0) {
        // Replacement is simple.  Do not use Apply to do the replacement.
        return true;
      } else {
        parts->Add(ReplacementPart::ReplacementSubString(last, length), zone);
      }
    }
    return false;
  }

References DCHECK, v8::internal::Vector< T >::length(), parts(), v8::internal::CompiledReplacement::ReplacementPart::ReplacementSubString(), v8::internal::CompiledReplacement::ReplacementPart::SubjectCapture(), v8::internal::CompiledReplacement::ReplacementPart::SubjectMatch(), v8::internal::CompiledReplacement::ReplacementPart::SubjectPrefix(), v8::internal::CompiledReplacement::ReplacementPart::SubjectSuffix(), and zone().

Referenced by Compile().

Here is the call graph for this function:

Here is the caller graph for this function:

parts()

int v8::internal::CompiledReplacement::parts ( )

inline

Definition at line 32 of file runtime-regexp.cc.

{ return parts_.length(); }

References parts_.

Referenced by ParseReplacementPattern(), and v8::internal::StringReplaceGlobalRegExpWithString().

Here is the caller graph for this function:

zone()

Zone* v8::internal::CompiledReplacement::zone ( ) const

inline

Definition at line 34 of file runtime-regexp.cc.

{ return zone_; }

References zone_.

Referenced by Compile(), and ParseReplacementPattern().

Here is the caller graph for this function:

Member Data Documentation

parts_

ZoneList<ReplacementPart> v8::internal::CompiledReplacement::parts_

private

Definition at line 199 of file runtime-regexp.cc.

Referenced by Apply(), Compile(), and parts().

replacement_substrings_

ZoneList<Handle<String> > v8::internal::CompiledReplacement::replacement_substrings_

private

Definition at line 200 of file runtime-regexp.cc.

Referenced by Apply(), and Compile().

zone_

Zone* v8::internal::CompiledReplacement::zone_

private

Definition at line 201 of file runtime-regexp.cc.

Referenced by zone().

---

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

• /mnt/V8SourceCode/src/runtime/runtime-regexp.cc