dart::RegExpEngine Class Reference

#include <regexp.h>

Inheritance diagram for dart::RegExpEngine:

Classes
struct	CompilationResult

Static Public Member Functions
static CompilationResult	CompileIR (RegExpCompileData *input, const ParsedFunction *parsed_function, const ZoneGrowableArray< const ICData * > &ic_data_array, intptr_t osr_id)
static CompilationResult	CompileBytecode (RegExpCompileData *data, const RegExp &regexp, bool is_one_byte, bool sticky, Zone *zone)
static RegExpPtr	CreateRegExp (Thread *thread, const String &pattern, RegExpFlags flags)
static void	DotPrint (const char *label, RegExpNode *node, bool ignore_case)

Detailed Description

Definition at line 1448 of file regexp.h.

Member Function Documentation

CompileBytecode()

RegExpEngine::CompilationResult dart::RegExpEngine::CompileBytecode ( RegExpCompileData *  data, const RegExp &  regexp, bool  is_one_byte, bool  sticky, Zone *  zone  )

static

Definition at line 5414 of file regexp.cc.

                {
  ASSERT(FLAG_interpret_irregexp);
  const String& pattern = String::Handle(zone, regexp.pattern());
 
  ASSERT(!regexp.IsNull());
  ASSERT(!pattern.IsNull());
 
  const bool is_global = regexp.flags().IsGlobal();
  const bool is_unicode = regexp.flags().IsUnicode();
 
  RegExpCompiler compiler(data->capture_count, is_one_byte);
 
  // TODO(zerny): Frequency sampling is currently disabled because of several
  // issues. We do not want to store subject strings in the regexp object since
  // they might be long and we should not prevent their garbage collection.
  // Passing them to this function explicitly does not help, since we must
  // generate exactly the same IR for both the unoptimizing and optimizing
  // pipelines (otherwise it gets confused when i.e. deopt id's differ).
  // An option would be to store sampling results in the regexp object, but
  // I'm not sure the performance gains are relevant enough.
 
  // Wrap the body of the regexp in capture #0.
  RegExpNode* captured_body =
      RegExpCapture::ToNode(data->tree, 0, &compiler, compiler.accept());
 
  RegExpNode* node = captured_body;
  bool is_end_anchored = data->tree->IsAnchoredAtEnd();
  bool is_start_anchored = data->tree->IsAnchoredAtStart();
  intptr_t max_length = data->tree->max_match();
  if (!is_start_anchored && !is_sticky) {
    // Add a .*? at the beginning, outside the body capture, unless
    // this expression is anchored at the beginning.
    RegExpNode* loop_node = RegExpQuantifier::ToNode(
        0, RegExpTree::kInfinity, false,
        new (zone) RegExpCharacterClass('*', RegExpFlags()), &compiler,
        captured_body, data->contains_anchor);
 
    if (data->contains_anchor) {
      // Unroll loop once, to take care of the case that might start
      // at the start of input.
      ChoiceNode* first_step_node = new (zone) ChoiceNode(2, zone);
      first_step_node->AddAlternative(GuardedAlternative(captured_body));
      first_step_node->AddAlternative(GuardedAlternative(new (zone) TextNode(
          new (zone) RegExpCharacterClass('*', RegExpFlags()),
          /*read_backwards=*/false, loop_node)));
      node = first_step_node;
    } else {
      node = loop_node;
    }
  }
  if (is_one_byte) {
    node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
    // Do it again to propagate the new nodes to places where they were not
    // put because they had not been calculated yet.
    if (node != nullptr) {
      node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
    }
  } else if (is_unicode && (is_global || is_sticky)) {
    node = OptionallyStepBackToLeadSurrogate(&compiler, node, regexp.flags());
  }
 
  if (node == nullptr) node = new (zone) EndNode(EndNode::BACKTRACK, zone);
  data->node = node;
  Analysis analysis(is_one_byte);
  analysis.EnsureAnalyzed(node);
  if (analysis.has_failed()) {
    const char* error_message = analysis.error_message();
    return CompilationResult(error_message);
  }
 
  // Bytecode regexp implementation.
 
  ZoneGrowableArray<uint8_t> buffer(zone, 1024);
  BytecodeRegExpMacroAssembler* macro_assembler =
      new (zone) BytecodeRegExpMacroAssembler(&buffer, zone);
 
  // Inserted here, instead of in Assembler, because it depends on information
  // in the AST that isn't replicated in the Node structure.
  const intptr_t kMaxBacksearchLimit = 1024;
  if (is_end_anchored && !is_start_anchored && !is_sticky &&
      max_length < kMaxBacksearchLimit) {
    macro_assembler->SetCurrentPositionFromEnd(max_length);
  }
 
  if (is_global) {
    RegExpMacroAssembler::GlobalMode mode = RegExpMacroAssembler::GLOBAL;
    if (data->tree->min_match() > 0) {
      mode = RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK;
    } else if (is_unicode) {
      mode = RegExpMacroAssembler::GLOBAL_UNICODE;
    }
    macro_assembler->set_global_mode(mode);
  }
 
  RegExpEngine::CompilationResult result =
      compiler.Assemble(macro_assembler, node, data->capture_count, pattern);
 
  if (FLAG_trace_irregexp) {
    macro_assembler->PrintBlocks();
  }
 
  return result;
}

CompileIR()

RegExpEngine::CompilationResult dart::RegExpEngine::CompileIR ( RegExpCompileData *  input, const ParsedFunction *  parsed_function, const ZoneGrowableArray< const ICData * > &  ic_data_array, intptr_t  osr_id  )

static

Definition at line 5298 of file regexp.cc.

                     {
  ASSERT(!FLAG_interpret_irregexp);
  Zone* zone = Thread::Current()->zone();
 
  const Function& function = parsed_function->function();
  const intptr_t specialization_cid = function.string_specialization_cid();
  const bool is_sticky = function.is_sticky_specialization();
  const bool is_one_byte = (specialization_cid == kOneByteStringCid);
  RegExp& regexp = RegExp::Handle(zone, function.regexp());
  const String& pattern = String::Handle(zone, regexp.pattern());
 
  ASSERT(!regexp.IsNull());
  ASSERT(!pattern.IsNull());
 
  const bool is_global = regexp.flags().IsGlobal();
  const bool is_unicode = regexp.flags().IsUnicode();
 
  RegExpCompiler compiler(data->capture_count, is_one_byte);
 
  // TODO(zerny): Frequency sampling is currently disabled because of several
  // issues. We do not want to store subject strings in the regexp object since
  // they might be long and we should not prevent their garbage collection.
  // Passing them to this function explicitly does not help, since we must
  // generate exactly the same IR for both the unoptimizing and optimizing
  // pipelines (otherwise it gets confused when i.e. deopt id's differ).
  // An option would be to store sampling results in the regexp object, but
  // I'm not sure the performance gains are relevant enough.
 
  // Wrap the body of the regexp in capture #0.
  RegExpNode* captured_body =
      RegExpCapture::ToNode(data->tree, 0, &compiler, compiler.accept());
 
  RegExpNode* node = captured_body;
  const bool is_end_anchored = data->tree->IsAnchoredAtEnd();
  const bool is_start_anchored = data->tree->IsAnchoredAtStart();
  intptr_t max_length = data->tree->max_match();
  if (!is_start_anchored && !is_sticky) {
    // Add a .*? at the beginning, outside the body capture, unless
    // this expression is anchored at the beginning or is sticky.
    RegExpNode* loop_node = RegExpQuantifier::ToNode(
        0, RegExpTree::kInfinity, false,
        new (zone) RegExpCharacterClass('*', RegExpFlags()), &compiler,
        captured_body, data->contains_anchor);
 
    if (data->contains_anchor) {
      // Unroll loop once, to take care of the case that might start
      // at the start of input.
      ChoiceNode* first_step_node = new (zone) ChoiceNode(2, zone);
      first_step_node->AddAlternative(GuardedAlternative(captured_body));
      first_step_node->AddAlternative(GuardedAlternative(new (zone) TextNode(
          new (zone) RegExpCharacterClass('*', RegExpFlags()),
          /*read_backwards=*/false, loop_node)));
      node = first_step_node;
    } else {
      node = loop_node;
    }
  }
  if (is_one_byte) {
    node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
    // Do it again to propagate the new nodes to places where they were not
    // put because they had not been calculated yet.
    if (node != nullptr) {
      node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
    }
  } else if (is_unicode && (is_global || is_sticky)) {
    node = OptionallyStepBackToLeadSurrogate(&compiler, node, regexp.flags());
  }
 
  if (node == nullptr) node = new (zone) EndNode(EndNode::BACKTRACK, zone);
  data->node = node;
  Analysis analysis(is_one_byte);
  analysis.EnsureAnalyzed(node);
  if (analysis.has_failed()) {
    const char* error_message = analysis.error_message();
    return CompilationResult(error_message);
  }
 
  // Native regexp implementation.
 
  IRRegExpMacroAssembler* macro_assembler = new (zone)
      IRRegExpMacroAssembler(specialization_cid, data->capture_count,
                             parsed_function, ic_data_array, osr_id, zone);
 
  // Inserted here, instead of in Assembler, because it depends on information
  // in the AST that isn't replicated in the Node structure.
  const intptr_t kMaxBacksearchLimit = 1024;
  if (is_end_anchored && !is_start_anchored && !is_sticky &&
      max_length < kMaxBacksearchLimit) {
    macro_assembler->SetCurrentPositionFromEnd(max_length);
  }
 
  if (is_global) {
    RegExpMacroAssembler::GlobalMode mode = RegExpMacroAssembler::GLOBAL;
    if (data->tree->min_match() > 0) {
      mode = RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK;
    } else if (is_unicode) {
      mode = RegExpMacroAssembler::GLOBAL_UNICODE;
    }
    macro_assembler->set_global_mode(mode);
  }
 
  RegExpEngine::CompilationResult result =
      compiler.Assemble(macro_assembler, node, data->capture_count, pattern);
 
  if (FLAG_trace_irregexp) {
    macro_assembler->PrintBlocks();
  }
 
  return result;
}

CreateRegExp()

RegExpPtr dart::RegExpEngine::CreateRegExp ( Thread *  thread, const String &  pattern, RegExpFlags  flags  )

static

Definition at line 5573 of file regexp.cc.

                                                        {
  Zone* zone = thread->zone();
  const RegExp& regexp = RegExp::Handle(RegExp::New(zone));
 
  regexp.set_pattern(pattern);
  regexp.set_flags(flags);
 
  // TODO(zerny): We might want to use normal string searching algorithms
  // for simple patterns.
  regexp.set_is_complex();
  regexp.set_is_global();  // All dart regexps are global.
 
  if (!FLAG_interpret_irregexp) {
    const Library& lib = Library::Handle(zone, Library::CoreLibrary());
    const Class& owner =
        Class::Handle(zone, lib.LookupClass(Symbols::RegExp()));
 
    for (intptr_t cid = kOneByteStringCid; cid <= kTwoByteStringCid; cid++) {
      CreateSpecializedFunction(thread, zone, regexp, cid, /*sticky=*/false,
                                owner);
      CreateSpecializedFunction(thread, zone, regexp, cid, /*sticky=*/true,
                                owner);
    }
  }
 
  return regexp.ptr();
}

DotPrint()

static void dart::RegExpEngine::DotPrint ( const char *  label, RegExpNode *  node, bool  ignore_case  )

static

---

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