All RegExp data are set on a single FixedArray instead of nesting them three deep.

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@1398 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/factory.cc

@@ -826,12 +826,13 @@ Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
 }
 
 
-void Factory::SetRegExpData(Handle<JSRegExp> regexp,
+void Factory::SetRegExpAtomData(Handle<JSRegExp> regexp,
                                 JSRegExp::Type type,
                                 Handle<String> source,
                                 JSRegExp::Flags flags,
                                 Handle<Object> data) {
-  Handle<FixedArray> store = NewFixedArray(JSRegExp::kDataSize);
+  Handle<FixedArray> store = NewFixedArray(JSRegExp::kAtomDataSize);
+
   store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
   store->set(JSRegExp::kSourceIndex, *source);
   store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
@@ -839,6 +840,25 @@ void Factory::SetRegExpData(Handle<JSRegExp> regexp,
   regexp->set_data(*store);
 }
 
+void Factory::SetRegExpIrregexpData(Handle<JSRegExp> regexp,
+                                    JSRegExp::Type type,
+                                    Handle<String> source,
+                                    JSRegExp::Flags flags,
+                                    int capture_count) {
+  Handle<FixedArray> store = NewFixedArray(JSRegExp::kIrregexpDataSize);
+
+  store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
+  store->set(JSRegExp::kSourceIndex, *source);
+  store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
+  store->set(JSRegExp::kIrregexpASCIICodeIndex, Heap::the_hole_value());
+  store->set(JSRegExp::kIrregexpUC16CodeIndex, Heap::the_hole_value());
+  store->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(0));
+  store->set(JSRegExp::kIrregexpCaptureCountIndex,
+             Smi::FromInt(capture_count));
+  regexp->set_data(*store);
+}
+
+
 
 void Factory::ConfigureInstance(Handle<FunctionTemplateInfo> desc,
                                 Handle<JSObject> instance,

src/factory.h

@@ -316,12 +316,20 @@ class Factory : public AllStatic {
                                                Handle<FixedArray> keys);
 
   // Creates a new FixedArray that holds the data associated with the
-  // regexp and stores it in the regexp.
-  static void SetRegExpData(Handle<JSRegExp> regexp,
+  // atom regexp and stores it in the regexp.
+  static void SetRegExpAtomData(Handle<JSRegExp> regexp,
                                 JSRegExp::Type type,
                                 Handle<String> source,
                                 JSRegExp::Flags flags,
-                            Handle<Object> data);
+                                Handle<Object> match_pattern);
+
+  // Creates a new FixedArray that holds the data associated with the
+  // irregexp regexp and stores it in the regexp.
+  static void SetRegExpIrregexpData(Handle<JSRegExp> regexp,
+                                    JSRegExp::Type type,
+                                    Handle<String> source,
+                                    JSRegExp::Flags flags,
+                                    int capture_count);
 
  private:
   static Handle<JSFunction> NewFunctionHelper(Handle<String> name,

src/jsregexp.h

@@ -51,6 +51,7 @@ class RegExpImpl {
   // Parses the RegExp pattern and prepares the JSRegExp object with
   // generic data and choice of implementation - as well as what
   // the implementation wants to store in the data field.
+  // Returns false if compilation fails.
   static Handle<Object> Compile(Handle<JSRegExp> re,
                                 Handle<String> pattern,
                                 Handle<String> flags);
@@ -70,12 +71,13 @@ class RegExpImpl {
                                    Handle<JSArray> lastMatchInfo);
 
   // Prepares a JSRegExp object with Irregexp-specific data.
-  static Handle<Object> IrregexpPrepare(Handle<JSRegExp> re,
+  static void IrregexpPrepare(Handle<JSRegExp> re,
                               Handle<String> pattern,
-                                        JSRegExp::Flags flags);
+                              JSRegExp::Flags flags,
+                              int capture_register_count);
 
 
-  static Handle<Object> AtomCompile(Handle<JSRegExp> re,
+  static void AtomCompile(Handle<JSRegExp> re,
                           Handle<String> pattern,
                           JSRegExp::Flags flags,
                           Handle<String> match_pattern);
@@ -107,12 +109,6 @@ class RegExpImpl {
   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;
@@ -141,10 +137,15 @@ class RegExpImpl {
   static String* last_ascii_string_;
   static String* two_byte_cached_string_;
 
+  static bool EnsureCompiledIrregexp(Handle<JSRegExp> re, bool is_ascii);
+
+  static int IrregexpMaxRegisterCount(Handle<FixedArray> re);
+  static void SetIrregexpMaxRegisterCount(Handle<FixedArray> re, int value);
   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);
+  static Handle<ByteArray> IrregexpByteCode(Handle<FixedArray> re,
+                                            bool is_ascii);
+  static Handle<Code> IrregexpNativeCode(Handle<FixedArray> re, bool is_ascii);
 
   // On a successful match, the result is a JSArray containing
   // captured positions. On a failure, the result is the null value.
@@ -1354,7 +1355,21 @@ struct RegExpCompileData {
 
 class RegExpEngine: public AllStatic {
  public:
-  static Handle<FixedArray> Compile(RegExpCompileData* input,
+  struct CompilationResult {
+    explicit CompilationResult(const char* error_message)
+        : error_message(error_message),
+          code(Heap::the_hole_value()),
+          num_registers(0) {}
+    CompilationResult(Object* code, int registers)
+      : error_message(NULL),
+        code(code),
+        num_registers(registers) {}
+    const char* error_message;
+    Object* code;
+    int num_registers;
+  };
+
+  static CompilationResult Compile(RegExpCompileData* input,
                                    bool ignore_case,
                                    bool multiline,
                                    Handle<String> pattern,

src/objects-debug.cc

@@ -697,8 +697,18 @@ void JSRegExp::JSRegExpVerify() {
     }
     case JSRegExp::IRREGEXP: {
       FixedArray* arr = FixedArray::cast(data());
-      Object* irregexp_data = arr->get(JSRegExp::kIrregexpDataIndex);
-      ASSERT(irregexp_data->IsFixedArray());
+      Object* ascii_data = arr->get(JSRegExp::kIrregexpASCIICodeIndex);
+      ASSERT(ascii_data->IsTheHole()
+          || (FLAG_regexp_native ?
+              ascii_data->IsCode()
+            : ascii_data->IsByteArray()));
+      Object* uc16_data = arr->get(JSRegExp::kIrregexpUC16CodeIndex);
+      ASSERT(uc16_data->IsTheHole()
+          || (FLAG_regexp_native ?
+              uc16_data->IsCode()
+            : uc16_data->IsByteArray()));
+      ASSERT(arr->get(JSRegExp::kIrregexpCaptureCountIndex)->IsSmi());
+      ASSERT(arr->get(JSRegExp::kIrregexpMaxRegisterCountIndex)->IsSmi());
       break;
     }
     default:

src/objects-inl.h

@@ -2337,6 +2337,13 @@ Object* JSRegExp::DataAt(int index) {
 }
 
 
+void JSRegExp::SetDataAt(int index, Object* value) {
+  ASSERT(TypeTag() != NOT_COMPILED);
+  ASSERT(index >= kDataIndex);  // Only implementation data can be set this way.
+  FixedArray::cast(data())->set(index, value);
+}
+
+
 bool JSObject::HasFastElements() {
   return !elements()->IsDictionary();
 }

src/objects.h

@@ -2946,6 +2946,19 @@ class JSValue: public JSObject {
 };
 
 // Regular expressions
+// The regular expression holds a single reference to a FixedArray in
+// the kDataOffset field.
+// The FixedArray contains the following data:
+// - tag : type of regexp implementation (not compiled yet, atom or irregexp)
+// - reference to the original source string
+// - reference to the original flag string
+// If it is an atom regexp
+// - a reference to a literal string to search for
+// If it is an irregexp regexp:
+// - a reference to code for ASCII inputs (bytecode or compiled).
+// - a reference to code for UC16 inputs (bytecode or compiled).
+// - max number of registers used by irregexp implementations.
+// - number of capture registers (output values) of the regexp.
 class JSRegExp: public JSObject {
  public:
   // Meaning of Type:
@@ -2973,6 +2986,8 @@ class JSRegExp: public JSObject {
   inline Flags GetFlags();
   inline String* Pattern();
   inline Object* DataAt(int index);
+  // Set implementation data after the object has been prepared.
+  inline void SetDataAt(int index, Object* value);
 
   static inline JSRegExp* cast(Object* obj);
 
@@ -2984,14 +2999,29 @@ class JSRegExp: public JSObject {
   static const int kDataOffset = JSObject::kHeaderSize;
   static const int kSize = kDataOffset + kIntSize;
 
+  // Indices in the data array.
   static const int kTagIndex = 0;
   static const int kSourceIndex = kTagIndex + 1;
   static const int kFlagsIndex = kSourceIndex + 1;
-  // These two are the same since the same entry is shared for
-  // different purposes in different types of regexps.
-  static const int kAtomPatternIndex = kFlagsIndex + 1;
-  static const int kIrregexpDataIndex = kFlagsIndex + 1;
-  static const int kDataSize = kAtomPatternIndex + 1;
+  static const int kDataIndex = kFlagsIndex + 1;
+  // The data fields are used in different ways depending on the
+  // value of the tag.
+  // Atom regexps (literal strings).
+  static const int kAtomPatternIndex = kDataIndex;
+
+  static const int kAtomDataSize = kAtomPatternIndex + 1;
+
+  // Irregexp compiled code or bytecode for ASCII.
+  static const int kIrregexpASCIICodeIndex = kDataIndex;
+  // Irregexp compiled code or bytecode for UC16.
+  static const int kIrregexpUC16CodeIndex = kDataIndex + 1;
+  // Maximal number of registers used by either ASCII or UC16.
+  // Only used to check that there is enough stack space
+  static const int kIrregexpMaxRegisterCountIndex = kDataIndex + 2;
+  // Number of captures in the compiled regexp.
+  static const int kIrregexpCaptureCountIndex = kDataIndex + 3;
+
+  static const int kIrregexpDataSize = kIrregexpCaptureCountIndex + 1;
 };