Revert r13275 and 13276 (Remove most uses of StringInputBuffer).

src/runtime.cc

 // Copyright 2012 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 3471 matching lines @@
 
   // No need to flatten if we are going to find the answer on the first
   // character.  At this point we know there is at least one character
   // in each string, due to the trivial case handling above.
   int d = str1->Get(0) - str2->Get(0);
   if (d != 0) return Smi::FromInt(d);
 
   str1->TryFlatten();
   str2->TryFlatten();
 
-  ConsStringIteratorOp* op1 =
-      isolate->runtime_state()->string_locale_compare_it1();
-  ConsStringIteratorOp* op2 =
-      isolate->runtime_state()->string_locale_compare_it2();
-  // TODO(dcarney) Can do array compares here more efficiently.
-  StringCharacterStream stream1(str1, op1);
-  StringCharacterStream stream2(str2, op2);
+  StringInputBuffer& buf1 =
+      *isolate->runtime_state()->string_locale_compare_buf1();
+  StringInputBuffer& buf2 =
+      *isolate->runtime_state()->string_locale_compare_buf2();
+
+  buf1.Reset(str1);
+  buf2.Reset(str2);
 
   for (int i = 0; i < end; i++) {
-    uint16_t char1 = stream1.GetNext();
-    uint16_t char2 = stream2.GetNext();
+    uint16_t char1 = buf1.GetNext();
+    uint16_t char2 = buf2.GetNext();
     if (char1 != char2) return Smi::FromInt(char1 - char2);
   }
 
   return Smi::FromInt(str1_length - str2_length);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_SubString) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 3);
@@ skipping 1623 matching lines @@
   const char hex_chars[] = "0123456789ABCDEF";
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   CONVERT_ARG_CHECKED(String, source, 0);
 
   source->TryFlatten();
 
   int escaped_length = 0;
   int length = source->length();
   {
-    Access<ConsStringIteratorOp> op(
-        isolate->runtime_state()->string_iterator());
-    StringCharacterStream stream(source, op.value());
-    while (stream.HasMore()) {
-      uint16_t character = stream.GetNext();
+    Access<StringInputBuffer> buffer(
+        isolate->runtime_state()->string_input_buffer());
+    buffer->Reset(source);
+    while (buffer->has_more()) {
+      uint16_t character = buffer->GetNext();
       if (character >= 256) {
         escaped_length += 6;
       } else if (IsNotEscaped(character)) {
         escaped_length++;
       } else {
         escaped_length += 3;
       }
       // We don't allow strings that are longer than a maximal length.
       ASSERT(String::kMaxLength < 0x7fffffff - 6);  // Cannot overflow.
       if (escaped_length > String::kMaxLength) {
         isolate->context()->mark_out_of_memory();
         return Failure::OutOfMemoryException();
       }
     }
   }
   // No length change implies no change.  Return original string if no change.
   if (escaped_length == length) {
     return source;
   }
   Object* o;
   { MaybeObject* maybe_o =
         isolate->heap()->AllocateRawOneByteString(escaped_length);
     if (!maybe_o->ToObject(&o)) return maybe_o;
   }
   String* destination = String::cast(o);
   int dest_position = 0;
 
-  Access<ConsStringIteratorOp> op(
-      isolate->runtime_state()->string_iterator());
-  StringCharacterStream stream(source, op.value());
-  while (stream.HasMore()) {
-    uint16_t chr = stream.GetNext();
+  Access<StringInputBuffer> buffer(
+      isolate->runtime_state()->string_input_buffer());
+  buffer->Rewind();
+  while (buffer->has_more()) {
+    uint16_t chr = buffer->GetNext();
     if (chr >= 256) {
       destination->Set(dest_position, '%');
       destination->Set(dest_position+1, 'u');
       destination->Set(dest_position+2, hex_chars[chr >> 12]);
       destination->Set(dest_position+3, hex_chars[(chr >> 8) & 0xf]);
       destination->Set(dest_position+4, hex_chars[(chr >> 4) & 0xf]);
       destination->Set(dest_position+5, hex_chars[chr & 0xf]);
       dest_position += 6;
     } else if (IsNotEscaped(chr)) {
       destination->Set(dest_position, chr);
@@ skipping 517 matching lines @@
   { MaybeObject* maybe_o = s->IsOneByteRepresentation()
         ? isolate->heap()->AllocateRawOneByteString(length)
         : isolate->heap()->AllocateRawTwoByteString(length);
     if (!maybe_o->ToObject(&o)) return maybe_o;
   }
   String* result = String::cast(o);
   bool has_changed_character = false;
 
   // Convert all characters to upper case, assuming that they will fit
   // in the buffer
-  Access<ConsStringIteratorOp> op(
-      isolate->runtime_state()->string_iterator());
-  StringCharacterStream stream(s, op.value());
+  Access<StringInputBuffer> buffer(
+      isolate->runtime_state()->string_input_buffer());
+  buffer->Reset(s);
   unibrow::uchar chars[Converter::kMaxWidth];
   // We can assume that the string is not empty
-  uc32 current = stream.GetNext();
+  uc32 current = buffer->GetNext();
   for (int i = 0; i < length;) {
-    bool has_next = stream.HasMore();
-    uc32 next = has_next ? stream.GetNext() : 0;
+    bool has_next = buffer->has_more();
+    uc32 next = has_next ? buffer->GetNext() : 0;
     int char_length = mapping->get(current, next, chars);
     if (char_length == 0) {
       // The case conversion of this character is the character itself.
       result->Set(i, current);
       i++;
     } else if (char_length == 1) {
       // Common case: converting the letter resulted in one character.
       ASSERT(static_cast<uc32>(chars[0]) != current);
       result->Set(i, chars[0]);
       has_changed_character = true;
       i++;
     } else if (length == input_string_length) {
       // We've assumed that the result would be as long as the
       // input but here is a character that converts to several
       // characters.  No matter, we calculate the exact length
       // of the result and try the whole thing again.
       //
       // Note that this leaves room for optimization.  We could just
       // memcpy what we already have to the result string.  Also,
       // the result string is the last object allocated we could
       // "realloc" it and probably, in the vast majority of cases,
       // extend the existing string to be able to hold the full
       // result.
       int next_length = 0;
       if (has_next) {
         next_length = mapping->get(next, 0, chars);
         if (next_length == 0) next_length = 1;
       }
       int current_length = i + char_length + next_length;
-      while (stream.HasMore()) {
-        current = stream.GetNext();
+      while (buffer->has_more()) {
+        current = buffer->GetNext();
         // NOTE: we use 0 as the next character here because, while
         // the next character may affect what a character converts to,
         // it does not in any case affect the length of what it convert
         // to.
         int char_length = mapping->get(current, 0, chars);
         if (char_length == 0) char_length = 1;
         current_length += char_length;
         if (current_length > Smi::kMaxValue) {
           isolate->context()->mark_out_of_memory();
           return Failure::OutOfMemoryException();
@@ skipping 1183 matching lines @@
     x_scaled /= 10;
     tie = GREATER;
   }
 
   if (x_scaled < y_scaled) return Smi::FromInt(LESS);
   if (x_scaled > y_scaled) return Smi::FromInt(GREATER);
   return Smi::FromInt(tie);
 }
 
 
-static Object* StringCharacterStreamCompare(RuntimeState* state,
+static Object* StringInputBufferCompare(RuntimeState* state,
                                         String* x,
                                         String* y) {
-  StringCharacterStream stream_x(x, state->string_iterator_compare_x());
-  StringCharacterStream stream_y(y, state->string_iterator_compare_y());
-  while (stream_x.HasMore() && stream_y.HasMore()) {
-    int d = stream_x.GetNext() - stream_y.GetNext();
+  StringInputBuffer& bufx = *state->string_input_buffer_compare_bufx();
+  StringInputBuffer& bufy = *state->string_input_buffer_compare_bufy();
+  bufx.Reset(x);
+  bufy.Reset(y);
+  while (bufx.has_more() && bufy.has_more()) {
+    int d = bufx.GetNext() - bufy.GetNext();
     if (d < 0) return Smi::FromInt(LESS);
     else if (d > 0) return Smi::FromInt(GREATER);
   }
 
   // x is (non-trivial) prefix of y:
-  if (stream_y.HasMore()) return Smi::FromInt(LESS);
+  if (bufy.has_more()) return Smi::FromInt(LESS);
   // y is prefix of x:
-  return Smi::FromInt(stream_x.HasMore() ? GREATER : EQUAL);
+  return Smi::FromInt(bufx.has_more() ? GREATER : EQUAL);
 }
 
 
 static Object* FlatStringCompare(String* x, String* y) {
   ASSERT(x->IsFlat());
   ASSERT(y->IsFlat());
   Object* equal_prefix_result = Smi::FromInt(EQUAL);
   int prefix_length = x->length();
   if (y->length() < prefix_length) {
     prefix_length = y->length();
@@ skipping 23 matching lines @@
       r = CompareChars(x_chars.start(), y_chars.start(), prefix_length);
     }
   }
   Object* result;
   if (r == 0) {
     result = equal_prefix_result;
   } else {
     result = (r < 0) ? Smi::FromInt(LESS) : Smi::FromInt(GREATER);
   }
   ASSERT(result ==
-      StringCharacterStreamCompare(Isolate::Current()->runtime_state(), x, y));
+      StringInputBufferCompare(Isolate::Current()->runtime_state(), x, y));
   return result;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_StringCompare) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_ARG_CHECKED(String, x, 0);
   CONVERT_ARG_CHECKED(String, y, 1);
@@ skipping 15 matching lines @@
 
   Object* obj;
   { MaybeObject* maybe_obj = isolate->heap()->PrepareForCompare(x);
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
   { MaybeObject* maybe_obj = isolate->heap()->PrepareForCompare(y);
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
 
   return (x->IsFlat() && y->IsFlat()) ? FlatStringCompare(x, y)
-      : StringCharacterStreamCompare(isolate->runtime_state(), x, y);
+      : StringInputBufferCompare(isolate->runtime_state(), x, y);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_acos) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   isolate->counters()->math_acos()->Increment();
 
   CONVERT_DOUBLE_ARG_CHECKED(x, 0);
   return isolate->transcendental_cache()->Get(TranscendentalCache::ACOS, x);
@@ skipping 2808 matching lines @@
 }
 
 
 // This will not allocate (flatten the string), but it may run
 // very slowly for very deeply nested ConsStrings.  For debugging use only.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_GlobalPrint) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   CONVERT_ARG_CHECKED(String, string, 0);
-  ConsStringIteratorOp op;
-  StringCharacterStream stream(string, &op);
-  while (stream.HasMore()) {
-    uint16_t character = stream.GetNext();
+  StringInputBuffer buffer(string);
+  while (buffer.has_more()) {
+    uint16_t character = buffer.GetNext();
     PrintF("%c", character);
   }
   return string;
 }
 
 // Moves all own elements of an object, that are below a limit, to positions
 // starting at zero. All undefined values are placed after non-undefined values,
 // and are followed by non-existing element. Does not change the length
 // property.
 // Returns the number of non-undefined elements collected.
@@ skipping 3750 matching lines @@
     // 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(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal