static RegExpNode* Compile(const char* input, bool multiline, bool is_ascii) {
V8::Initialize(NULL);
- FlatStringReader reader(Isolate::Current(), CStrVector(input));
+ Isolate* isolate = Isolate::Current();
+ FlatStringReader reader(isolate, CStrVector(input));
RegExpCompileData compile_data;
if (!v8::internal::RegExpParser::ParseRegExp(&reader, multiline,
&compile_data))
return NULL;
- Handle<String> pattern = FACTORY->NewStringFromUtf8(CStrVector(input));
+ Handle<String> pattern = isolate->factory()->
+ NewStringFromUtf8(CStrVector(input));
RegExpEngine::Compile(&compile_data, false, multiline, pattern, is_ascii);
return compile_data.node;
}
TEST(MacroAssemblerNativeSuccess) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4);
m.Succeed();
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector(""));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector(""));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
int captures[4] = {42, 37, 87, 117};
- Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foofoo"));
+ Handle<String> input = factory->NewStringFromAscii(CStrVector("foofoo"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
const byte* start_adr =
reinterpret_cast<const byte*>(seq_input->GetCharsAddress());
TEST(MacroAssemblerNativeSimple) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4);
m.Bind(&fail);
m.Fail();
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^foo"));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector("^foo"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
int captures[4] = {42, 37, 87, 117};
- Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foofoo"));
+ Handle<String> input = factory->NewStringFromAscii(CStrVector("foofoo"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
CHECK_EQ(-1, captures[2]);
CHECK_EQ(-1, captures[3]);
- input = FACTORY->NewStringFromAscii(CStrVector("barbarbar"));
+ input = factory->NewStringFromAscii(CStrVector("barbarbar"));
seq_input = Handle<SeqAsciiString>::cast(input);
start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblerNativeSimpleUC16) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4);
m.Bind(&fail);
m.Fail();
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^foo"));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector("^foo"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
int captures[4] = {42, 37, 87, 117};
const uc16 input_data[6] = {'f', 'o', 'o', 'f', 'o', '\xa0'};
Handle<String> input =
- FACTORY->NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
+ factory->NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
CHECK_EQ(-1, captures[3]);
const uc16 input_data2[9] = {'b', 'a', 'r', 'b', 'a', 'r', 'b', 'a', '\xa0'};
- input = FACTORY->NewStringFromTwoByte(Vector<const uc16>(input_data2, 9));
+ input = factory->NewStringFromTwoByte(Vector<const uc16>(input_data2, 9));
seq_input = Handle<SeqTwoByteString>::cast(input);
start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblerNativeBacktrack) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0);
m.Bind(&backtrack);
m.Fail();
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector(".........."));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector(".........."));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
- Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foofoo"));
+ Handle<String> input = factory->NewStringFromAscii(CStrVector("foofoo"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblerNativeBackReferenceASCII) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4);
m.Bind(&missing_match);
m.Fail();
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^(..)..\1"));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector("^(..)..\1"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
- Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("fooofo"));
+ Handle<String> input = factory->NewStringFromAscii(CStrVector("fooofo"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblerNativeBackReferenceUC16) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4);
m.Bind(&missing_match);
m.Fail();
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^(..)..\1"));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector("^(..)..\1"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
const uc16 input_data[6] = {'f', 0x2028, 'o', 'o', 'f', 0x2028};
Handle<String> input =
- FACTORY->NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
+ factory->NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblernativeAtStart) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0);
m.CheckNotCharacter('b', &fail);
m.Succeed();
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("(^f|ob)"));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector("(^f|ob)"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
- Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foobar"));
+ Handle<String> input = factory->NewStringFromAscii(CStrVector("foobar"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblerNativeBackRefNoCase) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4);
m.Succeed();
Handle<String> source =
- FACTORY->NewStringFromAscii(CStrVector("^(abc)\1\1(?!\1)...(?!\1)"));
+ factory->NewStringFromAscii(CStrVector("^(abc)\1\1(?!\1)...(?!\1)"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
Handle<String> input =
- FACTORY->NewStringFromAscii(CStrVector("aBcAbCABCxYzab"));
+ factory->NewStringFromAscii(CStrVector("aBcAbCABCxYzab"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblerNativeRegisters) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Factory* factory = Isolate::Current()->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 6);
m.Fail();
Handle<String> source =
- FACTORY->NewStringFromAscii(CStrVector("<loop test>"));
+ factory->NewStringFromAscii(CStrVector("<loop test>"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
// String long enough for test (content doesn't matter).
Handle<String> input =
- FACTORY->NewStringFromAscii(CStrVector("foofoofoofoofoo"));
+ factory->NewStringFromAscii(CStrVector("foofoofoofoofoo"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
TEST(MacroAssemblerStackOverflow) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Isolate* isolate = Isolate::Current();
+ Factory* factory = isolate->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0);
m.GoTo(&loop);
Handle<String> source =
- FACTORY->NewStringFromAscii(CStrVector("<stack overflow test>"));
+ factory->NewStringFromAscii(CStrVector("<stack overflow test>"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
// String long enough for test (content doesn't matter).
Handle<String> input =
- FACTORY->NewStringFromAscii(CStrVector("dummy"));
+ factory->NewStringFromAscii(CStrVector("dummy"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
NULL);
CHECK_EQ(NativeRegExpMacroAssembler::EXCEPTION, result);
- CHECK(Isolate::Current()->has_pending_exception());
- Isolate::Current()->clear_pending_exception();
+ CHECK(isolate->has_pending_exception());
+ isolate->clear_pending_exception();
}
TEST(MacroAssemblerNativeLotsOfRegisters) {
v8::V8::Initialize();
ContextInitializer initializer;
+ Isolate* isolate = Isolate::Current();
+ Factory* factory = isolate->factory();
ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 2);
m.Succeed();
Handle<String> source =
- FACTORY->NewStringFromAscii(CStrVector("<huge register space test>"));
+ factory->NewStringFromAscii(CStrVector("<huge register space test>"));
Handle<Object> code_object = m.GetCode(source);
Handle<Code> code = Handle<Code>::cast(code_object);
// String long enough for test (content doesn't matter).
Handle<String> input =
- FACTORY->NewStringFromAscii(CStrVector("sample text"));
+ factory->NewStringFromAscii(CStrVector("sample text"));
Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
Address start_adr = seq_input->GetCharsAddress();
CHECK_EQ(0, captures[0]);
CHECK_EQ(42, captures[1]);
- Isolate::Current()->clear_pending_exception();
+ isolate->clear_pending_exception();
}
#else // V8_INTERPRETED_REGEXP
m.PopRegister(0);
m.Fail();
- v8::HandleScope scope;
+ Isolate* isolate = Isolate::Current();
+ Factory* factory = isolate->factory();
+ HandleScope scope(isolate);
- Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^f(o)o"));
+ Handle<String> source = factory->NewStringFromAscii(CStrVector("^f(o)o"));
Handle<ByteArray> array = Handle<ByteArray>::cast(m.GetCode(source));
int captures[5];
const uc16 str1[] = {'f', 'o', 'o', 'b', 'a', 'r'};
Handle<String> f1_16 =
- FACTORY->NewStringFromTwoByte(Vector<const uc16>(str1, 6));
+ factory->NewStringFromTwoByte(Vector<const uc16>(str1, 6));
- CHECK(IrregexpInterpreter::Match(array, f1_16, captures, 0));
+ CHECK(IrregexpInterpreter::Match(isolate, array, f1_16, captures, 0));
CHECK_EQ(0, captures[0]);
CHECK_EQ(3, captures[1]);
CHECK_EQ(1, captures[2]);
const uc16 str2[] = {'b', 'a', 'r', 'f', 'o', 'o'};
Handle<String> f2_16 =
- FACTORY->NewStringFromTwoByte(Vector<const uc16>(str2, 6));
+ factory->NewStringFromTwoByte(Vector<const uc16>(str2, 6));
- CHECK(!IrregexpInterpreter::Match(array, f2_16, captures, 0));
+ CHECK(!IrregexpInterpreter::Match(isolate, array, f2_16, captures, 0));
CHECK_EQ(42, captures[0]);
}