Tentative implementation of string slices (hidden under the flag --string-slices).

src/jsregexp.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 218 matching lines @@
                                     Handle<String> subject,
                                     int index,
                                     Handle<JSArray> last_match_info) {
   Isolate* isolate = re->GetIsolate();
 
   ASSERT(0 <= index);
   ASSERT(index <= subject->length());
 
   if (!subject->IsFlat()) FlattenString(subject);
   AssertNoAllocation no_heap_allocation;  // ensure vectors stay valid
   // Extract flattened substrings of cons strings before determining asciiness.

[Vitaly Repeshko, 2011/08/17 19:20:23]

Update the comment.

-  String* seq_sub = *subject;
-  if (seq_sub->IsConsString()) seq_sub = ConsString::cast(seq_sub)->first();
+  String* seq_sub = StringShape(*subject).IsIndirect()
+                    ? subject->GetIndirect()
+                    : *subject;
 
   String* needle = String::cast(re->DataAt(JSRegExp::kAtomPatternIndex));
   int needle_len = needle->length();
 
   if (needle_len != 0) {
     if (index + needle_len > subject->length())
         return isolate->factory()->null_value();
 
     // dispatch on type of strings
     index = (needle->IsAsciiRepresentation()
              ? (seq_sub->IsAsciiRepresentation()
                 ? SearchString(isolate,
-                               seq_sub->ToAsciiVector(),
+                               subject->ToAsciiVector(),

[Vitaly Repeshko, 2011/08/17 19:20:23]

To{Ascii,UC16}Vector won't work in case an indirect string encoding disagrees
with its underlying string encoding.

[Yang, 2011/08/18 12:17:32]

I solved this by changing the assertion in both ToAsciiVector and ToUC16Vector
to consider indirect strings.

                                needle->ToAsciiVector(),
                                index)
                 : SearchString(isolate,
-                               seq_sub->ToUC16Vector(),
+                               subject->ToUC16Vector(),
                                needle->ToAsciiVector(),
                                index))
              : (seq_sub->IsAsciiRepresentation()
                 ? SearchString(isolate,
-                               seq_sub->ToAsciiVector(),
+                               subject->ToAsciiVector(),
                                needle->ToUC16Vector(),
                                index)
                 : SearchString(isolate,
-                               seq_sub->ToUC16Vector(),
+                               subject->ToUC16Vector(),
                                needle->ToUC16Vector(),
                                index)));
     if (index == -1) return FACTORY->null_value();
   }
   ASSERT(last_match_info->HasFastElements());
 
   {
     NoHandleAllocation no_handles;
     FixedArray* array = FixedArray::cast(last_match_info->elements());
     SetAtomLastCapture(array, *subject, index, index + needle_len);
@@ skipping 70 matching lines @@
     Object* error_string = re->DataAt(JSRegExp::saved_code_index(is_ascii));
     ASSERT(error_string->IsString());
     Handle<String> error_message(String::cast(error_string));
     CreateRegExpErrorObjectAndThrow(re, is_ascii, error_message, isolate);
     return false;
   }
 
   JSRegExp::Flags flags = re->GetFlags();
 
   Handle<String> pattern(re->Pattern());
-  if (!pattern->IsFlat()) {
-    FlattenString(pattern);
-  }
-
+  if (!pattern->IsFlat()) FlattenString(pattern);
   RegExpCompileData compile_data;
   FlatStringReader reader(isolate, pattern);
   if (!RegExpParser::ParseRegExp(&reader, flags.is_multiline(),
                                  &compile_data)) {
     // Throw an exception if we fail to parse the pattern.
     // THIS SHOULD NOT HAPPEN. We already pre-parsed it successfully once.
     ThrowRegExpException(re,
                          pattern,
                          compile_data.error,
                          "malformed_regexp");
@@ skipping 63 matching lines @@
   re->GetIsolate()->factory()->SetRegExpIrregexpData(re,
                                                      JSRegExp::IRREGEXP,
                                                      pattern,
                                                      flags,
                                                      capture_count);
 }
 
 
 int RegExpImpl::IrregexpPrepare(Handle<JSRegExp> regexp,
                                 Handle<String> subject) {
-  if (!subject->IsFlat()) {
-    FlattenString(subject);
-  }
+  if (!subject->IsFlat()) FlattenString(subject);
+
   // Check the asciiness of the underlying storage.
   bool is_ascii;
   {
     AssertNoAllocation no_gc;
-    String* sequential_string = *subject;
-    if (subject->IsConsString()) {
-      sequential_string = ConsString::cast(*subject)->first();
-    }
+    String* sequential_string = StringShape(*subject).IsIndirect()
+                                ? subject->GetIndirect()
+                                : *subject;
     is_ascii = sequential_string->IsAsciiRepresentation();
   }
   if (!EnsureCompiledIrregexp(regexp, is_ascii)) {
     return -1;
   }
 #ifdef V8_INTERPRETED_REGEXP
   // Byte-code regexp needs space allocated for all its registers.
   return IrregexpNumberOfRegisters(FixedArray::cast(regexp->data()));
 #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
 }
 
 
 RegExpImpl::IrregexpResult RegExpImpl::IrregexpExecOnce(
     Handle<JSRegExp> regexp,
     Handle<String> subject,
     int index,
     Vector<int> output) {
   Isolate* isolate = regexp->GetIsolate();
 
   Handle<FixedArray> irregexp(FixedArray::cast(regexp->data()), isolate);
 
   ASSERT(index >= 0);
   ASSERT(index <= subject->length());
   ASSERT(subject->IsFlat());
 
-  // A flat ASCII string might have a two-byte first part.
-  if (subject->IsConsString()) {
-    subject = Handle<String>(ConsString::cast(*subject)->first(), isolate);

[Vitaly Repeshko, 2011/08/17 19:20:23]

This unwrapping didn't help the code called below because it can handle flat
conses, right? What about interpreted regexps? I think the encoding can now be
incorrect for them.

-  }
-
 #ifndef V8_INTERPRETED_REGEXP
   ASSERT(output.length() >= (IrregexpNumberOfCaptures(*irregexp) + 1) * 2);
   do {
-    bool is_ascii = subject->IsAsciiRepresentation();
+    // A flat ASCII indirect string might actually be two-byte.
+    bool is_ascii;
+    if (StringShape(*subject).IsIndirect()) {
+      is_ascii = subject->GetIndirect()->IsAsciiRepresentation();
+    } else {
+      is_ascii = subject->IsAsciiRepresentation();
+    }
     EnsureCompiledIrregexp(regexp, is_ascii);
     Handle<Code> code(IrregexpNativeCode(*irregexp, is_ascii), isolate);
     NativeRegExpMacroAssembler::Result res =
         NativeRegExpMacroAssembler::Match(code,
                                           subject,
                                           output.start(),
                                           output.length(),
                                           index,
                                           isolate);
     if (res != NativeRegExpMacroAssembler::RETRY) {
@@ skipping 4853 matching lines @@
   }
 
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal