v8::internal::TextNode Class Reference

#include <jsregexp.h>

Inheritance diagram for v8::internal::TextNode:

Collaboration diagram for v8::internal::TextNode:

Public Member Functions
	TextNode (ZoneList< TextElement > *elms, RegExpNode *on_success)
	TextNode (RegExpCharacterClass *that, RegExpNode *on_success)
virtual void	Accept (NodeVisitor *visitor)
virtual void	Emit (RegExpCompiler *compiler, Trace *trace)
virtual int	EatsAtLeast (int still_to_find, int budget, bool not_at_start)
virtual void	GetQuickCheckDetails (QuickCheckDetails *details, RegExpCompiler *compiler, int characters_filled_in, bool not_at_start)
ZoneList< TextElement > *	elements ()
void	MakeCaseIndependent (bool is_one_byte)
virtual int	GreedyLoopTextLength ()
virtual RegExpNode *	GetSuccessorOfOmnivorousTextNode (RegExpCompiler *compiler)
virtual void	FillInBMInfo (int offset, int budget, BoyerMooreLookahead *bm, bool not_at_start)
void	CalculateOffsets ()
virtual RegExpNode *	FilterOneByte (int depth, bool ignore_case)
Public Member Functions inherited from v8::internal::SeqRegExpNode
	SeqRegExpNode (RegExpNode *on_success)
RegExpNode *	on_success ()
void	set_on_success (RegExpNode *node)
Public Member Functions inherited from v8::internal::RegExpNode
	RegExpNode (Zone *zone)
virtual	~RegExpNode ()
bool	EmitQuickCheck (RegExpCompiler *compiler, Trace *bounds_check_trace, Trace *trace, bool preload_has_checked_bounds, Label *on_possible_success, QuickCheckDetails *details_return, bool fall_through_on_failure)
RegExpNode *	replacement ()
RegExpNode *	set_replacement (RegExpNode *replacement)
void	SaveBMInfo (BoyerMooreLookahead *bm, bool not_at_start, int offset)
Label *	label ()
NodeInfo *	info ()
BoyerMooreLookahead *	bm_info (bool not_at_start)
Zone *	zone () const
Public Member Functions inherited from v8::internal::ZoneObject
	INLINE (void *operator new(size_t size, Zone *zone))
void	operator delete (void *, size_t)
void	operator delete (void *pointer, Zone *zone)

Private Types
enum	TextEmitPassType {   NON_LATIN1_MATCH , SIMPLE_CHARACTER_MATCH , NON_LETTER_CHARACTER_MATCH , CASE_CHARACTER_MATCH ,   CHARACTER_CLASS_MATCH }

Private Member Functions
void	TextEmitPass (RegExpCompiler *compiler, TextEmitPassType pass, bool preloaded, Trace *trace, bool first_element_checked, int *checked_up_to)
int	Length ()

Static Private Member Functions
static bool	SkipPass (int pass, bool ignore_case)

Private Attributes
ZoneList< TextElement > *	elms_

Static Private Attributes
static const int	kFirstRealPass = SIMPLE_CHARACTER_MATCH
static const int	kLastPass = CHARACTER_CLASS_MATCH

Additional Inherited Members
Static Public Attributes inherited from v8::internal::RegExpNode
static const int	kNodeIsTooComplexForGreedyLoops = -1
static const int	kRecursionBudget = 200
static const int	kMaxCopiesCodeGenerated = 10
Protected Types inherited from v8::internal::RegExpNode
enum	LimitResult { DONE , CONTINUE }
Protected Member Functions inherited from v8::internal::SeqRegExpNode
RegExpNode *	FilterSuccessor (int depth, bool ignore_case)
Protected Member Functions inherited from v8::internal::RegExpNode
LimitResult	LimitVersions (RegExpCompiler *compiler, Trace *trace)
void	set_bm_info (bool not_at_start, BoyerMooreLookahead *bm)
Protected Attributes inherited from v8::internal::RegExpNode
RegExpNode *	replacement_

Detailed Description

Definition at line 830 of file jsregexp.h.

Member Enumeration Documentation

TextEmitPassType

enum v8::internal::TextNode::TextEmitPassType

private

Enumerator
NON_LATIN1_MATCH
SIMPLE_CHARACTER_MATCH
NON_LETTER_CHARACTER_MATCH
CASE_CHARACTER_MATCH
CHARACTER_CLASS_MATCH

Definition at line 862 of file jsregexp.h.

                        {
    NON_LATIN1_MATCH,            // Check for characters that can't match.
    SIMPLE_CHARACTER_MATCH,      // Case-dependent single character check.
    NON_LETTER_CHARACTER_MATCH,  // Check characters that have no case equivs.
    CASE_CHARACTER_MATCH,        // Case-independent single character check.
    CHARACTER_CLASS_MATCH        // Character class.
  };

Constructor & Destructor Documentation

TextNode() [1/2]

v8::internal::TextNode::TextNode ( ZoneList< TextElement > *  elms, RegExpNode *  on_success  )

inline

Definition at line 832 of file jsregexp.h.

      : SeqRegExpNode(on_success),
        elms_(elms) { }

TextNode() [2/2]

v8::internal::TextNode::TextNode ( RegExpCharacterClass *  that, RegExpNode *  on_success  )

inline

Definition at line 836 of file jsregexp.h.

      : SeqRegExpNode(on_success),
        elms_(new(zone()) ZoneList<TextElement>(1, zone())) {
    elms_->Add(TextElement::CharClass(that), zone());
  }

References v8::internal::List< T, AllocationPolicy >::Add(), elms_, and v8::internal::RegExpNode::zone().

Here is the call graph for this function:

Member Function Documentation

Accept()

virtual void v8::internal::TextNode::Accept ( NodeVisitor *  visitor )

virtual

Implements v8::internal::RegExpNode.

CalculateOffsets()

void v8::internal::TextNode::CalculateOffsets

(

)

Definition at line 5744 of file jsregexp.cc.

                                {
  int element_count = elements()->length();
  // Set up the offsets of the elements relative to the start.  This is a fixed
  // quantity since a TextNode can only contain fixed-width things.
  int cp_offset = 0;
  for (int i = 0; i < element_count; i++) {
    TextElement& elm = elements()->at(i);
    elm.set_cp_offset(cp_offset);
    cp_offset += elm.length();
  }
}

References v8::internal::List< T, AllocationPolicy >::at(), and elements().

Here is the call graph for this function:

EatsAtLeast()

int v8::internal::TextNode::EatsAtLeast ( int  still_to_find, int  budget, bool  not_at_start  )

virtual

Implements v8::internal::RegExpNode.

Definition at line 2334 of file jsregexp.cc.

                                             {
  int answer = Length();
  if (answer >= still_to_find) return answer;
  if (budget <= 0) return answer;
  // We are not at start after this node so we set the last argument to 'true'.
  return answer + on_success()->EatsAtLeast(still_to_find - answer,
                                            budget - 1,
                                            true);
}

elements()

ZoneList<TextElement>* v8::internal::TextNode::elements ( )

inline

Definition at line 849 of file jsregexp.h.

{ return elms_; }

References elms_.

Referenced by CalculateOffsets(), and FillInBMInfo().

Here is the caller graph for this function:

Emit()

void v8::internal::TextNode::Emit ( RegExpCompiler *  compiler, Trace *  trace  )

virtual

Implements v8::internal::RegExpNode.

Definition at line 3315 of file jsregexp.cc.

                                                          {
  LimitResult limit_result = LimitVersions(compiler, trace);
  if (limit_result == DONE) return;
  DCHECK(limit_result == CONTINUE);
 
  if (trace->cp_offset() + Length() > RegExpMacroAssembler::kMaxCPOffset) {
    compiler->SetRegExpTooBig();
    return;
  }
 
  if (compiler->one_byte()) {
    int dummy = 0;
    TextEmitPass(compiler, NON_LATIN1_MATCH, false, trace, false, &dummy);
  }
 
  bool first_elt_done = false;
  int bound_checked_to = trace->cp_offset() - 1;
  bound_checked_to += trace->bound_checked_up_to();
 
  // If a character is preloaded into the current character register then
  // check that now.
  if (trace->characters_preloaded() == 1) {
    for (int pass = kFirstRealPass; pass <= kLastPass; pass++) {
      if (!SkipPass(pass, compiler->ignore_case())) {
        TextEmitPass(compiler,
                     static_cast<TextEmitPassType>(pass),
                     true,
                     trace,
                     false,
                     &bound_checked_to);
      }
    }
    first_elt_done = true;
  }
 
  for (int pass = kFirstRealPass; pass <= kLastPass; pass++) {
    if (!SkipPass(pass, compiler->ignore_case())) {
      TextEmitPass(compiler,
                   static_cast<TextEmitPassType>(pass),
                   false,
                   trace,
                   first_elt_done,
                   &bound_checked_to);
    }
  }
 
  Trace successor_trace(*trace);
  successor_trace.set_at_start(false);
  successor_trace.AdvanceCurrentPositionInTrace(Length(), compiler);
  RecursionCheck rc(compiler);
  on_success()->Emit(compiler, &successor_trace);
}

References v8::internal::Trace::AdvanceCurrentPositionInTrace(), v8::internal::Trace::bound_checked_up_to(), v8::internal::Trace::characters_preloaded(), v8::internal::Trace::cp_offset(), DCHECK, v8::internal::DONE, v8::internal::RegExpCompiler::ignore_case(), v8::internal::RegExpMacroAssembler::kMaxCPOffset, v8::internal::RegExpCompiler::one_byte(), v8::internal::Trace::set_at_start(), and v8::internal::RegExpCompiler::SetRegExpTooBig().

Here is the call graph for this function:

FillInBMInfo()

void v8::internal::TextNode::FillInBMInfo ( int  offset, int  budget, BoyerMooreLookahead *  bm, bool  not_at_start  )

virtual

Reimplemented from v8::internal::SeqRegExpNode.

Definition at line 5855 of file jsregexp.cc.

                                               {
  if (initial_offset >= bm->length()) return;
  int offset = initial_offset;
  int max_char = bm->max_char();
  for (int i = 0; i < elements()->length(); i++) {
    if (offset >= bm->length()) {
      if (initial_offset == 0) set_bm_info(not_at_start, bm);
      return;
    }
    TextElement text = elements()->at(i);
    if (text.text_type() == TextElement::ATOM) {
      RegExpAtom* atom = text.atom();
      for (int j = 0; j < atom->length(); j++, offset++) {
        if (offset >= bm->length()) {
          if (initial_offset == 0) set_bm_info(not_at_start, bm);
          return;
        }
        uc16 character = atom->data()[j];
        if (bm->compiler()->ignore_case()) {
          unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
          int length = GetCaseIndependentLetters(
              Isolate::Current(),
              character,
              bm->max_char() == String::kMaxOneByteCharCode,
              chars);
          for (int j = 0; j < length; j++) {
            bm->Set(offset, chars[j]);
          }
        } else {
          if (character <= max_char) bm->Set(offset, character);
        }
      }
    } else {
      DCHECK_EQ(TextElement::CHAR_CLASS, text.text_type());
      RegExpCharacterClass* char_class = text.char_class();
      ZoneList<CharacterRange>* ranges = char_class->ranges(zone());
      if (char_class->is_negated()) {
        bm->SetAll(offset);
      } else {
        for (int k = 0; k < ranges->length(); k++) {
          CharacterRange& range = ranges->at(k);
          if (range.from() > max_char) continue;
          int to = Min(max_char, static_cast<int>(range.to()));
          bm->SetInterval(offset, Interval(range.from(), to));
        }
      }
      offset++;
    }
  }
  if (offset >= bm->length()) {
    if (initial_offset == 0) set_bm_info(not_at_start, bm);
    return;
  }
  on_success()->FillInBMInfo(offset,
                             budget - 1,
                             bm,
                             true);  // Not at start after a text node.
  if (initial_offset == 0) set_bm_info(not_at_start, bm);
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::BoyerMooreLookahead::compiler(), DCHECK_EQ, elements(), v8::internal::RegExpNode::FillInBMInfo(), v8::internal::CharacterRange::from(), v8::internal::GetCaseIndependentLetters(), v8::internal::RegExpCompiler::ignore_case(), v8::internal::String::kMaxOneByteCharCode, unibrow::Ecma262UnCanonicalize::kMaxWidth, v8::internal::BoyerMooreLookahead::length(), v8::internal::BoyerMooreLookahead::max_char(), v8::internal::Min(), v8::internal::SeqRegExpNode::on_success(), v8::internal::BoyerMooreLookahead::Set(), v8::internal::RegExpNode::set_bm_info(), v8::internal::BoyerMooreLookahead::SetAll(), v8::internal::BoyerMooreLookahead::SetInterval(), v8::internal::CharacterRange::to(), to(), and v8::internal::RegExpNode::zone().

Here is the call graph for this function:

FilterOneByte()

RegExpNode * v8::internal::TextNode::FilterOneByte ( int  depth, bool  ignore_case  )

virtual

Reimplemented from v8::internal::SeqRegExpNode.

Definition at line 2789 of file jsregexp.cc.

                                                               {
  if (info()->replacement_calculated) return replacement();
  if (depth < 0) return this;
  DCHECK(!info()->visited);
  VisitMarker marker(info());
  int element_count = elms_->length();
  for (int i = 0; i < element_count; i++) {
    TextElement elm = elms_->at(i);
    if (elm.text_type() == TextElement::ATOM) {
      Vector<const uc16> quarks = elm.atom()->data();
      for (int j = 0; j < quarks.length(); j++) {
        uint16_t c = quarks[j];
        if (c <= String::kMaxOneByteCharCode) continue;
        if (!ignore_case) return set_replacement(NULL);
        // Here, we need to check for characters whose upper and lower cases
        // are outside the Latin-1 range.
        uint16_t converted = unibrow::Latin1::ConvertNonLatin1ToLatin1(c);
        // Character is outside Latin-1 completely
        if (converted == 0) return set_replacement(NULL);
        // Convert quark to Latin-1 in place.
        uint16_t* copy = const_cast<uint16_t*>(quarks.start());
        copy[j] = converted;
      }
    } else {
      DCHECK(elm.text_type() == TextElement::CHAR_CLASS);
      RegExpCharacterClass* cc = elm.char_class();
      ZoneList<CharacterRange>* ranges = cc->ranges(zone());
      if (!CharacterRange::IsCanonical(ranges)) {
        CharacterRange::Canonicalize(ranges);
      }
      // Now they are in order so we only need to look at the first.
      int range_count = ranges->length();
      if (cc->is_negated()) {
        if (range_count != 0 &&
            ranges->at(0).from() == 0 &&
            ranges->at(0).to() >= String::kMaxOneByteCharCode) {
          // This will be handled in a later filter.
          if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;
          return set_replacement(NULL);
        }
      } else {
        if (range_count == 0 ||
            ranges->at(0).from() > String::kMaxOneByteCharCode) {
          // This will be handled in a later filter.
          if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;
          return set_replacement(NULL);
        }
      }
    }
  }
  return FilterSuccessor(depth - 1, ignore_case);
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::CharacterRange::Canonicalize(), v8::internal::cc, unibrow::Latin1::ConvertNonLatin1ToLatin1(), DCHECK, v8::internal::CharacterRange::IsCanonical(), v8::internal::String::kMaxOneByteCharCode, v8::internal::Vector< T >::length(), NULL, v8::internal::RangesContainLatin1Equivalents(), and v8::internal::Vector< T >::start().

Here is the call graph for this function:

GetQuickCheckDetails()

void v8::internal::TextNode::GetQuickCheckDetails ( QuickCheckDetails *  details, RegExpCompiler *  compiler, int  characters_filled_in, bool  not_at_start  )

virtual

Implements v8::internal::RegExpNode.

Definition at line 2527 of file jsregexp.cc.

                                                       {
  Isolate* isolate = compiler->macro_assembler()->zone()->isolate();
  DCHECK(characters_filled_in < details->characters());
  int characters = details->characters();
  int char_mask;
  if (compiler->one_byte()) {
    char_mask = String::kMaxOneByteCharCode;
  } else {
    char_mask = String::kMaxUtf16CodeUnit;
  }
  for (int k = 0; k < elms_->length(); k++) {
    TextElement elm = elms_->at(k);
    if (elm.text_type() == TextElement::ATOM) {
      Vector<const uc16> quarks = elm.atom()->data();
      for (int i = 0; i < characters && i < quarks.length(); i++) {
        QuickCheckDetails::Position* pos =
            details->positions(characters_filled_in);
        uc16 c = quarks[i];
        if (c > char_mask) {
          // If we expect a non-Latin1 character from an one-byte string,
          // there is no way we can match. Not even case-independent
          // matching can turn an Latin1 character into non-Latin1 or
          // vice versa.
          // TODO(dcarney): issue 3550.  Verify that this works as expected.
          // For example, \u0178 is uppercase of \u00ff (y-umlaut).
          details->set_cannot_match();
          pos->determines_perfectly = false;
          return;
        }
        if (compiler->ignore_case()) {
          unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
          int length = GetCaseIndependentLetters(isolate, c,
                                                 compiler->one_byte(), chars);
          DCHECK(length != 0);  // Can only happen if c > char_mask (see above).
          if (length == 1) {
            // This letter has no case equivalents, so it's nice and simple
            // and the mask-compare will determine definitely whether we have
            // a match at this character position.
            pos->mask = char_mask;
            pos->value = c;
            pos->determines_perfectly = true;
          } else {
            uint32_t common_bits = char_mask;
            uint32_t bits = chars[0];
            for (int j = 1; j < length; j++) {
              uint32_t differing_bits = ((chars[j] & common_bits) ^ bits);
              common_bits ^= differing_bits;
              bits &= common_bits;
            }
            // If length is 2 and common bits has only one zero in it then
            // our mask and compare instruction will determine definitely
            // whether we have a match at this character position.  Otherwise
            // it can only be an approximate check.
            uint32_t one_zero = (common_bits | ~char_mask);
            if (length == 2 && ((~one_zero) & ((~one_zero) - 1)) == 0) {
              pos->determines_perfectly = true;
            }
            pos->mask = common_bits;
            pos->value = bits;
          }
        } else {
          // Don't ignore case.  Nice simple case where the mask-compare will
          // determine definitely whether we have a match at this character
          // position.
          pos->mask = char_mask;
          pos->value = c;
          pos->determines_perfectly = true;
        }
        characters_filled_in++;
        DCHECK(characters_filled_in <= details->characters());
        if (characters_filled_in == details->characters()) {
          return;
        }
      }
    } else {
      QuickCheckDetails::Position* pos =
          details->positions(characters_filled_in);
      RegExpCharacterClass* tree = elm.char_class();
      ZoneList<CharacterRange>* ranges = tree->ranges(zone());
      if (tree->is_negated()) {
        // A quick check uses multi-character mask and compare.  There is no
        // useful way to incorporate a negative char class into this scheme
        // so we just conservatively create a mask and value that will always
        // succeed.
        pos->mask = 0;
        pos->value = 0;
      } else {
        int first_range = 0;
        while (ranges->at(first_range).from() > char_mask) {
          first_range++;
          if (first_range == ranges->length()) {
            details->set_cannot_match();
            pos->determines_perfectly = false;
            return;
          }
        }
        CharacterRange range = ranges->at(first_range);
        uc16 from = range.from();
        uc16 to = range.to();
        if (to > char_mask) {
          to = char_mask;
        }
        uint32_t differing_bits = (from ^ to);
        // A mask and compare is only perfect if the differing bits form a
        // number like 00011111 with one single block of trailing 1s.
        if ((differing_bits & (differing_bits + 1)) == 0 &&
             from + differing_bits == to) {
          pos->determines_perfectly = true;
        }
        uint32_t common_bits = ~SmearBitsRight(differing_bits);
        uint32_t bits = (from & common_bits);
        for (int i = first_range + 1; i < ranges->length(); i++) {
          CharacterRange range = ranges->at(i);
          uc16 from = range.from();
          uc16 to = range.to();
          if (from > char_mask) continue;
          if (to > char_mask) to = char_mask;
          // Here we are combining more ranges into the mask and compare
          // value.  With each new range the mask becomes more sparse and
          // so the chances of a false positive rise.  A character class
          // with multiple ranges is assumed never to be equivalent to a
          // mask and compare operation.
          pos->determines_perfectly = false;
          uint32_t new_common_bits = (from ^ to);
          new_common_bits = ~SmearBitsRight(new_common_bits);
          common_bits &= new_common_bits;
          bits &= new_common_bits;
          uint32_t differing_bits = (from & common_bits) ^ bits;
          common_bits ^= differing_bits;
          bits &= common_bits;
        }
        pos->mask = common_bits;
        pos->value = bits;
      }
      characters_filled_in++;
      DCHECK(characters_filled_in <= details->characters());
      if (characters_filled_in == details->characters()) {
        return;
      }
    }
  }
  DCHECK(characters_filled_in != details->characters());
  if (!details->cannot_match()) {
    on_success()-> GetQuickCheckDetails(details,
                                        compiler,
                                        characters_filled_in,
                                        true);
  }
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::QuickCheckDetails::cannot_match(), v8::internal::QuickCheckDetails::characters(), DCHECK, v8::internal::QuickCheckDetails::Position::determines_perfectly, v8::internal::CharacterRange::from(), v8::internal::GetCaseIndependentLetters(), v8::internal::RegExpCompiler::ignore_case(), v8::internal::Zone::isolate(), v8::internal::String::kMaxOneByteCharCode, v8::internal::String::kMaxUtf16CodeUnit, unibrow::Ecma262UnCanonicalize::kMaxWidth, v8::internal::Vector< T >::length(), v8::internal::RegExpCompiler::macro_assembler(), v8::internal::QuickCheckDetails::Position::mask, v8::internal::RegExpCompiler::one_byte(), v8::internal::QuickCheckDetails::positions(), v8::internal::QuickCheckDetails::set_cannot_match(), v8::internal::SmearBitsRight(), v8::internal::CharacterRange::to(), to(), v8::internal::QuickCheckDetails::Position::value, and v8::internal::RegExpMacroAssembler::zone().

Here is the call graph for this function:

GetSuccessorOfOmnivorousTextNode()

RegExpNode * v8::internal::TextNode::GetSuccessorOfOmnivorousTextNode ( RegExpCompiler *  compiler )

virtual

Reimplemented from v8::internal::RegExpNode.

Definition at line 3418 of file jsregexp.cc.

                              {
  if (elms_->length() != 1) return NULL;
  TextElement elm = elms_->at(0);
  if (elm.text_type() != TextElement::CHAR_CLASS) return NULL;
  RegExpCharacterClass* node = elm.char_class();
  ZoneList<CharacterRange>* ranges = node->ranges(zone());
  if (!CharacterRange::IsCanonical(ranges)) {
    CharacterRange::Canonicalize(ranges);
  }
  if (node->is_negated()) {
    return ranges->length() == 0 ? on_success() : NULL;
  }
  if (ranges->length() != 1) return NULL;
  uint32_t max_char;
  if (compiler->one_byte()) {
    max_char = String::kMaxOneByteCharCode;
  } else {
    max_char = String::kMaxUtf16CodeUnit;
  }
  return ranges->at(0).IsEverything(max_char) ? on_success() : NULL;
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::CharacterRange::Canonicalize(), v8::internal::CharacterRange::IsCanonical(), v8::internal::String::kMaxOneByteCharCode, v8::internal::String::kMaxUtf16CodeUnit, NULL, and v8::internal::RegExpCompiler::one_byte().

Here is the call graph for this function:

GreedyLoopTextLength()

int v8::internal::TextNode::GreedyLoopTextLength ( )

virtual

Reimplemented from v8::internal::RegExpNode.

Definition at line 3412 of file jsregexp.cc.

                                   {
  TextElement elm = elms_->at(elms_->length() - 1);
  return elm.cp_offset() + elm.length();
}

Length()

int v8::internal::TextNode::Length ( )

private

Definition at line 3292 of file jsregexp.cc.

                     {
  TextElement elm = elms_->last();
  DCHECK(elm.cp_offset() >= 0);
  return elm.cp_offset() + elm.length();
}

References DCHECK.

MakeCaseIndependent()

void v8::internal::TextNode::MakeCaseIndependent

(

bool

is_one_byte

)

Definition at line 3393 of file jsregexp.cc.

                                                   {
  int element_count = elms_->length();
  for (int i = 0; i < element_count; i++) {
    TextElement elm = elms_->at(i);
    if (elm.text_type() == TextElement::CHAR_CLASS) {
      RegExpCharacterClass* cc = elm.char_class();
      // None of the standard character classes is different in the case
      // independent case and it slows us down if we don't know that.
      if (cc->is_standard(zone())) continue;
      ZoneList<CharacterRange>* ranges = cc->ranges(zone());
      int range_count = ranges->length();
      for (int j = 0; j < range_count; j++) {
        ranges->at(j).AddCaseEquivalents(ranges, is_one_byte, zone());
      }
    }
  }
}

References v8::internal::List< T, AllocationPolicy >::at(), and v8::internal::cc.

Here is the call graph for this function:

SkipPass()

bool v8::internal::TextNode::SkipPass ( int  pass, bool  ignore_case  )

staticprivate

Definition at line 3299 of file jsregexp.cc.

                                                      {
  TextEmitPassType pass = static_cast<TextEmitPassType>(int_pass);
  if (ignore_case) {
    return pass == SIMPLE_CHARACTER_MATCH;
  } else {
    return pass == NON_LETTER_CHARACTER_MATCH || pass == CASE_CHARACTER_MATCH;
  }
}

TextEmitPass()

void v8::internal::TextNode::TextEmitPass ( RegExpCompiler *  compiler, TextEmitPassType  pass, bool  preloaded, Trace *  trace, bool  first_element_checked, int *  checked_up_to  )

private

Definition at line 3225 of file jsregexp.cc.

                                                {
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
  Isolate* isolate = assembler->zone()->isolate();
  bool one_byte = compiler->one_byte();
  Label* backtrack = trace->backtrack();
  QuickCheckDetails* quick_check = trace->quick_check_performed();
  int element_count = elms_->length();
  for (int i = preloaded ? 0 : element_count - 1; i >= 0; i--) {
    TextElement elm = elms_->at(i);
    int cp_offset = trace->cp_offset() + elm.cp_offset();
    if (elm.text_type() == TextElement::ATOM) {
      Vector<const uc16> quarks = elm.atom()->data();
      for (int j = preloaded ? 0 : quarks.length() - 1; j >= 0; j--) {
        if (first_element_checked && i == 0 && j == 0) continue;
        if (DeterminedAlready(quick_check, elm.cp_offset() + j)) continue;
        EmitCharacterFunction* emit_function = NULL;
        switch (pass) {
          case NON_LATIN1_MATCH:
            DCHECK(one_byte);
            if (quarks[j] > String::kMaxOneByteCharCode) {
              assembler->GoTo(backtrack);
              return;
            }
            break;
          case NON_LETTER_CHARACTER_MATCH:
            emit_function = &EmitAtomNonLetter;
            break;
          case SIMPLE_CHARACTER_MATCH:
            emit_function = &EmitSimpleCharacter;
            break;
          case CASE_CHARACTER_MATCH:
            emit_function = &EmitAtomLetter;
            break;
          default:
            break;
        }
        if (emit_function != NULL) {
          bool bound_checked = emit_function(isolate,
                                             compiler,
                                             quarks[j],
                                             backtrack,
                                             cp_offset + j,
                                             *checked_up_to < cp_offset + j,
                                             preloaded);
          if (bound_checked) UpdateBoundsCheck(cp_offset + j, checked_up_to);
        }
      }
    } else {
      DCHECK_EQ(TextElement::CHAR_CLASS, elm.text_type());
      if (pass == CHARACTER_CLASS_MATCH) {
        if (first_element_checked && i == 0) continue;
        if (DeterminedAlready(quick_check, elm.cp_offset())) continue;
        RegExpCharacterClass* cc = elm.char_class();
        EmitCharClass(assembler, cc, one_byte, backtrack, cp_offset,
                      *checked_up_to < cp_offset, preloaded, zone());
        UpdateBoundsCheck(cp_offset, checked_up_to);
      }
    }
  }
}

References v8::internal::Trace::backtrack(), v8::internal::cc, v8::internal::Trace::cp_offset(), DCHECK, DCHECK_EQ, v8::internal::DeterminedAlready(), v8::internal::EmitAtomLetter(), v8::internal::EmitAtomNonLetter(), v8::internal::EmitCharClass(), v8::internal::EmitSimpleCharacter(), v8::internal::RegExpMacroAssembler::GoTo(), v8::internal::Zone::isolate(), v8::internal::String::kMaxOneByteCharCode, v8::internal::Vector< T >::length(), v8::internal::RegExpCompiler::macro_assembler(), NULL, v8::internal::RegExpCompiler::one_byte(), v8::internal::Trace::quick_check_performed(), v8::internal::UpdateBoundsCheck(), and v8::internal::RegExpMacroAssembler::zone().

Here is the call graph for this function:

Member Data Documentation

elms_

ZoneList<TextElement>* v8::internal::TextNode::elms_

private

Definition at line 879 of file jsregexp.h.

Referenced by elements(), and TextNode().

kFirstRealPass

const int v8::internal::TextNode::kFirstRealPass = SIMPLE_CHARACTER_MATCH

staticprivate

Definition at line 870 of file jsregexp.h.

kLastPass

const int v8::internal::TextNode::kLastPass = CHARACTER_CLASS_MATCH

staticprivate

Definition at line 871 of file jsregexp.h.

---

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

• /mnt/V8SourceCode/src/jsregexp.h
• /mnt/V8SourceCode/src/jsregexp.cc