Removed some handlers and made regexp.test avoid creating a result array.

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 291 matching lines @@
                              pattern,
                              flags,
                              match_pattern);
 }
 
 
 static void SetAtomLastCapture(FixedArray* array,
                                String* subject,
                                int from,
                                int to) {
+  NoHandleAllocation no_handles;
   RegExpImpl::SetLastCaptureCount(array, 2);
   RegExpImpl::SetLastSubject(array, subject);
   RegExpImpl::SetLastInput(array, subject);
   RegExpImpl::SetCapture(array, 0, from);
   RegExpImpl::SetCapture(array, 1, to);
 }
 
 
 Handle<Object> RegExpImpl::AtomExec(Handle<JSRegExp> re,
                                     Handle<String> subject,
                                     int index,
                                     Handle<JSArray> last_match_info) {
   Handle<String> needle(String::cast(re->DataAt(JSRegExp::kAtomPatternIndex)));
 
   uint32_t start_index = index;
 
   int value = Runtime::StringMatch(subject, needle, start_index);
   if (value == -1) return Factory::null_value();
   ASSERT(last_match_info->HasFastElements());
 

[Erik Corry, 2009/03/03 10:44:13]

Add a NoHandleAllocation here.

-  Handle<FixedArray> array(last_match_info->elements());
-  SetAtomLastCapture(*array, *subject, value, value + needle->length());
+  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);
@@ skipping 101 matching lines @@
     SetElement(array,
                1,
                Factory::NewStringFromUtf8(CStrVector(result.error_message)));
     Handle<Object> regexp_err =
         Factory::NewSyntaxError("malformed_regexp", array);
     Top::Throw(*regexp_err);
     re->SetDataAt(index, *regexp_err);
     return false;
   }
 
-  Handle<FixedArray> data(FixedArray::cast(re->data()));
+  FixedArray* data = FixedArray::cast(re->data());

[Erik Corry, 2009/03/03 10:44:13]

NoHandleAllocation

   data->set(index, result.code);
   int register_max = IrregexpMaxRegisterCount(data);
   if (result.num_registers > register_max) {
     SetIrregexpMaxRegisterCount(data, result.num_registers);
   }
 
   return true;
 }
 
 
-int RegExpImpl::IrregexpMaxRegisterCount(Handle<FixedArray> re) {
+int RegExpImpl::IrregexpMaxRegisterCount(FixedArray* re) {
   return Smi::cast(
       re->get(JSRegExp::kIrregexpMaxRegisterCountIndex))->value();
 }
 
 
-void RegExpImpl::SetIrregexpMaxRegisterCount(Handle<FixedArray> re, int value) {
-  re->set(JSRegExp::kIrregexpMaxRegisterCountIndex,
-          Smi::FromInt(value));
+void RegExpImpl::SetIrregexpMaxRegisterCount(FixedArray* re, int value) {
+  re->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(value));
 }
 
 
-int RegExpImpl::IrregexpNumberOfCaptures(Handle<FixedArray> re) {
-  return Smi::cast(
-      re->get(JSRegExp::kIrregexpCaptureCountIndex))->value();
+int RegExpImpl::IrregexpNumberOfCaptures(FixedArray* re) {
+  return Smi::cast(re->get(JSRegExp::kIrregexpCaptureCountIndex))->value();
 }
 
 
-int RegExpImpl::IrregexpNumberOfRegisters(Handle<FixedArray> re) {
-  return Smi::cast(
-      re->get(JSRegExp::kIrregexpMaxRegisterCountIndex))->value();
+int RegExpImpl::IrregexpNumberOfRegisters(FixedArray* re) {
+  return Smi::cast(re->get(JSRegExp::kIrregexpMaxRegisterCountIndex))->value();
 }
 
 
-Handle<ByteArray> RegExpImpl::IrregexpByteCode(Handle<FixedArray> re,
-                                               bool is_ascii) {
+ByteArray* RegExpImpl::IrregexpByteCode(FixedArray* re, bool is_ascii) {
   int index;
   if (is_ascii) {
     index = JSRegExp::kIrregexpASCIICodeIndex;
   } else {
     index = JSRegExp::kIrregexpUC16CodeIndex;
   }
-  Object* value = re->get(index);
-  ASSERT(value->IsByteArray());
-  return Handle<ByteArray>(ByteArray::cast(value));
+  return ByteArray::cast(re->get(index));
 }
 
 
-Handle<Code> RegExpImpl::IrregexpNativeCode(Handle<FixedArray> re,
-                                            bool is_ascii) {
+Code* RegExpImpl::IrregexpNativeCode(FixedArray* re, bool is_ascii) {
   int index;
   if (is_ascii) {
     index = JSRegExp::kIrregexpASCIICodeIndex;
   } else {
     index = JSRegExp::kIrregexpUC16CodeIndex;
   }
-  Object* value = re->get(index);
-  ASSERT(value->IsCode());
-  return Handle<Code>(Code::cast(value));
+  return Code::cast(re->get(index));
 }
 
 
 void RegExpImpl::IrregexpPrepare(Handle<JSRegExp> re,
                                  Handle<String> pattern,
                                  JSRegExp::Flags flags,
                                  int capture_count) {
   // Initialize compiled code entries to null.
   Factory::SetRegExpIrregexpData(re,
                                  JSRegExp::IRREGEXP,
@@ skipping 10 matching lines @@
   ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
 
   bool is_ascii = StringShape(*subject).IsAsciiRepresentation();
   if (!EnsureCompiledIrregexp(regexp, is_ascii)) {
     return Handle<Object>::null();
   }
 
   // Prepare space for the return values.
   Handle<FixedArray> re_data(FixedArray::cast(regexp->data()));
   int number_of_capture_registers =
-      (IrregexpNumberOfCaptures(re_data) + 1) * 2;
+      (IrregexpNumberOfCaptures(*re_data) + 1) * 2;
   OffsetsVector offsets(number_of_capture_registers);
 
   int previous_index = index;
 
 #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()));
   }
@@ skipping 21 matching lines @@
   ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
   Handle<FixedArray> irregexp(FixedArray::cast(regexp->data()));
 
   bool is_ascii = StringShape(*subject).IsAsciiRepresentation();
   if (!EnsureCompiledIrregexp(regexp, is_ascii)) {
     return Handle<Object>::null();
   }
 
   // Prepare space for the return values.
   int number_of_capture_registers =
-      (IrregexpNumberOfCaptures(irregexp) + 1) * 2;
+      (IrregexpNumberOfCaptures(*irregexp) + 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(StringShape(*subject))) {
     FlattenString(subject);
@@ skipping 65 matching lines @@
                                             int previous_index,
                                             int* offsets_vector,
                                             int offsets_vector_length) {
   StringShape shape(*subject);
   ASSERT(subject->IsFlat(shape));
   bool is_ascii = shape.IsAsciiRepresentation();
   bool rc;
 
   if (FLAG_regexp_native) {
 #ifndef ARM
-    Handle<Code> code(IrregexpNativeCode(regexp, is_ascii));
+    Handle<Code> code(IrregexpNativeCode(*regexp, is_ascii));
 
     // Character offsets into string.
     int start_offset = previous_index;
     int end_offset = subject->length(shape);
 
     if (shape.IsCons()) {
       subject = Handle<String>(ConsString::cast(*subject)->first());
     } else if (shape.IsSliced()) {
       SlicedString* slice = SlicedString::cast(*subject);
       start_offset += slice->start();
@@ skipping 55 matching lines @@
     }
   } else {
 #else
   // Unimplemented on ARM, fall through to bytecode.
   }
   {
 #endif
     for (int i = number_of_capture_registers - 1; i >= 0; i--) {
       offsets_vector[i] = -1;
     }
-    Handle<ByteArray> byte_codes = IrregexpByteCode(regexp, is_ascii);
+    Handle<ByteArray> byte_codes(IrregexpByteCode(*regexp, is_ascii));
 
     rc = IrregexpInterpreter::Match(byte_codes,
                                     subject,
                                     offsets_vector,
                                     previous_index);
   }
 
   if (!rc) {
     return Factory::null_value();
   }
@@ skipping 3979 matching lines @@
   EmbeddedVector<byte, 1024> codes;
   RegExpMacroAssemblerIrregexp macro_assembler(codes);
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal