dart::RegExpNode Class Reference

#include <regexp.h>

Inheritance diagram for dart::RegExpNode:

Public Member Functions
	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 Attributes
static constexpr intptr_t	kNodeIsTooComplexForGreedyLoops = -1
static constexpr intptr_t	kRecursionBudget = 200
static constexpr intptr_t	kMaxCopiesCodeGenerated = 10

Protected Types
enum	LimitResult { DONE , CONTINUE }

Protected Member Functions
LimitResult	LimitVersions (RegExpCompiler *compiler, Trace *trace)
void	set_bm_info (bool not_at_start, BoyerMooreLookahead *bm)

Protected Attributes
RegExpNode *	replacement_

Detailed Description

Definition at line 384 of file regexp.h.

Member Enumeration Documentation

LimitResult

enum dart::RegExpNode::LimitResult

protected

Enumerator
DONE
CONTINUE

Definition at line 486 of file regexp.h.

{ DONE, CONTINUE };

Constructor & Destructor Documentation

RegExpNode()

dart::RegExpNode::RegExpNode ( Zone *  zone )

inlineexplicit

Definition at line 386 of file regexp.h.

      : replacement_(nullptr), trace_count_(0), zone_(zone) {
    bm_info_[0] = bm_info_[1] = nullptr;
  }

~RegExpNode()

dart::RegExpNode::~RegExpNode ( )

virtual

Definition at line 1429 of file regexp.cc.

{}

Member Function Documentation

Accept()

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

pure virtual

Implemented in dart::ActionNode, dart::TextNode, dart::AssertionNode, dart::BackReferenceNode, dart::EndNode, dart::ChoiceNode, and dart::LoopChoiceNode.

bm_info()

BoyerMooreLookahead * dart::RegExpNode::bm_info ( bool  not_at_start )

inline

Definition at line 479 of file regexp.h.

                                                  {
    return bm_info_[not_at_start ? 1 : 0];
  }

EatsAtLeast()

virtual intptr_t dart::RegExpNode::EatsAtLeast ( intptr_t  still_to_find, intptr_t  budget, bool  not_at_start  )

pure virtual

Implemented in dart::ActionNode, dart::TextNode, dart::AssertionNode, dart::ChoiceNode, dart::NegativeLookaroundChoiceNode, dart::LoopChoiceNode, dart::BackReferenceNode, and dart::EndNode.

Emit()

virtual void dart::RegExpNode::Emit ( RegExpCompiler *  compiler, Trace *  trace  )

pure virtual

Implemented in dart::ActionNode, dart::TextNode, dart::AssertionNode, dart::BackReferenceNode, dart::EndNode, dart::NegativeSubmatchSuccess, dart::ChoiceNode, and dart::LoopChoiceNode.

EmitQuickCheck()

bool dart::RegExpNode::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
	)

Definition at line 1621 of file regexp.cc.

                                                              {
  if (details->characters() == 0) return false;
  GetQuickCheckDetails(details, compiler, 0,
                       trace->at_start() == Trace::FALSE_VALUE);
  if (details->cannot_match()) return false;
  if (!details->Rationalize(compiler->one_byte())) return false;
  ASSERT(details->characters() == 1 ||
         compiler->macro_assembler()->CanReadUnaligned());
  uint32_t mask = details->mask();
  uint32_t value = details->value();
 
  RegExpMacroAssembler* assembler = compiler->macro_assembler();
 
  if (trace->characters_preloaded() != details->characters()) {
    ASSERT(trace->cp_offset() == bounds_check_trace->cp_offset());
    // We are attempting to preload the minimum number of characters
    // any choice would eat, so if the bounds check fails, then none of the
    // choices can succeed, so we can just immediately backtrack, rather
    // than go to the next choice.
    assembler->LoadCurrentCharacter(
        trace->cp_offset(), bounds_check_trace->backtrack(),
        !preload_has_checked_bounds, details->characters());
  }
 
  bool need_mask = true;
 
  if (details->characters() == 1) {
    // If number of characters preloaded is 1 then we used a byte or 16 bit
    // load so the value is already masked down.
    uint32_t char_mask;
    if (compiler->one_byte()) {
      char_mask = Symbols::kMaxOneCharCodeSymbol;
    } else {
      char_mask = Utf16::kMaxCodeUnit;
    }
    if ((mask & char_mask) == char_mask) need_mask = false;
    mask &= char_mask;
  } else {
    // For 2-character preloads in one-byte mode or 1-character preloads in
    // two-byte mode we also use a 16 bit load with zero extend.
    if (details->characters() == 2 && compiler->one_byte()) {
      if ((mask & 0xffff) == 0xffff) need_mask = false;
    } else if (details->characters() == 1 && !compiler->one_byte()) {
      if ((mask & 0xffff) == 0xffff) need_mask = false;
    } else {
      if (mask == 0xffffffff) need_mask = false;
    }
  }
 
  if (fall_through_on_failure) {
    if (need_mask) {
      assembler->CheckCharacterAfterAnd(value, mask, on_possible_success);
    } else {
      assembler->CheckCharacter(value, on_possible_success);
    }
  } else {
    if (need_mask) {
      assembler->CheckNotCharacterAfterAnd(value, mask, trace->backtrack());
    } else {
      assembler->CheckNotCharacter(value, trace->backtrack());
    }
  }
  return true;
}

FillInBMInfo()

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

inlinevirtual

Reimplemented in dart::SeqRegExpNode, dart::ActionNode, dart::TextNode, dart::AssertionNode, dart::BackReferenceNode, dart::EndNode, dart::ChoiceNode, dart::NegativeLookaroundChoiceNode, and dart::LoopChoiceNode.

Definition at line 439 of file regexp.h.

                                               {
    UNREACHABLE();
  }

FilterOneByte()

virtual RegExpNode * dart::RegExpNode::FilterOneByte ( intptr_t  depth )

inlinevirtual

Reimplemented in dart::SeqRegExpNode, dart::TextNode, dart::ChoiceNode, dart::NegativeLookaroundChoiceNode, and dart::LoopChoiceNode.

Definition at line 449 of file regexp.h.

{ return this; }

GetQuickCheckDetails()

virtual void dart::RegExpNode::GetQuickCheckDetails ( QuickCheckDetails *  details, RegExpCompiler *  compiler, intptr_t  characters_filled_in, bool  not_at_start  )

pure virtual

Implemented in dart::TextNode, dart::BackReferenceNode, dart::EndNode, dart::ChoiceNode, dart::NegativeLookaroundChoiceNode, dart::LoopChoiceNode, dart::ActionNode, and dart::AssertionNode.

GetSuccessorOfOmnivorousTextNode()

virtual RegExpNode * dart::RegExpNode::GetSuccessorOfOmnivorousTextNode ( RegExpCompiler *  compiler )

inlinevirtual

Reimplemented in dart::TextNode.

Definition at line 428 of file regexp.h.

                                {
    return nullptr;
  }

GreedyLoopTextLength()

virtual intptr_t dart::RegExpNode::GreedyLoopTextLength ( )

inlinevirtual

Reimplemented in dart::ActionNode, and dart::TextNode.

Definition at line 423 of file regexp.h.

                                          {
    return kNodeIsTooComplexForGreedyLoops;
  }

info()

NodeInfo * dart::RegExpNode::info ( )

inline

Definition at line 477 of file regexp.h.

{ return &info_; }

label()

BlockLabel * dart::RegExpNode::label ( )

inline

Definition at line 469 of file regexp.h.

{ return &label_; }

LimitVersions()

RegExpNode::LimitResult dart::RegExpNode::LimitVersions ( RegExpCompiler *  compiler, Trace *  trace  )

protected

Definition at line 1431 of file regexp.cc.

                                                                {
  // If we are generating a greedy loop then don't stop and don't reuse code.
  if (trace->stop_node() != nullptr) {
    return CONTINUE;
  }
 
  RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
  if (trace->is_trivial()) {
    if (label_.is_bound()) {
      // We are being asked to generate a generic version, but that's already
      // been done so just go to it.
      macro_assembler->GoTo(&label_);
      return DONE;
    }
    if (compiler->recursion_depth() >= RegExpCompiler::kMaxRecursion) {
      // To avoid too deep recursion we push the node to the work queue and just
      // generate a goto here.
      compiler->AddWork(this);
      macro_assembler->GoTo(&label_);
      return DONE;
    }
    // Generate generic version of the node and bind the label for later use.
    macro_assembler->BindBlock(&label_);
    return CONTINUE;
  }
 
  // We are being asked to make a non-generic version.  Keep track of how many
  // non-generic versions we generate so as not to overdo it.
  trace_count_++;
  if (kRegexpOptimization && trace_count_ < kMaxCopiesCodeGenerated &&
      compiler->recursion_depth() <= RegExpCompiler::kMaxRecursion) {
    return CONTINUE;
  }
 
  // If we get here code has been generated for this node too many times or
  // recursion is too deep.  Time to switch to a generic version.  The code for
  // generic versions above can handle deep recursion properly.
  trace->Flush(compiler, this);
  return DONE;
}

replacement()

RegExpNode * dart::RegExpNode::replacement ( )

inline

Definition at line 451 of file regexp.h.

                            {
    ASSERT(info()->replacement_calculated);
    return replacement_;
  }

SaveBMInfo()

void dart::RegExpNode::SaveBMInfo ( BoyerMooreLookahead *  bm, bool  not_at_start, intptr_t  offset  )

inline

Definition at line 465 of file regexp.h.

                                                                               {
    if (offset == 0) set_bm_info(not_at_start, bm);
  }

set_bm_info()

void dart::RegExpNode::set_bm_info ( bool  not_at_start, BoyerMooreLookahead *  bm  )

inlineprotected

Definition at line 491 of file regexp.h.

                                                               {
    bm_info_[not_at_start ? 1 : 0] = bm;
  }

set_replacement()

RegExpNode * dart::RegExpNode::set_replacement ( RegExpNode *  replacement )

inline

Definition at line 455 of file regexp.h.

                                                       {
    info()->replacement_calculated = true;
    replacement_ = replacement;
    return replacement;  // For convenience.
  }

zone()

Zone * dart::RegExpNode::zone ( ) const

inline

Definition at line 483 of file regexp.h.

{ return zone_; }

Member Data Documentation

kMaxCopiesCodeGenerated

constexpr intptr_t dart::RegExpNode::kMaxCopiesCodeGenerated = 10

staticconstexpr

Definition at line 475 of file regexp.h.

kNodeIsTooComplexForGreedyLoops

constexpr intptr_t dart::RegExpNode::kNodeIsTooComplexForGreedyLoops = -1

staticconstexpr

Definition at line 422 of file regexp.h.

kRecursionBudget

constexpr intptr_t dart::RegExpNode::kRecursionBudget = 200

staticconstexpr

Definition at line 438 of file regexp.h.

replacement_

RegExpNode* dart::RegExpNode::replacement_

protected

Definition at line 487 of file regexp.h.

---

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