Experimental: periodic merge of the bleeding_edge branch to the...

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 569 matching lines @@
     return true;    // An Ape, an ABCBook.
   } else if ((c1 == 0 || (c1 >= 'A' && c1 <= 'Z')) &&
            (c0 == 'F' || c0 == 'H' || c0 == 'M' || c0 == 'N' || c0 == 'R' ||
             c0 == 'S' || c0 == 'X')) {
     return true;    // An MP3File, an M.
   }
   return false;
 }
 
 
-Object* String::Flatten(StringShape shape) {
+Object* String::TryFlatten(StringShape shape) {
 #ifdef DEBUG
   // Do not attempt to flatten in debug mode when allocation is not
   // allowed.  This is to avoid an assertion failure when allocating.
   // Flattening strings is the only case where we always allow
   // allocation because no GC is performed if the allocation fails.
   if (!Heap::IsAllocationAllowed()) return this;
 #endif
 
   switch (shape.representation_tag()) {
     case kSlicedStringTag: {
       SlicedString* ss = SlicedString::cast(this);
       // The SlicedString constructor should ensure that there are no
       // SlicedStrings that are constructed directly on top of other
       // SlicedStrings.
       String* buf = ss->buffer();
       ASSERT(!buf->IsSlicedString());
-      Object* ok = buf->Flatten(StringShape(buf));
+      Object* ok = buf->TryFlatten(StringShape(buf));
       if (ok->IsFailure()) return ok;
-      // Under certain circumstances (TryFlatten fails in String::Slice)
-      // we can have a cons string under a slice.  In this case we need
-      // to get the flat string out of the cons!
+      // Under certain circumstances (TryFlattenIfNotFlat fails in
+      // String::Slice) we can have a cons string under a slice.
+      // In this case we need to get the flat string out of the cons!
       if (StringShape(String::cast(ok)).IsCons()) {
         ss->set_buffer(ConsString::cast(ok)->first());
       }
       return this;
     }
     case kConsStringTag: {
       ConsString* cs = ConsString::cast(this);
       if (cs->second()->length() == 0) {
         return this;
       }
@@ skipping 1318 matching lines @@
     } else {
       int byte_array_length = ByteArray::LengthFor(instance_size_delta);
       int byte_array_length_offset = new_instance_size + kPointerSize;
       WRITE_FIELD(this, new_instance_size, Heap::byte_array_map());
       WRITE_INT_FIELD(this, byte_array_length_offset, byte_array_length);
     }
     WRITE_BARRIER(this, new_instance_size);
   }
   new_map->set_unused_property_fields(0);
 
-  // We have now sucessfully allocated all the necessary objects.
+  // We have now successfully allocated all the necessary objects.
   // Changes can now be made with the guarantee that all of them take effect.
   set_map(new_map);
   map()->set_instance_descriptors(Heap::empty_descriptor_array());
 
   set_properties(dictionary);
 
   Counters::props_to_dictionary.Increment();
 
 #ifdef DEBUG
   if (FLAG_trace_normalization) {
@@ skipping 445 matching lines @@
   // interceptor calls.
   AssertNoContextChange ncc;
 
   // Check access rights if needed.
   if (IsAccessCheckNeeded() &&
       !Top::MayNamedAccess(this, name, v8::ACCESS_SET)) {
     Top::ReportFailedAccessCheck(this, v8::ACCESS_SET);
     return Heap::undefined_value();
   }
 
-  // TryFlatten before operating on the string.
-  name->TryFlatten(StringShape(name));
+  // Try to flatten before operating on the string.
+  name->TryFlattenIfNotFlat(StringShape(name));
 
   // Make sure name is not an index.
   uint32_t index;
   if (name->AsArrayIndex(&index)) return Heap::undefined_value();
 
   // Check if there is an API defined callback object which prohibits
   // callback overwriting in this object or it's prototype chain.
   // This mechanism is needed for instance in a browser setting, where
   // certain accessors such as window.location should not be allowed
-  // to be overwriten because allowing overwriting could potentially
+  // to be overwritten because allowing overwriting could potentially
   // cause security problems.
   LookupResult callback_result;
   LookupCallback(name, &callback_result);
   if (callback_result.IsValid()) {
     Object* obj = callback_result.GetCallbackObject();
     if (obj->IsAccessorInfo() &&
         AccessorInfo::cast(obj)->prohibits_overwriting()) {
       return Heap::undefined_value();
     }
   }
@@ skipping 620 matching lines @@
 }
 
 
 int String::Utf8Length() {
   StringShape shape(this);
   if (shape.IsAsciiRepresentation()) return length(shape);
   // Attempt to flatten before accessing the string.  It probably
   // doesn't make Utf8Length faster, but it is very likely that
   // the string will be accessed later (for example by WriteUtf8)
   // so it's still a good idea.
-  if (!IsFlat(shape)) {
-    TryFlatten(shape);  // shape is now no longer valid.
-  }
+  TryFlattenIfNotFlat(shape);  // shape is now no longer valid.
   Access<StringInputBuffer> buffer(&string_input_buffer);
   buffer->Reset(0, this);
   int result = 0;
   while (buffer->has_more())
     result += unibrow::Utf8::Length(buffer->GetNext());
   return result;
 }
 
 
 Vector<const char> String::ToAsciiVector() {
@@ skipping 2072 matching lines @@
     JSArray* array = JSArray::cast(this);
     Object* return_value = array->JSArrayUpdateLengthFromIndex(index, value);
     if (return_value->IsFailure()) return return_value;
   }
 
   // Attempt to put this object back in fast case.
   if (ShouldConvertToFastElements()) {
     uint32_t new_length = 0;
     if (IsJSArray()) {
       CHECK(Array::IndexFromObject(JSArray::cast(this)->length(), &new_length));
+      JSArray::cast(this)->set_length(Smi::FromInt(new_length));
     } else {
       new_length = Dictionary::cast(elements())->max_number_key() + 1;
     }
     Object* obj = Heap::AllocateFixedArrayWithHoles(new_length);
     if (obj->IsFailure()) return obj;
     SetFastElements(FixedArray::cast(obj));
 #ifdef DEBUG
     if (FLAG_trace_normalization) {
       PrintF("Object elements are fast case again:\n");
       Print();
@@ skipping 515 matching lines @@
   } else {
     HeapSortPairs(this, smis);
     return;
   }
 }
 
 
 // Fill in the names of local properties into the supplied storage. The main
 // purpose of this function is to provide reflection information for the object
 // mirrors.
-void JSObject::GetLocalPropertyNames(FixedArray* storage) {
-  ASSERT(storage->length() ==
-         NumberOfLocalProperties(static_cast<PropertyAttributes>(NONE)));
-  int index = 0;
+void JSObject::GetLocalPropertyNames(FixedArray* storage, int index) {
+  ASSERT(storage->length() >=
+         NumberOfLocalProperties(static_cast<PropertyAttributes>(NONE)) -
+             index);
   if (HasFastProperties()) {
     for (DescriptorReader r(map()->instance_descriptors());
          !r.eos();
          r.advance()) {
       if (!r.IsTransition()) {
         storage->set(index++, r.GetKey());
       }
     }
-    ASSERT(storage->length() == index);
+    ASSERT(storage->length() >= index);
   } else {
     property_dictionary()->CopyKeysTo(storage);
   }
 }
 
 
 int JSObject::NumberOfLocalElements(PropertyAttributes filter) {
   return GetLocalElementKeys(NULL, filter);
 }
 
@@ skipping 1294 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