Runtime logging

src/jsregexp.cc

 // 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 355 matching lines @@
 Handle<Object> RegExpImpl::AtomExec(Handle<JSRegExp> re,
                                     Handle<String> subject,
                                     Handle<Object> index) {
   Handle<String> needle(String::cast(re->DataAt(JSRegExp::kAtomPatternIndex)));
 
   uint32_t start_index;
   if (!Array::IndexFromObject(*index, &start_index)) {
     return Handle<Smi>(Smi::FromInt(-1));
   }
 
-  LOG(RegExpExecEvent(re, start_index, subject));
   int value = Runtime::StringMatch(subject, needle, start_index);
   if (value == -1) return Factory::null_value();
 
   Handle<FixedArray> array = Factory::NewFixedArray(2);
   array->set(0, Smi::FromInt(value));
   array->set(1, Smi::FromInt(value + needle->length()));
   return Factory::NewJSArrayWithElements(array);
 }
 
 
 Handle<Object> RegExpImpl::AtomExecGlobal(Handle<JSRegExp> re,
                                           Handle<String> subject) {
   Handle<String> needle(String::cast(re->DataAt(JSRegExp::kAtomPatternIndex)));
   Handle<JSArray> result = Factory::NewJSArray(1);
   int index = 0;
   int match_count = 0;
   int subject_length = subject->length();
   int needle_length = needle->length();
   while (true) {
-    LOG(RegExpExecEvent(re, index, subject));
     int value = -1;
     if (index + needle_length <= subject_length) {
       value = Runtime::StringMatch(subject, needle, index);
     }
     if (value == -1) break;
     HandleScope scope;
     int end = value + needle_length;
 
     Handle<FixedArray> array = Factory::NewFixedArray(2);
     array->set(0, Smi::FromInt(value));
@@ skipping 161 matching lines @@
                                          int* offsets_vector,
                                          int offsets_vector_length) {
   int rc;
   {
     AssertNoAllocation a;
     ByteArray* internal = JscreInternal(regexp);
     const v8::jscre::JscreRegExp* js_regexp =
         reinterpret_cast<v8::jscre::JscreRegExp*>(
             internal->GetDataStartAddress());
 
-    LOG(RegExpExecEvent(regexp, previous_index, subject));
-
     rc = v8::jscre::jsRegExpExecute(js_regexp,
                                     two_byte_subject,
                                     subject->length(),
                                     previous_index,
                                     offsets_vector,
                                     offsets_vector_length);
   }
 
   // The KJS JavaScript engine returns null (ie, a failed match) when
   // JSRE's internal match limit is exceeded.  We duplicate that behavior here.
@@ skipping 194 matching lines @@
 
   int previous_index = static_cast<int>(DoubleToInteger(index->Number()));
 
 #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
-  LOG(RegExpExecEvent(regexp, previous_index, subject));
 
   if (!subject->IsFlat(StringShape(*subject))) {
     FlattenString(subject);
   }
 
   return IrregexpExecOnce(irregexp,
                           num_captures,
                           subject,
                           previous_index,
                           offsets.vector(),
@@ skipping 33 matching lines @@
       matches = Factory::null_value();
       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
-      LOG(RegExpExecEvent(regexp, previous_index, subject));
       matches = IrregexpExecOnce(irregexp,
                                  IrregexpNumberOfCaptures(irregexp),
                                  subject,
                                  previous_index,
                                  offsets.vector(),
                                  offsets.length());
 
       if (matches->IsJSArray()) {
         SetElement(result, i, matches);
         i++;
@@ skipping 3534 matching lines @@
   EmbeddedVector<byte, 1024> codes;
   RegExpMacroAssemblerIrregexp macro_assembler(codes);
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal