Merged bleeding_edge -r 685:746 into regexp2000.

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 181 matching lines @@
   }
 
   // __defineGetter__ callback
   if (structure->IsFixedArray()) {
     Object* getter = FixedArray::cast(structure)->get(kGetterIndex);
     if (getter->IsJSFunction()) {
       HandleScope scope;
       Handle<JSFunction> fun(JSFunction::cast(getter));
       Handle<Object> self(receiver);
       bool has_pending_exception;
-      Object* result =
-          *Execution::Call(fun, self, 0, NULL, &has_pending_exception);
+      Handle<Object> result =
+          Execution::Call(fun, self, 0, NULL, &has_pending_exception);
       // Check for pending exception and return the result.
       if (has_pending_exception) return Failure::Exception();
-      return result;
+      return *result;
     }
     // Getter is not a function.
     return Heap::undefined_value();
   }
 
   UNREACHABLE();
   return 0;
 }
 
 
@@ skipping 3493 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 111 matching lines @@
   const Char* pa = a.start();
   const Char* pb = b.start();
   int i = 0;
 #ifndef CAN_READ_UNALIGNED
   // If this architecture isn't comfortable reading unaligned ints
   // then we have to check that the strings are aligned before
   // comparing them blockwise.
   const int kAlignmentMask = sizeof(uint32_t) - 1;  // NOLINT
   uint32_t pa_addr = reinterpret_cast<uint32_t>(pa);
   uint32_t pb_addr = reinterpret_cast<uint32_t>(pb);
-  if ((pa_addr & kAlignmentMask) | (pb_addr & kAlignmentMask) == 0) {
+  if (((pa_addr & kAlignmentMask) | (pb_addr & kAlignmentMask)) == 0) {
 #endif
     const int kStepSize = sizeof(int) / sizeof(Char);  // NOLINT
     int endpoint = length - kStepSize;
     // Compare blocks until we reach near the end of the string.
     for (; i <= endpoint; i += kStepSize) {
       uint32_t wa = *reinterpret_cast<const uint32_t*>(pa + i);
       uint32_t wb = *reinterpret_cast<const uint32_t*>(pb + i);
       if (wa != wb) {
         return false;
       }
@@ skipping 91 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