dart::QuickCheckDetails Class Reference

#include <regexp.h>

Classes
struct	Position

Public Member Functions
	QuickCheckDetails ()
	QuickCheckDetails (intptr_t characters)
bool	Rationalize (bool one_byte)
void	Merge (QuickCheckDetails *other, intptr_t from_index)
void	Advance (intptr_t by, bool one_byte)
void	Clear ()
bool	cannot_match ()
void	set_cannot_match ()
intptr_t	characters ()
void	set_characters (intptr_t characters)
Position *	positions (intptr_t index)
uint32_t	mask ()
uint32_t	value ()

Detailed Description

Definition at line 339 of file regexp.h.

Constructor & Destructor Documentation

QuickCheckDetails() [1/2]

dart::QuickCheckDetails::QuickCheckDetails ( )

inline

Definition at line 341 of file regexp.h.

      : characters_(0), mask_(0), value_(0), cannot_match_(false) {}

QuickCheckDetails() [2/2]

dart::QuickCheckDetails::QuickCheckDetails ( intptr_t  characters )

inlineexplicit

Definition at line 343 of file regexp.h.

      : characters_(characters), mask_(0), value_(0), cannot_match_(false) {}

Member Function Documentation

Advance()

void dart::QuickCheckDetails::Advance	(	intptr_t	by,
		bool	one_byte
	)

Definition at line 1871 of file regexp.cc.

                                                          {
  if (by >= characters_ || by < 0) {
    // check that by < 0 => characters_ == 0
    ASSERT(by >= 0 || characters_ == 0);
    Clear();
    return;
  }
  for (intptr_t i = 0; i < characters_ - by; i++) {
    positions_[i] = positions_[by + i];
  }
  for (intptr_t i = characters_ - by; i < characters_; i++) {
    positions_[i].mask = 0;
    positions_[i].value = 0;
    positions_[i].determines_perfectly = false;
  }
  characters_ -= by;
  // We could change mask_ and value_ here but we would never advance unless
  // they had already been used in a check and they won't be used again because
  // it would gain us nothing.  So there's no point.
}

cannot_match()

bool dart::QuickCheckDetails::cannot_match ( )

inline

Definition at line 351 of file regexp.h.

{ return cannot_match_; }

characters()

intptr_t dart::QuickCheckDetails::characters ( )

inline

Definition at line 359 of file regexp.h.

{ return characters_; }

Clear()

void dart::QuickCheckDetails::Clear

(

)

Definition at line 1862 of file regexp.cc.

                              {
  for (int i = 0; i < characters_; i++) {
    positions_[i].mask = 0;
    positions_[i].value = 0;
    positions_[i].determines_perfectly = false;
  }
  characters_ = 0;
}

mask()

uint32_t dart::QuickCheckDetails::mask ( )

inline

Definition at line 366 of file regexp.h.

{ return mask_; }

Merge()

void dart::QuickCheckDetails::Merge	(	QuickCheckDetails *	other,
		intptr_t	from_index
	)

Definition at line 1892 of file regexp.cc.

                                                                           {
  ASSERT(characters_ == other->characters_);
  if (other->cannot_match_) {
    return;
  }
  if (cannot_match_) {
    *this = *other;
    return;
  }
  for (intptr_t i = from_index; i < characters_; i++) {
    QuickCheckDetails::Position* pos = positions(i);
    QuickCheckDetails::Position* other_pos = other->positions(i);
    if (pos->mask != other_pos->mask || pos->value != other_pos->value ||
        !other_pos->determines_perfectly) {
      // Our mask-compare operation will be approximate unless we have the
      // exact same operation on both sides of the alternation.
      pos->determines_perfectly = false;
    }
    pos->mask &= other_pos->mask;
    pos->value &= pos->mask;
    other_pos->value &= pos->mask;
    uint16_t differing_bits = (pos->value ^ other_pos->value);
    pos->mask &= ~differing_bits;
    pos->value &= pos->mask;
  }
}

positions()

Position * dart::QuickCheckDetails::positions ( intptr_t  index )

inline

Definition at line 361 of file regexp.h.

                                      {
    ASSERT(index >= 0);
    ASSERT(index < characters_);
    return positions_ + index;
  }

Rationalize()

bool dart::QuickCheckDetails::Rationalize

(

bool

one_byte

)

Definition at line 1598 of file regexp.cc.

                                            {
  bool found_useful_op = false;
  uint32_t char_mask;
  if (asc) {
    char_mask = Symbols::kMaxOneCharCodeSymbol;
  } else {
    char_mask = Utf16::kMaxCodeUnit;
  }
  mask_ = 0;
  value_ = 0;
  intptr_t char_shift = 0;
  for (intptr_t i = 0; i < characters_; i++) {
    Position* pos = &positions_[i];
    if ((pos->mask & Symbols::kMaxOneCharCodeSymbol) != 0) {
      found_useful_op = true;
    }
    mask_ |= (pos->mask & char_mask) << char_shift;
    value_ |= (pos->value & char_mask) << char_shift;
    char_shift += asc ? 8 : 16;
  }
  return found_useful_op;
}

set_cannot_match()

void dart::QuickCheckDetails::set_cannot_match ( )

inline

Definition at line 352 of file regexp.h.

{ cannot_match_ = true; }

set_characters()

void dart::QuickCheckDetails::set_characters ( intptr_t  characters )

inline

Definition at line 360 of file regexp.h.

{ characters_ = characters; }

value()

uint32_t dart::QuickCheckDetails::value ( )

inline

Definition at line 367 of file regexp.h.

{ return value_; }

---

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