Implement string.match in C++.

src/jsregexp.cc

 // Copyright 2006-2009 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 187 matching lines @@
       ASSERT(!result.is_null() || Top::has_pending_exception());
       return result;
     }
     default:
       UNREACHABLE();
       return Handle<Object>::null();
   }
 }
 
 
-Handle<Object> RegExpImpl::ExecGlobal(Handle<JSRegExp> regexp,
-                                      Handle<String> subject,
-                                      Handle<JSArray> last_match_info) {
-  switch (regexp->TypeTag()) {
-    case JSRegExp::ATOM:
-      return AtomExecGlobal(regexp, subject, last_match_info);
-    case JSRegExp::IRREGEXP: {
-      Handle<Object> result =
-          IrregexpExecGlobal(regexp, subject, last_match_info);
-      ASSERT(!result.is_null() || Top::has_pending_exception());
-      return result;
-    }
-    default:
-      UNREACHABLE();
-      return Handle<Object>::null();
-  }
-}
-
-
 // RegExp Atom implementation: Simple string search using indexOf.
 
 
 void RegExpImpl::AtomCompile(Handle<JSRegExp> re,
                              Handle<String> pattern,
                              JSRegExp::Flags flags,
                              Handle<String> match_pattern) {
   Factory::SetRegExpAtomData(re,
                              JSRegExp::ATOM,
                              pattern,
@@ skipping 29 matching lines @@
 
   {
     NoHandleAllocation no_handles;
     FixedArray* array = last_match_info->elements();
     SetAtomLastCapture(array, *subject, value, value + needle->length());
   }
   return last_match_info;
 }
 
 
-Handle<Object> RegExpImpl::AtomExecGlobal(Handle<JSRegExp> re,
-                                          Handle<String> subject,
-                                          Handle<JSArray> last_match_info) {
-  Handle<String> needle(String::cast(re->DataAt(JSRegExp::kAtomPatternIndex)));
-  ASSERT(last_match_info->HasFastElements());
-  Handle<JSArray> result = Factory::NewJSArray(1);
-  int index = 0;
-  int match_count = 0;
-  int subject_length = subject->length();
-  int needle_length = needle->length();
-  int last_value = -1;
-  while (true) {
-    HandleScope scope;
-    int value = -1;
-    if (index + needle_length <= subject_length) {
-      value = Runtime::StringMatch(subject, needle, index);
-    }
-    if (value == -1) {
-      if (last_value != -1) {
-        Handle<FixedArray> array(last_match_info->elements());
-        SetAtomLastCapture(*array,
-                           *subject,
-                           last_value,
-                           last_value + needle->length());
-      }
-      break;
-    }
-
-    int end = value + needle_length;
-
-    // Create an array that looks like the static last_match_info array
-    // that is attached to the global RegExp object.  We will be returning
-    // an array of these.
-    Handle<FixedArray> array = Factory::NewFixedArray(kFirstCapture + 2);
-    SetLastCaptureCount(*array, 2);
-    // Ignore subject and input fields.
-    SetCapture(*array, 0, value);
-    SetCapture(*array, 1, end);
-    Handle<JSArray> pair = Factory::NewJSArrayWithElements(array);
-    SetElement(result, match_count, pair);
-    match_count++;
-    index = end;
-    if (needle_length == 0) index++;
-    last_value = value;
-  }
-  return result;
-}
-
-
 // Irregexp implementation.
 
 
 // Ensures that the regexp object contains a compiled version of the
 // source for either ASCII or non-ASCII strings.
 // If the compiled version doesn't already exist, it is compiled
 // from the source pattern.
 // If compilation fails, an exception is thrown and this function
 // returns false.
-bool RegExpImpl::EnsureCompiledIrregexp(Handle<JSRegExp> re,
-                                        bool is_ascii) {
+bool RegExpImpl::EnsureCompiledIrregexp(Handle<JSRegExp> re, bool is_ascii) {
   int index;
   if (is_ascii) {
     index = JSRegExp::kIrregexpASCIICodeIndex;
   } else {
     index = JSRegExp::kIrregexpUC16CodeIndex;
   }
   Object* entry = re->DataAt(index);
   if (!entry->IsTheHole()) {
     // A value has already been compiled.
     if (entry->IsJSObject()) {
@@ skipping 107 matching lines @@
                                  int capture_count) {
   // Initialize compiled code entries to null.
   Factory::SetRegExpIrregexpData(re,
                                  JSRegExp::IRREGEXP,
                                  pattern,
                                  flags,
                                  capture_count);
 }
 
 
-Handle<Object> RegExpImpl::IrregexpExec(Handle<JSRegExp> regexp,
+Handle<Object> RegExpImpl::IrregexpExec(Handle<JSRegExp> jsregexp,
                                         Handle<String> subject,
-                                        int index,
+                                        int previous_index,
                                         Handle<JSArray> last_match_info) {
-  ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
+  ASSERT_EQ(jsregexp->TypeTag(), JSRegExp::IRREGEXP);
 
   // Prepare space for the return values.
   int number_of_capture_registers =
-      (IrregexpNumberOfCaptures(FixedArray::cast(regexp->data())) + 1) * 2;
+      (IrregexpNumberOfCaptures(FixedArray::cast(jsregexp->data())) + 1) * 2;
   OffsetsVector offsets(number_of_capture_registers);
 
-  int previous_index = index;
-
 #ifdef DEBUG
   if (FLAG_trace_regexp_bytecodes) {
-    String* pattern = regexp->Pattern();
+    String* pattern = jsregexp->Pattern();
     PrintF("\n\nRegexp match:   /%s/\n\n", *(pattern->ToCString()));
     PrintF("\n\nSubject string: '%s'\n\n", *(subject->ToCString()));
   }
 #endif
 
   if (!subject->IsFlat()) {
     FlattenString(subject);
   }
 
   last_match_info->EnsureSize(number_of_capture_registers + kLastMatchOverhead);
 
-  return IrregexpExecOnce(regexp,
-                          number_of_capture_registers,
-                          last_match_info,
-                          subject,
-                          previous_index,
-                          offsets.vector(),
-                          offsets.length());
-}
+  int* offsets_vector = offsets.vector();
+  int offsets_vector_length = offsets.length();
+  bool rc;
 
-
-Handle<Object> RegExpImpl::IrregexpExecGlobal(Handle<JSRegExp> regexp,
-                                              Handle<String> subject,
-                                              Handle<JSArray> last_match_info) {
-  ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
-
-  // Prepare space for the return values.
-  int number_of_capture_registers =
-      (IrregexpNumberOfCaptures(FixedArray::cast(regexp->data())) + 1) * 2;
-  OffsetsVector offsets(number_of_capture_registers);
-
-  int previous_index = 0;
-
-  Handle<JSArray> result = Factory::NewJSArray(0);
-  int result_length = 0;
-  Handle<Object> matches;
-
-  if (!subject->IsFlat()) {
-    FlattenString(subject);
-  }
-
-  last_match_info->EnsureSize(number_of_capture_registers + kLastMatchOverhead);
-
-  while (true) {
-    if (previous_index > subject->length() || previous_index < 0) {
-      // Per ECMA-262 15.10.6.2, if the previous index is greater than the
-      // string length, there is no match.
-      return result;
-    } else {
-#ifdef DEBUG
-      if (FLAG_trace_regexp_bytecodes) {
-        String* pattern = regexp->Pattern();
-        PrintF("\n\nRegexp match:   /%s/\n\n", *(pattern->ToCString()));
-        PrintF("\n\nSubject string: '%s'\n\n", *(subject->ToCString()));
-      }
-#endif
-      HandleScope scope;
-      matches = IrregexpExecOnce(regexp,
-                                 number_of_capture_registers,
-                                 last_match_info,
-                                 subject,
-                                 previous_index,
-                                 offsets.vector(),
-                                 offsets.length());
-
-      if (matches.is_null()) {
-        ASSERT(Top::has_pending_exception());
-        return matches;
-      }
-
-      if (matches->IsJSArray()) {
-        // Create an array that looks like the static last_match_info array
-        // that is attached to the global RegExp object.  We will be returning
-        // an array of these.
-        int match_length = kFirstCapture + number_of_capture_registers;
-        Handle<JSArray> latest_match =
-            Factory::NewJSArray(match_length);
-
-        AssertNoAllocation no_allocation;
-        FixedArray* match_array = JSArray::cast(*matches)->elements();
-        match_array->CopyTo(0,
-                            latest_match->elements(),
-                            0,
-                            match_length);
-        SetElement(result, result_length, latest_match);
-        result_length++;
-        previous_index = GetCapture(match_array, 1);
-        if (GetCapture(match_array, 0) == previous_index) {
-          previous_index++;
-        }
-      } else {
-        ASSERT(matches->IsNull());
-        return result;
-      }
-    }
-  }
-}
-
-
-Handle<Object> RegExpImpl::IrregexpExecOnce(Handle<JSRegExp> jsregexp,
-                                            int number_of_capture_registers,
-                                            Handle<JSArray> last_match_info,
-                                            Handle<String> subject,
-                                            int previous_index,
-                                            int* offsets_vector,
-                                            int offsets_vector_length) {
-  ASSERT(subject->IsFlat());
-  bool rc;
+  // Dispatch to the correct RegExp implementation.
 
   Handle<String> original_subject = subject;
   Handle<FixedArray> regexp(FixedArray::cast(jsregexp->data()));
   if (UseNativeRegexp()) {
 #ifdef ARM
     UNREACHABLE();
 #else
     RegExpMacroAssemblerIA32::Result res;
     do {
       bool is_ascii = StringShape(*subject).IsAsciiRepresentation();
@@ skipping 27 matching lines @@
       offsets_vector[i] = -1;
     }
     Handle<ByteArray> byte_codes(IrregexpByteCode(*regexp, is_ascii));
 
     rc = IrregexpInterpreter::Match(byte_codes,
                                     subject,
                                     offsets_vector,
                                     previous_index);
   }
 
+  // Handle results from RegExp implementation.
+
   if (!rc) {
     return Factory::null_value();
   }
 
   FixedArray* array = last_match_info->elements();
   ASSERT(array->length() >= number_of_capture_registers + kLastMatchOverhead);
   // The captures come in (start, end+1) pairs.
   SetLastCaptureCount(array, number_of_capture_registers);
   SetLastSubject(array, *original_subject);
   SetLastInput(array, *original_subject);
@@ skipping 3972 matching lines @@
   EmbeddedVector<byte, 1024> codes;
   RegExpMacroAssemblerIrregexp macro_assembler(codes);
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal