|
|
@ -2663,21 +2663,22 @@ class CompiledReplacement { |
|
|
void CompiledReplacement::Compile(Handle<String> replacement, |
|
|
void CompiledReplacement::Compile(Handle<String> replacement, |
|
|
int capture_count, |
|
|
int capture_count, |
|
|
int subject_length) { |
|
|
int subject_length) { |
|
|
ASSERT(replacement->IsFlat()); |
|
|
{ |
|
|
if (replacement->IsAsciiRepresentation()) { |
|
|
|
|
|
AssertNoAllocation no_alloc; |
|
|
|
|
|
ParseReplacementPattern(&parts_, |
|
|
|
|
|
replacement->ToAsciiVector(), |
|
|
|
|
|
capture_count, |
|
|
|
|
|
subject_length); |
|
|
|
|
|
} else { |
|
|
|
|
|
ASSERT(replacement->IsTwoByteRepresentation()); |
|
|
|
|
|
AssertNoAllocation no_alloc; |
|
|
AssertNoAllocation no_alloc; |
|
|
|
|
|
String::FlatContent content = replacement->GetFlatContent(); |
|
|
ParseReplacementPattern(&parts_, |
|
|
ASSERT(content.IsFlat()); |
|
|
replacement->ToUC16Vector(), |
|
|
if (content.IsAscii()) { |
|
|
capture_count, |
|
|
ParseReplacementPattern(&parts_, |
|
|
subject_length); |
|
|
content.ToAsciiVector(), |
|
|
|
|
|
capture_count, |
|
|
|
|
|
subject_length); |
|
|
|
|
|
} else { |
|
|
|
|
|
ASSERT(content.IsTwoByte()); |
|
|
|
|
|
ParseReplacementPattern(&parts_, |
|
|
|
|
|
content.ToUC16Vector(), |
|
|
|
|
|
capture_count, |
|
|
|
|
|
subject_length); |
|
|
|
|
|
} |
|
|
} |
|
|
} |
|
|
Isolate* isolate = replacement->GetIsolate(); |
|
|
Isolate* isolate = replacement->GetIsolate(); |
|
|
// Find substrings of replacement string and create them as String objects.
|
|
|
// Find substrings of replacement string and create them as String objects.
|
|
|
@ -3049,34 +3050,32 @@ int Runtime::StringMatch(Isolate* isolate, |
|
|
|
|
|
|
|
|
AssertNoAllocation no_heap_allocation; // ensure vectors stay valid
|
|
|
AssertNoAllocation no_heap_allocation; // ensure vectors stay valid
|
|
|
// Extract flattened substrings of cons strings before determining asciiness.
|
|
|
// Extract flattened substrings of cons strings before determining asciiness.
|
|
|
String* seq_sub = *sub; |
|
|
String::FlatContent seq_sub = sub->GetFlatContent(); |
|
|
if (seq_sub->IsConsString()) seq_sub = ConsString::cast(seq_sub)->first(); |
|
|
String::FlatContent seq_pat = pat->GetFlatContent(); |
|
|
String* seq_pat = *pat; |
|
|
|
|
|
if (seq_pat->IsConsString()) seq_pat = ConsString::cast(seq_pat)->first(); |
|
|
|
|
|
|
|
|
|
|
|
// dispatch on type of strings
|
|
|
// dispatch on type of strings
|
|
|
if (seq_pat->IsAsciiRepresentation()) { |
|
|
if (seq_pat.IsAscii()) { |
|
|
Vector<const char> pat_vector = seq_pat->ToAsciiVector(); |
|
|
Vector<const char> pat_vector = seq_pat.ToAsciiVector(); |
|
|
if (seq_sub->IsAsciiRepresentation()) { |
|
|
if (seq_sub.IsAscii()) { |
|
|
return SearchString(isolate, |
|
|
return SearchString(isolate, |
|
|
seq_sub->ToAsciiVector(), |
|
|
seq_sub.ToAsciiVector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} |
|
|
} |
|
|
return SearchString(isolate, |
|
|
return SearchString(isolate, |
|
|
seq_sub->ToUC16Vector(), |
|
|
seq_sub.ToUC16Vector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} |
|
|
} |
|
|
Vector<const uc16> pat_vector = seq_pat->ToUC16Vector(); |
|
|
Vector<const uc16> pat_vector = seq_pat.ToUC16Vector(); |
|
|
if (seq_sub->IsAsciiRepresentation()) { |
|
|
if (seq_sub.IsAscii()) { |
|
|
return SearchString(isolate, |
|
|
return SearchString(isolate, |
|
|
seq_sub->ToAsciiVector(), |
|
|
seq_sub.ToAsciiVector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} |
|
|
} |
|
|
return SearchString(isolate, |
|
|
return SearchString(isolate, |
|
|
seq_sub->ToUC16Vector(), |
|
|
seq_sub.ToUC16Vector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} |
|
|
} |
|
|
@ -3159,29 +3158,31 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StringLastIndexOf) { |
|
|
if (!sub->IsFlat()) FlattenString(sub); |
|
|
if (!sub->IsFlat()) FlattenString(sub); |
|
|
if (!pat->IsFlat()) FlattenString(pat); |
|
|
if (!pat->IsFlat()) FlattenString(pat); |
|
|
|
|
|
|
|
|
|
|
|
int position = -1; |
|
|
AssertNoAllocation no_heap_allocation; // ensure vectors stay valid
|
|
|
AssertNoAllocation no_heap_allocation; // ensure vectors stay valid
|
|
|
|
|
|
|
|
|
int position = -1; |
|
|
String::FlatContent sub_content = sub->GetFlatContent(); |
|
|
|
|
|
String::FlatContent pat_content = pat->GetFlatContent(); |
|
|
|
|
|
|
|
|
if (pat->IsAsciiRepresentation()) { |
|
|
if (pat_content.IsAscii()) { |
|
|
Vector<const char> pat_vector = pat->ToAsciiVector(); |
|
|
Vector<const char> pat_vector = pat_content.ToAsciiVector(); |
|
|
if (sub->IsAsciiRepresentation()) { |
|
|
if (sub_content.IsAscii()) { |
|
|
position = StringMatchBackwards(sub->ToAsciiVector(), |
|
|
position = StringMatchBackwards(sub_content.ToAsciiVector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} else { |
|
|
} else { |
|
|
position = StringMatchBackwards(sub->ToUC16Vector(), |
|
|
position = StringMatchBackwards(sub_content.ToUC16Vector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} |
|
|
} |
|
|
} else { |
|
|
} else { |
|
|
Vector<const uc16> pat_vector = pat->ToUC16Vector(); |
|
|
Vector<const uc16> pat_vector = pat_content.ToUC16Vector(); |
|
|
if (sub->IsAsciiRepresentation()) { |
|
|
if (sub_content.IsAscii()) { |
|
|
position = StringMatchBackwards(sub->ToAsciiVector(), |
|
|
position = StringMatchBackwards(sub_content.ToAsciiVector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} else { |
|
|
} else { |
|
|
position = StringMatchBackwards(sub->ToUC16Vector(), |
|
|
position = StringMatchBackwards(sub_content.ToUC16Vector(), |
|
|
pat_vector, |
|
|
pat_vector, |
|
|
start_index); |
|
|
start_index); |
|
|
} |
|
|
} |
|
|
@ -3399,36 +3400,38 @@ static bool SearchStringMultiple(Isolate* isolate, |
|
|
for (;;) { // Break when search complete.
|
|
|
for (;;) { // Break when search complete.
|
|
|
builder->EnsureCapacity(kMaxBuilderEntriesPerRegExpMatch); |
|
|
builder->EnsureCapacity(kMaxBuilderEntriesPerRegExpMatch); |
|
|
AssertNoAllocation no_gc; |
|
|
AssertNoAllocation no_gc; |
|
|
if (subject->IsAsciiRepresentation()) { |
|
|
String::FlatContent subject_content = subject->GetFlatContent(); |
|
|
Vector<const char> subject_vector = subject->ToAsciiVector(); |
|
|
String::FlatContent pattern_content = pattern->GetFlatContent(); |
|
|
if (pattern->IsAsciiRepresentation()) { |
|
|
if (subject_content.IsAscii()) { |
|
|
|
|
|
Vector<const char> subject_vector = subject_content.ToAsciiVector(); |
|
|
|
|
|
if (pattern_content.IsAscii()) { |
|
|
if (SearchStringMultiple(isolate, |
|
|
if (SearchStringMultiple(isolate, |
|
|
subject_vector, |
|
|
subject_vector, |
|
|
pattern->ToAsciiVector(), |
|
|
pattern_content.ToAsciiVector(), |
|
|
*pattern, |
|
|
*pattern, |
|
|
builder, |
|
|
builder, |
|
|
&match_pos)) break; |
|
|
&match_pos)) break; |
|
|
} else { |
|
|
} else { |
|
|
if (SearchStringMultiple(isolate, |
|
|
if (SearchStringMultiple(isolate, |
|
|
subject_vector, |
|
|
subject_vector, |
|
|
pattern->ToUC16Vector(), |
|
|
pattern_content.ToUC16Vector(), |
|
|
*pattern, |
|
|
*pattern, |
|
|
builder, |
|
|
builder, |
|
|
&match_pos)) break; |
|
|
&match_pos)) break; |
|
|
} |
|
|
} |
|
|
} else { |
|
|
} else { |
|
|
Vector<const uc16> subject_vector = subject->ToUC16Vector(); |
|
|
Vector<const uc16> subject_vector = subject_content.ToUC16Vector(); |
|
|
if (pattern->IsAsciiRepresentation()) { |
|
|
if (pattern_content.IsAscii()) { |
|
|
if (SearchStringMultiple(isolate, |
|
|
if (SearchStringMultiple(isolate, |
|
|
subject_vector, |
|
|
subject_vector, |
|
|
pattern->ToAsciiVector(), |
|
|
pattern_content.ToAsciiVector(), |
|
|
*pattern, |
|
|
*pattern, |
|
|
builder, |
|
|
builder, |
|
|
&match_pos)) break; |
|
|
&match_pos)) break; |
|
|
} else { |
|
|
} else { |
|
|
if (SearchStringMultiple(isolate, |
|
|
if (SearchStringMultiple(isolate, |
|
|
subject_vector, |
|
|
subject_vector, |
|
|
pattern->ToUC16Vector(), |
|
|
pattern_content.ToUC16Vector(), |
|
|
*pattern, |
|
|
*pattern, |
|
|
builder, |
|
|
builder, |
|
|
&match_pos)) break; |
|
|
&match_pos)) break; |
|
|
@ -5416,12 +5419,14 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_QuoteJSONString) { |
|
|
str = String::cast(flat); |
|
|
str = String::cast(flat); |
|
|
ASSERT(str->IsFlat()); |
|
|
ASSERT(str->IsFlat()); |
|
|
} |
|
|
} |
|
|
if (str->IsTwoByteRepresentation()) { |
|
|
String::FlatContent flat = str->GetFlatContent(); |
|
|
|
|
|
ASSERT(flat.IsFlat()); |
|
|
|
|
|
if (flat.IsTwoByte()) { |
|
|
return QuoteJsonString<uc16, SeqTwoByteString, false>(isolate, |
|
|
return QuoteJsonString<uc16, SeqTwoByteString, false>(isolate, |
|
|
str->ToUC16Vector()); |
|
|
flat.ToUC16Vector()); |
|
|
} else { |
|
|
} else { |
|
|
return QuoteJsonString<char, SeqAsciiString, false>(isolate, |
|
|
return QuoteJsonString<char, SeqAsciiString, false>(isolate, |
|
|
str->ToAsciiVector()); |
|
|
flat.ToAsciiVector()); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
@ -5438,12 +5443,13 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_QuoteJSONStringComma) { |
|
|
str = String::cast(flat); |
|
|
str = String::cast(flat); |
|
|
ASSERT(str->IsFlat()); |
|
|
ASSERT(str->IsFlat()); |
|
|
} |
|
|
} |
|
|
if (str->IsTwoByteRepresentation()) { |
|
|
String::FlatContent flat = str->GetFlatContent(); |
|
|
|
|
|
if (flat.IsTwoByte()) { |
|
|
return QuoteJsonString<uc16, SeqTwoByteString, true>(isolate, |
|
|
return QuoteJsonString<uc16, SeqTwoByteString, true>(isolate, |
|
|
str->ToUC16Vector()); |
|
|
flat.ToUC16Vector()); |
|
|
} else { |
|
|
} else { |
|
|
return QuoteJsonString<char, SeqAsciiString, true>(isolate, |
|
|
return QuoteJsonString<char, SeqAsciiString, true>(isolate, |
|
|
str->ToAsciiVector()); |
|
|
flat.ToAsciiVector()); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
@ -5478,14 +5484,16 @@ static MaybeObject* QuoteJsonStringArray(Isolate* isolate, |
|
|
for (int i = 0; i < length; i++) { |
|
|
for (int i = 0; i < length; i++) { |
|
|
if (i != 0) *(write_cursor++) = ','; |
|
|
if (i != 0) *(write_cursor++) = ','; |
|
|
String* str = String::cast(array->get(i)); |
|
|
String* str = String::cast(array->get(i)); |
|
|
if (str->IsTwoByteRepresentation()) { |
|
|
String::FlatContent content = str->GetFlatContent(); |
|
|
|
|
|
ASSERT(content.IsFlat()); |
|
|
|
|
|
if (content.IsTwoByte()) { |
|
|
write_cursor = WriteQuoteJsonString<Char, uc16>(isolate, |
|
|
write_cursor = WriteQuoteJsonString<Char, uc16>(isolate, |
|
|
write_cursor, |
|
|
write_cursor, |
|
|
str->ToUC16Vector()); |
|
|
content.ToUC16Vector()); |
|
|
} else { |
|
|
} else { |
|
|
write_cursor = WriteQuoteJsonString<Char, char>(isolate, |
|
|
write_cursor = WriteQuoteJsonString<Char, char>(isolate, |
|
|
write_cursor, |
|
|
write_cursor, |
|
|
str->ToAsciiVector()); |
|
|
content.ToAsciiVector()); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
*(write_cursor++) = ']'; |
|
|
*(write_cursor++) = ']'; |
|
|
@ -5964,11 +5972,15 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StringSplit) { |
|
|
|
|
|
|
|
|
// No allocation block.
|
|
|
// No allocation block.
|
|
|
{ |
|
|
{ |
|
|
AssertNoAllocation nogc; |
|
|
AssertNoAllocation no_gc; |
|
|
if (subject->IsAsciiRepresentation()) { |
|
|
String::FlatContent subject_content = subject->GetFlatContent(); |
|
|
Vector<const char> subject_vector = subject->ToAsciiVector(); |
|
|
String::FlatContent pattern_content = pattern->GetFlatContent(); |
|
|
if (pattern->IsAsciiRepresentation()) { |
|
|
ASSERT(subject_content.IsFlat()); |
|
|
Vector<const char> pattern_vector = pattern->ToAsciiVector(); |
|
|
ASSERT(pattern_content.IsFlat()); |
|
|
|
|
|
if (subject_content.IsAscii()) { |
|
|
|
|
|
Vector<const char> subject_vector = subject_content.ToAsciiVector(); |
|
|
|
|
|
if (pattern_content.IsAscii()) { |
|
|
|
|
|
Vector<const char> pattern_vector = pattern_content.ToAsciiVector(); |
|
|
if (pattern_vector.length() == 1) { |
|
|
if (pattern_vector.length() == 1) { |
|
|
FindAsciiStringIndices(subject_vector, |
|
|
FindAsciiStringIndices(subject_vector, |
|
|
pattern_vector[0], |
|
|
pattern_vector[0], |
|
|
@ -5984,22 +5996,22 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StringSplit) { |
|
|
} else { |
|
|
} else { |
|
|
FindStringIndices(isolate, |
|
|
FindStringIndices(isolate, |
|
|
subject_vector, |
|
|
subject_vector, |
|
|
pattern->ToUC16Vector(), |
|
|
pattern_content.ToUC16Vector(), |
|
|
&indices, |
|
|
&indices, |
|
|
limit); |
|
|
limit); |
|
|
} |
|
|
} |
|
|
} else { |
|
|
} else { |
|
|
Vector<const uc16> subject_vector = subject->ToUC16Vector(); |
|
|
Vector<const uc16> subject_vector = subject_content.ToUC16Vector(); |
|
|
if (pattern->IsAsciiRepresentation()) { |
|
|
if (pattern->IsAsciiRepresentation()) { |
|
|
FindStringIndices(isolate, |
|
|
FindStringIndices(isolate, |
|
|
subject_vector, |
|
|
subject_vector, |
|
|
pattern->ToAsciiVector(), |
|
|
pattern_content.ToAsciiVector(), |
|
|
&indices, |
|
|
&indices, |
|
|
limit); |
|
|
limit); |
|
|
} else { |
|
|
} else { |
|
|
FindStringIndices(isolate, |
|
|
FindStringIndices(isolate, |
|
|
subject_vector, |
|
|
subject_vector, |
|
|
pattern->ToUC16Vector(), |
|
|
pattern_content.ToUC16Vector(), |
|
|
&indices, |
|
|
&indices, |
|
|
limit); |
|
|
limit); |
|
|
} |
|
|
} |
|
|
@ -6048,7 +6060,7 @@ static int CopyCachedAsciiCharsToArray(Heap* heap, |
|
|
const char* chars, |
|
|
const char* chars, |
|
|
FixedArray* elements, |
|
|
FixedArray* elements, |
|
|
int length) { |
|
|
int length) { |
|
|
AssertNoAllocation nogc; |
|
|
AssertNoAllocation no_gc; |
|
|
FixedArray* ascii_cache = heap->single_character_string_cache(); |
|
|
FixedArray* ascii_cache = heap->single_character_string_cache(); |
|
|
Object* undefined = heap->undefined_value(); |
|
|
Object* undefined = heap->undefined_value(); |
|
|
int i; |
|
|
int i; |
|
|
@ -6081,36 +6093,39 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StringToArray) { |
|
|
CONVERT_ARG_CHECKED(String, s, 0); |
|
|
CONVERT_ARG_CHECKED(String, s, 0); |
|
|
CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[1]); |
|
|
CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[1]); |
|
|
|
|
|
|
|
|
s->TryFlatten(); |
|
|
s = FlattenGetString(s); |
|
|
const int length = static_cast<int>(Min<uint32_t>(s->length(), limit)); |
|
|
const int length = static_cast<int>(Min<uint32_t>(s->length(), limit)); |
|
|
|
|
|
|
|
|
Handle<FixedArray> elements; |
|
|
Handle<FixedArray> elements; |
|
|
|
|
|
int position = 0; |
|
|
if (s->IsFlat() && s->IsAsciiRepresentation()) { |
|
|
if (s->IsFlat() && s->IsAsciiRepresentation()) { |
|
|
|
|
|
// Try using cached chars where possible.
|
|
|
Object* obj; |
|
|
Object* obj; |
|
|
{ MaybeObject* maybe_obj = |
|
|
{ MaybeObject* maybe_obj = |
|
|
isolate->heap()->AllocateUninitializedFixedArray(length); |
|
|
isolate->heap()->AllocateUninitializedFixedArray(length); |
|
|
if (!maybe_obj->ToObject(&obj)) return maybe_obj; |
|
|
if (!maybe_obj->ToObject(&obj)) return maybe_obj; |
|
|
} |
|
|
} |
|
|
elements = Handle<FixedArray>(FixedArray::cast(obj), isolate); |
|
|
elements = Handle<FixedArray>(FixedArray::cast(obj), isolate); |
|
|
|
|
|
String::FlatContent content = s->GetFlatContent(); |
|
|
Vector<const char> chars = s->ToAsciiVector(); |
|
|
if (content.IsAscii()) { |
|
|
// Note, this will initialize all elements (not only the prefix)
|
|
|
Vector<const char> chars = content.ToAsciiVector(); |
|
|
// to prevent GC from seeing partially initialized array.
|
|
|
// Note, this will initialize all elements (not only the prefix)
|
|
|
int num_copied_from_cache = CopyCachedAsciiCharsToArray(isolate->heap(), |
|
|
// to prevent GC from seeing partially initialized array.
|
|
|
chars.start(), |
|
|
position = CopyCachedAsciiCharsToArray(isolate->heap(), |
|
|
*elements, |
|
|
chars.start(), |
|
|
length); |
|
|
*elements, |
|
|
|
|
|
length); |
|
|
for (int i = num_copied_from_cache; i < length; ++i) { |
|
|
} else { |
|
|
Handle<Object> str = LookupSingleCharacterStringFromCode(chars[i]); |
|
|
MemsetPointer(elements->data_start(), |
|
|
elements->set(i, *str); |
|
|
isolate->heap()->undefined_value(), |
|
|
|
|
|
length); |
|
|
} |
|
|
} |
|
|
} else { |
|
|
} else { |
|
|
elements = isolate->factory()->NewFixedArray(length); |
|
|
elements = isolate->factory()->NewFixedArray(length); |
|
|
for (int i = 0; i < length; ++i) { |
|
|
} |
|
|
Handle<Object> str = LookupSingleCharacterStringFromCode(s->Get(i)); |
|
|
for (int i = position; i < length; ++i) { |
|
|
elements->set(i, *str); |
|
|
Handle<Object> str = LookupSingleCharacterStringFromCode(s->Get(i)); |
|
|
} |
|
|
elements->set(i, *str); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
#ifdef DEBUG |
|
|
#ifdef DEBUG |
|
|
@ -6921,22 +6936,24 @@ static Object* FlatStringCompare(String* x, String* y) { |
|
|
equal_prefix_result = Smi::FromInt(LESS); |
|
|
equal_prefix_result = Smi::FromInt(LESS); |
|
|
} |
|
|
} |
|
|
int r; |
|
|
int r; |
|
|
if (x->IsAsciiRepresentation()) { |
|
|
String::FlatContent x_content = x->GetFlatContent(); |
|
|
Vector<const char> x_chars = x->ToAsciiVector(); |
|
|
String::FlatContent y_content = y->GetFlatContent(); |
|
|
if (y->IsAsciiRepresentation()) { |
|
|
if (x_content.IsAscii()) { |
|
|
Vector<const char> y_chars = y->ToAsciiVector(); |
|
|
Vector<const char> x_chars = x_content.ToAsciiVector(); |
|
|
|
|
|
if (y_content.IsAscii()) { |
|
|
|
|
|
Vector<const char> y_chars = y_content.ToAsciiVector(); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
} else { |
|
|
} else { |
|
|
Vector<const uc16> y_chars = y->ToUC16Vector(); |
|
|
Vector<const uc16> y_chars = y_content.ToUC16Vector(); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
} |
|
|
} |
|
|
} else { |
|
|
} else { |
|
|
Vector<const uc16> x_chars = x->ToUC16Vector(); |
|
|
Vector<const uc16> x_chars = x_content.ToUC16Vector(); |
|
|
if (y->IsAsciiRepresentation()) { |
|
|
if (y_content.IsAscii()) { |
|
|
Vector<const char> y_chars = y->ToAsciiVector(); |
|
|
Vector<const char> y_chars = y_content.ToAsciiVector(); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
} else { |
|
|
} else { |
|
|
Vector<const uc16> y_chars = y->ToUC16Vector(); |
|
|
Vector<const uc16> y_chars = y_content.ToUC16Vector(); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
r = CompareChars(x_chars.start(), y_chars.start(), prefix_length); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
@ -8817,13 +8834,14 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DateParseString) { |
|
|
FixedArray* output_array = FixedArray::cast(output->elements()); |
|
|
FixedArray* output_array = FixedArray::cast(output->elements()); |
|
|
RUNTIME_ASSERT(output_array->length() >= DateParser::OUTPUT_SIZE); |
|
|
RUNTIME_ASSERT(output_array->length() >= DateParser::OUTPUT_SIZE); |
|
|
bool result; |
|
|
bool result; |
|
|
if (str->IsAsciiRepresentation()) { |
|
|
String::FlatContent str_content = str->GetFlatContent(); |
|
|
result = DateParser::Parse(str->ToAsciiVector(), |
|
|
if (str_content.IsAscii()) { |
|
|
|
|
|
result = DateParser::Parse(str_content.ToAsciiVector(), |
|
|
output_array, |
|
|
output_array, |
|
|
isolate->unicode_cache()); |
|
|
isolate->unicode_cache()); |
|
|
} else { |
|
|
} else { |
|
|
ASSERT(str->IsTwoByteRepresentation()); |
|
|
ASSERT(str_content.IsTwoByte()); |
|
|
result = DateParser::Parse(str->ToUC16Vector(), |
|
|
result = DateParser::Parse(str_content.ToUC16Vector(), |
|
|
output_array, |
|
|
output_array, |
|
|
isolate->unicode_cache()); |
|
|
isolate->unicode_cache()); |
|
|
} |
|
|
} |
|
|
@ -12803,7 +12821,9 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_Log) { |
|
|
ASSERT(args.length() == 2); |
|
|
ASSERT(args.length() == 2); |
|
|
CONVERT_CHECKED(String, format, args[0]); |
|
|
CONVERT_CHECKED(String, format, args[0]); |
|
|
CONVERT_CHECKED(JSArray, elms, args[1]); |
|
|
CONVERT_CHECKED(JSArray, elms, args[1]); |
|
|
Vector<const char> chars = format->ToAsciiVector(); |
|
|
String::FlatContent format_content = format->GetFlatContent(); |
|
|
|
|
|
RUNTIME_ASSERT(format_content.IsAscii()); |
|
|
|
|
|
Vector<const char> chars = format_content.ToAsciiVector(); |
|
|
LOGGER->LogRuntime(chars, elms); |
|
|
LOGGER->LogRuntime(chars, elms); |
|
|
return isolate->heap()->undefined_value(); |
|
|
return isolate->heap()->undefined_value(); |
|
|
} |
|
|
} |
|
|
|
Ryan Dahl
14 years ago