dart::AssertionNode Class Reference

#include <regexp.h>

Inheritance diagram for dart::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 intptr_t	EatsAtLeast (intptr_t still_to_find, intptr_t budget, bool not_at_start)
virtual void	GetQuickCheckDetails (QuickCheckDetails *details, RegExpCompiler *compiler, intptr_t filled_in, bool not_at_start)
virtual void	FillInBMInfo (intptr_t offset, intptr_t budget, BoyerMooreLookahead *bm, bool not_at_start)
AssertionType	assertion_type ()
Public Member Functions inherited from dart::SeqRegExpNode
	SeqRegExpNode (RegExpNode *on_success)
RegExpNode *	on_success ()
void	set_on_success (RegExpNode *node)
virtual RegExpNode *	FilterOneByte (intptr_t depth)
virtual void	FillInBMInfo (intptr_t offset, intptr_t budget, BoyerMooreLookahead *bm, bool not_at_start)
Public Member Functions inherited from dart::RegExpNode
	RegExpNode (Zone *zone)
virtual	~RegExpNode ()
virtual void	Accept (NodeVisitor *visitor)=0
virtual void	Emit (RegExpCompiler *compiler, Trace *trace)=0
virtual intptr_t	EatsAtLeast (intptr_t still_to_find, intptr_t budget, bool not_at_start)=0
bool	EmitQuickCheck (RegExpCompiler *compiler, Trace *bounds_check_trace, Trace *trace, bool preload_has_checked_bounds, BlockLabel *on_possible_success, QuickCheckDetails *details_return, bool fall_through_on_failure)
virtual void	GetQuickCheckDetails (QuickCheckDetails *details, RegExpCompiler *compiler, intptr_t characters_filled_in, bool not_at_start)=0
virtual intptr_t	GreedyLoopTextLength ()
virtual RegExpNode *	GetSuccessorOfOmnivorousTextNode (RegExpCompiler *compiler)
virtual void	FillInBMInfo (intptr_t offset, intptr_t budget, BoyerMooreLookahead *bm, bool not_at_start)
virtual RegExpNode *	FilterOneByte (intptr_t depth)
RegExpNode *	replacement ()
RegExpNode *	set_replacement (RegExpNode *replacement)
void	SaveBMInfo (BoyerMooreLookahead *bm, bool not_at_start, intptr_t offset)
BlockLabel *	label ()
NodeInfo *	info ()
BoyerMooreLookahead *	bm_info (bool not_at_start)
Zone *	zone () const
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

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)

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

Detailed Description

Definition at line 721 of file regexp.h.

Member Enumeration Documentation

AssertionType

enum dart::AssertionNode::AssertionType

Enumerator
AT_END
AT_START
AT_BOUNDARY
AT_NON_BOUNDARY
AFTER_NEWLINE

Definition at line 723 of file regexp.h.

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

Member Function Documentation

Accept()

virtual void dart::AssertionNode::Accept ( NodeVisitor *  visitor )

virtual

Implements dart::RegExpNode.

AfterNewline()

static AssertionNode * dart::AssertionNode::AfterNewline ( RegExpNode *  on_success )

inlinestatic

Definition at line 742 of file regexp.h.

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

assertion_type()

AssertionType dart::AssertionNode::assertion_type ( )

inline

Definition at line 758 of file regexp.h.

{ return assertion_type_; }

AtBoundary()

static AssertionNode * dart::AssertionNode::AtBoundary ( RegExpNode *  on_success )

inlinestatic

Definition at line 736 of file regexp.h.

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

AtEnd()

static AssertionNode * dart::AssertionNode::AtEnd ( RegExpNode *  on_success )

inlinestatic

Definition at line 730 of file regexp.h.

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

AtNonBoundary()

static AssertionNode * dart::AssertionNode::AtNonBoundary ( RegExpNode *  on_success )

inlinestatic

Definition at line 739 of file regexp.h.

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

AtStart()

static AssertionNode * dart::AssertionNode::AtStart ( RegExpNode *  on_success )

inlinestatic

Definition at line 733 of file regexp.h.

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

EatsAtLeast()

intptr_t dart::AssertionNode::EatsAtLeast ( intptr_t  still_to_find, intptr_t  budget, bool  not_at_start  )

virtual

Implements dart::RegExpNode.

Definition at line 1493 of file regexp.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 dart::AssertionNode::Emit ( RegExpCompiler *  compiler, Trace *  trace  )

virtual

Implements dart::RegExpNode.

Definition at line 2316 of file regexp.cc.

                                                               {
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
  switch (assertion_type_) {
    case AT_END: {
      BlockLabel ok;
      assembler->CheckPosition(trace->cp_offset(), &ok);
      assembler->GoTo(trace->backtrack());
      assembler->BindBlock(&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->cp_offset(), trace->backtrack());
        Trace at_start_trace = *trace;
        at_start_trace.set_at_start(Trace::TRUE_VALUE);
        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);
}

FillInBMInfo()

void dart::AssertionNode::FillInBMInfo ( intptr_t  offset, intptr_t  budget, BoyerMooreLookahead *  bm, bool  not_at_start  )

virtual

Reimplemented from dart::SeqRegExpNode.

Definition at line 1506 of file regexp.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 dart::AssertionNode::GetQuickCheckDetails ( QuickCheckDetails *  details, RegExpCompiler *  compiler, intptr_t  filled_in, bool  not_at_start  )

virtual

Implements dart::RegExpNode.

Definition at line 2304 of file regexp.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);
}

---

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

• third_party/dart-lang/sdk/runtime/vm/regexp.h
• third_party/dart-lang/sdk/runtime/vm/regexp.cc