Merged bleeding_edge -r 685:746 into regexp2000.

src/objects.h

 // 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 3012 matching lines @@
   bool is_valid_;
 };
 
 
 // The characteristics of a string are stored in its map.  Retrieving these
 // few bits of information is moderately expensive, involving two memory
 // loads where the second is dependent on the first.  To improve efficiency
 // the shape of the string is given its own class so that it can be retrieved
 // once and used for several string operations.  A StringShape is small enough
 // to be passed by value and is immutable, but be aware that flattening a
-// string can potentially alter its shape.
+// string can potentially alter its shape.  Also be aware that a GC caused by
+// something else can alter the shape of a string due to ConsString
+// shortcutting.
 //
 // Most of the methods designed to interrogate a string as to its exact nature
 // have been made into methods on StringShape in order to encourage the use of
 // StringShape.  The String class has both a length() and a length(StringShape)
 // operation.  The former is simpler to type, but the latter is faster if you
 // need the StringShape for some other operation immediately before or after.
 class StringShape BASE_EMBEDDED {
  public:
   inline explicit StringShape(String* s);
   inline explicit StringShape(Map* s);
@@ skipping 71 matching lines @@
   inline void TryFlatten(StringShape shape);
 
   Vector<const char> ToAsciiVector();
   Vector<const uc16> ToUC16Vector();
 
   // Mark the string as an undetectable object. It only applies to
   // ascii and two byte string types.
   bool MarkAsUndetectable();
 
   // Slice the string and return a substring.
-  Object* Slice(StringShape shape, int from, int to);
+  Object* Slice(int from, int to);
 
   // String equality operations.
   inline bool Equals(String* other);
   bool IsEqualTo(Vector<const char> str);
 
   // Return a UTF8 representation of the string.  The string is null
   // terminated but may optionally contain nulls.  Length is returned
   // in length_output if length_output is not a null pointer  The string
   // should be nearly flat, otherwise the performance of this method may
   // be very slow (quadratic in the length).  Setting robustness_flag to
@@ skipping 334 matching lines @@
   inline String* buffer();
   inline void set_buffer(String* buffer);
 
   // The start index of the slice.
   inline int start();
   inline void set_start(int start);
 
   // Dispatched behavior.
   uint16_t SlicedStringGet(int index);
 
-  // Flatten any ConsString hiding behind this SlicedString.
-  Object* SlicedStringFlatten();
-
   // Casting.
   static inline SlicedString* cast(Object* obj);
 
   // Garbage collection support.
   void SlicedStringIterateBody(ObjectVisitor* v);
 
   // Layout description
   static const int kBufferOffset = String::kSize;
   static const int kStartOffset = kBufferOffset + kPointerSize;
   static const int kSize = kStartOffset + kIntSize;
@@ skipping 679 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_