v8::internal::AssertionNode Class Reference

#include <jsregexp.h>

Inheritance diagram for v8::internal::AssertionNode:

Collaboration diagram for v8::internal::AssertionNode:

Public Types
enum	AssertionType {   AT_END , AT_START , AT_BOUNDARY , AT_NON_BOUNDARY ,   AFTER_NEWLINE }

Public Member Functions
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 filled_in, bool not_at_start)
virtual void	FillInBMInfo (int offset, int budget, BoyerMooreLookahead *bm, bool not_at_start)
AssertionType	assertion_type ()
Public Member Functions inherited from v8::internal::SeqRegExpNode
	SeqRegExpNode (RegExpNode *on_success)
RegExpNode *	on_success ()
void	set_on_success (RegExpNode *node)
virtual RegExpNode *	FilterOneByte (int depth, bool ignore_case)
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)
virtual int	GreedyLoopTextLength ()
virtual RegExpNode *	GetSuccessorOfOmnivorousTextNode (RegExpCompiler *compiler)
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)

Static Public Member Functions
static AssertionNode *	AtEnd (RegExpNode *on_success)
static AssertionNode *	AtStart (RegExpNode *on_success)
static AssertionNode *	AtBoundary (RegExpNode *on_success)
static AssertionNode *	AtNonBoundary (RegExpNode *on_success)
static AssertionNode *	AfterNewline (RegExpNode *on_success)

Private Types
enum	IfPrevious { kIsNonWord , kIsWord }

Private Member Functions
void	EmitBoundaryCheck (RegExpCompiler *compiler, Trace *trace)
void	BacktrackIfPrevious (RegExpCompiler *compiler, Trace *trace, IfPrevious backtrack_if_previous)
	AssertionNode (AssertionType t, RegExpNode *on_success)

Private Attributes
AssertionType	assertion_type_

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 883 of file jsregexp.h.

Member Enumeration Documentation

AssertionType

enum v8::internal::AssertionNode::AssertionType

Enumerator
AT_END
AT_START
AT_BOUNDARY
AT_NON_BOUNDARY
AFTER_NEWLINE

Definition at line 885 of file jsregexp.h.

                     {
    AT_END,
    AT_START,
    AT_BOUNDARY,
    AT_NON_BOUNDARY,
    AFTER_NEWLINE
  };

IfPrevious

enum v8::internal::AssertionNode::IfPrevious

private

Enumerator
kIsNonWord
kIsWord

Definition at line 922 of file jsregexp.h.

{ kIsNonWord, kIsWord };

Constructor & Destructor Documentation

AssertionNode()

v8::internal::AssertionNode::AssertionNode ( AssertionType  t, RegExpNode *  on_success  )

inlineprivate

Definition at line 926 of file jsregexp.h.

      : SeqRegExpNode(on_success), assertion_type_(t) { }

Referenced by AfterNewline(), AtBoundary(), AtEnd(), AtNonBoundary(), and AtStart().

Here is the caller graph for this function:

Member Function Documentation

Accept()

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

virtual

Implements v8::internal::RegExpNode.

AfterNewline()

static AssertionNode* v8::internal::AssertionNode::AfterNewline ( RegExpNode *  on_success )

inlinestatic

Definition at line 904 of file jsregexp.h.

                                                             {
    return new(on_success->zone()) AssertionNode(AFTER_NEWLINE, on_success);
  }

References AFTER_NEWLINE, AssertionNode(), v8::internal::SeqRegExpNode::on_success(), and v8::internal::RegExpNode::zone().

Here is the call graph for this function:

assertion_type()

AssertionType v8::internal::AssertionNode::assertion_type ( )

inline

Definition at line 918 of file jsregexp.h.

{ return assertion_type_; }

References assertion_type_.

AtBoundary()

static AssertionNode* v8::internal::AssertionNode::AtBoundary ( RegExpNode *  on_success )

inlinestatic

Definition at line 898 of file jsregexp.h.

                                                           {
    return new(on_success->zone()) AssertionNode(AT_BOUNDARY, on_success);
  }

References AssertionNode(), AT_BOUNDARY, v8::internal::SeqRegExpNode::on_success(), and v8::internal::RegExpNode::zone().

Here is the call graph for this function:

AtEnd()

static AssertionNode* v8::internal::AssertionNode::AtEnd ( RegExpNode *  on_success )

inlinestatic

Definition at line 892 of file jsregexp.h.

                                                      {
    return new(on_success->zone()) AssertionNode(AT_END, on_success);
  }

References AssertionNode(), AT_END, v8::internal::SeqRegExpNode::on_success(), and v8::internal::RegExpNode::zone().

Here is the call graph for this function:

AtNonBoundary()

static AssertionNode* v8::internal::AssertionNode::AtNonBoundary ( RegExpNode *  on_success )

inlinestatic

Definition at line 901 of file jsregexp.h.

                                                              {
    return new(on_success->zone()) AssertionNode(AT_NON_BOUNDARY, on_success);
  }

References AssertionNode(), AT_NON_BOUNDARY, v8::internal::SeqRegExpNode::on_success(), and v8::internal::RegExpNode::zone().

Here is the call graph for this function:

AtStart()

static AssertionNode* v8::internal::AssertionNode::AtStart ( RegExpNode *  on_success )

inlinestatic

Definition at line 895 of file jsregexp.h.

                                                        {
    return new(on_success->zone()) AssertionNode(AT_START, on_success);
  }

References AssertionNode(), AT_START, v8::internal::SeqRegExpNode::on_success(), and v8::internal::RegExpNode::zone().

Here is the call graph for this function:

BacktrackIfPrevious()

void v8::internal::AssertionNode::BacktrackIfPrevious ( RegExpCompiler *  compiler, Trace *  trace, AssertionNode::IfPrevious  backtrack_if_previous  )

private

Definition at line 3098 of file jsregexp.cc.

                                                   {
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
  Trace new_trace(*trace);
  new_trace.InvalidateCurrentCharacter();
 
  Label fall_through, dummy;
 
  Label* non_word = backtrack_if_previous == kIsNonWord ?
                    new_trace.backtrack() :
                    &fall_through;
  Label* word = backtrack_if_previous == kIsNonWord ?
                &fall_through :
                new_trace.backtrack();
 
  if (new_trace.cp_offset() == 0) {
    // The start of input counts as a non-word character, so the question is
    // decided if we are at the start.
    assembler->CheckAtStart(non_word);
  }
  // We already checked that we are not at the start of input so it must be
  // OK to load the previous character.
  assembler->LoadCurrentCharacter(new_trace.cp_offset() - 1, &dummy, false);
  EmitWordCheck(assembler, word, non_word, backtrack_if_previous == kIsNonWord);
 
  assembler->Bind(&fall_through);
  on_success()->Emit(compiler, &new_trace);
}

References v8::internal::Trace::backtrack(), v8::internal::RegExpMacroAssembler::Bind(), v8::internal::RegExpMacroAssembler::CheckAtStart(), v8::internal::Trace::cp_offset(), v8::internal::EmitWordCheck(), v8::internal::Trace::InvalidateCurrentCharacter(), v8::internal::RegExpMacroAssembler::LoadCurrentCharacter(), and v8::internal::RegExpCompiler::macro_assembler().

Here is the call graph for this function:

EatsAtLeast()

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

virtual

Implements v8::internal::RegExpNode.

Definition at line 2297 of file jsregexp.cc.

                                                  {
  if (budget <= 0) return 0;
  // If we know we are not at the start and we are asked "how many characters
  // will you match if you succeed?" then we can answer anything since false
  // implies false.  So lets just return the max answer (still_to_find) since
  // that won't prevent us from preloading a lot of characters for the other
  // branches in the node graph.
  if (assertion_type() == AT_START && not_at_start) return still_to_find;
  return on_success()->EatsAtLeast(still_to_find,
                                   budget - 1,
                                   not_at_start);
}

Emit()

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

virtual

Implements v8::internal::RegExpNode.

Definition at line 3145 of file jsregexp.cc.

                                                               {
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
  switch (assertion_type_) {
    case AT_END: {
      Label ok;
      assembler->CheckPosition(trace->cp_offset(), &ok);
      assembler->GoTo(trace->backtrack());
      assembler->Bind(&ok);
      break;
    }
    case AT_START: {
      if (trace->at_start() == Trace::FALSE_VALUE) {
        assembler->GoTo(trace->backtrack());
        return;
      }
      if (trace->at_start() == Trace::UNKNOWN) {
        assembler->CheckNotAtStart(trace->backtrack());
        Trace at_start_trace = *trace;
        at_start_trace.set_at_start(true);
        on_success()->Emit(compiler, &at_start_trace);
        return;
      }
    }
    break;
    case AFTER_NEWLINE:
      EmitHat(compiler, on_success(), trace);
      return;
    case AT_BOUNDARY:
    case AT_NON_BOUNDARY: {
      EmitBoundaryCheck(compiler, trace);
      return;
    }
  }
  on_success()->Emit(compiler, trace);
}

References v8::internal::Trace::at_start(), v8::internal::Trace::backtrack(), v8::internal::RegExpMacroAssembler::Bind(), v8::internal::RegExpMacroAssembler::CheckNotAtStart(), v8::internal::RegExpMacroAssembler::CheckPosition(), v8::internal::Trace::cp_offset(), v8::internal::EmitHat(), v8::internal::Trace::FALSE_VALUE, v8::internal::RegExpMacroAssembler::GoTo(), v8::internal::RegExpCompiler::macro_assembler(), v8::internal::Trace::set_at_start(), and v8::internal::Trace::UNKNOWN.

Here is the call graph for this function:

EmitBoundaryCheck()

void v8::internal::AssertionNode::EmitBoundaryCheck ( RegExpCompiler *  compiler, Trace *  trace  )

private

Definition at line 3047 of file jsregexp.cc.

                                                                            {
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
  Trace::TriBool next_is_word_character = Trace::UNKNOWN;
  bool not_at_start = (trace->at_start() == Trace::FALSE_VALUE);
  BoyerMooreLookahead* lookahead = bm_info(not_at_start);
  if (lookahead == NULL) {
    int eats_at_least =
        Min(kMaxLookaheadForBoyerMoore, EatsAtLeast(kMaxLookaheadForBoyerMoore,
                                                    kRecursionBudget,
                                                    not_at_start));
    if (eats_at_least >= 1) {
      BoyerMooreLookahead* bm =
          new(zone()) BoyerMooreLookahead(eats_at_least, compiler, zone());
      FillInBMInfo(0, kRecursionBudget, bm, not_at_start);
      if (bm->at(0)->is_non_word())
        next_is_word_character = Trace::FALSE_VALUE;
      if (bm->at(0)->is_word()) next_is_word_character = Trace::TRUE_VALUE;
    }
  } else {
    if (lookahead->at(0)->is_non_word())
      next_is_word_character = Trace::FALSE_VALUE;
    if (lookahead->at(0)->is_word())
      next_is_word_character = Trace::TRUE_VALUE;
  }
  bool at_boundary = (assertion_type_ == AssertionNode::AT_BOUNDARY);
  if (next_is_word_character == Trace::UNKNOWN) {
    Label before_non_word;
    Label before_word;
    if (trace->characters_preloaded() != 1) {
      assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
    }
    // Fall through on non-word.
    EmitWordCheck(assembler, &before_word, &before_non_word, false);
    // Next character is not a word character.
    assembler->Bind(&before_non_word);
    Label ok;
    BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
    assembler->GoTo(&ok);
 
    assembler->Bind(&before_word);
    BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
    assembler->Bind(&ok);
  } else if (next_is_word_character == Trace::TRUE_VALUE) {
    BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
  } else {
    DCHECK(next_is_word_character == Trace::FALSE_VALUE);
    BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
  }
}

References v8::internal::BoyerMooreLookahead::at(), AT_BOUNDARY, v8::internal::Trace::at_start(), v8::internal::RegExpMacroAssembler::Bind(), v8::internal::Trace::characters_preloaded(), v8::internal::Trace::cp_offset(), DCHECK, v8::internal::EmitWordCheck(), v8::internal::Trace::FALSE_VALUE, v8::internal::RegExpMacroAssembler::GoTo(), v8::internal::BoyerMoorePositionInfo::is_non_word(), v8::internal::BoyerMoorePositionInfo::is_word(), v8::internal::kMaxLookaheadForBoyerMoore, v8::internal::RegExpMacroAssembler::LoadCurrentCharacter(), v8::internal::RegExpCompiler::macro_assembler(), v8::internal::Min(), NULL, v8::internal::Trace::TRUE_VALUE, and v8::internal::Trace::UNKNOWN.

Here is the call graph for this function:

FillInBMInfo()

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

virtual

Reimplemented from v8::internal::SeqRegExpNode.

Definition at line 2313 of file jsregexp.cc.

                                                    {
  // Match the behaviour of EatsAtLeast on this node.
  if (assertion_type() == AT_START && not_at_start) return;
  on_success()->FillInBMInfo(offset, budget - 1, bm, not_at_start);
  SaveBMInfo(bm, not_at_start, offset);
}

GetQuickCheckDetails()

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

virtual

Implements v8::internal::RegExpNode.

Definition at line 3130 of file jsregexp.cc.

                                                            {
  if (assertion_type_ == AT_START && not_at_start) {
    details->set_cannot_match();
    return;
  }
  return on_success()->GetQuickCheckDetails(details,
                                            compiler,
                                            filled_in,
                                            not_at_start);
}

References v8::internal::QuickCheckDetails::set_cannot_match().

Here is the call graph for this function:

Member Data Documentation

assertion_type_

AssertionType v8::internal::AssertionNode::assertion_type_

private

Definition at line 928 of file jsregexp.h.

Referenced by assertion_type().

---

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

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