Lines Matching refs:Handle
56 Handle<JSRegExp> re, Handle<String> pattern, Handle<String> error_text) {
64 inline void ThrowRegExpException(Handle<JSRegExp> re,
65 Handle<String> error_text) {
66 USE(ThrowRegExpException(re, Handle<String>(re->Pattern()), error_text));
103 static bool HasFewDifferentCharacters(Handle<String> pattern) {
127 MaybeHandle<Object> RegExpImpl::Compile(Handle<JSRegExp> re,
128 Handle<String> pattern,
135 Handle<FixedArray> cached;
139 Handle<Object> result;
166 Handle<String> atom_string;
182 Handle<FixedArray> data(FixedArray::cast(re->data()));
189 MaybeHandle<Object> RegExpImpl::Exec(Handle<JSRegExp> regexp,
190 Handle<String> subject,
192 Handle<JSArray> last_match_info) {
209 void RegExpImpl::AtomCompile(Handle<JSRegExp> re,
210 Handle<String> pattern,
212 Handle<String> match_pattern) {
234 int RegExpImpl::AtomExecRaw(Handle<JSRegExp> regexp,
235 Handle<String> subject,
286 Handle<Object> RegExpImpl::AtomExec(Handle<JSRegExp> re,
287 Handle<String> subject,
289 Handle<JSArray> last_match_info) {
316 bool RegExpImpl::EnsureCompiledIrregexp(Handle<JSRegExp> re,
317 Handle<String> sample_subject,
338 bool RegExpImpl::CompileIrregexp(Handle<JSRegExp> re,
339 Handle<String> sample_subject,
363 Handle<String> error_message(String::cast(error_string));
370 Handle<String> pattern(re->Pattern());
388 Handle<String> error_message = isolate->factory()->NewStringFromUtf8(
394 Handle<FixedArray> data = Handle<FixedArray>(FixedArray::cast(re->data()));
436 void RegExpImpl::IrregexpInitialize(Handle<JSRegExp> re,
437 Handle<String> pattern,
449 int RegExpImpl::IrregexpPrepare(Handle<JSRegExp> regexp,
450 Handle<String> subject) {
472 int RegExpImpl::IrregexpExecRaw(Handle<JSRegExp> regexp,
473 Handle<String> subject,
479 Handle<FixedArray> irregexp(FixedArray::cast(regexp->data()), isolate);
491 Handle<Code> code(IrregexpNativeCode(*irregexp, is_one_byte), isolate);
516 // In this case, it means we must make sure we are prepared to handle
539 Handle<ByteArray> byte_codes(IrregexpByteCode(*irregexp, is_one_byte),
560 MaybeHandle<Object> RegExpImpl::IrregexpExec(Handle<JSRegExp> regexp,
561 Handle<String> subject,
563 Handle<JSArray> last_match_info) {
608 static void EnsureSize(Handle<JSArray> array, uint32_t minimum_size) {
615 Handle<JSArray> RegExpImpl::SetLastMatchInfo(Handle<JSArray> last_match_info,
616 Handle<String> subject,
637 RegExpImpl::GlobalCache::GlobalCache(Handle<JSRegExp> regexp,
638 Handle<String> subject,
961 Handle<String> pattern);
1042 // a fixed array or a null handle depending on whether it succeeded.
1067 Handle<String> pattern) {
1096 Handle<HeapObject> code = macro_assembler_->GetCode(pattern);
1103 Handle<Code>::cast(code)->Disassemble(pattern->ToCString().get(), os);
1635 // We handle the length > 1 case in a later pass.
1834 Handle<ByteArray> ba = factory->NewByteArray(kSize, TENURED);
2243 // generic versions above can handle deep recursion properly.
3029 // Emit the code to handle \b and \B (word-boundary or non-word-boundary).
3712 Handle<ByteArray> boolean_skip_table) {
3766 // The mask-compare can probably handle this better.
3788 Handle<ByteArray> boolean_skip_table = factory->NewByteArray(kSize, TENURED);
6262 bool is_global, bool is_multiline, bool is_sticky, Handle<String> pattern,
6263 Handle<String> sample_subject, bool is_one_byte) {
6397 bool RegExpEngine::TooMuchRegExpCode(Handle<String> pattern) {
6443 void RegExpResultsCache::Enter(Isolate* isolate, Handle<String> key_string,
6444 Handle<Object> key_pattern,
6445 Handle<FixedArray> value_array,
6446 Handle<FixedArray> last_match_cache,
6449 Handle<FixedArray> cache;
6492 Handle<String> str(String::cast(value_array->get(i)), isolate);
6493 Handle<String> internalized_str = factory->InternalizeString(str);
