dart::BoyerMooreLookahead Class Reference

#include <regexp.h>

Inheritance diagram for dart::BoyerMooreLookahead:

Public Member Functions
	BoyerMooreLookahead (intptr_t length, RegExpCompiler *compiler, Zone *Zone)
intptr_t	length ()
intptr_t	max_char ()
RegExpCompiler *	compiler ()
intptr_t	Count (intptr_t map_number)
BoyerMoorePositionInfo *	at (intptr_t i)
void	Set (intptr_t map_number, intptr_t character)
void	SetInterval (intptr_t map_number, const Interval &interval)
void	SetAll (intptr_t map_number)
void	SetRest (intptr_t from_map)
void	EmitSkipInstructions (RegExpMacroAssembler *masm)
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)

Detailed Description

Definition at line 1132 of file regexp.h.

Constructor & Destructor Documentation

BoyerMooreLookahead()

dart::BoyerMooreLookahead::BoyerMooreLookahead	(	intptr_t	length,
		RegExpCompiler *	compiler,
		Zone *	Zone
	)

Definition at line 2825 of file regexp.cc.

    : length_(length), compiler_(compiler) {
  if (compiler->one_byte()) {
    max_char_ = Symbols::kMaxOneCharCodeSymbol;
  } else {
    max_char_ = Utf16::kMaxCodeUnit;
  }
  bitmaps_ = new (zone) ZoneGrowableArray<BoyerMoorePositionInfo*>(length);
  for (intptr_t i = 0; i < length; i++) {
    bitmaps_->Add(new (zone) BoyerMoorePositionInfo(zone));
  }
}

Member Function Documentation

at()

BoyerMoorePositionInfo * dart::BoyerMooreLookahead::at ( intptr_t  i )

inline

Definition at line 1144 of file regexp.h.

{ return bitmaps_->At(i); }

compiler()

RegExpCompiler * dart::BoyerMooreLookahead::compiler ( )

inline

Definition at line 1138 of file regexp.h.

{ return compiler_; }

Count()

intptr_t dart::BoyerMooreLookahead::Count ( intptr_t  map_number )

inline

Definition at line 1140 of file regexp.h.

                                      {
    return bitmaps_->At(map_number)->map_count();
  }

EmitSkipInstructions()

void dart::BoyerMooreLookahead::EmitSkipInstructions

(

RegExpMacroAssembler *

masm

)

Definition at line 2948 of file regexp.cc.

                                                                         {
  const intptr_t kSize = RegExpMacroAssembler::kTableSize;
 
  intptr_t min_lookahead = 0;
  intptr_t max_lookahead = 0;
 
  if (!FindWorthwhileInterval(&min_lookahead, &max_lookahead)) return;
 
  bool found_single_character = false;
  intptr_t single_character = 0;
  for (intptr_t i = max_lookahead; i >= min_lookahead; i--) {
    BoyerMoorePositionInfo* map = bitmaps_->At(i);
    if (map->map_count() > 1 ||
        (found_single_character && map->map_count() != 0)) {
      found_single_character = false;
      break;
    }
    for (intptr_t j = 0; j < kSize; j++) {
      if (map->at(j)) {
        found_single_character = true;
        single_character = j;
        break;
      }
    }
  }
 
  intptr_t lookahead_width = max_lookahead + 1 - min_lookahead;
 
  if (found_single_character && lookahead_width == 1 && max_lookahead < 3) {
    // The mask-compare can probably handle this better.
    return;
  }
 
  if (found_single_character) {
    BlockLabel cont, again;
    masm->BindBlock(&again);
    masm->LoadCurrentCharacter(max_lookahead, &cont, true);
    if (max_char_ > kSize) {
      masm->CheckCharacterAfterAnd(single_character,
                                   RegExpMacroAssembler::kTableMask, &cont);
    } else {
      masm->CheckCharacter(single_character, &cont);
    }
    masm->AdvanceCurrentPosition(lookahead_width);
    masm->GoTo(&again);
    masm->BindBlock(&cont);
    return;
  }
 
  const TypedData& boolean_skip_table = TypedData::ZoneHandle(
      compiler_->zone(),
      TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));
  intptr_t skip_distance =
      GetSkipTable(min_lookahead, max_lookahead, boolean_skip_table);
  ASSERT(skip_distance != 0);
 
  BlockLabel cont, again;
 
  masm->BindBlock(&again);
  masm->CheckPreemption(/*is_backtrack=*/false);
  masm->LoadCurrentCharacter(max_lookahead, &cont, true);
  masm->CheckBitInTable(boolean_skip_table, &cont);
  masm->AdvanceCurrentPosition(skip_distance);
  masm->GoTo(&again);
  masm->BindBlock(&cont);
 
  return;
}

length()

intptr_t dart::BoyerMooreLookahead::length ( )

inline

Definition at line 1136 of file regexp.h.

{ return length_; }

max_char()

intptr_t dart::BoyerMooreLookahead::max_char ( )

inline

Definition at line 1137 of file regexp.h.

{ return max_char_; }

Set()

void dart::BoyerMooreLookahead::Set ( intptr_t  map_number, intptr_t  character  )

inline

Definition at line 1146 of file regexp.h.

                                                    {
    if (character > max_char_) return;
    BoyerMoorePositionInfo* info = bitmaps_->At(map_number);
    info->Set(character);
  }

SetAll()

void dart::BoyerMooreLookahead::SetAll ( intptr_t  map_number )

inline

Definition at line 1162 of file regexp.h.

{ bitmaps_->At(map_number)->SetAll(); }

SetInterval()

void dart::BoyerMooreLookahead::SetInterval ( intptr_t  map_number, const Interval &  interval  )

inline

Definition at line 1152 of file regexp.h.

                                                                  {
    if (interval.from() > max_char_) return;
    BoyerMoorePositionInfo* info = bitmaps_->At(map_number);
    if (interval.to() > max_char_) {
      info->SetInterval(Interval(interval.from(), max_char_));
    } else {
      info->SetInterval(interval);
    }
  }

SetRest()

void dart::BoyerMooreLookahead::SetRest ( intptr_t  from_map )

inline

Definition at line 1164 of file regexp.h.

                                  {
    for (intptr_t i = from_map; i < length_; i++)
      SetAll(i);
  }

---

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