Avoids allocating a JSArray of capture information on each non-global...

src/jsregexp.h

 // Copyright 2006-2008 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 41 matching lines @@
   // generic data and choice of implementation - as well as what
   // the implementation wants to store in the data field.
   static Handle<Object> Compile(Handle<JSRegExp> re,
                                 Handle<String> pattern,
                                 Handle<String> flags);
 
   // See ECMA-262 section 15.10.6.2.
   // This function calls the garbage collector if necessary.
   static Handle<Object> Exec(Handle<JSRegExp> regexp,
                              Handle<String> subject,
-                             Handle<Object> index);
+                             Smi* index,
+                             Handle<JSArray> lastMatchInfo);
 
   // Call RegExp.prototyp.exec(string) in a loop.
   // Used by String.prototype.match and String.prototype.replace.
   // This function calls the garbage collector if necessary.
   static Handle<Object> ExecGlobal(Handle<JSRegExp> regexp,
-                                   Handle<String> subject);
+                                   Handle<String> subject,
+                                   Handle<JSArray> lastMatchInfo);
 
   // Prepares a JSRegExp object with Irregexp-specific data.
   static Handle<Object> IrregexpPrepare(Handle<JSRegExp> re,
                                         Handle<String> pattern,
                                         JSRegExp::Flags flags);
 
 
   static Handle<Object> AtomCompile(Handle<JSRegExp> re,
                                     Handle<String> pattern,
                                     JSRegExp::Flags flags,
                                     Handle<String> match_pattern);
   static Handle<Object> AtomExec(Handle<JSRegExp> regexp,
                                  Handle<String> subject,
-                                 Handle<Object> index);
+                                 Smi* index,
+                                 Handle<JSArray> lastMatchInfo);
 
   static Handle<Object> AtomExecGlobal(Handle<JSRegExp> regexp,
-                                       Handle<String> subject);
+                                       Handle<String> subject,
+                                       Handle<JSArray> lastMatchInfo);
 
   // Execute an Irregexp bytecode pattern.
   static Handle<Object> IrregexpExec(Handle<JSRegExp> regexp,
                                      Handle<String> subject,
-                                     Handle<Object> index);
+                                     Smi* index,
+                                     Handle<JSArray> lastMatchInfo);
 
   static Handle<Object> IrregexpExecGlobal(Handle<JSRegExp> regexp,
-                                           Handle<String> subject);
+                                           Handle<String> subject,
+                                           Handle<JSArray> lastMatchInfo);
 
   static void NewSpaceCollectionPrologue();
   static void OldSpaceCollectionPrologue();
 
   // Converts a source string to a 16 bit flat string.  The string
   // will be either sequential or it will be a SlicedString backed
   // by a flat string.
   static Handle<String> StringToTwoByte(Handle<String> pattern);
   static Handle<String> CachedStringToTwoByte(Handle<String> pattern);
 
   static const int kIrregexpImplementationIndex = 0;
   static const int kIrregexpNumberOfCapturesIndex = 1;
   static const int kIrregexpNumberOfRegistersIndex = 2;
   static const int kIrregexpCodeIndex = 3;
   static const int kIrregexpDataLength = 4;
 
+  // Offsets in the lastMatchInfo array.
+  static const int kLastCaptureCount = 0;
+  static const int kLastSubject = 1;
+  static const int kLastInput = 2;
+  static const int kFirstCapture = 1;
+  static const int kLastMatchOverhead = 3;
+  static int GetCapture(FixedArray* array, int index) {
+    return Smi::cast(array->get(index + kFirstCapture))->value();
+  }
+  static void SetLastCaptureCount(FixedArray* array, int to) {
+    array->set(kLastCaptureCount, Smi::FromInt(to));
+  }
+  static void SetLastSubject(FixedArray* array, String* to) {
+    int capture_count = GetLastCaptureCount(array);
+    array->set(capture_count + kLastSubject, to);
+  }
+  static void SetLastInput(FixedArray* array, String* to) {
+    int capture_count = GetLastCaptureCount(array);
+    array->set(capture_count + kLastInput, to);
+  }
+  static void SetCapture(FixedArray* array, int index, int to) {
+    array->set(index + kFirstCapture, Smi::FromInt(to));
+  }
+
  private:
   static String* last_ascii_string_;
   static String* two_byte_cached_string_;
 
   static int IrregexpNumberOfCaptures(Handle<FixedArray> re);
   static int IrregexpNumberOfRegisters(Handle<FixedArray> re);
   static Handle<ByteArray> IrregexpByteCode(Handle<FixedArray> re);
   static Handle<Code> IrregexpNativeCode(Handle<FixedArray> re);
 
   // On a successful match, the result is a JSArray containing
   // captured positions. On a failure, the result is the null value.
   // Returns an empty handle in case of an exception.
   static Handle<Object> IrregexpExecOnce(Handle<FixedArray> regexp,
                                          int num_captures,
+                                         Handle<JSArray> lastMatchInfo,
                                          Handle<String> subject16,
                                          int previous_index,
                                          int* ovector,
                                          int ovector_length);
 
   // Set the subject cache.  The previous string buffer is not deleted, so the
   // caller should ensure that it doesn't leak.
   static void SetSubjectCache(String* subject,
                               char* utf8_subject,
                               int uft8_length,
                               int character_position,
                               int utf8_position);
 
+  // Used to access the lastMatchInfo array.
+  static int GetLastCaptureCount(FixedArray* array) {
+    return Smi::cast(array->get(kLastCaptureCount))->value();
+  }
   // A one element cache of the last utf8_subject string and its length.  The
   // subject JS String object is cached in the heap.  We also cache a
   // translation between position and utf8 position.
   static char* utf8_subject_cache_;
   static int utf8_length_cache_;
   static int utf8_position_;
   static int character_position_;
 };
 
 
@@ skipping 1178 matching lines @@
                                     Handle<String> pattern,
                                     bool is_ascii);
 
   static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_