Pool implementation for zone segments

src/runtime/runtime-regexp.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/conversions-inl.h"
 #include "src/isolate-inl.h"
 #include "src/messages.h"
@@ skipping 363 matching lines @@
         } else {
           FindStringIndices(isolate, subject_vector, pattern_vector, indices,
                             limit);
         }
       }
     }
   }
 }
 
 namespace {
-List<int>* GetRewindedRegexpIndicesList(Isolate* isolate) {
+List<int>* GetRewoundRegexpIndicesList(Isolate* isolate) {
   List<int>* list = isolate->regexp_indices();
   list->Rewind(0);
   return list;
 }
 
 void TruncateRegexpIndicesList(Isolate* isolate) {
   // Same size as smallest zone segment, preserving behavior from the
   // runtime zone.
   static const size_t kMaxRegexpIndicesListCapacity = 8 * KB;
   if (isolate->regexp_indices()->capacity() > kMaxRegexpIndicesListCapacity) {
     isolate->regexp_indices()->Clear();  //  Throw away backing storage
   }
 }
 }  // namespace
 
 template <typename ResultSeqString>
 MUST_USE_RESULT static Object* StringReplaceGlobalAtomRegExpWithString(
     Isolate* isolate, Handle<String> subject, Handle<JSRegExp> pattern_regexp,
     Handle<String> replacement, Handle<JSObject> last_match_info) {
   DCHECK(subject->IsFlat());
   DCHECK(replacement->IsFlat());
 
-  List<int>* indices = GetRewindedRegexpIndicesList(isolate);
+  List<int>* indices = GetRewoundRegexpIndicesList(isolate);
 
   DCHECK_EQ(JSRegExp::ATOM, pattern_regexp->TypeTag());
   String* pattern =
       String::cast(pattern_regexp->DataAt(JSRegExp::kAtomPatternIndex));
   int subject_len = subject->length();
   int pattern_len = pattern->length();
   int replacement_len = replacement->length();
 
   FindStringIndicesDispatch(isolate, *subject, pattern, indices, 0xffffffff);
 
@@ skipping 296 matching lines @@
     }
   }
 
   // The limit can be very large (0xffffffffu), but since the pattern
   // isn't empty, we can never create more parts than ~half the length
   // of the subject.
 
   subject = String::Flatten(subject);
   pattern = String::Flatten(pattern);
 
-  List<int>* indices = GetRewindedRegexpIndicesList(isolate);
+  List<int>* indices = GetRewoundRegexpIndicesList(isolate);
 
   FindStringIndicesDispatch(isolate, *subject, *pattern, indices, limit);
 
   if (static_cast<uint32_t>(indices->length()) < limit) {
     indices->Add(subject_length);
   }
 
   // The list indices now contains the end of each part to create.
 
   // Create JSArray of substrings separated by separator.
@@ skipping 285 matching lines @@
 
 
 RUNTIME_FUNCTION(Runtime_IsRegExp) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_CHECKED(Object, obj, 0);
   return isolate->heap()->ToBoolean(obj->IsJSRegExp());
 }
 }  // namespace internal
 }  // namespace v8