Fixing presubmit error.

src/runtime.cc

 // Copyright 2011 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 2489 matching lines @@
   FixedArrayBuilder array_builder_;
   Handle<String> subject_;
   int character_count_;
   bool is_ascii_;
 };
 
 
 class CompiledReplacement {
  public:
   CompiledReplacement()
-      : parts_(1), replacement_substrings_(0) {}
+      : parts_(1), replacement_substrings_(0), simple_hint(false) {}
 
   void Compile(Handle<String> replacement,
                int capture_count,
                int subject_length);
 
   void Apply(ReplacementStringBuilder* builder,
              int match_from,
              int match_to,
              Handle<JSArray> last_match_info);
 
   // Number of distinct parts of the replacement pattern.
   int parts() {
     return parts_.length();
   }
 
+  int IsSimple() {

[Jakob Kummerow, 2011/09/07 16:11:24]

nit 1: This is C++. We have bools.
nit 2: A simple getter for my_favorite_variable_ is typically called
my_favorite_variable(), so in this case "simple_hint()".

+    return simple_hint;
+  }
+
  private:
   enum PartType {
     SUBJECT_PREFIX = 1,
     SUBJECT_SUFFIX,
     SUBJECT_CAPTURE,
     REPLACEMENT_SUBSTRING,
     REPLACEMENT_STRING,
 
     NUMBER_OF_PART_TYPES
   };
@@ skipping 35 matching lines @@
     // tag == SUBJECT_SUFFIX:  data is unused.
     // tag == SUBJECT_CAPTURE: data is the number of the capture.
     // tag == REPLACEMENT_SUBSTRING ||
     // tag == REPLACEMENT_STRING:    data is index into array of substrings
     //                               of the replacement string.
     // tag <= 0: Temporary representation of the substring of the replacement
     //           string ranging over -tag .. data.
     //           Is replaced by REPLACEMENT_{SUB,}STRING when we create the
     //           substring objects.
     int data;
+
   };
 
   template<typename Char>
-  static void ParseReplacementPattern(ZoneList<ReplacementPart>* parts,
+  static bool ParseReplacementPattern(ZoneList<ReplacementPart>* parts,
                                       Vector<Char> characters,
                                       int capture_count,
                                       int subject_length) {
     int length = characters.length();
     int last = 0;
+    bool simple = true;
     for (int i = 0; i < length; i++) {
       Char c = characters[i];
       if (c == '$') {
+        simple = false;
         int next_index = i + 1;
         if (next_index == length) {  // No next character!
           break;
         }
         Char c2 = characters[next_index];
         switch (c2) {
         case '$':
           if (i > last) {
             // There is a substring before. Include the first "$".
             parts->Add(ReplacementPart::ReplacementSubString(last, next_index));
@@ skipping 72 matching lines @@
         }
       }
     }
     if (length > last) {
       if (last == 0) {
         parts->Add(ReplacementPart::ReplacementString());
       } else {
         parts->Add(ReplacementPart::ReplacementSubString(last, length));
       }
     }
+    return simple;
   }
 
   ZoneList<ReplacementPart> parts_;
   ZoneList<Handle<String> > replacement_substrings_;
+  bool simple_hint;

[Jakob Kummerow, 2011/09/07 16:11:24]

nit: trailing underscore please

 };
 
 
 void CompiledReplacement::Compile(Handle<String> replacement,
                                   int capture_count,
                                   int subject_length) {
   {
     AssertNoAllocation no_alloc;
     String::FlatContent content = replacement->GetFlatContent();
     ASSERT(content.IsFlat());
     if (content.IsAscii()) {
-      ParseReplacementPattern(&parts_,
-                              content.ToAsciiVector(),
-                              capture_count,
-                              subject_length);
+      simple_hint = ParseReplacementPattern(&parts_,
+                                            content.ToAsciiVector(),
+                                            capture_count,
+                                            subject_length);
     } else {
       ASSERT(content.IsTwoByte());
-      ParseReplacementPattern(&parts_,
-                              content.ToUC16Vector(),
-                              capture_count,
-                              subject_length);
+      simple_hint = ParseReplacementPattern(&parts_,
+                                            content.ToUC16Vector(),
+                                            capture_count,
+                                            subject_length);
     }
   }
   Isolate* isolate = replacement->GetIsolate();
   // Find substrings of replacement string and create them as String objects.
   int substring_index = 0;
   for (int i = 0, n = parts_.length(); i < n; i++) {
     int tag = parts_[i].tag;
     if (tag <= 0) {  // A replacement string slice.
       int from = -tag;
       int to = parts_[i].data;
@@ skipping 174 matching lines @@
 
   Handle<ResultSeqString> result;
   if (ResultSeqString::kHasAsciiEncoding) {
     result = Handle<ResultSeqString>::cast(
         isolate->factory()->NewRawAsciiString(result_len));
   } else {
     result = Handle<ResultSeqString>::cast(
         isolate->factory()->NewRawTwoByteString(result_len));
   }
 
-  for(int i = 0; i < matches; i++) {
+  for (int i = 0; i < matches; i++) {
     // Copy non-matched subject content.
     String::WriteToFlat(*subject,
                         result->GetChars() + result_pos,
                         subject_pos,
                         indices.at(i));
     result_pos += indices.at(i) - subject_pos;
     // Replace match.
 
     if (replacement_len > 0) {
       String::WriteToFlat(*replacement,
@@ skipping 47 matching lines @@
   CompiledReplacement compiled_replacement;
   compiled_replacement.Compile(replacement_handle,
                                capture_count,
                                length);
 
   bool is_global = regexp_handle->GetFlags().is_global();
 
   // Shortcut for simple non-regexp global replacements
   if (is_global &&
       regexp->TypeTag() == JSRegExp::ATOM &&
-      compiled_replacement.parts() == 1) {
+      compiled_replacement.IsSimple()) {
     if (subject_handle->HasOnlyAsciiChars() &&
         replacement_handle->HasOnlyAsciiChars()) {
       return StringReplaceStringWithString<SeqAsciiString>(
           isolate, subject_handle, regexp_handle, replacement_handle);
     } else {
       return StringReplaceStringWithString<SeqTwoByteString>(
           isolate, subject_handle, regexp_handle, replacement_handle);
     }
   }
 
@@ skipping 10135 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal