v8::internal::RegExpImpl Class Reference

#include <jsregexp.h>

Collaboration diagram for v8::internal::RegExpImpl:

Classes
class	GlobalCache

Public Types
enum	IrregexpResult { RE_FAILURE = 0 , RE_SUCCESS = 1 , RE_EXCEPTION = -1 }

Static Public Member Functions
static bool	UsesNativeRegExp ()
static MUST_USE_RESULT MaybeHandle< Object >	CreateRegExpLiteral (Handle< JSFunction > constructor, Handle< String > pattern, Handle< String > flags)
static Handle< String >	ToString (Handle< Object > value)
static MUST_USE_RESULT MaybeHandle< Object >	Compile (Handle< JSRegExp > re, Handle< String > pattern, Handle< String > flags)
static MUST_USE_RESULT MaybeHandle< Object >	Exec (Handle< JSRegExp > regexp, Handle< String > subject, int index, Handle< JSArray > lastMatchInfo)
static void	IrregexpInitialize (Handle< JSRegExp > re, Handle< String > pattern, JSRegExp::Flags flags, int capture_register_count)
static void	AtomCompile (Handle< JSRegExp > re, Handle< String > pattern, JSRegExp::Flags flags, Handle< String > match_pattern)
static int	AtomExecRaw (Handle< JSRegExp > regexp, Handle< String > subject, int index, int32_t *output, int output_size)
static Handle< Object >	AtomExec (Handle< JSRegExp > regexp, Handle< String > subject, int index, Handle< JSArray > lastMatchInfo)
static int	IrregexpPrepare (Handle< JSRegExp > regexp, Handle< String > subject)
static int	IrregexpExecRaw (Handle< JSRegExp > regexp, Handle< String > subject, int index, int32_t *output, int output_size)
static MUST_USE_RESULT MaybeHandle< Object >	IrregexpExec (Handle< JSRegExp > regexp, Handle< String > subject, int index, Handle< JSArray > lastMatchInfo)
static Handle< JSArray >	SetLastMatchInfo (Handle< JSArray > last_match_info, Handle< String > subject, int capture_count, int32_t *match)
static int	GetCapture (FixedArray *array, int index)
static void	SetLastCaptureCount (FixedArray *array, int to)
static void	SetLastSubject (FixedArray *array, String *to)
static void	SetLastInput (FixedArray *array, String *to)
static void	SetCapture (FixedArray *array, int index, int to)
static int	GetLastCaptureCount (FixedArray *array)
static int	IrregexpMaxRegisterCount (FixedArray *re)
static void	SetIrregexpMaxRegisterCount (FixedArray *re, int value)
static int	IrregexpNumberOfCaptures (FixedArray *re)
static int	IrregexpNumberOfRegisters (FixedArray *re)
static ByteArray *	IrregexpByteCode (FixedArray *re, bool is_one_byte)
static Code *	IrregexpNativeCode (FixedArray *re, bool is_one_byte)

Static Public Attributes
static const int	kLastCaptureCount = 0
static const int	kLastSubject = 1
static const int	kLastInput = 2
static const int	kFirstCapture = 3
static const int	kLastMatchOverhead = 3
static const int	kLastCaptureCountOffset
static const int	kLastSubjectOffset
static const int	kLastInputOffset
static const int	kFirstCaptureOffset
static const int	kRegExpExecutableMemoryLimit = 16 * MB
static const int	kRegWxpCompiledLimit = 1 * MB

Static Private Member Functions
static bool	CompileIrregexp (Handle< JSRegExp > re, Handle< String > sample_subject, bool is_one_byte)
static bool	EnsureCompiledIrregexp (Handle< JSRegExp > re, Handle< String > sample_subject, bool is_one_byte)

Detailed Description

Definition at line 22 of file jsregexp.h.

Member Enumeration Documentation

IrregexpResult

enum v8::internal::RegExpImpl::IrregexpResult

Enumerator
RE_FAILURE
RE_SUCCESS
RE_EXCEPTION

Definition at line 87 of file jsregexp.h.

{ RE_FAILURE = 0, RE_SUCCESS = 1, RE_EXCEPTION = -1 };

Member Function Documentation

AtomCompile()

void v8::internal::RegExpImpl::AtomCompile ( Handle< JSRegExp >  re, Handle< String >  pattern, JSRegExp::Flags  flags, Handle< String >  match_pattern  )

static

Definition at line 245 of file jsregexp.cc.

                                                           {
  re->GetIsolate()->factory()->SetRegExpAtomData(re,
                                                 JSRegExp::ATOM,
                                                 pattern,
                                                 flags,
                                                 match_pattern);
}

References v8::internal::JSRegExp::ATOM, and v8::internal::anonymous_namespace{flags.cc}::flags.

Referenced by Compile().

Here is the caller graph for this function:

AtomExec()

Handle< Object > v8::internal::RegExpImpl::AtomExec ( Handle< JSRegExp >  regexp, Handle< String >  subject, int  index, Handle< JSArray >  lastMatchInfo  )

static

Definition at line 322 of file jsregexp.cc.

                                                                     {
  Isolate* isolate = re->GetIsolate();
 
  static const int kNumRegisters = 2;
  STATIC_ASSERT(kNumRegisters <= Isolate::kJSRegexpStaticOffsetsVectorSize);
  int32_t* output_registers = isolate->jsregexp_static_offsets_vector();
 
  int res = AtomExecRaw(re, subject, index, output_registers, kNumRegisters);
 
  if (res == RegExpImpl::RE_FAILURE) return isolate->factory()->null_value();
 
  DCHECK_EQ(res, RegExpImpl::RE_SUCCESS);
  SealHandleScope shs(isolate);
  FixedArray* array = FixedArray::cast(last_match_info->elements());
  SetAtomLastCapture(array, *subject, output_registers[0], output_registers[1]);
  return last_match_info;
}

References AtomExecRaw(), DCHECK_EQ, v8::internal::Isolate::factory(), v8::internal::Isolate::kJSRegexpStaticOffsetsVectorSize, v8::internal::kNumRegisters, RE_FAILURE, RE_SUCCESS, v8::internal::SetAtomLastCapture(), and v8::internal::STATIC_ASSERT().

Referenced by Exec().

Here is the call graph for this function:

Here is the caller graph for this function:

AtomExecRaw()

int v8::internal::RegExpImpl::AtomExecRaw ( Handle< JSRegExp >  regexp, Handle< String >  subject, int  index, int32_t *  output, int  output_size  )

static

Definition at line 270 of file jsregexp.cc.

                                             {
  Isolate* isolate = regexp->GetIsolate();
 
  DCHECK(0 <= index);
  DCHECK(index <= subject->length());
 
  subject = String::Flatten(subject);
  DisallowHeapAllocation no_gc;  // ensure vectors stay valid
 
  String* needle = String::cast(regexp->DataAt(JSRegExp::kAtomPatternIndex));
  int needle_len = needle->length();
  DCHECK(needle->IsFlat());
  DCHECK_LT(0, needle_len);
 
  if (index + needle_len > subject->length()) {
    return RegExpImpl::RE_FAILURE;
  }
 
  for (int i = 0; i < output_size; i += 2) {
    String::FlatContent needle_content = needle->GetFlatContent();
    String::FlatContent subject_content = subject->GetFlatContent();
    DCHECK(needle_content.IsFlat());
    DCHECK(subject_content.IsFlat());
    // dispatch on type of strings
    index =
        (needle_content.IsOneByte()
             ? (subject_content.IsOneByte()
                    ? SearchString(isolate, subject_content.ToOneByteVector(),
                                   needle_content.ToOneByteVector(), index)
                    : SearchString(isolate, subject_content.ToUC16Vector(),
                                   needle_content.ToOneByteVector(), index))
             : (subject_content.IsOneByte()
                    ? SearchString(isolate, subject_content.ToOneByteVector(),
                                   needle_content.ToUC16Vector(), index)
                    : SearchString(isolate, subject_content.ToUC16Vector(),
                                   needle_content.ToUC16Vector(), index)));
    if (index == -1) {
      return i / 2;  // Return number of matches.
    } else {
      output[i] = index;
      output[i+1] = index + needle_len;
      index += needle_len;
    }
  }
  return output_size / 2;
}

References DCHECK, DCHECK_LT, v8::internal::String::Flatten(), v8::internal::String::GetFlatContent(), v8::internal::String::FlatContent::IsFlat(), v8::internal::String::IsFlat(), v8::internal::String::FlatContent::IsOneByte(), v8::internal::JSRegExp::kAtomPatternIndex, v8::internal::String::length(), RE_FAILURE, v8::internal::SearchString(), v8::internal::String::FlatContent::ToOneByteVector(), and v8::internal::String::FlatContent::ToUC16Vector().

Referenced by AtomExec().

Here is the call graph for this function:

Here is the caller graph for this function:

Compile()

MaybeHandle< Object > v8::internal::RegExpImpl::Compile ( Handle< JSRegExp >  re, Handle< String >  pattern, Handle< String >  flags  )

static

Definition at line 156 of file jsregexp.cc.

                                                                 {
  Isolate* isolate = re->GetIsolate();
  Zone zone(isolate);
  JSRegExp::Flags flags = RegExpFlagsFromString(flag_str);
  CompilationCache* compilation_cache = isolate->compilation_cache();
  MaybeHandle<FixedArray> maybe_cached =
      compilation_cache->LookupRegExp(pattern, flags);
  Handle<FixedArray> cached;
  bool in_cache = maybe_cached.ToHandle(&cached);
  LOG(isolate, RegExpCompileEvent(re, in_cache));
 
  Handle<Object> result;
  if (in_cache) {
    re->set_data(*cached);
    return re;
  }
  pattern = String::Flatten(pattern);
  PostponeInterruptsScope postpone(isolate);
  RegExpCompileData parse_result;
  FlatStringReader reader(isolate, pattern);
  if (!RegExpParser::ParseRegExp(&reader, flags.is_multiline(),
                                 &parse_result, &zone)) {
    // Throw an exception if we fail to parse the pattern.
    return ThrowRegExpException(re,
                                pattern,
                                parse_result.error,
                                "malformed_regexp");
  }
 
  bool has_been_compiled = false;
 
  if (parse_result.simple &&
      !flags.is_ignore_case() &&
      !flags.is_sticky() &&
      !HasFewDifferentCharacters(pattern)) {
    // Parse-tree is a single atom that is equal to the pattern.
    AtomCompile(re, pattern, flags, pattern);
    has_been_compiled = true;
  } else if (parse_result.tree->IsAtom() &&
      !flags.is_ignore_case() &&
      !flags.is_sticky() &&
      parse_result.capture_count == 0) {
    RegExpAtom* atom = parse_result.tree->AsAtom();
    Vector<const uc16> atom_pattern = atom->data();
    Handle<String> atom_string;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate, atom_string,
        isolate->factory()->NewStringFromTwoByte(atom_pattern),
        Object);
    if (!HasFewDifferentCharacters(atom_string)) {
      AtomCompile(re, pattern, flags, atom_string);
      has_been_compiled = true;
    }
  }
  if (!has_been_compiled) {
    IrregexpInitialize(re, pattern, flags, parse_result.capture_count);
  }
  DCHECK(re->data()->IsFixedArray());
  // Compilation succeeded so the data is set on the regexp
  // and we can store it in the cache.
  Handle<FixedArray> data(FixedArray::cast(re->data()));
  compilation_cache->PutRegExp(pattern, flags, data);
 
  return re;
}

References ASSIGN_RETURN_ON_EXCEPTION, AtomCompile(), v8::internal::RegExpCompileData::capture_count, v8::internal::Isolate::compilation_cache(), DCHECK, v8::internal::RegExpCompileData::error, v8::internal::Isolate::factory(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::String::Flatten(), v8::internal::HasFewDifferentCharacters(), IrregexpInitialize(), LOG, v8::internal::CompilationCache::LookupRegExp(), v8::internal::CompilationCache::PutRegExp(), v8::internal::RegExpFlagsFromString(), v8::internal::RegExpCompileData::simple, v8::internal::ThrowRegExpException(), and v8::internal::RegExpCompileData::tree.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileIrregexp()

bool v8::internal::RegExpImpl::CompileIrregexp ( Handle< JSRegExp >  re, Handle< String >  sample_subject, bool  is_one_byte  )

staticprivate

Definition at line 389 of file jsregexp.cc.

                                                   {
  // Compile the RegExp.
  Isolate* isolate = re->GetIsolate();
  Zone zone(isolate);
  PostponeInterruptsScope postpone(isolate);
  // If we had a compilation error the last time this is saved at the
  // saved code index.
  Object* entry = re->DataAt(JSRegExp::code_index(is_one_byte));
  // When arriving here entry can only be a smi, either representing an
  // uncompiled regexp, a previous compilation error, or code that has
  // been flushed.
  DCHECK(entry->IsSmi());
  int entry_value = Smi::cast(entry)->value();
  DCHECK(entry_value == JSRegExp::kUninitializedValue ||
         entry_value == JSRegExp::kCompilationErrorValue ||
         (entry_value < JSRegExp::kCodeAgeMask && entry_value >= 0));
 
  if (entry_value == JSRegExp::kCompilationErrorValue) {
    // A previous compilation failed and threw an error which we store in
    // the saved code index (we store the error message, not the actual
    // error). Recreate the error object and throw it.
    Object* error_string = re->DataAt(JSRegExp::saved_code_index(is_one_byte));
    DCHECK(error_string->IsString());
    Handle<String> error_message(String::cast(error_string));
    CreateRegExpErrorObjectAndThrow(re, error_message, isolate);
    return false;
  }
 
  JSRegExp::Flags flags = re->GetFlags();
 
  Handle<String> pattern(re->Pattern());
  pattern = String::Flatten(pattern);
  RegExpCompileData compile_data;
  FlatStringReader reader(isolate, pattern);
  if (!RegExpParser::ParseRegExp(&reader, flags.is_multiline(),
                                 &compile_data,
                                 &zone)) {
    // Throw an exception if we fail to parse the pattern.
    // THIS SHOULD NOT HAPPEN. We already pre-parsed it successfully once.
    USE(ThrowRegExpException(re,
                             pattern,
                             compile_data.error,
                             "malformed_regexp"));
    return false;
  }
  RegExpEngine::CompilationResult result = RegExpEngine::Compile(
      &compile_data, flags.is_ignore_case(), flags.is_global(),
      flags.is_multiline(), flags.is_sticky(), pattern, sample_subject,
      is_one_byte, &zone);
  if (result.error_message != NULL) {
    // Unable to compile regexp.
    Handle<String> error_message = isolate->factory()->NewStringFromUtf8(
        CStrVector(result.error_message)).ToHandleChecked();
    CreateRegExpErrorObjectAndThrow(re, error_message, isolate);
    return false;
  }
 
  Handle<FixedArray> data = Handle<FixedArray>(FixedArray::cast(re->data()));
  data->set(JSRegExp::code_index(is_one_byte), result.code);
  int register_max = IrregexpMaxRegisterCount(*data);
  if (result.num_registers > register_max) {
    SetIrregexpMaxRegisterCount(*data, result.num_registers);
  }
 
  return true;
}

References v8::internal::RegExpEngine::CompilationResult::code, v8::internal::JSRegExp::code_index(), v8::internal::RegExpEngine::Compile(), v8::internal::CreateRegExpErrorObjectAndThrow(), v8::internal::CStrVector(), DCHECK, v8::internal::RegExpCompileData::error, v8::internal::RegExpEngine::CompilationResult::error_message, v8::internal::Isolate::factory(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::String::Flatten(), IrregexpMaxRegisterCount(), v8::internal::JSRegExp::kCompilationErrorValue, v8::internal::JSRegExp::kUninitializedValue, NULL, v8::internal::RegExpEngine::CompilationResult::num_registers, v8::internal::JSRegExp::saved_code_index(), SetIrregexpMaxRegisterCount(), v8::internal::ThrowRegExpException(), and USE().

Referenced by EnsureCompiledIrregexp().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateRegExpLiteral()

MaybeHandle< Object > v8::internal::RegExpImpl::CreateRegExpLiteral ( Handle< JSFunction >  constructor, Handle< String >  pattern, Handle< String >  flags  )

static

Definition at line 50 of file jsregexp.cc.

                          {
  // Call the construct code with 2 arguments.
  Handle<Object> argv[] = { pattern, flags };
  return Execution::New(constructor, arraysize(argv), argv);
}

References arraysize, and v8::internal::anonymous_namespace{flags.cc}::flags.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

EnsureCompiledIrregexp()

bool v8::internal::RegExpImpl::EnsureCompiledIrregexp ( Handle< JSRegExp >  re, Handle< String >  sample_subject, bool  is_one_byte  )

inlinestaticprivate

Definition at line 352 of file jsregexp.cc.

                                                          {
  Object* compiled_code = re->DataAt(JSRegExp::code_index(is_one_byte));
#ifdef V8_INTERPRETED_REGEXP
  if (compiled_code->IsByteArray()) return true;
#else  // V8_INTERPRETED_REGEXP (RegExp native code)
  if (compiled_code->IsCode()) return true;
#endif
  // We could potentially have marked this as flushable, but have kept
  // a saved version if we did not flush it yet.
  Object* saved_code = re->DataAt(JSRegExp::saved_code_index(is_one_byte));
  if (saved_code->IsCode()) {
    // Reinstate the code in the original place.
    re->SetDataAt(JSRegExp::code_index(is_one_byte), saved_code);
    DCHECK(compiled_code->IsSmi());
    return true;
  }
  return CompileIrregexp(re, sample_subject, is_one_byte);
}

References v8::internal::JSRegExp::code_index(), CompileIrregexp(), DCHECK, and v8::internal::JSRegExp::saved_code_index().

Referenced by IrregexpExecRaw(), and IrregexpPrepare().

Here is the call graph for this function:

Here is the caller graph for this function:

Exec()

MaybeHandle< Object > v8::internal::RegExpImpl::Exec ( Handle< JSRegExp >  regexp, Handle< String >  subject, int  index, Handle< JSArray >  lastMatchInfo  )

static

Definition at line 225 of file jsregexp.cc.

                                                                      {
  switch (regexp->TypeTag()) {
    case JSRegExp::ATOM:
      return AtomExec(regexp, subject, index, last_match_info);
    case JSRegExp::IRREGEXP: {
      return IrregexpExec(regexp, subject, index, last_match_info);
    }
    default:
      UNREACHABLE();
      return MaybeHandle<Object>();
  }
}

References v8::internal::JSRegExp::ATOM, AtomExec(), v8::internal::JSRegExp::IRREGEXP, IrregexpExec(), and UNREACHABLE.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCapture()

static int v8::internal::RegExpImpl::GetCapture ( FixedArray *  array, int  index  )

inlinestatic

Definition at line 178 of file jsregexp.h.

                                                      {
    return Smi::cast(array->get(index + kFirstCapture))->value();
  }

References v8::internal::FixedArray::get(), and kFirstCapture.

Here is the call graph for this function:

GetLastCaptureCount()

static int v8::internal::RegExpImpl::GetLastCaptureCount ( FixedArray *  array )

inlinestatic

Definition at line 198 of file jsregexp.h.

                                                    {
    return Smi::cast(array->get(kLastCaptureCount))->value();
  }

References v8::internal::FixedArray::get(), and kLastCaptureCount.

Here is the call graph for this function:

IrregexpByteCode()

ByteArray * v8::internal::RegExpImpl::IrregexpByteCode ( FixedArray *  re, bool  is_one_byte  )

static

Definition at line 480 of file jsregexp.cc.

                                                                        {
  return ByteArray::cast(re->get(JSRegExp::code_index(is_one_byte)));
}

References v8::internal::JSRegExp::code_index(), and v8::internal::FixedArray::get().

Referenced by IrregexpExecRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

IrregexpExec()

MaybeHandle< Object > v8::internal::RegExpImpl::IrregexpExec ( Handle< JSRegExp >  regexp, Handle< String >  subject, int  index, Handle< JSArray >  lastMatchInfo  )

static

Definition at line 614 of file jsregexp.cc.

                                                                              {
  Isolate* isolate = regexp->GetIsolate();
  DCHECK_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
 
  // Prepare space for the return values.
#if defined(V8_INTERPRETED_REGEXP) && defined(DEBUG)
  if (FLAG_trace_regexp_bytecodes) {
    String* pattern = regexp->Pattern();
    PrintF("\n\nRegexp match:   /%s/\n\n", pattern->ToCString().get());
    PrintF("\n\nSubject string: '%s'\n\n", subject->ToCString().get());
  }
#endif
  int required_registers = RegExpImpl::IrregexpPrepare(regexp, subject);
  if (required_registers < 0) {
    // Compiling failed with an exception.
    DCHECK(isolate->has_pending_exception());
    return MaybeHandle<Object>();
  }
 
  int32_t* output_registers = NULL;
  if (required_registers > Isolate::kJSRegexpStaticOffsetsVectorSize) {
    output_registers = NewArray<int32_t>(required_registers);
  }
  SmartArrayPointer<int32_t> auto_release(output_registers);
  if (output_registers == NULL) {
    output_registers = isolate->jsregexp_static_offsets_vector();
  }
 
  int res = RegExpImpl::IrregexpExecRaw(
      regexp, subject, previous_index, output_registers, required_registers);
  if (res == RE_SUCCESS) {
    int capture_count =
        IrregexpNumberOfCaptures(FixedArray::cast(regexp->data()));
    return SetLastMatchInfo(
        last_match_info, subject, capture_count, output_registers);
  }
  if (res == RE_EXCEPTION) {
    DCHECK(isolate->has_pending_exception());
    return MaybeHandle<Object>();
  }
  DCHECK(res == RE_FAILURE);
  return isolate->factory()->null_value();
}

References DCHECK, DCHECK_EQ, v8::internal::Isolate::factory(), v8::internal::Isolate::has_pending_exception(), v8::internal::JSRegExp::IRREGEXP, IrregexpExecRaw(), IrregexpNumberOfCaptures(), IrregexpPrepare(), v8::internal::Isolate::kJSRegexpStaticOffsetsVectorSize, NULL, v8::internal::PrintF(), RE_EXCEPTION, RE_FAILURE, RE_SUCCESS, SetLastMatchInfo(), and v8::internal::String::ToCString().

Referenced by Exec().

Here is the call graph for this function:

Here is the caller graph for this function:

IrregexpExecRaw()

int v8::internal::RegExpImpl::IrregexpExecRaw ( Handle< JSRegExp >  regexp, Handle< String >  subject, int  index, int32_t *  output, int  output_size  )

static

Definition at line 526 of file jsregexp.cc.

                                                 {
  Isolate* isolate = regexp->GetIsolate();
 
  Handle<FixedArray> irregexp(FixedArray::cast(regexp->data()), isolate);
 
  DCHECK(index >= 0);
  DCHECK(index <= subject->length());
  DCHECK(subject->IsFlat());
 
  bool is_one_byte = subject->IsOneByteRepresentationUnderneath();
 
#ifndef V8_INTERPRETED_REGEXP
  DCHECK(output_size >= (IrregexpNumberOfCaptures(*irregexp) + 1) * 2);
  do {
    EnsureCompiledIrregexp(regexp, subject, is_one_byte);
    Handle<Code> code(IrregexpNativeCode(*irregexp, is_one_byte), isolate);
    // The stack is used to allocate registers for the compiled regexp code.
    // This means that in case of failure, the output registers array is left
    // untouched and contains the capture results from the previous successful
    // match.  We can use that to set the last match info lazily.
    NativeRegExpMacroAssembler::Result res =
        NativeRegExpMacroAssembler::Match(code,
                                          subject,
                                          output,
                                          output_size,
                                          index,
                                          isolate);
    if (res != NativeRegExpMacroAssembler::RETRY) {
      DCHECK(res != NativeRegExpMacroAssembler::EXCEPTION ||
             isolate->has_pending_exception());
      STATIC_ASSERT(
          static_cast<int>(NativeRegExpMacroAssembler::SUCCESS) == RE_SUCCESS);
      STATIC_ASSERT(
          static_cast<int>(NativeRegExpMacroAssembler::FAILURE) == RE_FAILURE);
      STATIC_ASSERT(static_cast<int>(NativeRegExpMacroAssembler::EXCEPTION)
                    == RE_EXCEPTION);
      return static_cast<IrregexpResult>(res);
    }
    // If result is RETRY, the string has changed representation, and we
    // must restart from scratch.
    // In this case, it means we must make sure we are prepared to handle
    // the, potentially, different subject (the string can switch between
    // being internal and external, and even between being Latin1 and UC16,
    // but the characters are always the same).
    IrregexpPrepare(regexp, subject);
    is_one_byte = subject->IsOneByteRepresentationUnderneath();
  } while (true);
  UNREACHABLE();
  return RE_EXCEPTION;
#else  // V8_INTERPRETED_REGEXP
 
  DCHECK(output_size >= IrregexpNumberOfRegisters(*irregexp));
  // We must have done EnsureCompiledIrregexp, so we can get the number of
  // registers.
  int number_of_capture_registers =
      (IrregexpNumberOfCaptures(*irregexp) + 1) * 2;
  int32_t* raw_output = &output[number_of_capture_registers];
  // We do not touch the actual capture result registers until we know there
  // has been a match so that we can use those capture results to set the
  // last match info.
  for (int i = number_of_capture_registers - 1; i >= 0; i--) {
    raw_output[i] = -1;
  }
  Handle<ByteArray> byte_codes(IrregexpByteCode(*irregexp, is_one_byte),
                               isolate);
 
  IrregexpResult result = IrregexpInterpreter::Match(isolate,
                                                     byte_codes,
                                                     subject,
                                                     raw_output,
                                                     index);
  if (result == RE_SUCCESS) {
    // Copy capture results to the start of the registers array.
    MemCopy(output, raw_output, number_of_capture_registers * sizeof(int32_t));
  }
  if (result == RE_EXCEPTION) {
    DCHECK(!isolate->has_pending_exception());
    isolate->StackOverflow();
  }
  return result;
#endif  // V8_INTERPRETED_REGEXP
}

References DCHECK, EnsureCompiledIrregexp(), v8::internal::NativeRegExpMacroAssembler::EXCEPTION, v8::internal::NativeRegExpMacroAssembler::FAILURE, v8::internal::Isolate::has_pending_exception(), IrregexpByteCode(), IrregexpNativeCode(), IrregexpNumberOfCaptures(), IrregexpNumberOfRegisters(), IrregexpPrepare(), v8::internal::NativeRegExpMacroAssembler::Match(), v8::internal::IrregexpInterpreter::Match(), v8::internal::MemCopy(), RE_EXCEPTION, RE_FAILURE, RE_SUCCESS, v8::internal::NativeRegExpMacroAssembler::RETRY, v8::internal::Isolate::StackOverflow(), v8::internal::STATIC_ASSERT(), v8::internal::NativeRegExpMacroAssembler::SUCCESS, and UNREACHABLE.

Referenced by IrregexpExec().

Here is the call graph for this function:

Here is the caller graph for this function:

IrregexpInitialize()

void v8::internal::RegExpImpl::IrregexpInitialize ( Handle< JSRegExp >  re, Handle< String >  pattern, JSRegExp::Flags  flags, int  capture_register_count  )

static

Definition at line 490 of file jsregexp.cc.

                                                       {
  // Initialize compiled code entries to null.
  re->GetIsolate()->factory()->SetRegExpIrregexpData(re,
                                                     JSRegExp::IRREGEXP,
                                                     pattern,
                                                     flags,
                                                     capture_count);
}

References v8::internal::anonymous_namespace{flags.cc}::flags, and v8::internal::JSRegExp::IRREGEXP.

Referenced by Compile().

Here is the caller graph for this function:

IrregexpMaxRegisterCount()

int v8::internal::RegExpImpl::IrregexpMaxRegisterCount ( FixedArray *  re )

static

Definition at line 459 of file jsregexp.cc.

                                                       {
  return Smi::cast(
      re->get(JSRegExp::kIrregexpMaxRegisterCountIndex))->value();
}

References v8::internal::FixedArray::get(), and v8::internal::JSRegExp::kIrregexpMaxRegisterCountIndex.

Referenced by CompileIrregexp().

Here is the call graph for this function:

Here is the caller graph for this function:

IrregexpNativeCode()

Code * v8::internal::RegExpImpl::IrregexpNativeCode ( FixedArray *  re, bool  is_one_byte  )

static

Definition at line 485 of file jsregexp.cc.

                                                                     {
  return Code::cast(re->get(JSRegExp::code_index(is_one_byte)));
}

References v8::internal::JSRegExp::code_index(), and v8::internal::FixedArray::get().

Referenced by IrregexpExecRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

IrregexpNumberOfCaptures()

int v8::internal::RegExpImpl::IrregexpNumberOfCaptures ( FixedArray *  re )

static

Definition at line 470 of file jsregexp.cc.

                                                       {
  return Smi::cast(re->get(JSRegExp::kIrregexpCaptureCountIndex))->value();
}

References v8::internal::FixedArray::get(), and v8::internal::JSRegExp::kIrregexpCaptureCountIndex.

Referenced by IrregexpExec(), IrregexpExecRaw(), and IrregexpPrepare().

Here is the call graph for this function:

Here is the caller graph for this function:

IrregexpNumberOfRegisters()

int v8::internal::RegExpImpl::IrregexpNumberOfRegisters ( FixedArray *  re )

static

Definition at line 475 of file jsregexp.cc.

                                                        {
  return Smi::cast(re->get(JSRegExp::kIrregexpMaxRegisterCountIndex))->value();
}

References v8::internal::FixedArray::get(), and v8::internal::JSRegExp::kIrregexpMaxRegisterCountIndex.

Referenced by IrregexpExecRaw(), and IrregexpPrepare().

Here is the call graph for this function:

Here is the caller graph for this function:

IrregexpPrepare()

int v8::internal::RegExpImpl::IrregexpPrepare ( Handle< JSRegExp >  regexp, Handle< String >  subject  )

static

Definition at line 503 of file jsregexp.cc.

                                                        {
  subject = String::Flatten(subject);
 
  // Check representation of the underlying storage.
  bool is_one_byte = subject->IsOneByteRepresentationUnderneath();
  if (!EnsureCompiledIrregexp(regexp, subject, is_one_byte)) return -1;
 
#ifdef V8_INTERPRETED_REGEXP
  // Byte-code regexp needs space allocated for all its registers.
  // The result captures are copied to the start of the registers array
  // if the match succeeds.  This way those registers are not clobbered
  // when we set the last match info from last successful match.
  return IrregexpNumberOfRegisters(FixedArray::cast(regexp->data())) +
         (IrregexpNumberOfCaptures(FixedArray::cast(regexp->data())) + 1) * 2;
#else  // V8_INTERPRETED_REGEXP
  // Native regexp only needs room to output captures. Registers are handled
  // internally.
  return (IrregexpNumberOfCaptures(FixedArray::cast(regexp->data())) + 1) * 2;
#endif  // V8_INTERPRETED_REGEXP
}

References EnsureCompiledIrregexp(), v8::internal::String::Flatten(), IrregexpNumberOfCaptures(), and IrregexpNumberOfRegisters().

Referenced by v8::internal::RegExpImpl::GlobalCache::GlobalCache(), IrregexpExec(), and IrregexpExecRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCapture()

static void v8::internal::RegExpImpl::SetCapture ( FixedArray *  array, int  index, int  to  )

inlinestatic

Definition at line 194 of file jsregexp.h.

                                                               {
    array->set(index + kFirstCapture, Smi::FromInt(to));
  }

References v8::internal::Smi::FromInt(), kFirstCapture, v8::internal::FixedArray::set(), and to().

Referenced by v8::internal::SetAtomLastCapture(), and SetLastMatchInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

SetIrregexpMaxRegisterCount()

void v8::internal::RegExpImpl::SetIrregexpMaxRegisterCount ( FixedArray *  re, int  value  )

static

Definition at line 465 of file jsregexp.cc.

                                                                      {
  re->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(value));
}

References v8::internal::Smi::FromInt(), v8::internal::JSRegExp::kIrregexpMaxRegisterCountIndex, and v8::internal::FixedArray::set().

Referenced by CompileIrregexp().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastCaptureCount()

static void v8::internal::RegExpImpl::SetLastCaptureCount ( FixedArray *  array, int  to  )

inlinestatic

Definition at line 182 of file jsregexp.h.

                                                             {
    array->set(kLastCaptureCount, Smi::FromInt(to));
  }

References v8::internal::Smi::FromInt(), kLastCaptureCount, v8::internal::FixedArray::set(), and to().

Referenced by v8::internal::SetAtomLastCapture(), and SetLastMatchInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastInput()

static void v8::internal::RegExpImpl::SetLastInput ( FixedArray *  array, String *  to  )

inlinestatic

Definition at line 190 of file jsregexp.h.

                                                          {
    array->set(kLastInput, to);
  }

References kLastInput, v8::internal::FixedArray::set(), and to().

Referenced by v8::internal::SetAtomLastCapture(), and SetLastMatchInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastMatchInfo()

Handle< JSArray > v8::internal::RegExpImpl::SetLastMatchInfo ( Handle< JSArray >  last_match_info, Handle< String >  subject, int  capture_count, int32_t *  match  )

static

Definition at line 662 of file jsregexp.cc.

                                                             {
  DCHECK(last_match_info->HasFastObjectElements());
  int capture_register_count = (capture_count + 1) * 2;
  JSArray::EnsureSize(last_match_info,
                      capture_register_count + kLastMatchOverhead);
  DisallowHeapAllocation no_allocation;
  FixedArray* array = FixedArray::cast(last_match_info->elements());
  if (match != NULL) {
    for (int i = 0; i < capture_register_count; i += 2) {
      SetCapture(array, i, match[i]);
      SetCapture(array, i + 1, match[i + 1]);
    }
  }
  SetLastCaptureCount(array, capture_register_count);
  SetLastSubject(array, *subject);
  SetLastInput(array, *subject);
  return last_match_info;
}

References DCHECK, v8::internal::JSArray::EnsureSize(), kLastMatchOverhead, NULL, SetCapture(), SetLastCaptureCount(), SetLastInput(), and SetLastSubject().

Referenced by IrregexpExec(), v8::internal::RUNTIME_FUNCTION(), v8::internal::SearchRegExpMultiple(), v8::internal::StringReplaceGlobalAtomRegExpWithString(), v8::internal::StringReplaceGlobalRegExpWithEmptyString(), and v8::internal::StringReplaceGlobalRegExpWithString().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastSubject()

static void v8::internal::RegExpImpl::SetLastSubject ( FixedArray *  array, String *  to  )

inlinestatic

Definition at line 186 of file jsregexp.h.

                                                            {
    array->set(kLastSubject, to);
  }

References kLastSubject, v8::internal::FixedArray::set(), and to().

Referenced by v8::internal::SetAtomLastCapture(), and SetLastMatchInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

ToString()

static Handle<String> v8::internal::RegExpImpl::ToString ( Handle< Object >  value )

static

UsesNativeRegExp()

static bool v8::internal::RegExpImpl::UsesNativeRegExp ( )

inlinestatic

Definition at line 25 of file jsregexp.h.

                                 {
#ifdef V8_INTERPRETED_REGEXP
    return false;
#else
    return true;
#endif
  }

Member Data Documentation

kFirstCapture

const int v8::internal::RegExpImpl::kFirstCapture = 3

static

Definition at line 164 of file jsregexp.h.

Referenced by GetCapture(), and SetCapture().

kFirstCaptureOffset

const int v8::internal::RegExpImpl::kFirstCaptureOffset

static

Initial value:

=
      FixedArray::kHeaderSize + kFirstCapture * kPointerSize

Definition at line 174 of file jsregexp.h.

kLastCaptureCount

const int v8::internal::RegExpImpl::kLastCaptureCount = 0

static

Definition at line 161 of file jsregexp.h.

Referenced by GetLastCaptureCount(), and SetLastCaptureCount().

kLastCaptureCountOffset

const int v8::internal::RegExpImpl::kLastCaptureCountOffset

static

Initial value:

=
      FixedArray::kHeaderSize + kLastCaptureCount * kPointerSize

Definition at line 168 of file jsregexp.h.

kLastInput

const int v8::internal::RegExpImpl::kLastInput = 2

static

Definition at line 163 of file jsregexp.h.

Referenced by SetLastInput().

kLastInputOffset

const int v8::internal::RegExpImpl::kLastInputOffset

static

Initial value:

=
      FixedArray::kHeaderSize + kLastInput * kPointerSize

Definition at line 172 of file jsregexp.h.

kLastMatchOverhead

const int v8::internal::RegExpImpl::kLastMatchOverhead = 3

static

Definition at line 165 of file jsregexp.h.

Referenced by SetLastMatchInfo().

kLastSubject

const int v8::internal::RegExpImpl::kLastSubject = 1

static

Definition at line 162 of file jsregexp.h.

Referenced by SetLastSubject().

kLastSubjectOffset

const int v8::internal::RegExpImpl::kLastSubjectOffset

static

Initial value:

=
      FixedArray::kHeaderSize + kLastSubject * kPointerSize

Definition at line 170 of file jsregexp.h.

kRegExpExecutableMemoryLimit

const int v8::internal::RegExpImpl::kRegExpExecutableMemoryLimit = 16 * MB

static

Definition at line 215 of file jsregexp.h.

Referenced by v8::internal::RegExpCompiler::Assemble().

kRegWxpCompiledLimit

const int v8::internal::RegExpImpl::kRegWxpCompiledLimit = 1 * MB

static

Definition at line 216 of file jsregexp.h.

Referenced by v8::internal::RegExpCompiler::Assemble().

---

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

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