Added ability to lock strings to prevent their representation or encoding from changing.

src/objects.h

 // Copyright 2011 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 5675 matching lines @@
     ASSERT(is_array_index());
     return array_index_;
   }
 
   inline uint32_t GetHash();
 
   int length_;
   uint32_t raw_running_hash_;
   uint32_t array_index_;
   bool is_array_index_;
-  bool is_first_char_;
   bool is_valid_;
   friend class TwoCharHashTableKey;
 };
 
 
 // Calculates string hash.
 template <typename schar>
 inline uint32_t HashSequentialString(const schar* chars, int length);
 
 
@@ skipping 436 matching lines @@
   static inline SeqString* cast(Object* obj);
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
 };
 
 
-// The AsciiString class captures sequential ascii string objects.
-// Each character in the AsciiString is an ascii character.
+// The SeqAsciiString class captures sequential ASCII string objects.
+// Each character in the AsciiString is an ASCII character.
 class SeqAsciiString: public SeqString {
  public:
+  typedef char CharType;
   static const bool kHasAsciiEncoding = true;
 
   // Dispatched behavior.
   inline uint16_t SeqAsciiStringGet(int index);
   inline void SeqAsciiStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
   inline char* GetChars();
 
   // Casting
   static inline SeqAsciiString* cast(Object* obj);
 
+  bool IsSeqAsciiString() {

[Rico, 2011/09/23 07:06:52]

Why this, we can always just call IsSequentialAscii right? Is this just to be
able to assert this?

[Lasse Reichstein, 2011/09/23 09:54:39]

As discussed offline, this is to allow templated functions to get a quick answer
without using the generic String::IsSeqAsciiString. I'll add fast false-returns
to the other non-composite string types too.

+    ASSERT(this->Object::IsSeqAsciiString());
+    return true;
+  }
+
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of an AsciiString
   // instance.
   inline int SeqAsciiStringSize(InstanceType instance_type);
 
   // Computes the size for an AsciiString instance of a given length.
   static int SizeFor(int length) {
     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kCharSize);
   }
 
   // Maximal memory usage for a single sequential ASCII string.
   static const int kMaxSize = 512 * MB - 1;
   // Maximal length of a single sequential ASCII string.
   // Q.v. String::kMaxLength which is the maximal size of concatenated strings.
   static const int kMaxLength = (kMaxSize - kHeaderSize);
 
   // Support for StringInputBuffer.
   inline void SeqAsciiStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
                                                 unsigned* offset,
                                                 unsigned chars);
   inline const unibrow::byte* SeqAsciiStringReadBlock(unsigned* remaining,
                                                       unsigned* offset,
                                                       unsigned chars);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqAsciiString);
 };
 
 
-// The TwoByteString class captures sequential unicode string objects.
+// The SeqTwoByteString class captures sequential unicode string objects.
 // Each character in the TwoByteString is a two-byte uint16_t.
 class SeqTwoByteString: public SeqString {
  public:
+  typedef uc16 CharType;
+
   static const bool kHasAsciiEncoding = false;
 
   // Dispatched behavior.
   inline uint16_t SeqTwoByteStringGet(int index);
   inline void SeqTwoByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
   inline uc16* GetChars();
 
   // For regexp code.
   const uint16_t* SeqTwoByteStringGetData(unsigned start);
 
   // Casting
   static inline SeqTwoByteString* cast(Object* obj);
+  bool IsSeqTwoByteString() {
+    ASSERT(this->Object::IsSeqTwoByteString());

[Rico, 2011/09/23 07:06:52]

Same question as for ascii

[Lasse Reichstein, 2011/09/23 09:54:39]

Same answer.

+    return true;
+  }
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of a TwoByteString
   // instance.
   inline int SeqTwoByteStringSize(InstanceType instance_type);
 
   // Computes the size for a TwoByteString instance of a given length.
   static int SizeFor(int length) {
     return OBJECT_POINTER_ALIGN(kHeaderSize + length * kShortSize);
   }
@@ skipping 149 matching lines @@
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalString);
 };
 
 
 // The ExternalAsciiString class is an external string backed by an
 // ASCII string.
 class ExternalAsciiString: public ExternalString {
  public:
+  typedef char CharType;
+
   static const bool kHasAsciiEncoding = true;
 
   typedef v8::String::ExternalAsciiStringResource Resource;
 
   // The underlying resource.
   inline const Resource* resource();
   inline void set_resource(const Resource* buffer);
 
   // Dispatched behavior.
   uint16_t ExternalAsciiStringGet(int index);
 
   // Casting.
   static inline ExternalAsciiString* cast(Object* obj);
+  bool IsExternalAsciiString() {
+    ASSERT(this->Object::IsExternalAsciiString());
+    return true;
+  }
 
   // Garbage collection support.
   inline void ExternalAsciiStringIterateBody(ObjectVisitor* v);
 
   template<typename StaticVisitor>
   inline void ExternalAsciiStringIterateBody();
 
   // Support for StringInputBuffer.
   const unibrow::byte* ExternalAsciiStringReadBlock(unsigned* remaining,
                                                     unsigned* offset,
                                                     unsigned chars);
   inline void ExternalAsciiStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
                                                      unsigned* offset,
                                                      unsigned chars);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalAsciiString);
 };
 
 
-// The ExternalTwoByteString class is an external string backed by a UTF-16
-// encoded string.
+// The ExternalTwoByteString class is an external string backed by a 16-bit
+// character sequence.
 class ExternalTwoByteString: public ExternalString {
  public:
+  typedef uc16 CharType;
   static const bool kHasAsciiEncoding = false;
 
   typedef v8::String::ExternalStringResource Resource;
 
   // The underlying string resource.
   inline const Resource* resource();
   inline void set_resource(const Resource* buffer);
 
   // Dispatched behavior.
   uint16_t ExternalTwoByteStringGet(int index);
 
   // For regexp code.
   const uint16_t* ExternalTwoByteStringGetData(unsigned start);
 
   // Casting.
   static inline ExternalTwoByteString* cast(Object* obj);
+  bool IsExternalTwoByteString() {
+    ASSERT(this->Object::IsExternalTwoByteString());
+    return true;
+  }
 
   // Garbage collection support.
   inline void ExternalTwoByteStringIterateBody(ObjectVisitor* v);
 
   template<typename StaticVisitor>
   inline void ExternalTwoByteStringIterateBody();
 
 
   // Support for StringInputBuffer.
   void ExternalTwoByteStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
@@ skipping 951 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_