v8::internal::RegExpEngine Class Reference

#include <jsregexp.h>

Inheritance diagram for v8::internal::RegExpEngine:

Collaboration diagram for v8::internal::RegExpEngine:

Classes
struct	CompilationResult

Static Public Member Functions
static CompilationResult	Compile (RegExpCompileData *input, bool ignore_case, bool global, bool multiline, bool sticky, Handle< String > pattern, Handle< String > sample_subject, bool is_one_byte, Zone *zone)
static void	DotPrint (const char *label, RegExpNode *node, bool ignore_case)

Detailed Description

Definition at line 1647 of file jsregexp.h.

Member Function Documentation

Compile()

RegExpEngine::CompilationResult v8::internal::RegExpEngine::Compile ( RegExpCompileData *  input, bool  ignore_case, bool  global, bool  multiline, bool  sticky, Handle< String >  pattern, Handle< String >  sample_subject, bool  is_one_byte, Zone *  zone  )

static

Definition at line 6034 of file jsregexp.cc.

                                                                 {
  if ((data->capture_count + 1) * 2 - 1 > RegExpMacroAssembler::kMaxRegister) {
    return IrregexpRegExpTooBig(zone->isolate());
  }
  RegExpCompiler compiler(data->capture_count, ignore_case, is_one_byte, zone);
 
  // Sample some characters from the middle of the string.
  static const int kSampleSize = 128;
 
  sample_subject = String::Flatten(sample_subject);
  int chars_sampled = 0;
  int half_way = (sample_subject->length() - kSampleSize) / 2;
  for (int i = Max(0, half_way);
       i < sample_subject->length() && chars_sampled < kSampleSize;
       i++, chars_sampled++) {
    compiler.frequency_collator()->CountCharacter(sample_subject->Get(i));
  }
 
  // 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();
  int 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 sticky.
    RegExpNode* loop_node =
        RegExpQuantifier::ToNode(0,
                                 RegExpTree::kInfinity,
                                 false,
                                 new(zone) RegExpCharacterClass('*'),
                                 &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('*'), loop_node)));
      node = first_step_node;
    } else {
      node = loop_node;
    }
  }
  if (is_one_byte) {
    node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
    // Do it again to propagate the new nodes to places where they were not
    // put because they had not been calculated yet.
    if (node != NULL) {
      node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
    }
  }
 
  if (node == NULL) node = new(zone) EndNode(EndNode::BACKTRACK, zone);
  data->node = node;
  Analysis analysis(ignore_case, is_one_byte);
  analysis.EnsureAnalyzed(node);
  if (analysis.has_failed()) {
    const char* error_message = analysis.error_message();
    return CompilationResult(zone->isolate(), error_message);
  }
 
  // Create the correct assembler for the architecture.
#ifndef V8_INTERPRETED_REGEXP
  // Native regexp implementation.
 
  NativeRegExpMacroAssembler::Mode mode =
      is_one_byte ? NativeRegExpMacroAssembler::LATIN1
                  : NativeRegExpMacroAssembler::UC16;
 
#if V8_TARGET_ARCH_IA32
  RegExpMacroAssemblerIA32 macro_assembler(mode, (data->capture_count + 1) * 2,
                                           zone);
#elif V8_TARGET_ARCH_X64
  RegExpMacroAssemblerX64 macro_assembler(mode, (data->capture_count + 1) * 2,
                                          zone);
#elif V8_TARGET_ARCH_ARM
  RegExpMacroAssemblerARM macro_assembler(mode, (data->capture_count + 1) * 2,
                                          zone);
#elif V8_TARGET_ARCH_ARM64
  RegExpMacroAssemblerARM64 macro_assembler(mode, (data->capture_count + 1) * 2,
                                            zone);
#elif V8_TARGET_ARCH_MIPS
  RegExpMacroAssemblerMIPS macro_assembler(mode, (data->capture_count + 1) * 2,
                                           zone);
#elif V8_TARGET_ARCH_MIPS64
  RegExpMacroAssemblerMIPS macro_assembler(mode, (data->capture_count + 1) * 2,
                                           zone);
#elif V8_TARGET_ARCH_X87
  RegExpMacroAssemblerX87 macro_assembler(mode, (data->capture_count + 1) * 2,
                                          zone);
#else
#error "Unsupported architecture"
#endif
 
#else  // V8_INTERPRETED_REGEXP
  // Interpreted regexp implementation.
  EmbeddedVector<byte, 1024> codes;
  RegExpMacroAssemblerIrregexp macro_assembler(codes, zone);
#endif  // V8_INTERPRETED_REGEXP
 
  // Inserted here, instead of in Assembler, because it depends on information
  // in the AST that isn't replicated in the Node structure.
  static const int kMaxBacksearchLimit = 1024;
  if (is_end_anchored &&
      !is_start_anchored &&
      max_length < kMaxBacksearchLimit) {
    macro_assembler.SetCurrentPositionFromEnd(max_length);
  }
 
  if (is_global) {
    macro_assembler.set_global_mode(
        (data->tree->min_match() > 0)
            ? RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK
            : RegExpMacroAssembler::GLOBAL);
  }
 
  return compiler.Assemble(&macro_assembler,
                           node,
                           data->capture_count,
                           pattern);
}

References v8::internal::RegExpCompiler::accept(), v8::internal::ChoiceNode::AddAlternative(), v8::internal::RegExpCompiler::Assemble(), v8::internal::EndNode::BACKTRACK, v8::internal::RegExpCompileData::capture_count, v8::internal::RegExpCompileData::contains_anchor, v8::internal::FrequencyCollator::CountCharacter(), v8::internal::Analysis::EnsureAnalyzed(), v8::internal::Analysis::error_message(), v8::internal::RegExpNode::FilterOneByte(), v8::internal::String::Flatten(), v8::internal::RegExpCompiler::frequency_collator(), v8::internal::RegExpMacroAssembler::GLOBAL, v8::internal::RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK, v8::internal::Analysis::has_failed(), v8::internal::IrregexpRegExpTooBig(), v8::internal::RegExpTree::IsAnchoredAtEnd(), v8::internal::RegExpTree::IsAnchoredAtStart(), v8::internal::Zone::isolate(), v8::internal::RegExpTree::kInfinity, v8::internal::RegExpCompiler::kMaxRecursion, v8::internal::RegExpMacroAssembler::kMaxRegister, v8::internal::NativeRegExpMacroAssembler::LATIN1, v8::internal::Max(), v8::internal::RegExpTree::max_match(), v8::internal::RegExpTree::min_match(), mode(), v8::internal::RegExpCompileData::node, NULL, v8::internal::RegExpMacroAssembler::set_global_mode(), v8::internal::RegExpMacroAssemblerIA32::SetCurrentPositionFromEnd(), v8::internal::RegExpCompileData::tree, and v8::internal::NativeRegExpMacroAssembler::UC16.

Referenced by v8::internal::RegExpImpl::CompileIrregexp().

Here is the call graph for this function:

Here is the caller graph for this function:

DotPrint()

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

static

---

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

• /mnt/V8SourceCode/src/jsregexp.h
• /mnt/V8SourceCode/src/jsregexp.cc