Push string shape fixes to trunk (version 0.4.3.1).

src/objects.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 3699 matching lines @@
     } else {
       return string->Get(shape, index);
     }
   }
 
   UNREACHABLE();
   return 0;
 }
 
 
-Object* SlicedString::SlicedStringFlatten() {
-  // The SlicedString constructor should ensure that there are no
-  // SlicedStrings that are constructed directly on top of other
-  // SlicedStrings.
-  String* buf = String::cast(buffer());
-  StringShape buf_shape(buf);
-  ASSERT(!buf_shape.IsSliced());
-  if (buf_shape.IsCons()) {
-    Object* ok = buf->Flatten(buf_shape);
-    if (ok->IsFailure()) return ok;
-  }
-  return this;
-}
-
-
 template <typename sinkchar>
 void String::WriteToFlat(String* src,
                          StringShape src_shape,
                          sinkchar* sink,
                          int f,
                          int t) {
   String* source = src;
   StringShape shape = src_shape;
   int from = f;
   int to = t;
@@ skipping 223 matching lines @@
       }
     }
   } else {
     string_compare_buffer_a.Reset(0, this);
     return CompareStringContentsPartial(&string_compare_buffer_a, other);
   }
 }
 
 
 bool String::MarkAsUndetectable() {
-  StringShape shape(this);
-  if (shape.IsSymbol()) return false;
+  if (StringShape(this).IsSymbol()) return false;
 
   Map* map = this->map();
   if (map == Heap::short_string_map()) {
     this->set_map(Heap::undetectable_short_string_map());
     return true;
   } else if (map == Heap::medium_string_map()) {
     this->set_map(Heap::undetectable_medium_string_map());
     return true;
   } else if (map == Heap::long_string_map()) {
     this->set_map(Heap::undetectable_long_string_map());
@@ skipping 137 matching lines @@
   // Process the remaining characters without updating the array
   // index.
   while (buffer->has_more()) {
     hasher.AddCharacterNoIndex(buffer->GetNext());
   }
 
   return hasher.GetHashField();
 }
 
 
-Object* String::Slice(StringShape shape, int start, int end) {
+Object* String::Slice(int start, int end) {
+  StringShape shape(this);
   if (start == 0 && end == length(shape)) return this;
   if (shape.representation_tag() == kSlicedStringTag) {
     // Translate slices of a SlicedString into slices of the
     // underlying string buffer.
     SlicedString* str = SlicedString::cast(this);
     String* buf = str->buffer();
     return Heap::AllocateSlicedString(buf,
-                                      StringShape(buf),
                                       str->start() + start,
                                       str->start() + end);
   }
-  Object* result = Heap::AllocateSlicedString(this, shape, start, end);
+  Object* result = Heap::AllocateSlicedString(this, start, end);
   if (result->IsFailure()) {
     return result;
   }
   // Due to the way we retry after GC on allocation failure we are not allowed
   // to fail on allocation after this point.  This is the one-allocation rule.
 
   // Try to flatten a cons string that is under the sliced string.
   // This is to avoid memory leaks and possible stack overflows caused by
   // building 'towers' of sliced strings on cons strings.
   // This may fail due to an allocation failure (when a GC is needed), but it
@@ skipping 2760 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 
 } }  // namespace v8::internal