dart::RegExpBuilder Class Reference

#include <regexp_parser.h>

Inheritance diagram for dart::RegExpBuilder:

Public Member Functions
	RegExpBuilder (RegExpFlags flags)
void	AddCharacter (uint16_t character)
void	AddUnicodeCharacter (uint32_t character)
void	AddEscapedUnicodeCharacter (uint32_t character)
void	AddEmpty ()
void	AddCharacterClass (RegExpCharacterClass *cc)
void	AddCharacterClassForDesugaring (uint32_t c)
void	AddAtom (RegExpTree *tree)
void	AddTerm (RegExpTree *tree)
void	AddAssertion (RegExpTree *tree)
void	NewAlternative ()
bool	AddQuantifierToAtom (intptr_t min, intptr_t max, RegExpQuantifier::QuantifierType type)
RegExpTree *	ToRegExp ()
RegExpFlags	flags () const
bool	ignore_case () const
bool	is_multi_line () const
bool	is_dot_all () 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)

Detailed Description

Definition at line 15 of file regexp_parser.h.

Constructor & Destructor Documentation

RegExpBuilder()

dart::RegExpBuilder::RegExpBuilder ( RegExpFlags  flags )

explicit

Definition at line 23 of file regexp_parser.cc.

    : zone_(Thread::Current()->zone()),
      pending_empty_(false),
      flags_(flags),
      characters_(nullptr),
      pending_surrogate_(kNoPendingSurrogate),
      terms_(),
      text_(),
      alternatives_()
#ifdef DEBUG
      ,
      last_added_(ADD_NONE)
#endif
{
}

Member Function Documentation

AddAssertion()

void dart::RegExpBuilder::AddAssertion

(

RegExpTree *

tree

)

Definition at line 182 of file regexp_parser.cc.

                                                   {
  FlushText();
  terms_.Add(assert);
  LAST(ADD_ASSERT);
}

AddAtom()

void dart::RegExpBuilder::AddAtom

(

RegExpTree *

tree

)

Definition at line 161 of file regexp_parser.cc.

                                            {
  if (term->IsEmpty()) {
    AddEmpty();
    return;
  }
  if (term->IsTextElement()) {
    FlushCharacters();
    text_.Add(term);
  } else {
    FlushText();
    terms_.Add(term);
  }
  LAST(ADD_ATOM);
}

AddCharacter()

void dart::RegExpBuilder::AddCharacter

(

uint16_t

character

)

Definition at line 104 of file regexp_parser.cc.

                                           {
  FlushPendingSurrogate();
  pending_empty_ = false;
  if (NeedsDesugaringForIgnoreCase(c)) {
    AddCharacterClassForDesugaring(c);
  } else {
    if (characters_ == nullptr) {
      characters_ = new (Z) ZoneGrowableArray<uint16_t>(4);
    }
    characters_->Add(c);
    LAST(ADD_CHAR);
  }
}

AddCharacterClass()

void dart::RegExpBuilder::AddCharacterClass

(

RegExpCharacterClass *

cc

)

Definition at line 146 of file regexp_parser.cc.

                                                              {
  if (NeedsDesugaringForUnicode(cc)) {
    // With /u, character class needs to be desugared, so it
    // must be a standalone term instead of being part of a RegExpText.
    AddTerm(cc);
  } else {
    AddAtom(cc);
  }
}

AddCharacterClassForDesugaring()

void dart::RegExpBuilder::AddCharacterClassForDesugaring

(

uint32_t

c

)

Definition at line 156 of file regexp_parser.cc.

                                                             {
  auto ranges = CharacterRange::List(Z, CharacterRange::Singleton(c));
  AddTerm(new (Z) RegExpCharacterClass(ranges, flags_));
}

AddEmpty()

void dart::RegExpBuilder::AddEmpty

(

)

Definition at line 142 of file regexp_parser.cc.

                             {
  pending_empty_ = true;
}

AddEscapedUnicodeCharacter()

void dart::RegExpBuilder::AddEscapedUnicodeCharacter

(

uint32_t

character

)

Definition at line 134 of file regexp_parser.cc.

                                                                 {
  // A lead or trail surrogate parsed via escape sequence will not
  // pair up with any preceding lead or following trail surrogate.
  FlushPendingSurrogate();
  AddUnicodeCharacter(character);
  FlushPendingSurrogate();
}

AddQuantifierToAtom()

bool dart::RegExpBuilder::AddQuantifierToAtom	(	intptr_t	min,
		intptr_t	max,
		RegExpQuantifier::QuantifierType	type
	)

Definition at line 269 of file regexp_parser.cc.

                                                    {
  if (pending_empty_) {
    pending_empty_ = false;
    return true;
  }
  RegExpTree* atom;
  if (characters_ != nullptr) {
    DEBUG_ASSERT(last_added_ == ADD_CHAR);
    // Last atom was character.
 
    ZoneGrowableArray<uint16_t>* char_vector =
        new (Z) ZoneGrowableArray<uint16_t>();
    char_vector->AddArray(*characters_);
    intptr_t num_chars = char_vector->length();
    if (num_chars > 1) {
      ZoneGrowableArray<uint16_t>* prefix =
          new (Z) ZoneGrowableArray<uint16_t>();
      for (intptr_t i = 0; i < num_chars - 1; i++) {
        prefix->Add(char_vector->At(i));
      }
      text_.Add(new (Z) RegExpAtom(prefix, flags_));
      ZoneGrowableArray<uint16_t>* tail = new (Z) ZoneGrowableArray<uint16_t>();
      tail->Add(char_vector->At(num_chars - 1));
      char_vector = tail;
    }
    characters_ = nullptr;
    atom = new (Z) RegExpAtom(char_vector, flags_);
    FlushText();
  } else if (text_.length() > 0) {
    DEBUG_ASSERT(last_added_ == ADD_ATOM);
    atom = text_.RemoveLast();
    FlushText();
  } else if (terms_.length() > 0) {
    DEBUG_ASSERT(last_added_ == ADD_ATOM);
    atom = terms_.RemoveLast();
    if (auto lookaround = atom->AsLookaround()) {
      // With /u, lookarounds are not quantifiable.
      if (is_unicode()) return false;
      // Lookbehinds are not quantifiable.
      if (lookaround->type() == RegExpLookaround::LOOKBEHIND) {
        return false;
      }
    }
    if (atom->max_match() == 0) {
      // Guaranteed to only match an empty string.
      LAST(ADD_TERM);
      if (min == 0) {
        return true;
      }
      terms_.Add(atom);
      return true;
    }
  } else {
    // Only call immediately after adding an atom or character!
    UNREACHABLE();
  }
  terms_.Add(new (Z) RegExpQuantifier(min, max, quantifier_type, atom));
  LAST(ADD_TERM);
  return true;
}

AddTerm()

void dart::RegExpBuilder::AddTerm

(

RegExpTree *

tree

)

Definition at line 176 of file regexp_parser.cc.

                                            {
  FlushText();
  terms_.Add(term);
  LAST(ADD_ATOM);
}

AddUnicodeCharacter()

void dart::RegExpBuilder::AddUnicodeCharacter

(

uint32_t

character

)

Definition at line 118 of file regexp_parser.cc.

                                                  {
  if (c > static_cast<uint32_t>(Utf16::kMaxCodeUnit)) {
    ASSERT(is_unicode());
    uint16_t surrogates[2];
    Utf16::Encode(c, surrogates);
    AddLeadSurrogate(surrogates[0]);
    AddTrailSurrogate(surrogates[1]);
  } else if (is_unicode() && Utf16::IsLeadSurrogate(c)) {
    AddLeadSurrogate(c);
  } else if (is_unicode() && Utf16::IsTrailSurrogate(c)) {
    AddTrailSurrogate(c);
  } else {
    AddCharacter(static_cast<uint16_t>(c));
  }
}

flags()

RegExpFlags dart::RegExpBuilder::flags ( ) const

inline

Definition at line 38 of file regexp_parser.h.

{ return flags_; }

ignore_case()

bool dart::RegExpBuilder::ignore_case ( ) const

inline

Definition at line 39 of file regexp_parser.h.

{ return flags_.IgnoreCase(); }

is_dot_all()

bool dart::RegExpBuilder::is_dot_all ( ) const

inline

Definition at line 41 of file regexp_parser.h.

{ return flags_.IsDotAll(); }

is_multi_line()

bool dart::RegExpBuilder::is_multi_line ( ) const

inline

Definition at line 40 of file regexp_parser.h.

{ return flags_.IsMultiLine(); }

NewAlternative()

void dart::RegExpBuilder::NewAlternative

(

)

Definition at line 188 of file regexp_parser.cc.

                                   {
  FlushTerms();
}

ToRegExp()

RegExpTree * dart::RegExpBuilder::ToRegExp

(

)

Definition at line 252 of file regexp_parser.cc.

                                    {
  FlushTerms();
  intptr_t num_alternatives = alternatives_.length();
  if (num_alternatives == 0) {
    return RegExpEmpty::GetInstance();
  }
  if (num_alternatives == 1) {
    return alternatives_.Last();
  }
  ZoneGrowableArray<RegExpTree*>* alternatives =
      new (Z) ZoneGrowableArray<RegExpTree*>();
  for (intptr_t i = 0; i < alternatives_.length(); i++) {
    alternatives->Add(alternatives_[i]);
  }
  return new (Z) RegExpDisjunction(alternatives);
}

---

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

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