vendor/v8/test/cctest/test-regexp.cc in mustang-0.0.1 vs vendor/v8/test/cctest/test-regexp.cc in mustang-0.1.0
- old
+ new
@@ -43,10 +43,14 @@
#else // V8_INTERPRETED_REGEXP
#ifdef V8_TARGET_ARCH_ARM
#include "arm/macro-assembler-arm.h"
#include "arm/regexp-macro-assembler-arm.h"
#endif
+#ifdef V8_TARGET_ARCH_MIPS
+#include "mips/macro-assembler-mips.h"
+#include "mips/regexp-macro-assembler-mips.h"
+#endif
#ifdef V8_TARGET_ARCH_X64
#include "x64/macro-assembler-x64.h"
#include "x64/regexp-macro-assembler-x64.h"
#endif
#ifdef V8_TARGET_ARCH_IA32
@@ -60,21 +64,21 @@
static bool CheckParse(const char* input) {
V8::Initialize(NULL);
v8::HandleScope scope;
ZoneScope zone_scope(DELETE_ON_EXIT);
- FlatStringReader reader(CStrVector(input));
+ FlatStringReader reader(Isolate::Current(), CStrVector(input));
RegExpCompileData result;
return v8::internal::RegExpParser::ParseRegExp(&reader, false, &result);
}
static SmartPointer<const char> Parse(const char* input) {
V8::Initialize(NULL);
v8::HandleScope scope;
ZoneScope zone_scope(DELETE_ON_EXIT);
- FlatStringReader reader(CStrVector(input));
+ FlatStringReader reader(Isolate::Current(), CStrVector(input));
RegExpCompileData result;
CHECK(v8::internal::RegExpParser::ParseRegExp(&reader, false, &result));
CHECK(result.tree != NULL);
CHECK(result.error.is_null());
SmartPointer<const char> output = result.tree->ToString();
@@ -84,11 +88,11 @@
static bool CheckSimple(const char* input) {
V8::Initialize(NULL);
v8::HandleScope scope;
unibrow::Utf8InputBuffer<> buffer(input, StrLength(input));
ZoneScope zone_scope(DELETE_ON_EXIT);
- FlatStringReader reader(CStrVector(input));
+ FlatStringReader reader(Isolate::Current(), CStrVector(input));
RegExpCompileData result;
CHECK(v8::internal::RegExpParser::ParseRegExp(&reader, false, &result));
CHECK(result.tree != NULL);
CHECK(result.error.is_null());
return result.simple;
@@ -102,11 +106,11 @@
static MinMaxPair CheckMinMaxMatch(const char* input) {
V8::Initialize(NULL);
v8::HandleScope scope;
unibrow::Utf8InputBuffer<> buffer(input, StrLength(input));
ZoneScope zone_scope(DELETE_ON_EXIT);
- FlatStringReader reader(CStrVector(input));
+ FlatStringReader reader(Isolate::Current(), CStrVector(input));
RegExpCompileData result;
CHECK(v8::internal::RegExpParser::ParseRegExp(&reader, false, &result));
CHECK(result.tree != NULL);
CHECK(result.error.is_null());
int min_match = result.tree->min_match();
@@ -373,11 +377,11 @@
static void ExpectError(const char* input,
const char* expected) {
V8::Initialize(NULL);
v8::HandleScope scope;
ZoneScope zone_scope(DELETE_ON_EXIT);
- FlatStringReader reader(CStrVector(input));
+ FlatStringReader reader(Isolate::Current(), CStrVector(input));
RegExpCompileData result;
CHECK(!v8::internal::RegExpParser::ParseRegExp(&reader, false, &result));
CHECK(result.tree == NULL);
CHECK(!result.error.is_null());
SmartPointer<char> str = result.error->ToCString(ALLOW_NULLS);
@@ -469,10 +473,11 @@
}
}
TEST(CharacterClassEscapes) {
+ v8::internal::V8::Initialize(NULL);
TestCharacterClassEscapes('.', IsRegExpNewline);
TestCharacterClassEscapes('d', IsDigit);
TestCharacterClassEscapes('D', NotDigit);
TestCharacterClassEscapes('s', IsWhiteSpace);
TestCharacterClassEscapes('S', NotWhiteSpace);
@@ -481,16 +486,16 @@
}
static RegExpNode* Compile(const char* input, bool multiline, bool is_ascii) {
V8::Initialize(NULL);
- FlatStringReader reader(CStrVector(input));
+ FlatStringReader reader(Isolate::Current(), 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 = FACTORY->NewStringFromUtf8(CStrVector(input));
RegExpEngine::Compile(&compile_data, false, multiline, pattern, is_ascii);
return compile_data.node;
}
@@ -536,10 +541,11 @@
return ~(~((i * 781) ^ (j * 329)));
}
TEST(SplayTreeSimple) {
+ v8::internal::V8::Initialize(NULL);
static const unsigned kLimit = 1000;
ZoneScope zone_scope(DELETE_ON_EXIT);
ZoneSplayTree<TestConfig> tree;
bool seen[kLimit];
for (unsigned i = 0; i < kLimit; i++) seen[i] = false;
@@ -588,10 +594,11 @@
}
}
TEST(DispatchTableConstruction) {
+ v8::internal::V8::Initialize(NULL);
// Initialize test data.
static const int kLimit = 1000;
static const int kRangeCount = 8;
static const int kRangeSize = 16;
uc16 ranges[kRangeCount][2 * kRangeSize];
@@ -665,17 +672,17 @@
#elif V8_TARGET_ARCH_X64
typedef RegExpMacroAssemblerX64 ArchRegExpMacroAssembler;
#elif V8_TARGET_ARCH_ARM
typedef RegExpMacroAssemblerARM ArchRegExpMacroAssembler;
#elif V8_TARGET_ARCH_MIPS
-typedef RegExpMacroAssembler ArchRegExpMacroAssembler;
+typedef RegExpMacroAssemblerMIPS ArchRegExpMacroAssembler;
#endif
class ContextInitializer {
public:
ContextInitializer()
- : env_(), scope_(), zone_(DELETE_ON_EXIT), stack_guard_() {
+ : env_(), scope_(), zone_(DELETE_ON_EXIT) {
env_ = v8::Context::New();
env_->Enter();
}
~ContextInitializer() {
env_->Exit();
@@ -683,11 +690,10 @@
}
private:
v8::Persistent<v8::Context> env_;
v8::HandleScope scope_;
v8::internal::ZoneScope zone_;
- v8::internal::StackGuard stack_guard_;
};
static ArchRegExpMacroAssembler::Result Execute(Code* code,
String* input,
@@ -699,11 +705,12 @@
code,
input,
start_offset,
input_start,
input_end,
- captures);
+ captures,
+ Isolate::Current());
}
TEST(MacroAssemblerNativeSuccess) {
v8::V8::Initialize();
@@ -711,16 +718,16 @@
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());
NativeRegExpMacroAssembler::Result result =
@@ -755,16 +762,16 @@
m.WriteCurrentPositionToRegister(1, 0);
m.Succeed();
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();
NativeRegExpMacroAssembler::Result result =
Execute(*code,
@@ -778,11 +785,11 @@
CHECK_EQ(0, captures[0]);
CHECK_EQ(3, captures[1]);
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();
result = Execute(*code,
*input,
@@ -811,18 +818,18 @@
m.WriteCurrentPositionToRegister(1, 0);
m.Succeed();
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();
NativeRegExpMacroAssembler::Result result =
Execute(*code,
@@ -837,11 +844,11 @@
CHECK_EQ(3, captures[1]);
CHECK_EQ(-1, captures[2]);
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();
result = Execute(*code,
*input,
@@ -869,15 +876,15 @@
m.LoadCurrentCharacter(10, NULL);
m.Succeed();
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();
NativeRegExpMacroAssembler::Result result =
Execute(*code,
@@ -910,15 +917,15 @@
m.WriteCurrentPositionToRegister(2, 0);
m.Succeed();
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();
int output[4];
NativeRegExpMacroAssembler::Result result =
@@ -956,17 +963,17 @@
m.WriteCurrentPositionToRegister(2, 0);
m.Succeed();
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();
int output[4];
NativeRegExpMacroAssembler::Result result =
@@ -1011,15 +1018,15 @@
m.Bind(&prevo);
m.LoadCurrentCharacter(0, &fail);
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();
NativeRegExpMacroAssembler::Result result =
Execute(*code,
@@ -1069,16 +1076,16 @@
m.Bind(&succ);
m.WriteCurrentPositionToRegister(1, 0);
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();
int output[4];
NativeRegExpMacroAssembler::Result result =
@@ -1167,17 +1174,17 @@
m.Bind(&fail);
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();
int output[6];
NativeRegExpMacroAssembler::Result result =
@@ -1208,17 +1215,17 @@
m.Bind(&loop);
m.PushBacktrack(&loop);
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();
NativeRegExpMacroAssembler::Result result =
Execute(*code,
@@ -1227,12 +1234,12 @@
start_adr,
start_adr + input->length(),
NULL);
CHECK_EQ(NativeRegExpMacroAssembler::EXCEPTION, result);
- CHECK(Top::has_pending_exception());
- Top::clear_pending_exception();
+ CHECK(Isolate::Current()->has_pending_exception());
+ Isolate::Current()->clear_pending_exception();
}
TEST(MacroAssemblerNativeLotsOfRegisters) {
v8::V8::Initialize();
@@ -1252,17 +1259,17 @@
m.PushRegister(large_number, RegExpMacroAssembler::kNoStackLimitCheck);
m.PopRegister(1);
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();
int captures[2];
NativeRegExpMacroAssembler::Result result =
@@ -1275,11 +1282,11 @@
CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result);
CHECK_EQ(0, captures[0]);
CHECK_EQ(42, captures[1]);
- Top::clear_pending_exception();
+ Isolate::Current()->clear_pending_exception();
}
#else // V8_INTERPRETED_REGEXP
TEST(MacroAssembler) {
@@ -1320,37 +1327,38 @@
m.PopRegister(0);
m.Fail();
v8::HandleScope scope;
- 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_EQ(0, captures[0]);
CHECK_EQ(3, captures[1]);
CHECK_EQ(1, captures[2]);
CHECK_EQ(2, captures[3]);
CHECK_EQ(84, captures[4]);
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_EQ(42, captures[0]);
}
#endif // V8_INTERPRETED_REGEXP
TEST(AddInverseToTable) {
+ v8::internal::V8::Initialize(NULL);
static const int kLimit = 1000;
static const int kRangeCount = 16;
for (int t = 0; t < 10; t++) {
ZoneScope zone_scope(DELETE_ON_EXIT);
ZoneList<CharacterRange>* ranges =
@@ -1505,10 +1513,11 @@
TestRangeCaseIndependence(input, vector);
}
TEST(CharacterRangeCaseIndependence) {
+ v8::internal::V8::Initialize(NULL);
TestSimpleRangeCaseIndependence(CharacterRange::Singleton('a'),
CharacterRange::Singleton('A'));
TestSimpleRangeCaseIndependence(CharacterRange::Singleton('z'),
CharacterRange::Singleton('Z'));
TestSimpleRangeCaseIndependence(CharacterRange('a', 'z'),
@@ -1546,10 +1555,11 @@
return false;
}
TEST(CharClassDifference) {
+ v8::internal::V8::Initialize(NULL);
ZoneScope zone_scope(DELETE_ON_EXIT);
ZoneList<CharacterRange>* base = new ZoneList<CharacterRange>(1);
base->Add(CharacterRange::Everything());
Vector<const uc16> overlay = CharacterRange::GetWordBounds();
ZoneList<CharacterRange>* included = NULL;
@@ -1572,10 +1582,11 @@
}
}
TEST(CanonicalizeCharacterSets) {
+ v8::internal::V8::Initialize(NULL);
ZoneScope scope(DELETE_ON_EXIT);
ZoneList<CharacterRange>* list = new ZoneList<CharacterRange>(4);
CharacterSet set(list);
list->Add(CharacterRange(10, 20));
@@ -1642,9 +1653,10 @@
}
return false;
}
TEST(CharacterRangeMerge) {
+ v8::internal::V8::Initialize(NULL);
ZoneScope zone_scope(DELETE_ON_EXIT);
ZoneList<CharacterRange> l1(4);
ZoneList<CharacterRange> l2(4);
// Create all combinations of intersections of ranges, both singletons and
// longer.